passenger 4.0.59 → 4.0.60

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/memory/store.h

@@ -0,0 +1 @@
+extern ngx_http_push_store_t  ngx_http_push_store_memory;

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/ngx_http_push_module_ipc.c

@@ -0,0 +1,146 @@
+//worker processes of the world, unite.
+#include <ngx_http_push_module.h>
+#include <ngx_channel.h>
+#include <store/ngx_http_push_module_ipc.h>
+
+static void ngx_http_push_channel_handler(ngx_event_t *ev);
+#define NGX_CMD_HTTP_PUSH_CHECK_MESSAGES 49
+
+static ngx_socket_t                       ngx_http_push_socketpairs[NGX_MAX_PROCESSES][2];
+ngx_int_t ngx_http_push_init_ipc(ngx_cycle_t *cycle, ngx_int_t workers) {
+//initialize socketpairs for workers in advance.
+    static int invalid_sockets_initialized = 0;
+    int                             i, s = 0, on = 1;
+    ngx_int_t                       last_expected_process = ngx_last_process;
+	
+    if(!invalid_sockets_initialized) {
+      for(i=0; i< NGX_MAX_PROCESSES; i++) {
+        ngx_http_push_socketpairs[i][0]=NGX_INVALID_FILE;
+        ngx_http_push_socketpairs[i][1]=NGX_INVALID_FILE;
+      }
+      invalid_sockets_initialized=1;
+    }
+    
+    /* here's the deal: we have no control over fork()ing, nginx's internal 
+     * socketpairs are unusable for our purposes (as of nginx 0.8 -- check the 
+     * code to see why), and the module initialization callbacks occur before
+     * any workers are spawned. Rather than futzing around with existing 
+     * socketpairs, we populate our own socketpairs array. 
+     * Trouble is, ngx_spawn_process() creates them one-by-one, and we need to 
+     * do it all at once. So we must guess all the workers' ngx_process_slots in 
+     * advance. Meaning the spawning logic must be copied to the T.
+     * ... with some allowances for already-opened sockets...
+     */
+	for(i=0; i < workers; i++) {
+		//copypasta from os/unix/ngx_process.c (ngx_spawn_process)
+        while (s < last_expected_process && ngx_processes[s].pid != -1) {
+          //find empty existing slot
+          s++;
+        }
+        ngx_socket_t               *socks = ngx_http_push_socketpairs[s];
+        if(socks[0] == NGX_INVALID_FILE || socks[1] == NGX_INVALID_FILE) {
+          //copypasta from os/unix/ngx_process.c (ngx_spawn_process)
+          if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "socketpair() failed on socketpair while initializing push module");
+            return NGX_ERROR;
+          }
+          if (ngx_nonblocking(socks[0]) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, ngx_nonblocking_n " failed on socketpair while initializing push module");
+            ngx_close_channel(socks, cycle->log);
+            return NGX_ERROR;
+          }
+          if (ngx_nonblocking(socks[1]) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, ngx_nonblocking_n " failed on socketpair while initializing push module");
+            ngx_close_channel(socks, cycle->log);
+            return NGX_ERROR;
+          }
+          if (ioctl(socks[0], FIOASYNC, &on) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "ioctl(FIOASYNC) failed on socketpair while initializing push module");
+            ngx_close_channel(socks, cycle->log);
+            return NGX_ERROR;
+          }
+          
+          if (fcntl(socks[0], F_SETOWN, ngx_pid) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "fcntl(F_SETOWN) failed on socketpair while initializing push module");
+            ngx_close_channel(socks, cycle->log);
+            return NGX_ERROR;
+          }
+          if (fcntl(socks[0], F_SETFD, FD_CLOEXEC) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "fcntl(FD_CLOEXEC) failed on socketpair while initializing push module");
+            ngx_close_channel(socks, cycle->log);
+            return NGX_ERROR;
+          }
+          
+          if (fcntl(socks[1], F_SETFD, FD_CLOEXEC) == -1) {
+            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "fcntl(FD_CLOEXEC) failed while initializing push module");
+            ngx_close_channel(socks, cycle->log);
+            return NGX_ERROR;
+          }
+        }
+        s++; //NEXT!!
+	}
+	return NGX_OK;
+}
+
+ngx_int_t ngx_http_push_shutdown_ipc(ngx_cycle_t *cycle) {
+  int i;
+  for (i=0; i<NGX_MAX_PROCESSES; i++) {
+    if(ngx_http_push_socketpairs[i][0] != NGX_INVALID_FILE || ngx_http_push_socketpairs[i][1] != NGX_INVALID_FILE) {
+      ngx_close_channel(ngx_http_push_socketpairs[i], cycle->log);
+    }
+  }
+  return NGX_OK;
+}
+
+void ngx_http_push_ipc_exit_worker(ngx_cycle_t *cycle) {
+  ngx_http_push_shutdown_ipc(cycle);
+}
+ 
+ngx_int_t ngx_http_push_ipc_init_worker(ngx_cycle_t *cycle) {
+    if (ngx_add_channel_event(cycle, ngx_http_push_socketpairs[ngx_process_slot][1], NGX_READ_EVENT, ngx_http_push_channel_handler) == NGX_ERROR) {
+		ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno, "failed to register channel handler while initializing push module worker");
+		return NGX_ERROR;
+	}
+	return NGX_OK;
+}
+
+static void ngx_http_push_channel_handler(ngx_event_t *ev) {
+	//copypasta from os/unix/ngx_process_cycle.c (ngx_channel_handler)
+	ngx_int_t          n;
+	ngx_channel_t      ch;
+	ngx_connection_t  *c;
+	if (ev->timedout) {
+		ev->timedout = 0;
+		return;
+	}
+	c = ev->data;
+	
+	while(1) {
+		n = ngx_read_channel(c->fd, &ch, sizeof(ch), ev->log);
+		if (n == NGX_ERROR) {
+			if (ngx_event_flags & NGX_USE_EPOLL_EVENT) {
+				ngx_del_conn(c, 0);
+			}
+			ngx_close_connection(c);
+			return;
+		}
+		if ((ngx_event_flags & NGX_USE_EVENTPORT_EVENT) && (ngx_add_event(ev, NGX_READ_EVENT, 0) == NGX_ERROR)) {
+			return;
+		}
+		if (n == NGX_AGAIN) {
+			return;
+		}
+		//ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0, "push module: channel command: %d", ch.command);
+
+		if (ch.command==NGX_CMD_HTTP_PUSH_CHECK_MESSAGES) {
+			ngx_http_push_store->receive_worker_message();
+		}
+	}
+}
+
+ngx_int_t ngx_http_push_alert_worker(ngx_pid_t pid, ngx_int_t slot) {
+	//seems ch doesn't need to have fd set. odd, but roll with it. pid and process slot also unnecessary.
+	static ngx_channel_t            ch = {NGX_CMD_HTTP_PUSH_CHECK_MESSAGES, 0, 0, -1};
+	return ngx_write_channel(ngx_http_push_socketpairs[slot][0], &ch, sizeof(ngx_channel_t), ngx_cycle->log);
+}
+

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/ngx_http_push_module_ipc.h

@@ -0,0 +1,5 @@
+ngx_int_t ngx_http_push_alert_worker(ngx_pid_t pid,ngx_int_t slot);
+ngx_int_t ngx_http_push_ipc_init_worker(ngx_cycle_t *cycle);
+void ngx_http_push_ipc_exit_worker(ngx_cycle_t *cycle);
+ngx_int_t ngx_http_push_shutdown_ipc(ngx_cycle_t *cycle);
+ngx_int_t ngx_http_push_init_ipc(ngx_cycle_t *cycle,ngx_int_t workers);

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/ngx_http_push_store.h

@@ -0,0 +1,51 @@
+typedef struct {
+  //init
+  ngx_int_t (*init_module)(ngx_cycle_t *cycle);
+  ngx_int_t (*init_worker)(ngx_cycle_t *cycle);
+  ngx_int_t (*init_postconfig)(ngx_conf_t *cf);
+  void      (*create_main_conf)(ngx_conf_t *cf, ngx_http_push_main_conf_t *mcf);
+  
+  //quit
+  void      (*exit_worker)(ngx_cycle_t *cycle);
+  void      (*exit_master)(ngx_cycle_t *cycle);
+  
+  
+  //async-friendly functions with callbacks
+  ngx_http_push_msg_t * (*get_message) (ngx_str_t *channel_id, ngx_http_push_msg_id_t *msg_id, ngx_int_t *msg_search_outcome, ngx_http_request_t *r, ngx_int_t (*callback)(ngx_http_push_msg_t *msg, ngx_int_t msg_search_outcome, ngx_http_request_t *r));
+  ngx_int_t             (*subscribe)   (ngx_str_t *channel_id, ngx_http_push_msg_id_t *msg_id, ngx_http_request_t *r, ngx_int_t (*callback)(ngx_int_t status, ngx_http_request_t *r));
+  ngx_int_t             (*publish)     (ngx_str_t *channel_id, ngx_http_request_t *r, ngx_int_t (*callback)(ngx_int_t status, ngx_http_push_channel_t *ch, ngx_http_request_t *r));
+  
+  //channel actions
+  ngx_http_push_channel_t *(*get_channel)(ngx_str_t *id, time_t channel_timeout, ngx_int_t (*callback)(ngx_http_push_channel_t *channel));
+  ngx_http_push_channel_t *(*find_channel)(ngx_str_t *id, time_t channel_timeout, ngx_int_t (*callback)(ngx_http_push_channel_t *channel));
+  
+  ngx_int_t (*delete_channel)(ngx_str_t *channel_id);
+  ngx_http_push_msg_t *(*get_channel_message)(ngx_http_push_channel_t *channel, ngx_http_push_msg_id_t *msgid, ngx_int_t *msg_search_outcome, ngx_http_push_loc_conf_t *cf);
+  
+  void (*reserve_message)(ngx_http_push_channel_t *channel, ngx_http_push_msg_t *msg);
+  void (*release_message)(ngx_http_push_channel_t *channel, ngx_http_push_msg_t *msg);
+  
+  //channel properties
+  ngx_int_t (*channel_subscribers)(ngx_http_push_channel_t * channel);
+  ngx_int_t (*channel_worker_subscribers)(ngx_http_push_subscriber_t * worker_sentinel);
+  ngx_http_push_subscriber_t *(*next_subscriber)(ngx_http_push_channel_t *channel, ngx_http_push_subscriber_t *sentinel, ngx_http_push_subscriber_t *cur, int release_previous);
+  ngx_int_t (*release_subscriber_sentinel)(ngx_http_push_channel_t *channel, ngx_http_push_subscriber_t *sentinel);
+  
+  void (*lock)(void); //legacy shared-memory store helpers
+  void (*unlock)(void);
+  void * (*alloc_locked)(size_t size, char * label);
+  void (*free_locked)(void *ptr);
+  
+  //message actions and properties
+  ngx_http_push_msg_t * (*create_message)(ngx_http_push_channel_t *channel, ngx_http_request_t *r);
+  ngx_int_t (*delete_message)(ngx_http_push_channel_t *channel, ngx_http_push_msg_t *msg, ngx_int_t force);
+  ngx_int_t (*delete_message_locked)(ngx_http_push_channel_t *channel, ngx_http_push_msg_t *msg, ngx_int_t force);
+  ngx_int_t (*enqueue_message)(ngx_http_push_channel_t *channel, ngx_http_push_msg_t *msg, ngx_http_push_loc_conf_t *cf);
+  ngx_str_t * (*message_etag)(ngx_http_push_msg_t *msg, ngx_pool_t *pool);
+  ngx_str_t * (*message_content_type)(ngx_http_push_msg_t *msg, ngx_pool_t *pool);
+  
+  //ipc
+  ngx_int_t (*send_worker_message)(ngx_http_push_channel_t *channel, ngx_http_push_subscriber_t *subscriber_sentinel, ngx_pid_t pid, ngx_int_t worker_slot, ngx_http_push_msg_t *msg, ngx_int_t status_code);
+  void (*receive_worker_message)(void);
+} ngx_http_push_store_t;
+

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/ngx_rwlock.c

@@ -0,0 +1,178 @@
+#include <ngx_http_push_module.h>
+#include "ngx_rwlock.h"
+
+#define NGX_RWLOCK_SPIN         2048
+#define NGX_RWLOCK_WRITE        -1
+
+#define DISABLE_RWLOCK 1  //just use a regular mutex for everything
+//#define DEBUG_NGX_RWLOCK 1
+
+void ngx_rwlock_init(ngx_rwlock_t *lock) {
+  lock->mutex=1;
+  lock->lock=0;
+  lock->write_pid=0;
+  lock->mutex=0;
+}
+
+static void rwl_lock_mutex(ngx_rwlock_t *lock) {
+  #if (NGX_HAVE_ATOMIC_OPS)
+  ngx_atomic_t  *mutex = &lock->mutex;
+  ngx_uint_t i, n;
+  for(;;) {
+    if(*mutex == 0 && ngx_atomic_cmp_set(mutex, 0, ngx_pid)) {
+      return;
+    }
+    if(ngx_ncpu > 1) {
+      for(n = 1; n < NGX_RWLOCK_SPIN; n <<= 1) {
+        for(i = 0; i < n; i++) {
+          ngx_cpu_pause();
+        }
+        #if (DEBUG_NGX_RWLOCK)
+        ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "rwlock %p mutex wait", lock);
+        #endif
+        if(*mutex == 0 && ngx_atomic_cmp_set(mutex, 0, ngx_pid)) {
+          return;
+        }
+      }
+    }
+    ngx_sched_yield();
+  }
+  #else
+  #if (NGX_THREADS)
+  #error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !
+  #endif
+  #endif
+}
+static void rwl_unlock_mutex(ngx_rwlock_t *lock) {
+  #if (NGX_HAVE_ATOMIC_OPS)
+  ngx_atomic_cmp_set(&lock->mutex, ngx_pid, 0);
+  #else
+  #if (NGX_THREADS)
+  #error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !
+  #endif
+  #endif
+}
+
+#define NGX_RWLOCK_MUTEX_COND(lock, cond, stmt)   \
+if(cond) {                                          \
+  rwl_lock_mutex(lock);                             \
+  if(cond) {                                        \
+    stmt;                                           \
+    rwl_unlock_mutex(lock);                         \
+    return;                                         \
+  }                                                 \
+  rwl_unlock_mutex(lock);                           \
+}
+
+void ngx_rwlock_reserve_read(ngx_rwlock_t *lock)
+{
+  #if (NGX_HAVE_ATOMIC_OPS)
+  ngx_uint_t i, n;
+  
+  #if (DISABLE_RWLOCK == 1)
+  rwl_lock_mutex(lock);
+  return;
+  #endif
+  
+  for(;;) {
+    NGX_RWLOCK_MUTEX_COND(lock, (lock->lock != NGX_RWLOCK_WRITE), lock->lock++)
+    #if (DEBUG_NGX_RWLOCK == 1)
+    ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "rwlock %p reserve read read (%i)", lock, lock->lock);
+    #endif
+    if(ngx_ncpu > 1) {
+      for(n = 1; n < NGX_RWLOCK_SPIN; n <<= 1) {
+        for(i = 0; i < n; i++) {
+          ngx_cpu_pause();
+        }
+        #if (DEBUG_NGX_RWLOCK == 1)
+        ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "rwlock %p read lock wait", lock);
+        #endif
+        NGX_RWLOCK_MUTEX_COND(lock, (lock->lock != NGX_RWLOCK_WRITE), lock->lock++)
+      }
+    }
+    ngx_sched_yield();
+  }
+  #else
+  #if (NGX_THREADS)
+  #error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !
+  #endif
+  #endif
+}
+void ngx_rwlock_release_read(ngx_rwlock_t *lock) {
+  #if (DISABLE_RWLOCK == 1)
+  rwl_unlock_mutex(lock);
+  #else
+  NGX_RWLOCK_MUTEX_COND(lock, lock->lock != NGX_RWLOCK_WRITE && lock->lock != 0, lock->lock--)
+  #endif
+}
+
+int ngx_rwlock_write_check(ngx_rwlock_t *lock) {
+  if(lock->lock==0) {
+    rwl_lock_mutex(lock);
+    if(lock->lock==0) {
+      lock->lock=NGX_RWLOCK_WRITE;
+      lock->write_pid=ngx_pid;
+      rwl_unlock_mutex(lock);
+      return 1;
+    }
+    rwl_unlock_mutex(lock);
+  }
+  return 0;
+}
+
+void ngx_rwlock_reserve_write(ngx_rwlock_t * lock) {
+  #if (NGX_HAVE_ATOMIC_OPS)
+  ngx_uint_t i, n;
+  
+  #if (DISABLE_RWLOCK == 1)
+  rwl_lock_mutex(lock);
+  return;
+  #endif
+  
+  for(;;) {
+    if(ngx_rwlock_write_check(lock))
+      return;
+    if(ngx_ncpu > 1) {
+      for(n = 1; n < NGX_RWLOCK_SPIN; n <<= 1) {
+        for(i = 0; i < n; i++) {
+          ngx_cpu_pause();
+        }
+        #if (DEBUG_NGX_RWLOCK == 1)
+        ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "rwlock %p write lock wait (reserved by %ui)", lock, lock->write_pid);
+        #endif
+        if(ngx_rwlock_write_check(lock))
+          return;
+      }
+    }
+    ngx_sched_yield();
+  }
+  #else
+  #if (NGX_THREADS)
+  #error ngx_spinlock() or ngx_atomic_cmp_set() are not defined !
+  #endif
+  #endif
+}
+
+void ngx_rwlock_release_write(ngx_rwlock_t *lock) {
+  #if (DISABLE_RWLOCK == 1)
+  rwl_unlock_mutex(lock);
+  return;
+  #endif
+  
+  if(lock->lock == NGX_RWLOCK_WRITE) {
+    rwl_lock_mutex(lock);
+    if(lock->lock == NGX_RWLOCK_WRITE) {
+      lock->lock=0;
+      if(lock->write_pid != ngx_pid) {
+        ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "rwlock %p releasing someone else's (pid %ui) write lock.", lock, lock->write_pid);
+      }
+      lock->write_pid = 0;
+      rwl_unlock_mutex(lock);
+      return;
+    }
+    rwl_unlock_mutex(lock);
+  }
+  else {
+    ngx_log_error(NGX_LOG_WARN, ngx_cycle->log, 0, "rwlock %p tried to release nonexistent write lock, lock=%i.", lock, lock->lock);
+  }
+}

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/ngx_rwlock.h

@@ -0,0 +1,5 @@
+void ngx_rwlock_init(ngx_rwlock_t *lock);
+void ngx_rwlock_release_write(ngx_rwlock_t *lock);
+void ngx_rwlock_reserve_write(ngx_rwlock_t *lock);
+void ngx_rwlock_release_read(ngx_rwlock_t *lock);
+void ngx_rwlock_reserve_read(ngx_rwlock_t *lock);

data/packaging/debian/debian_specs/nginx/modules/nginx-http-push/src/store/rbtree_util.c

@@ -0,0 +1,246 @@
+#include <ngx_http_push_module.h>
+#include "rbtree_util.h"
+
+ngx_http_push_channel_t * ngx_http_push_clean_channel_locked(ngx_http_push_channel_t * channel) {
+  ngx_queue_t                 *sentinel = &channel->message_queue->queue;
+  time_t                       now = ngx_time();
+  ngx_http_push_msg_t         *msg=NULL;
+  while(!ngx_queue_empty(sentinel)){
+    msg = ngx_queue_data(ngx_queue_head(sentinel), ngx_http_push_msg_t, queue);
+    if (msg!=NULL && msg->expires != 0 && now > msg->expires) {
+      ngx_http_push_store->delete_message_locked(channel, msg, 0);
+    }
+    else { //definitely a message left to send
+      return NULL;
+    }
+  }
+  //at this point, the queue is empty
+  return (channel->subscribers==0 && (channel->expires <= now)) ? channel : NULL; //if no waiting requests and channel expired, return this channel to be deleted
+}
+
+static ngx_int_t ngx_http_push_delete_node_locked(ngx_rbtree_t *tree, ngx_rbtree_node_t *trash) {
+//assume the shm zone is already locked
+  if(trash != NULL){ //take out the trash
+    ngx_rbtree_delete(tree, trash);
+    
+    //delete the worker-subscriber queue
+    ngx_queue_t                *sentinel = (ngx_queue_t *)((ngx_http_push_channel_t *)trash)->workers_with_subscribers;
+    ngx_queue_t                *cur = ngx_queue_head(sentinel);
+    ngx_queue_t                *next;
+    while(cur!=sentinel) {
+      next = ngx_queue_next(cur);
+      ngx_http_push_store->free_locked(cur);
+      cur = next;
+    }
+    
+    ngx_http_push_store->free_locked(trash);
+    ngx_http_push_store->free_locked(sentinel);
+    return NGX_OK;
+  }
+  return NGX_DECLINED;
+}
+
+ngx_int_t ngx_http_push_delete_channel_locked(ngx_http_push_channel_t *trash, ngx_shm_zone_t *shm_zone) {
+  ngx_int_t                      res;
+  res = ngx_http_push_delete_node_locked(&((ngx_http_push_shm_data_t *) shm_zone->data)->tree, (ngx_rbtree_node_t *)trash);
+  if(res==NGX_OK) {
+    ((ngx_http_push_shm_data_t *) shm_zone->data)->channels--;
+    return NGX_OK;
+  }
+  return res;
+  
+}
+
+ngx_http_push_channel_t * ngx_http_push_find_channel(ngx_str_t *id, time_t timeout, ngx_shm_zone_t *shm_zone) {
+  ngx_rbtree_t                   *tree = &((ngx_http_push_shm_data_t *) shm_zone->data)->tree;
+  uint32_t                        hash;
+  ngx_rbtree_node_t              *node, *sentinel;
+  ngx_int_t                       rc;
+  ngx_http_push_channel_t        *up = NULL;
+  ngx_http_push_channel_t        *trash[] = { NULL, NULL, NULL };
+  
+  ngx_uint_t                      i, trashed=0;
+  if (tree==NULL) {
+    return NULL;
+  }
+  
+  hash = ngx_crc32_short(id->data, id->len);
+
+  node = tree->root;
+  sentinel = tree->sentinel;
+
+  while (node != sentinel) {
+    
+    //every search is responsible for deleting a couple of empty, if it comes across them
+    if (trashed < (sizeof(trash) / sizeof(*trash))) {
+      if((trash[trashed]=ngx_http_push_clean_channel_locked((ngx_http_push_channel_t *) node))!=NULL) {
+        trashed++;
+      }
+    }
+    
+    if (hash < node->key) {
+      node = node->left;
+      continue;
+    }
+
+    if (hash > node->key) {
+      node = node->right;
+      continue;
+    }
+    
+    /* hash == node->key */
+
+    do {
+      up = (ngx_http_push_channel_t *) node;
+
+      rc = ngx_memn2cmp(id->data, up->id.data, id->len, up->id.len);
+
+      if (rc == 0) {
+        //found
+        for(i=0; i<trashed; i++) {
+          if(trash[i] != up){ //take out the trash
+            ngx_http_push_delete_channel_locked(trash[i], shm_zone);
+          }
+        }
+        up->expires = ngx_time() + timeout;
+        ngx_http_push_clean_channel_locked(up);
+        return up;
+      }
+
+      node = (rc < 0) ? node->left : node->right;
+
+    } while (node != sentinel && hash == node->key);
+
+    break;
+  }
+  //not found
+  for(i=0; i<trashed; i++) {
+    ngx_http_push_delete_channel_locked(trash[i], shm_zone);
+  }
+  return NULL;
+}
+
+//find a channel by id. if channel not found, make one, insert it, and return that.
+ngx_http_push_channel_t *ngx_http_push_get_channel(ngx_str_t *id, time_t timeout, ngx_shm_zone_t *shm_zone) {
+  ngx_rbtree_t                   *tree;
+  ngx_http_push_channel_t        *up=ngx_http_push_find_channel(id, timeout, shm_zone);
+  ngx_http_push_pid_queue_t      *worker_queue_sentinel;
+  
+  if(up != NULL) { //we found our channel
+    return up;
+  }
+  tree = &((ngx_http_push_shm_data_t *) shm_zone->data)->tree;
+  if((up = ngx_http_push_store->alloc_locked(sizeof(*up) + id->len + sizeof(ngx_http_push_msg_t), "channel"))==NULL) {
+    return NULL;
+  }
+  if((worker_queue_sentinel=ngx_http_push_store->alloc_locked(sizeof(*worker_queue_sentinel), "channel worker queue sentinel"))==NULL) {
+    ngx_http_push_store->free_locked(up);
+    ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate worker queue sentinel");
+    return NULL;
+  }
+  ngx_queue_init(&worker_queue_sentinel->queue);
+  
+  up->id.data = (u_char *) (up+1); //contiguous piggy
+  up->message_queue = (ngx_http_push_msg_t *) (up->id.data + id->len);
+  
+  up->id.len = (u_char) id->len;
+  ngx_memcpy(up->id.data, id->data, up->id.len);
+  up->node.key = ngx_crc32_short(id->data, id->len);
+  ngx_rbtree_insert(tree, (ngx_rbtree_node_t *) up);
+
+  //initialize queues
+  ngx_queue_init(&up->message_queue->queue);
+  up->messages=0;
+  
+  up->workers_with_subscribers=worker_queue_sentinel;
+  up->subscribers=0;
+  
+  up->last_seen=ngx_time();
+
+  up->expires = ngx_time() + timeout;
+  
+  ((ngx_http_push_shm_data_t *) shm_zone->data)->channels++;
+  
+  return up;
+}
+
+
+void ngx_rbtree_generic_insert(
+        ngx_rbtree_node_t *temp, 
+        ngx_rbtree_node_t *node, 
+        ngx_rbtree_node_t *sentinel, 
+        int (*compare)(const ngx_rbtree_node_t *left, const ngx_rbtree_node_t *right))
+{
+  for ( ;; ) {
+    if (node->key < temp->key) {
+
+      if (temp->left == sentinel) {
+        temp->left = node;
+        break;
+      }
+
+      temp = temp->left;
+
+    } else if (node->key > temp->key) {
+
+      if (temp->right == sentinel) {
+        temp->right = node;
+        break;
+      }
+
+      temp = temp->right;
+
+    } else { /* node->key == temp->key */
+      if (compare(node, temp) < 0) {
+
+        if (temp->left == sentinel) {
+          temp->left = node;
+          break;
+        }
+
+        temp = temp->left;
+
+      } else {
+
+        if (temp->right == sentinel) {
+          temp->right = node;
+          break;
+        }
+
+        temp = temp->right;
+      }
+    }
+  }
+
+  node->parent = temp;
+  node->left = sentinel;
+  node->right = sentinel;
+  ngx_rbt_red(node);
+}
+
+void ngx_http_push_rbtree_walker(ngx_rbtree_t *tree, ngx_int_t (*apply)(ngx_http_push_channel_t * channel), ngx_rbtree_node_t *node) {
+  ngx_rbtree_node_t              *sentinel = tree->sentinel;
+  
+  if(node!=sentinel) {
+    apply((ngx_http_push_channel_t *)node);
+    if(node->left!=NULL) {
+      ngx_http_push_rbtree_walker(tree, apply, node->left);
+    }
+    if(node->right!=NULL) {
+      ngx_http_push_rbtree_walker(tree, apply, node->right);
+    }
+  }
+}
+
+
+static int ngx_http_push_compare_rbtree_node(const ngx_rbtree_node_t *v_left, const ngx_rbtree_node_t *v_right)
+{
+  ngx_http_push_channel_t *left = (ngx_http_push_channel_t *) v_left, *right = (ngx_http_push_channel_t *) v_right;
+  return ngx_memn2cmp(left->id.data, right->id.data, left->id.len, right->id.len);
+}
+
+void ngx_http_push_rbtree_insert(ngx_rbtree_node_t *temp,  ngx_rbtree_node_t *node, ngx_rbtree_node_t *sentinel) 
+{
+  ngx_rbtree_generic_insert(temp, node, sentinel, ngx_http_push_compare_rbtree_node);
+}
+