RubyGems - passenger - Versions diffs - 4.0.60 → 5.0.0.beta1 - Mend

passenger 4.0.60 → 5.0.0.beta1

Potentially problematic release.

This version of passenger might be problematic. Click here for more details.

Files changed (1301) hide show

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/changelog.txt DELETED

@@ -1,54 +0,0 @@
-0.73 (Sep. 2 2014)
- fix: turning on gzip cleared Etag subscriber response header
- fix: channels incorrectly deleted when overwhelmed with connections
- feature: CORS support via OPTIONS request method response
- fix: file descriptor leak when restarting nginx via SIGHUP
- improve: concurrency for interprocess notifications
- refactor: completely encapsulated message store
- fix: slow memory leak introduced in 0.7
- fix: memory leak when not using message buffer
-0.712 (Mar. 21 2014)
- fix: intermittently dropped long-polling connections on internal redirects
- fix: unable to proxy long-polling subscribers. (thanks wandenberg and sanmai)
-0.711 (Mar. 13 2014)
- fix: incompatibility with cache manager (proxy_cache and fastcgi_cache directives)
-0.71 (Mar. 1 2014)
- fix: removed unused variables and functions to quiet down GCC
-0.7: (Feb. 20 2014)
- fix: last-in concurrency setting wasn't working reliably
- refactor: partially separated message storage. add a test harness.
- fix: segfault from concurrency bug while garbage-collecting channels
- fix: some large messages got lost
-0.692 (Feb. 3 2010)
- fix: error log reported failed close() for some publisher requests with large messages
- fix: occasional memory leak during message deletion
- fix: worker messages intended for dead worker processes were not deleted
-0.691 (Feb. 2 2010)
- fix: server reload (via SIGHUP signal) was failing
- fix: segfault on messages longer than client_body_buffer_size (thanks wfelipe)
- change: removed push_min_message_recipients, added push_delete_oldest_received_message
-0.69 (Nov. 17 2009)
- fix: publisher got a 201 Created response even if the channel had no subscribers at the time (should be 202 Accepted)
- fix: small memory leak after each message broadcast to a channel
- feature: optional push_max_channel_subscribers setting added
- fix: first-in concurrency setting wasn't responding to subscribers with a correct status code on conflict
- fix: reused subscriber connections sometimes failed to receive messages
- unfeature: no more nginx 0.6 support. not worth the hassle.
-0.683 (Nov. 10 2009)
- change: default max. reserved memory size changed form 16MB to 32 MB
- change: unused node garbage collection made a little more aggressive (max. 3 unused channels per channel search instead of 1)
- fix: unused nodes were deleted only on channel id hash collision (very rare)
- fix: segmentation fault from allocating insufficient memory for interprocess messaging
-0.681 (Nov. 6 2009)
- feature: added push_message_buffer_length setting, which sets push_message_max_buffer_length and push_message_min_buffer_length at once.
- fix: publisher channel info text/json response now uses double quotes instead of single.
- fix: interprocess messages were not removed from shared memory correctly, causing weird errors
-0.68 (Nov. 5 2009)
- change: default push_subscriber_concurrency value is now "broadcast"
- fix: incorrect error messages for invalid push_pubscriber and push_subscriber_concurrency settings
- change: removed deprecated push_buffer_size and push_queue_messages settings
- feature: rudimentary content-type negotiation for publisher channel info response.
-   support text/plain, text/json, text/yaml and application/xml (and mimetype equivalents)
- fix: publisher GET response has HTTP status 0
-0.67beta (Nov. 4 2009) and older
- see git repository

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/config DELETED

@@ -1,26 +0,0 @@
-ngx_feature="http_push_module"
-ngx_feature_name=
-ngx_feature_run=no
-ngx_feature_incs=
-ngx_feature_path=
-ngx_feature_libs=
-ngx_feature_test=
-ngx_addon_name=ngx_http_push_module
-HTTP_MODULES="$HTTP_MODULES ngx_http_push_module"
-CORE_INCS="$CORE_INCS \
-	$ngx_addon_dir/src"
-NGX_ADDON_SRCS="$NGX_ADDON_SRCS \
-    ${ngx_addon_dir}/src/ngx_http_push_defs.c \
-    ${ngx_addon_dir}/src/store/rbtree_util.c \
-    ${ngx_addon_dir}/src/store/ngx_http_push_module_ipc.c \
-    ${ngx_addon_dir}/src/store/memory/store.c \
-    ${ngx_addon_dir}/src/store/ngx_rwlock.c \
-    ${ngx_addon_dir}/src/ngx_http_push_module.c \
-    "
-have=NGX_HTTP_HEADERS . auto/have
-. auto/feature
-CORE_LIBS="$CORE_LIBS $ngx_feature_libs"
-CORE_INCS="$CORE_INCS $ngx_feature_incs"

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/protocol.txt DELETED

@@ -1,191 +0,0 @@
-                         Basic HTTP Push Relay Protocol
-   Rev. 2.23
-1. Introduction
-  1.1. Purpose
-   The primary purpose of this protocol is to enable a method of
-   long-polling, transparent to the web client, where client connections
-   idle only on the HTTP server and need not be forwarded.
-  1.2. Requirements
-   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
-   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
-   document are to be interpreted as described in RFC2119. An
-   implementation is not compliant if it fails to satisfy one or more of
-   the MUST or REQUIRED level requirements for the protocols it
-   implements.
-   An implementation that satisfies all the MUST or REQUIRED level and all
-   the SHOULD level requirements for its protocols is said to be
-   "unconditionally compliant"; one that satisfies all the MUST level
-   requirements but not all the SHOULD level requirements for its
-   protocols is said to be "conditionally compliant."
-  1.3. Terminology
-   This specification uses a number of terms to refer to the roles played
-   by participants in, and objects of, this protocol:
-   server
-          The HTTP server implementing this protocol.
-   client
-          A program that initiates TCP/IP connections with the HTTP server
-          for the purpose of sending HTTP requests.
-   message
-          Application specific data, usually enclosed in a request or
-          response body.
-   channel
-          A resource representing an isolated pathway for message
-          transmission. Each channel has a single unique message queue.
-   subscriber
-          A client that sends HTTP requests to the server for the purposes
-          of receiving messages via some channel.
-   publisher
-          A client that sends HTTP requests to the server in order to
-          transmit messages to subscribers via a channel.
-   channel id
-          A unique identifier for a channel.
-   location
-          A url (or set of urls) on the server.
-2. Requirements
-  2.1. Server Requirements
-   The HTTP server MUST have a mechanism of specifying a url, or a set of
-   urls as publisher and subscriber locations. All requests to the
-   publisher location MUST be treated as publisher requests, all to the
-   subscriber location as subscriber requests.
-   The server MUST implement a mechanism for identifying channels with
-   unique ids. This MAY, for example, be a url parameter (/foo/?id=123) or
-   a cookie. Methods of channel identification other than those using the
-   url MAY be used, but are strongly discouraged.
-   The server MUST accept requests on publisher locations and respond to
-   them immediately. It MUST also accept requests on subscriber locations,
-   but need not respond immediately.
-  2.2. Client Requirements
-   All clients must prodice valid HTTP requests. Subscriber clients must
-   have a caching mechanism that appropriately reacts to Last-Modified and
-   Etag response headers (web browsers, for example).
-  2.3. The Channel ID
-   It is not the responsibility of the server to generate IDs.
-3. Server Operation
-   A publisher request functions as notification to the server of a
-   message to send to some subscribers over some channel. A subscriber
-   request notifies the server of the subscriber's intent to receive a
-   message.
-  3.1. The Subscriber
-   The server MUST accept all valid HTTP GET requests to the subscriber
-   location. All other request methods SHOULD be responded to with a 405
-   Method Not Allowed status code.
-   Subscriber requests are considered notifications of intent to receive
-   some message. Subscribers may request existing messages, messages that
-   are not yet available, and messages that are no longer available. The
-   requested message is identified using the If-Modified-Since and
-   If-None-Match request headers. A request with no If-Modified-Since
-   header MUST be assumed to be requesting the oldest available message in
-   a channel. Each 200 OK response containing a message MUST have its
-   Last-Modified and Etag headers set so that a request using those
-   headers will be interpreted as a request for the next available
-   message. Additionally, said 200 OK MUST contain the Content-Type header
-   of the message publisher request, unless no Content-Type header had
-   been provided or it is explicitly overridden by server configuration.
-   There are several common mechanisms for performing an HTTP server push.
-   The rest of the behavior of the server in response to a subscriber
-   request SHOULD be configurable and MUST be selected from the following
-   list of mechanisms:
-   Long-Polling
-          Requests for existing messages will be responded to immediately;
-          responses to requests for messages not yet available MUST be
-          delayed until the message becomes available. Delayed responses
-          MUST satisfy all of the following conditions:
-          + A 200 OK response containing the message (and its
-            Content-Type) MUST be sent immediately after the message
-            becomes available. The entire response must be
-            indistinguishable from a response to a request for an existing
-            message.
-          + If the channel the subscriber is waiting on is deleted or for
-            some reason becomes unavailable, the server MUST immediately
-            send a 410 Gone response.
-          + If another subscriber has conflicted with this request, the
-            server MUST immediately send a 409 Conflict response.
-   Interval-Polling
-          All requests will be responded to immediately. Requests for
-          messages not yet available MUST produce a 304 Not Modified
-          response code.
-   In addition, when the server receives more than one concurrent
-   subscriber request on the same channel, it MUST do one of the
-   following:
-   Broadcast
-          No additional actions are performed
-   Last-in, first-out
-          All but the most recent long-held subscriber request on the
-          channel are sent a 409 Conflict response.
-   First-in, last-out
-          All but the oldest request will be sent a 409 Conflict
-   The server SHOULD make this selection configurable, and MUST default to
-   broadcast behavior.
-  3.2. The Publisher
-   The server MUST accept all valid HTTP requests to the publisher
-   location. The server, when sent a publisher request, MUST satisfy all
-   of the following conditions:
-     * GET requests receive a 200 OK response for existing channels and a
-       404 Not Found otherwise.
-     * PUT requests receive a 200 OK response. The request creates a
-       channel if no channel with the given channel id exists.
-     * DELETE requests receive a 200 OK if the channel identified by the
-       channel id exists and has been completely deleted. All subscribers
-       MUST have been sent a 410 Gone response. Requests for nonexistent
-       channels MUST be responded to with a 404 Not Found.
-     * POST requests are used to send messages. The request MAY contain a
-       body in any encoding representing a message to be sent over the
-       channel. The message MUST be immediately delivered to all currently
-       long-held subscriber requests. Additionally, the message MAY be
-       stored for future retrieval and the oldest message stored for the
-       channel MAY be deleted.
-       A POST request MUST be replied to with a 201 Created if there were
-       any long-held subscribers that have been sent this message, and
-       with a 202 Accepted otherwise.
-       The Content-Type header of the request MUST be forwarded with the
-       message.
-   Message storage limits SHOULD be configurable. publisher locations
-   SHOULD be configurable to allow foregoing message storage on POST
-   requests. All 200-level responses MUST, in the response body, contain
-   information about the applicable channel. This information MAY contain
-   the number of stored messages and the number of subscribers' requests
-   being long-held prior to this request. The server MAY implement a
-   content-negotiation scheme for this information.

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/ngx_http_push_defs.c DELETED

@@ -1,59 +0,0 @@
-#include <ngx_http.h>
-#include "ngx_http_push_defs.h"
-//string constants
-//headers
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_ETAG = ngx_string("Etag");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_IF_NONE_MATCH = ngx_string("If-None-Match");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_VARY = ngx_string("Vary");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_ALLOW = ngx_string("Allow");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_CACHE_CONTROL = ngx_string("Cache-Control");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_PRAGMA = ngx_string("Pragma");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_HEADERS = ngx_string("Access-Control-Allow-Headers");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_METHODS = ngx_string("Access-Control-Allow-Methods");
-const  ngx_str_t NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN = ngx_string("Access-Control-Allow-Origin");
-//header values
-const  ngx_str_t NGX_HTTP_PUSH_CACHE_CONTROL_VALUE = ngx_string("no-cache");
-//status strings
-const  ngx_str_t NGX_HTTP_PUSH_HTTP_STATUS_409 = ngx_string("409 Conflict");
-const  ngx_str_t NGX_HTTP_PUSH_HTTP_STATUS_410 = ngx_string("410 Gone");
-//other stuff
-const  ngx_str_t NGX_HTTP_PUSH_ANYSTRING= ngx_string("*");
-const  ngx_str_t NGX_HTTP_PUSH_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS = ngx_string("Content-Type, Origin");
-const  ngx_str_t NGX_HTTP_PUSH_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS = ngx_string("If-None-Match, If-Modified-Since, Origin");
-const  ngx_str_t NGX_HTTP_PUSH_ALLOW_GET_POST_PUT_DELETE_OPTIONS= ngx_string("GET, POST, PUT, DELETE, OPTIONS");
-const  ngx_str_t NGX_HTTP_PUSH_ALLOW_GET_OPTIONS= ngx_string("GET, OPTIONS");
-const  ngx_str_t NGX_HTTP_PUSH_VARY_HEADER_VALUE = ngx_string("If-None-Match, If-Modified-Since");
-const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_PLAIN = ngx_string(
-  "queued messages: %ui" CRLF
-  "last requested: %d sec. ago (-1=never)" CRLF
-  "active subscribers: %ui"
-  "\0");
-const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_JSON = ngx_string(
-  "{\"messages\": %ui, "
-  "\"requested\": %d, "
-  "\"subscribers\": %ui }"
-  "\0");
-const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_XML = ngx_string(
-  "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" CRLF
-  "<channel>" CRLF
-  "  <messages>%ui</messages>" CRLF
-  "  <requested>%d</requested>" CRLF
-  "  <subscribers>%ui</subscribers>" CRLF
-  "</channel>"
-  "\0");
-const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_YAML = ngx_string(
-  "---" CRLF
-  "messages: %ui" CRLF
-  "requested: %d" CRLF
-  "subscribers: %ui" CRLF
-  CRLF
-  "\0");

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/ngx_http_push_defs.h DELETED

@@ -1,73 +0,0 @@
-#define NGX_HTTP_PUSH_DEFAULT_SHM_SIZE 33554432 //32 megs
-#define NGX_HTTP_PUSH_DEFAULT_BUFFER_TIMEOUT 3600
-#define NGX_HTTP_PUSH_DEFAULT_SUBSCRIBER_TIMEOUT 0  //default: never timeout
-//(liucougar: this is a bit confusing, but it is what's the default behavior before this option is introducecd)
-#define NGX_HTTP_PUSH_DEFAULT_CHANNEL_TIMEOUT 5 //default: timeout in 5 seconds
-#define NGX_HTTP_PUSH_DEFAULT_MIN_MESSAGES 1
-#define NGX_HTTP_PUSH_DEFAULT_MAX_MESSAGES 10
-#define NGX_HTTP_PUSH_SUBSCRIBER_CONCURRENCY_LASTIN 0
-#define NGX_HTTP_PUSH_SUBSCRIBER_CONCURRENCY_FIRSTIN 1
-#define NGX_HTTP_PUSH_SUBSCRIBER_CONCURRENCY_BROADCAST 2
-#define NGX_HTTP_PUSH_MECHANISM_LONGPOLL 0
-#define NGX_HTTP_PUSH_MECHANISM_INTERVALPOLL 1
-#define NGX_HTTP_PUSH_MIN_MESSAGE_RECIPIENTS 0
-#define NGX_HTTP_PUSH_MAX_CHANNEL_ID_LENGTH 1024 //bytes
-#ifndef NGX_HTTP_CONFLICT
-#define NGX_HTTP_CONFLICT 409
-#endif
-#ifndef NGX_HTTP_GONE
-#define NGX_HTTP_GONE 410
-#endif
-#ifndef NGX_HTTP_CREATED
-#define NGX_HTTP_CREATED 201
-#endif
-#ifndef NGX_HTTP_ACCEPTED
-#define NGX_HTTP_ACCEPTED 202
-#endif
-#define NGX_HTTP_PUSH_MESSAGE_RECEIVED 9000
-#define NGX_HTTP_PUSH_MESSAGE_QUEUED   9001
-#define NGX_HTTP_PUSH_MESSAGE_FOUND     1000
-#define NGX_HTTP_PUSH_MESSAGE_EXPECTED  1001
-#define NGX_HTTP_PUSH_MESSAGE_EXPIRED   1002
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_ETAG;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_IF_NONE_MATCH;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_VARY;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_ALLOW;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_CACHE_CONTROL;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_PRAGMA;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_METHODS;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_HEADERS;
-extern const  ngx_str_t NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN;
-//header values
-extern const  ngx_str_t NGX_HTTP_PUSH_CACHE_CONTROL_VALUE;
-//status strings
-extern const  ngx_str_t NGX_HTTP_PUSH_HTTP_STATUS_409;
-extern const  ngx_str_t NGX_HTTP_PUSH_HTTP_STATUS_410;
-//other stuff
-extern const ngx_str_t NGX_HTTP_PUSH_ANYSTRING;
-extern const ngx_str_t NGX_HTTP_PUSH_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS;
-extern const ngx_str_t NGX_HTTP_PUSH_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS;
-extern const ngx_str_t NGX_HTTP_PUSH_ALLOW_GET_POST_PUT_DELETE_OPTIONS;
-extern const ngx_str_t NGX_HTTP_PUSH_ALLOW_GET_OPTIONS;
-extern const ngx_str_t NGX_HTTP_PUSH_VARY_HEADER_VALUE;
-extern const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_PLAIN;
-extern const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_JSON;
-extern const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_XML;
-extern const ngx_str_t NGX_HTTP_PUSH_CHANNEL_INFO_YAML;

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/ngx_http_push_module.c DELETED

@@ -1,783 +0,0 @@
-/*
- *  Copyright 2009 Leo Ponomarev.
- */
-#include <ngx_http_push_module.h>
-#include <store/memory/store.h>
-#include <ngx_http_push_module_setup.c>
-ngx_int_t           ngx_http_push_worker_processes;
-ngx_pool_t         *ngx_http_push_pool;
-ngx_module_t        ngx_http_push_module;
-ngx_http_push_store_t *ngx_http_push_store = &ngx_http_push_store_memory;
-ngx_int_t ngx_http_push_respond_status_only(ngx_http_request_t *r, ngx_int_t status_code, const ngx_str_t *statusline) {
-  r->headers_out.status=status_code;
-  if(statusline!=NULL) {
-    r->headers_out.status_line.len =statusline->len;
-    r->headers_out.status_line.data=statusline->data;
-  }
-  r->headers_out.content_length_n = 0;
-  r->header_only = 1;
-  return ngx_http_send_header(r);
-}
-void ngx_http_push_clean_timeouted_subscriber(ngx_event_t *ev)
-{
-  ngx_http_push_subscriber_t *subscriber = NULL;
-  ngx_http_request_t *r = NULL;
-  subscriber = ev->data;
-  r = subscriber->request;
-  if (r->connection->destroyed) {
-    return;
-  }
-  ngx_int_t rc = ngx_http_push_respond_status_only(r, NGX_HTTP_NOT_MODIFIED, NULL);
-  ngx_http_finalize_request(r, rc);
-  //the subscriber and channel counter will be freed by the pool cleanup callback
-}
-void ngx_http_push_subscriber_del_timer(ngx_http_push_subscriber_t *sb) {
-  if (sb->event.timer_set) {
-    ngx_del_timer(&sb->event);
-  }
-}
-void ngx_http_push_subscriber_clear_ctx(ngx_http_push_subscriber_t *sb) {
-  ngx_http_push_subscriber_del_timer(sb);
-  sb->clndata->subscriber = NULL;
-  sb->clndata->channel = NULL;
-}
-#define NGX_HTTP_BUF_ALLOC_SIZE(buf)                                          \
-(sizeof(*buf) +                                                           \
-(((buf)->temporary || (buf)->memory) ? ngx_buf_size(buf) : 0) +          \
-(((buf)->file!=NULL) ? (sizeof(*(buf)->file) + (buf)->file->name.len + 1) : 0))
-//buffer is _copied_
-ngx_chain_t * ngx_http_push_create_output_chain(ngx_buf_t *buf, ngx_pool_t *pool, ngx_log_t *log) {
-  ngx_chain_t                    *out;
-  ngx_file_t                     *file;
-  if((out = ngx_pcalloc(pool, sizeof(*out)))==NULL) {
-    return NULL;
-  }
-  ngx_buf_t                      *buf_copy;
-  if((buf_copy = ngx_pcalloc(pool, NGX_HTTP_BUF_ALLOC_SIZE(buf)))==NULL) {
-    return NULL;
-  }
-  ngx_http_push_copy_preallocated_buffer(buf, buf_copy);
-  if (buf->file!=NULL) {
-    file = buf_copy->file;
-    file->log=log;
-    if(file->fd==NGX_INVALID_FILE) {
-      file->fd=ngx_open_file(file->name.data, NGX_FILE_RDONLY, NGX_FILE_OPEN, NGX_FILE_OWNER_ACCESS);
-    }
-    if(file->fd==NGX_INVALID_FILE) {
-      return NULL;
-    }
-  }
-  buf_copy->last_buf = 1;
-  out->buf = buf_copy;
-  out->next = NULL;
-  return out;
-}
-#define NGX_HTTP_PUSH_NO_CHANNEL_ID_MESSAGE "No channel id provided."
-static ngx_str_t * ngx_http_push_get_channel_id(ngx_http_request_t *r, ngx_http_push_loc_conf_t *cf) {
-  ngx_http_variable_value_t      *vv = ngx_http_get_indexed_variable(r, cf->index);
-  ngx_str_t                      *group = &cf->channel_group;
-  size_t                          group_len = group->len;
-  size_t                          var_len;
-  size_t                          len;
-  ngx_str_t                      *id;
-    if (vv == NULL || vv->not_found || vv->len == 0) {
-        ngx_buf_t *buf = ngx_create_temp_buf(r->pool, sizeof(NGX_HTTP_PUSH_NO_CHANNEL_ID_MESSAGE));
-    ngx_chain_t *chain;
-    if(buf==NULL) {
-      return NULL;
-    }
-    buf->pos=(u_char *)NGX_HTTP_PUSH_NO_CHANNEL_ID_MESSAGE;
-    buf->last=buf->pos + sizeof(NGX_HTTP_PUSH_NO_CHANNEL_ID_MESSAGE)-1;
-    chain = ngx_http_push_create_output_chain(buf, r->pool, r->connection->log);
-    buf->last_buf=1;
-    r->headers_out.content_length_n=ngx_buf_size(buf);
-    r->headers_out.status=NGX_HTTP_NOT_FOUND;
-    r->headers_out.content_type.len = sizeof("text/plain") - 1;
-    r->headers_out.content_type.data = (u_char *) "text/plain";
-    r->headers_out.content_type_len = r->headers_out.content_type.len;
-    ngx_http_send_header(r);
-    ngx_http_output_filter(r, chain);
-    ngx_log_error(NGX_LOG_WARN, r->connection->log, 0,
-            "push module: the $push_channel_id variable is required but is not set");
-    return NULL;
-    }
-  //maximum length limiter for channel id
-  var_len = vv->len <= cf->max_channel_id_length ? vv->len : cf->max_channel_id_length;
-  len = group_len + 1 + var_len;
-  if((id = ngx_palloc(r->pool, sizeof(*id) + len))==NULL) {
-    ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-            "push module: unable to allocate memory for $push_channel_id string");
-    return NULL;
-  }
-  id->len=len;
-  id->data=(u_char *)(id+1);
-  ngx_memcpy(id->data, group->data, group_len);
-  id->data[group_len]='/';
-  ngx_memcpy(id->data + group_len + 1, vv->data, var_len);
-  return id;
-}
-ngx_table_elt_t * ngx_http_push_add_response_header(ngx_http_request_t *r, const ngx_str_t *header_name, const ngx_str_t *header_value) {
-  ngx_table_elt_t                *h = ngx_list_push(&r->headers_out.headers);
-  if (h == NULL) {
-    return NULL;
-  }
-  h->hash = 1;
-  h->key.len = header_name->len;
-  h->key.data = header_name->data;
-  h->value.len = header_value->len;
-  h->value.data = header_value->data;
-  return h;
-}
-static ngx_str_t * ngx_http_push_find_in_header_value(ngx_http_request_t * r, ngx_str_t header_name) {
-  ngx_uint_t                       i;
-  ngx_list_part_t                 *part = &r->headers_in.headers.part;
-  ngx_table_elt_t                 *header= part->elts;
-  for (i = 0; /* void */ ; i++) {
-    if (i >= part->nelts) {
-      if (part->next == NULL) {
-        break;
-      }
-      part = part->next;
-      header = part->elts;
-      i = 0;
-    }
-    if (header[i].key.len == header_name.len
-      && ngx_strncasecmp(header[i].key.data, header_name.data, header[i].key.len) == 0) {
-      return &header[i].value;
-      }
-  }
-  return NULL;
-}
-ngx_int_t ngx_http_push_allow_caching(ngx_http_request_t * r) {
-  ngx_str_t *tmp_header;
-  ngx_str_t header_checks[2] = { NGX_HTTP_PUSH_HEADER_CACHE_CONTROL, NGX_HTTP_PUSH_HEADER_PRAGMA };
-  ngx_int_t i = 0;
-  for(; i < 2; i++) {
-    tmp_header = ngx_http_push_find_in_header_value(r, header_checks[i]);
-    if (tmp_header != NULL) {
-      return !!ngx_strncasecmp(tmp_header->data, NGX_HTTP_PUSH_CACHE_CONTROL_VALUE.data, tmp_header->len);
-    }
-  }
-  return 1;
-}
-void ngx_http_push_subscriber_cleanup(ngx_http_push_subscriber_cleanup_t *data) {
-  if(data->subscriber!=NULL) { //still queued up
-    ngx_http_push_subscriber_t* sb = data->subscriber;
-    ngx_http_push_subscriber_del_timer(sb);
-    ngx_queue_remove(&data->subscriber->queue);
-    ngx_pfree(ngx_http_push_pool, data->subscriber); //was there an error? oh whatever.
-  }
-  if (data->rchain != NULL) {
-    ngx_pfree(data->rpool, data->rchain->buf);
-    ngx_pfree(data->rpool, data->rchain);
-    data->rchain=NULL;
-  }
-  if(data->buf_use_count != NULL && --(*data->buf_use_count) <= 0) {
-    ngx_buf_t                      *buf;
-    ngx_pfree(ngx_http_push_pool, data->buf_use_count);
-    buf=data->buf;
-    if(buf->file) {
-      ngx_close_file(buf->file->fd);
-    }
-    ngx_pfree(ngx_http_push_pool, buf);
-  }
-  if(data->channel!=NULL) { //we're expected to decrement the subscriber count
-    ngx_http_push_store->lock();
-    data->channel->subscribers--;
-    ngx_http_push_store->unlock();
-  }
-}
-ngx_str_t * ngx_http_push_subscriber_get_etag(ngx_http_request_t * r) {
-  ngx_uint_t                       i;
-  ngx_list_part_t                 *part = &r->headers_in.headers.part;
-  ngx_table_elt_t                 *header= part->elts;
-  for (i = 0; /* void */ ; i++) {
-    if (i >= part->nelts) {
-      if (part->next == NULL) {
-        break;
-      }
-      part = part->next;
-      header = part->elts;
-      i = 0;
-    }
-    if (header[i].key.len == NGX_HTTP_PUSH_HEADER_IF_NONE_MATCH.len
-      && ngx_strncasecmp(header[i].key.data, NGX_HTTP_PUSH_HEADER_IF_NONE_MATCH.data, header[i].key.len) == 0) {
-      return &header[i].value;
-      }
-  }
-  return NULL;
-}
-ngx_int_t ngx_http_push_subscriber_get_msg_id(ngx_http_request_t *r, ngx_http_push_msg_id_t *id) {
-  ngx_str_t                      *if_none_match = ngx_http_push_subscriber_get_etag(r);
-  ngx_int_t                       tag=0;
-  id->time=(r->headers_in.if_modified_since == NULL) ? 0 : ngx_http_parse_time(r->headers_in.if_modified_since->value.data, r->headers_in.if_modified_since->value.len);
-  if(if_none_match==NULL || (if_none_match!=NULL && (tag = ngx_atoi(if_none_match->data, if_none_match->len))==NGX_ERROR)) {
-    tag=0;
-  }
-  id->tag=ngx_abs(tag);
-  return NGX_OK;
-}
-//allocates nothing
-ngx_int_t ngx_http_push_prepare_response_to_subscriber_request(ngx_http_request_t *r, ngx_chain_t *chain, ngx_str_t *content_type, ngx_str_t *etag, time_t last_modified) {
-  ngx_int_t                      res;
-  if (content_type!=NULL) {
-    r->headers_out.content_type.len=content_type->len;
-    r->headers_out.content_type.data = content_type->data;
-    r->headers_out.content_type_len = r->headers_out.content_type.len;
-  }
-  if(last_modified) {
-    //if-modified-since header
-    r->headers_out.last_modified_time=last_modified;
-  }
-  if(etag!=NULL) {
-    //etag, if we need one
-    if ((ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ETAG, etag))==NULL) {
-      return NGX_HTTP_INTERNAL_SERVER_ERROR;
-    }
-  }
-  //Vary header needed for proper HTTP caching.
-  ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_VARY, &NGX_HTTP_PUSH_VARY_HEADER_VALUE);
-  r->headers_out.status=NGX_HTTP_OK;
-  //we know the entity length, and we're using just one buffer. so no chunking please.
-  r->headers_out.content_length_n=ngx_buf_size(chain->buf);
-  if((res = ngx_http_send_header(r)) >= NGX_HTTP_SPECIAL_RESPONSE) {
-    return res;
-  }
-  return ngx_http_output_filter(r, chain);
-}
-//allocates message and responds to subscriber
-ngx_int_t ngx_http_push_alloc_for_subscriber_response(ngx_pool_t *pool, ngx_int_t shared, ngx_http_push_msg_t *msg, ngx_chain_t **chain, ngx_str_t **content_type, ngx_str_t **etag, time_t *last_modified) {
-  if(etag != NULL && (*etag = ngx_http_push_store->message_etag(msg, pool))==NULL) {
-    //oh, nevermind...
-    ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate memory for Etag header");
-    return NGX_ERROR;
-  }
-  if(content_type != NULL && (*content_type= ngx_http_push_store->message_content_type(msg, pool))==NULL) {
-    //oh, nevermind...
-    ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate memory for Content Type header");
-    if(pool == NULL) {
-      ngx_free(*etag);
-    }
-    else {
-      ngx_pfree(pool, *etag);
-    }
-    return NGX_ERROR;
-  }
-  //preallocate output chain. yes, same one for every waiting subscriber
-  if(chain != NULL && (*chain = ngx_http_push_create_output_chain(msg->buf, pool, ngx_cycle->log))==NULL) {
-    ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate buffer chain while responding to subscriber request");
-    if(pool == NULL) {
-      ngx_free(*etag);
-      ngx_free(*content_type);
-    }
-    else {
-      ngx_pfree(pool, *etag);
-      ngx_pfree(pool, *content_type);
-    }
-    return NGX_ERROR;
-  }
-  if(last_modified != NULL) {
-    *last_modified = msg->message_time;
-  }
-  ngx_http_push_store->unlock();
-  if(pool!=NULL && shared == 0 && ((*chain)->buf->file!=NULL)) {
-    //close file when we're done with it
-    ngx_pool_cleanup_t *cln;
-    ngx_pool_cleanup_file_t *clnf;
-    if((cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t)))==NULL) {
-      ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate buffer chain pool cleanup while responding to subscriber request");
-      ngx_pfree(pool, *etag);
-      ngx_pfree(pool, *content_type);
-      ngx_pfree(pool, *chain);
-      return NGX_ERROR;
-    }
-    cln->handler = ngx_pool_cleanup_file;
-    clnf = cln->data;
-    clnf->fd = (*chain)->buf->file->fd;
-    clnf->name = (*chain)->buf->file->name.data;
-    clnf->log = ngx_cycle->log;
-  }
-  return NGX_OK;
-}
-static void ngx_http_push_match_channel_info_subtype(size_t off, u_char *cur, size_t rem, u_char **priority, const ngx_str_t **format, ngx_str_t *content_type) {
-  static ngx_http_push_content_subtype_t subtypes[] = {
-    { "json"  , 4, &NGX_HTTP_PUSH_CHANNEL_INFO_JSON },
-    { "yaml"  , 4, &NGX_HTTP_PUSH_CHANNEL_INFO_YAML },
-    { "xml"   , 3, &NGX_HTTP_PUSH_CHANNEL_INFO_XML  },
-    { "x-json", 6, &NGX_HTTP_PUSH_CHANNEL_INFO_JSON },
-    { "x-yaml", 6, &NGX_HTTP_PUSH_CHANNEL_INFO_YAML }
-  };
-  u_char                         *start = cur + off;
-  ngx_uint_t                      i;
-  for(i=0; i<(sizeof(subtypes)/sizeof(ngx_http_push_content_subtype_t)); i++) {
-    if(ngx_strncmp(start, subtypes[i].subtype, rem<subtypes[i].len ? rem : subtypes[i].len)==0) {
-      if(*priority>start) {
-        *format = subtypes[i].format;
-        *priority = start;
-        content_type->data=cur;
-        content_type->len= off + 1 + subtypes[i].len;
-      }
-    }
-  }
-}
-//print information about a channel
-static ngx_int_t ngx_http_push_channel_info(ngx_http_request_t *r, ngx_uint_t messages, ngx_uint_t subscribers, time_t last_seen) {
-  ngx_buf_t                      *b;
-  ngx_uint_t                      len;
-  ngx_str_t                       content_type = ngx_string("text/plain");
-  const ngx_str_t                *format = &NGX_HTTP_PUSH_CHANNEL_INFO_PLAIN;
-  time_t                          time_elapsed = ngx_time() - last_seen;
-  if(r->headers_in.accept) {
-    //lame content-negotiation (without regard for qvalues)
-    u_char                    *accept = r->headers_in.accept->value.data;
-    size_t                     len = r->headers_in.accept->value.len;
-    size_t                     rem;
-    u_char                    *cur = accept;
-    u_char                    *priority=&accept[len-1];
-    for(rem=len; (cur = ngx_strnstr(cur, "text/", rem))!=NULL; cur += sizeof("text/")-1) {
-      rem=len - ((size_t)(cur-accept)+sizeof("text/")-1);
-      if(ngx_strncmp(cur+sizeof("text/")-1, "plain", rem<5 ? rem : 5)==0) {
-        if(priority) {
-          format = &NGX_HTTP_PUSH_CHANNEL_INFO_PLAIN;
-          priority = cur+sizeof("text/")-1;
-          //content-type is already set by default
-        }
-      }
-      ngx_http_push_match_channel_info_subtype(sizeof("text/")-1, cur, rem, &priority, &format, &content_type);
-    }
-    cur = accept;
-    for(rem=len; (cur = ngx_strnstr(cur, "application/", rem))!=NULL; cur += sizeof("application/")-1) {
-      rem=len - ((size_t)(cur-accept)+sizeof("application/")-1);
-      ngx_http_push_match_channel_info_subtype(sizeof("application/")-1, cur, rem, &priority, &format, &content_type);
-    }
-  }
-  r->headers_out.content_type.len = content_type.len;
-  r->headers_out.content_type.data = content_type.data;
-  r->headers_out.content_type_len = r->headers_out.content_type.len;
-  len = format->len - 8 - 1 + 3*NGX_INT_T_LEN; //minus 8 sprintf
-  if ((b = ngx_create_temp_buf(r->pool, len)) == NULL) {
-    return NGX_HTTP_INTERNAL_SERVER_ERROR;
-  }
-  b->last = ngx_sprintf(b->last, (char *)format->data, messages, last_seen==0 ? -1 : (ngx_int_t) time_elapsed ,subscribers);
-  //lastly, set the content-length, because if the status code isn't 200, nginx may not do so automatically
-  r->headers_out.content_length_n = ngx_buf_size(b);
-  if (ngx_http_send_header(r) > NGX_HTTP_SPECIAL_RESPONSE) {
-    return NGX_HTTP_INTERNAL_SERVER_ERROR;
-  }
-  return ngx_http_output_filter(r, ngx_http_push_create_output_chain(b, r->pool, r->connection->log));
-}
-#define NGX_HTTP_PUSH_MAKE_CONTENT_TYPE(content_type, content_type_len, msg, pool)  \
-    if(((content_type) = ngx_palloc(pool, sizeof(*content_type)+content_type_len))!=NULL) { \
-        (content_type)->len=content_type_len;                                        \
-        (content_type)->data=(u_char *)((content_type)+1);                           \
-        ngx_memcpy(content_type->data, (msg)->content_type.data, content_type_len);  \
-    }
-#define NGX_HTTP_PUSH_OPTIONS_OK_MESSAGE "Go ahead"
-ngx_int_t ngx_push_longpoll_subscriber_enqueue(ngx_http_push_channel_t *channel, ngx_http_push_subscriber_t *subscriber, ngx_int_t subscriber_timeout) {
-  ngx_http_cleanup_t                 *cln;
-  ngx_http_push_subscriber_cleanup_t *clndata;
-  ngx_http_request_t                 *r = subscriber->request;
-  //attach a cleaner to remove the request from the channel and handle shared buffer deallocation.
-  if ((cln=ngx_http_cleanup_add(r, sizeof(*clndata))) == NULL) { //make sure we can.
-    return NGX_ERROR;
-  }
-  cln->handler = (ngx_http_cleanup_pt) ngx_http_push_subscriber_cleanup;
-  clndata = (ngx_http_push_subscriber_cleanup_t *) cln->data;
-  clndata->channel=channel;
-  clndata->subscriber=subscriber;
-  clndata->buf_use_count=0;
-  clndata->buf=NULL;
-  clndata->rchain=NULL;
-  clndata->rpool=NULL;
-  subscriber->clndata=clndata;
-  //set up subscriber timeout event
-  ngx_memzero(&subscriber->event, sizeof(subscriber->event));
-  if (subscriber_timeout > 0) {
-    subscriber->event.handler = ngx_http_push_clean_timeouted_subscriber;
-    subscriber->event.data = subscriber;
-    subscriber->event.log = r->connection->log;
-    ngx_add_timer(&subscriber->event, subscriber_timeout * 1000);
-  }
-  r->read_event_handler = ngx_http_test_reading;
-  r->write_event_handler = ngx_http_request_empty_handler;
-  r->main->count++; //this is the right way to hold and finalize the request... maybe
-  //r->keepalive = 1; //stayin' alive!!
-  return NGX_OK;
-}
-/*
-ngx_int_t ngx_push_longpoll_subscriber_dequeue(ngx_http_push_subscriber_t *subscriber) {
-  return NGX_OK;
-}
-*/
-static ngx_int_t ngx_http_push_response_channel_ptr_info(ngx_http_push_channel_t *channel, ngx_http_request_t *r, ngx_int_t status_code) {
-  time_t             last_seen = 0;
-  ngx_uint_t         subscribers = 0;
-  ngx_uint_t         messages = 0;
-  if(channel!=NULL) {
-    ngx_http_push_store->lock();
-    subscribers = channel->subscribers;
-    last_seen = channel->last_seen;
-    messages  = channel->messages;
-    ngx_http_push_store->unlock();
-    r->headers_out.status = status_code == (ngx_int_t) NULL ? NGX_HTTP_OK : status_code;
-    if (status_code == NGX_HTTP_CREATED) {
-      r->headers_out.status_line.len =sizeof("201 Created")- 1;
-      r->headers_out.status_line.data=(u_char *) "201 Created";
-    }
-    else if (status_code == NGX_HTTP_ACCEPTED) {
-      r->headers_out.status_line.len =sizeof("202 Accepted")- 1;
-      r->headers_out.status_line.data=(u_char *) "202 Accepted";
-    }
-    ngx_http_push_channel_info(r, messages, subscribers, last_seen);
-  }
-  else {
-    //404!
-    r->headers_out.status=NGX_HTTP_NOT_FOUND;
-    //just the headers, please. we don't care to describe the situation or
-    //respond with an html page
-    r->headers_out.content_length_n=0;
-    r->header_only = 1;
-    ngx_http_send_header(r);
-  }
-  return NGX_OK;
-}
-static ngx_int_t ngx_http_push_response_channel_info(ngx_str_t *channel_id, ngx_http_request_t *r, ngx_int_t status_code) {
-  ngx_http_push_channel_t        *channel;
-  ngx_http_push_loc_conf_t       *cf = ngx_http_get_module_loc_conf(r, ngx_http_push_module);
-  channel = channel_id == NULL ? NULL : ngx_http_push_store->find_channel(channel_id, cf->channel_timeout, NULL);
-  return ngx_http_push_response_channel_ptr_info(channel, r, status_code);
-}
-static ngx_int_t subscribe_longpoll_callback(ngx_int_t status, ngx_http_request_t *r) {
-  ngx_http_finalize_request(r, status);
-  return NGX_OK;
-}
-static ngx_int_t subscribe_intervalpoll_callback(ngx_http_push_msg_t *msg, ngx_int_t msg_search_outcome, ngx_http_request_t *r) {
-  ngx_chain_t                *chain;
-  ngx_str_t                  *content_type, *etag;
-  time_t                     last_modified;
-  switch(msg_search_outcome) {
-    case NGX_HTTP_PUSH_MESSAGE_EXPECTED:
-      //interval-polling subscriber requests get a 304 with their entity tags preserved.
-      if (r->headers_in.if_modified_since != NULL) {
-        r->headers_out.last_modified_time=ngx_http_parse_time(r->headers_in.if_modified_since->value.data, r->headers_in.if_modified_since->value.len);
-      }
-      if ((etag=ngx_http_push_subscriber_get_etag(r)) != NULL) {
-        ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ETAG, etag);
-      }
-      ngx_http_finalize_request(r, NGX_HTTP_NOT_MODIFIED);
-      return NGX_OK;
-    case NGX_HTTP_PUSH_MESSAGE_FOUND:
-      ngx_http_push_alloc_for_subscriber_response(r->pool, 0, msg, &chain, &content_type, &etag, &last_modified);
-      ngx_http_push_prepare_response_to_subscriber_request(r, chain, content_type, etag, last_modified);
-      ngx_http_push_store->release_message(NULL, msg);
-      ngx_http_finalize_request(r, NGX_OK);
-      return NGX_OK;
-    default:
-      ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
-      return NGX_ERROR;
-  }
-}
-ngx_int_t ngx_http_push_subscriber_handler(ngx_http_request_t *r) {
-  ngx_http_push_loc_conf_t       *cf = ngx_http_get_module_loc_conf(r, ngx_http_push_module);
-  ngx_str_t                      *channel_id;
-  ngx_http_push_msg_id_t          msg_id;
-  if((channel_id=ngx_http_push_get_channel_id(r, cf)) == NULL) {
-    return r->headers_out.status ? NGX_OK : NGX_HTTP_INTERNAL_SERVER_ERROR;
-  }
-  switch(r->method) {
-    case NGX_HTTP_GET:
-      ngx_http_push_subscriber_get_msg_id(r, &msg_id);
-      r->main->count++; //let it linger until callback
-      switch(cf->subscriber_poll_mechanism) {
-        ngx_int_t                       msg_search_outcome;
-        //for NGX_HTTP_PUSH_MECHANISM_LONGPOLL
-        case NGX_HTTP_PUSH_MECHANISM_INTERVALPOLL:
-          ngx_http_push_store->get_message(channel_id, &msg_id, &msg_search_outcome, r, &subscribe_intervalpoll_callback);
-          break;
-        case NGX_HTTP_PUSH_MECHANISM_LONGPOLL:
-          ngx_http_push_store->subscribe(channel_id, &msg_id, r, &subscribe_longpoll_callback);
-          break;
-      }
-      return NGX_DONE;
-    case NGX_HTTP_OPTIONS:
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,  &NGX_HTTP_PUSH_ANYSTRING);
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_HEADERS, &NGX_HTTP_PUSH_ACCESS_CONTROL_ALLOWED_SUBSCRIBER_HEADERS);
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_METHODS, &NGX_HTTP_PUSH_ALLOW_GET_OPTIONS);
-      r->headers_out.content_length_n = 0;
-      r->header_only = 1;
-      r->headers_out.status=NGX_HTTP_OK;
-      ngx_http_send_header(r);
-      return NGX_OK;
-    default:
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ALLOW, &NGX_HTTP_PUSH_ALLOW_GET_OPTIONS); //valid HTTP for the win
-      return NGX_HTTP_NOT_ALLOWED;
-  }
-}
-static ngx_int_t publish_callback(ngx_int_t status, ngx_http_push_channel_t *ch, ngx_http_request_t *r) {
-  switch(status) {
-    case NGX_HTTP_PUSH_MESSAGE_QUEUED:
-      //message was queued successfully, but there were no subscribers to receive it.
-      ngx_http_finalize_request(r, ngx_http_push_response_channel_ptr_info(ch, r, NGX_HTTP_ACCEPTED));
-      return NGX_OK;
-    case NGX_HTTP_PUSH_MESSAGE_RECEIVED:
-      //message was queued successfully, and it was already sent to at least one subscriber
-      ngx_http_finalize_request(r, ngx_http_push_response_channel_ptr_info(ch, r, NGX_HTTP_CREATED));
-      return NGX_OK;
-    case NGX_ERROR:
-      //WTF?
-      ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push module: error broadcasting message to workers");
-      ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
-      return NGX_ERROR;
-    default:
-      //for debugging, mostly. I don't expect this branch to behit during regular operation
-      ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push module: TOTALLY UNEXPECTED error broadcasting message to workers");
-      ngx_http_finalize_request(r, NGX_HTTP_INTERNAL_SERVER_ERROR);
-      return NGX_ERROR;
-  }
-}
-static void ngx_http_push_publisher_body_handler(ngx_http_request_t * r) {
-  ngx_str_t                      *channel_id;
-  ngx_http_push_loc_conf_t       *cf = ngx_http_get_module_loc_conf(r, ngx_http_push_module);
-  ngx_uint_t                      method = r->method;
-  if((channel_id = ngx_http_push_get_channel_id(r, cf))==NULL) {
-    ngx_http_finalize_request(r, r->headers_out.status ? NGX_OK : NGX_HTTP_INTERNAL_SERVER_ERROR);
-    return;
-  }
-  switch(method) {
-    case NGX_HTTP_POST:
-    case NGX_HTTP_PUT:
-      ngx_http_push_store->publish(channel_id, r, &publish_callback);
-      break;
-    case NGX_HTTP_DELETE:
-      ngx_http_finalize_request(r, ngx_http_push_response_channel_info(channel_id, r, NGX_HTTP_OK));
-      ngx_http_push_store->delete_channel(channel_id);
-      break;
-    case NGX_HTTP_GET:
-      ngx_http_finalize_request(r, ngx_http_push_response_channel_info(channel_id, r, NGX_HTTP_OK));
-      break;
-    case NGX_HTTP_OPTIONS:
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN, &NGX_HTTP_PUSH_ANYSTRING);
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,  &NGX_HTTP_PUSH_ACCESS_CONTROL_ALLOWED_PUBLISHER_HEADERS);
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ACCESS_CONTROL_ALLOW_METHODS, &NGX_HTTP_PUSH_ALLOW_GET_POST_PUT_DELETE_OPTIONS);
-      r->header_only = 1;
-      r->headers_out.content_length_n = 0;
-      r->headers_out.status=NGX_HTTP_OK;
-      ngx_http_send_header(r);
-      ngx_http_finalize_request(r, NGX_HTTP_OK);
-      break;
-    default:
-      //some other weird request method
-      ngx_http_push_add_response_header(r, &NGX_HTTP_PUSH_HEADER_ALLOW, &NGX_HTTP_PUSH_ALLOW_GET_POST_PUT_DELETE_OPTIONS);
-      ngx_http_finalize_request(r, NGX_HTTP_NOT_ALLOWED);
-      break;
-  }
-}
-ngx_int_t ngx_http_push_respond_to_subscribers(ngx_http_push_channel_t *channel, ngx_http_push_subscriber_t *sentinel, ngx_http_push_msg_t *msg, ngx_int_t status_code, const ngx_str_t *status_line) {
-  //copy everything we need first
-  ngx_str_t                  *content_type=NULL;
-  ngx_str_t                  *etag=NULL;
-  time_t                      last_modified = 0;
-  ngx_chain_t                *chain=NULL;
-  ngx_http_request_t         *r;
-  ngx_buf_t                  *buffer = NULL;
-  ngx_chain_t                *rchain;
-  ngx_buf_t                  *rbuffer;
-  ngx_int_t                  *buf_use_count = NULL;
-  ngx_http_push_subscriber_cleanup_t *clndata;
-  ngx_http_push_subscriber_t *cur=NULL;
-  ngx_int_t                   responded_subscribers=0;
-  if(sentinel==NULL) {
-    //ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "respond_to_subscribers with sentinel==NULL");
-    return NGX_OK;
-  }
-  if(msg!=NULL) {
-    if(ngx_http_push_alloc_for_subscriber_response(ngx_http_push_pool, 1, msg, &chain, &content_type, &etag, &last_modified)==NGX_ERROR) {
-      ngx_http_push_store->release_message(channel, msg);
-      return NGX_ERROR;
-    }
-    buffer = chain->buf;
-    buffer->recycled = 1;
-    buf_use_count = ngx_pcalloc(ngx_http_push_pool, sizeof(*buf_use_count));
-    *buf_use_count = ngx_http_push_store->channel_worker_subscribers(sentinel);
-  }
-  while((cur=ngx_http_push_store->next_subscriber(channel, sentinel, cur, 1))!=NULL) {
-    //in this block, nothing in shared memory should be dereferenced.
-    r=cur->request;
-    if(msg!=NULL) {
-      //chain and buffer for this request
-      rchain = ngx_pcalloc(r->pool, sizeof(*rchain));
-      rchain->next = NULL;
-      rbuffer = ngx_pcalloc(r->pool, sizeof(*rbuffer));
-      rchain->buf = rbuffer;
-      ngx_memcpy(rbuffer, buffer, sizeof(*buffer));
-      //request buffer cleanup
-      clndata = cur->clndata;
-      clndata->buf = buffer;
-      clndata->buf_use_count = buf_use_count;
-      clndata->rchain = rchain;
-      clndata->rpool = r->pool;
-      if (rbuffer->in_file && (fcntl(rbuffer->file->fd, F_GETFD) == -1)) {
-        ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "push module: buffer in invalid file descriptor");
-      }
-      //cleanup oughtn't dequeue anything. or decrement the subscriber count, for that matter
-      ngx_http_push_subscriber_clear_ctx(cur);
-      ngx_http_finalize_request(r, ngx_http_push_prepare_response_to_subscriber_request(r, rchain, content_type, etag, last_modified)); //BAM!
-    }
-    else {
-      ngx_http_push_subscriber_clear_ctx(cur);
-      ngx_http_finalize_request(r, ngx_http_push_respond_status_only(r, status_code, status_line));
-    }
-    responded_subscribers++;
-  }
-  if(msg!=NULL) {
-    ngx_http_push_store->release_message(channel, msg);
-    ngx_pfree(ngx_http_push_pool, etag);
-    ngx_pfree(ngx_http_push_pool, content_type);
-    ngx_pfree(ngx_http_push_pool, chain);
-  }
-  //ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "respond_to_subscribers with msg %p finished", msg);
-  ngx_http_push_store->lock();
-  channel->subscribers-=responded_subscribers;
-  //is the message still needed?
-  ngx_http_push_store->unlock();
-  ngx_http_push_store->release_subscriber_sentinel(channel, sentinel);
-  return NGX_OK;
-}
-ngx_int_t ngx_http_push_publisher_handler(ngx_http_request_t * r) {
-  ngx_int_t                       rc;
-  /* Instruct ngx_http_read_subscriber_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;
-  r->request_body_in_clean_file = 0;
-  r->request_body_file_log_level = 0;
-  rc = ngx_http_read_client_request_body(r, ngx_http_push_publisher_body_handler);
-  if (rc >= NGX_HTTP_SPECIAL_RESPONSE) {
-    return rc;
-  }
-  return NGX_DONE;
-}
-void ngx_http_push_copy_preallocated_buffer(ngx_buf_t *buf, ngx_buf_t *cbuf) {
-  if (cbuf!=NULL) {
-    ngx_memcpy(cbuf, buf, sizeof(*buf)); //overkill?
-    if(buf->temporary || buf->memory) { //we don't want to copy mmpapped memory, so no ngx_buf_in_momory(buf)
-      cbuf->pos = (u_char *) (cbuf+1);
-      cbuf->last = cbuf->pos + ngx_buf_size(buf);
-      cbuf->start=cbuf->pos;
-      cbuf->end = cbuf->start + ngx_buf_size(buf);
-      ngx_memcpy(cbuf->pos, buf->pos, ngx_buf_size(buf));
-      cbuf->memory=ngx_buf_in_memory_only(buf) ? 1 : 0;
-    }
-    if (buf->file!=NULL) {
-      cbuf->file = (ngx_file_t *) (cbuf+1) + ((buf->temporary || buf->memory) ? ngx_buf_size(buf) : 0);
-      cbuf->file->fd=NGX_INVALID_FILE;
-      cbuf->file->log=NULL;
-      cbuf->file->offset=buf->file->offset;
-      cbuf->file->sys_offset=buf->file->sys_offset;
-      cbuf->file->name.len=buf->file->name.len;
-      cbuf->file->name.data=(u_char *) (cbuf->file+1);
-      ngx_memcpy(cbuf->file->name.data, buf->file->name.data, buf->file->name.len);
-    }
-  }
-}