backported http-socket-modifier1/2

backported carbon hostname patch to 1.4.x

ChangeLog

@@ -1,5 +1,14 @@
 *** current ***
 
+ * 1.4.1
+
+- fixed typos in corerouter plugins
+- fixed offloading when the number of threads is higher than 1
+- fixed static_maps for non-existent paths
+- fixed uwsgi_connect() on modern Linux systems to reset the socket to blocking mode
+
+*** november 2012 ***
+
  * 1.4
 
 - gevent improvements
@@ -9,11 +18,13 @@
 - improved systemd support
 - log filtering and routing
 - improved tracebacker
-- offload transfer for static files
+- offload transfer for static files, and network transfers
 - matheval support
 - plugins can be written in Obj-C
 - smart attach daemon
 - added support for PEP 405 virtualenvs
+- rawrouter with xclient support
+- internal routing plugin for cache
 
 *** semptember 2012 ***
 

apache2/mod_proxy_uwsgi.c

@@ -1,3 +1,8 @@
+/*
+
+	 apxs2 -i -c mod_proxy_uwsgi.c
+
+*/
 #define APR_WANT_MEMFUNC
 #define APR_WANT_STRFUNC
 #include "apr_strings.h"
@@ -101,10 +106,26 @@ static int uwsgi_send_headers(request_rec *r, proxy_conn_rec *conn)
     ap_add_common_vars(r);
     ap_add_cgi_vars(r);
 
+    // this is not a security problem (in Linux) as uWSGI destroy the env memory area readable in /proc
+    // and generally if you host untrusted apps in your server and allows them to read others uid /proc/<pid>
+    // files you have higher problems...
+    const char *auth = apr_table_get(r->headers_in, "Authorization");
+    if (auth) {
+        apr_table_setn(r->subprocess_env, "HTTP_AUTHORIZATION", auth); 
+    }
+
     const char *script_name = apr_table_get(r->subprocess_env, "SCRIPT_NAME");
     const char *path_info = apr_table_get(r->subprocess_env, "PATH_INFO");
+
     if (script_name && path_info) {
-        apr_table_set(r->subprocess_env, "SCRIPT_NAME", apr_pstrndup(r->pool, script_name, strlen(script_name)-strlen(path_info)));
+        if (strcmp(path_info, "/")) {
+            apr_table_set(r->subprocess_env, "SCRIPT_NAME", apr_pstrndup(r->pool, script_name, strlen(script_name)-strlen(path_info)));
+	}
+        else {
+            if (!strcmp(script_name, "/")) {
+                apr_table_set(r->subprocess_env, "SCRIPT_NAME", "");
+            }
+        }
     }
 
     env_table = apr_table_elts(r->subprocess_env);
@@ -135,7 +156,7 @@ static int uwsgi_send_headers(request_rec *r, proxy_conn_rec *conn)
     buf[0] = 0;
     buf[1] = (uint8_t) (pktsize & 0xff);
     buf[2] = (uint8_t) ((pktsize >> 8) & 0xff);
-    buf[0] = 0;
+    buf[3] = 0;
 
     return uwsgi_send(conn, buf, headerlen, r);
 }
@@ -326,7 +347,13 @@ static int uwsgi_handler(request_rec *r, proxy_worker *worker,
     }
 
     // ADD PATH_INFO
-    apr_table_add(r->subprocess_env, "PATH_INFO", url+strlen(worker->name));
+    size_t w_len = strlen(worker->name);
+    char *u_path_info = r->filename + 6 + w_len;
+    int delta = 0;
+    if (u_path_info[0] != '/') {
+        delta = 1;
+    }
+    apr_table_add(r->subprocess_env, "PATH_INFO", url+w_len-delta);
 
 
     /* Create space for state information */

bin/uwsgi

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+cmd = File.expand_path "#{File.dirname(__FILE__)}/../ext/uwsgi/uwsgi.ruby"
+
+exec(cmd, *ARGV)

buildconf/base.ini

@@ -29,7 +29,7 @@ plugins =
 bin_name = uwsgi
 append_version =
 plugin_dir = .
-embedded_plugins = %(main_plugin)s, ping, cache, nagios, rrdtool, carbon, rpc, corerouter, fastrouter, http, ugreen, signal, syslog, rsyslog, logsocket, router_uwsgi, router_redirect, router_basicauth, zergpool, redislog, mongodblog, router_rewrite, router_http, logfile, router_cache
+embedded_plugins = %(main_plugin)s, ping, cache, nagios, rrdtool, carbon, rpc, corerouter, fastrouter, http, ugreen, signal, syslog, rsyslog, logsocket, router_uwsgi, router_redirect, router_basicauth, zergpool, redislog, mongodblog, router_rewrite, router_http, logfile, router_cache, rawrouter
 as_shared_library = false
 
 locking = auto

core/alarm.c

@@ -136,7 +136,7 @@ static struct uwsgi_alarm_instance *uwsgi_alarm_get_instance(char *name) {
 }
 
 
-static int uwsgi_alarm_log_add(char *alarms, char *regexp) {
+static int uwsgi_alarm_log_add(char *alarms, char *regexp, int negate) {
 
 	struct uwsgi_alarm_log *old_ual = NULL, *ual = uwsgi.alarm_logs;
 	while (ual) {
@@ -148,6 +148,7 @@ static int uwsgi_alarm_log_add(char *alarms, char *regexp) {
 	if (uwsgi_regexp_build(regexp, &ual->pattern, &ual->pattern_extra)) {
 		return -1;
 	}
+	ual->negate = negate;
 
 	if (old_ual) {
 		old_ual->next = ual;
@@ -223,7 +224,7 @@ void uwsgi_alarms_init() {
 		*space = 0;
 		char *regexp = space + 1;
 		// here the log-alarm is created
-		if (uwsgi_alarm_log_add(line, regexp)) {
+		if (uwsgi_alarm_log_add(line, regexp, usl->custom)) {
 			uwsgi_log("invalid log-alarm: %s\n", usl->value);
 			exit(1);
 		}
@@ -239,7 +240,12 @@ void uwsgi_alarm_log_check(char *msg, size_t len) {
 	struct uwsgi_alarm_log *ual = uwsgi.alarm_logs;
 	while (ual) {
 		if (uwsgi_regexp_match(ual->pattern, ual->pattern_extra, msg, len) >= 0) {
-			uwsgi_alarm_log_run(ual, msg, len);
+			if (!ual->negate) {
+				uwsgi_alarm_log_run(ual, msg, len);
+			}
+			else {
+				break;
+			}
 		}
 		ual = ual->next;
 	}

core/async.c

@@ -99,23 +99,23 @@ struct wsgi_request *find_first_available_wsgi_req() {
 void async_expire_timeouts() {
 
 	struct wsgi_request *wsgi_req;
-	time_t current_time = uwsgi_now();
+	uint64_t current_time = (uint64_t) uwsgi_now();
 	struct uwsgi_async_fd *uaf = NULL, *current_uaf;
 
 	struct uwsgi_rb_timer *urbt;
 
 	for (;;) {
 
-		urbt = uwsgi_min_rb_timer(uwsgi.rb_async_timeouts);
+		urbt = uwsgi_min_rb_timer(uwsgi.rb_async_timeouts, NULL);
 
 		if (urbt == NULL)
 			return;
 
-		if (urbt->key <= current_time) {
+		if (urbt->value <= current_time) {
 			wsgi_req = (struct wsgi_request *) urbt->data;
 			// timeout expired
 			wsgi_req->async_timed_out = 1;
-			rb_erase(&wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+			uwsgi_del_rb_timer(uwsgi.rb_async_timeouts, wsgi_req->async_timeout);
 			free(wsgi_req->async_timeout);
 			wsgi_req->async_timeout = NULL;
 			uaf = wsgi_req->waiting_fds;
@@ -258,12 +258,12 @@ void async_loop() {
 			timeout = 0;
 		}
 		else {
-			min_timeout = uwsgi_min_rb_timer(uwsgi.rb_async_timeouts);
+			min_timeout = uwsgi_min_rb_timer(uwsgi.rb_async_timeouts, NULL);
 			if (uwsgi.async_runqueue_cnt) {
 				timeout = 0;
 			}
 			if (min_timeout) {
-				timeout = min_timeout->key - uwsgi_now();
+				timeout = min_timeout->value - uwsgi_now();
 				if (timeout <= 0) {
 					async_expire_timeouts();
 					timeout = 0;
@@ -354,13 +354,14 @@ void async_loop() {
 				if (uwsgi.wsgi_req) {
 					proto_parser_status = uwsgi.wsgi_req->socket->proto(uwsgi.wsgi_req);
 					// reset timeout
-					rb_erase(&uwsgi.wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+					uwsgi_del_rb_timer(uwsgi.rb_async_timeouts, uwsgi.wsgi_req->async_timeout);
 					free(uwsgi.wsgi_req->async_timeout);
 					uwsgi.wsgi_req->async_timeout = NULL;
 					// parsing complete
 					if (!proto_parser_status) {
 						// remove fd from event poll and fd proto table 
 						uwsgi.async_proto_fd_table[interesting_fd] = NULL;
+						event_queue_del_fd(uwsgi.async_queue, interesting_fd, event_queue_read());
 						// put request in the runqueue
 						runqueue_push(uwsgi.wsgi_req);
 						continue;
@@ -395,7 +396,7 @@ void async_loop() {
 				}
 				uwsgi.wsgi_req->waiting_fds = NULL;
 				if (uwsgi.wsgi_req->async_timeout) {
-					rb_erase(&uwsgi.wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+					uwsgi_del_rb_timer(uwsgi.rb_async_timeouts, uwsgi.wsgi_req->async_timeout);
 					free(uwsgi.wsgi_req->async_timeout);
 					uwsgi.wsgi_req->async_timeout = NULL;
 				}
@@ -405,6 +406,7 @@ void async_loop() {
 
 				// put the request in the runqueue again
 				runqueue_push(uwsgi.wsgi_req);
+				break;
 			}
 		}
 
@@ -432,7 +434,7 @@ void async_loop() {
 				}
 				uwsgi.wsgi_req->waiting_fds = NULL;
 				if (uwsgi.wsgi_req->async_timeout) {
-					rb_erase(&uwsgi.wsgi_req->async_timeout->rbt, uwsgi.rb_async_timeouts);
+					uwsgi_del_rb_timer(uwsgi.rb_async_timeouts, uwsgi.wsgi_req->async_timeout);
 					free(uwsgi.wsgi_req->async_timeout);
 					uwsgi.wsgi_req->async_timeout = NULL;
 				}

core/buffer.c

@@ -114,3 +114,13 @@ int uwsgi_buffer_send(struct uwsgi_buffer *ub, int fd) {
 
 	return 0;
 }
+
+int uwsgi_buffer_num64(struct uwsgi_buffer *ub, int64_t num) {
+        char buf[sizeof(UMAX64_STR)+1];
+        int ret = snprintf(buf, sizeof(UMAX64_STR)+1, "%lld", (long long) num);
+        if (ret <= 0 || ret > (int) (sizeof(UMAX64_STR)+1)) {
+                return -1;
+        }
+        return uwsgi_buffer_append(ub, buf, ret);
+}
+

core/cache.c

@@ -105,7 +105,7 @@ static inline uint64_t uwsgi_cache_get_index(char *key, uint16_t keylen) {
 
 	uint32_t hash = djb33x_hash(key, keylen);
 
-	int hash_key = hash % 0xffff;
+	uint32_t hash_key = hash % 0xffff;
 
 	uint64_t slot = uwsgi.cache_hashtable[hash_key];
 
@@ -117,8 +117,9 @@ static inline uint64_t uwsgi_cache_get_index(char *key, uint16_t keylen) {
 	uci = &uwsgi.cache_items[slot];
 
 	// first round
+	if (hash_key != uci->djbhash % 0xffff) return 0;
 	if (uci->djbhash != hash)
-		return 0;
+		goto cycle;
 	if (uci->keysize != keylen)
 		goto cycle;
 	if (memcmp(uci->key, key, keylen))
@@ -144,7 +145,7 @@ cycle:
 			}
 		}
 		if (uci->djbhash != hash)
-			return 0;
+			continue;
 		if (uci->keysize != keylen)
 			continue;
 		if (!memcmp(uci->key, key, keylen))
@@ -188,11 +189,6 @@ int uwsgi_cache_del(char *key, uint16_t keylen, uint64_t index) {
 		uci->valsize = 0;
 		uwsgi.shared->cache_unused_stack_ptr++;
 		uwsgi.cache_unused_stack[uwsgi.shared->cache_unused_stack_ptr] = index;
-		// try to return to initial condition...
-		if (index == uwsgi.shared->cache_first_available_item - 1) {
-			uwsgi.shared->cache_first_available_item--;
-			//uwsgi_log("FACI: %llu STACK PTR: %llu\n", (unsigned long long) uwsgi.shared->cache_first_available_item, (unsigned long long) uwsgi.shared->cache_unused_stack_ptr);
-		}
 		ret = 0;
 		// relink collisioned entry
 		if (uci->prev) {

core/cluster.c

@@ -368,7 +368,7 @@ void manage_cluster_message(char *cluster_opt_buf, int cluster_opt_size) {
 		memset(&nucn, 0, sizeof(struct uwsgi_cluster_node));
 
 #ifdef __BIG_ENDIAN__
-		uwsgi.workers[0].cores[0].req.uh.pktsize = uwsgi_swap16(uwsgi.wsgi_requests[0]->uh.pktsize);
+		uwsgi.workers[0].cores[0].req.uh.pktsize = uwsgi_swap16(uwsgi.workers[0].cores[0].req.uh.pktsize);
 #endif
 		uwsgi_hooked_parse(uwsgi.workers[0].cores[0].req.buffer, uwsgi.workers[0].cores[0].req.uh.pktsize, manage_cluster_announce, &nucn);
 		if (nucn.name[0] != 0) {
@@ -377,7 +377,7 @@ void manage_cluster_message(char *cluster_opt_buf, int cluster_opt_size) {
 		break;
 	case 96:
 #ifdef __BIG_ENDIAN__
-		uwsgi.workers[0].cores[0].req.uh.pktsize = uwsgi_swap16(uwsgi.wsgi_requests[0]->uh.pktsize);
+		uwsgi.workers[0].cores[0].req.uh.pktsize = uwsgi_swap16(uwsgi.workers[0].cores[0].req.uh.pktsize);
 #endif
 		uwsgi_log_verbose("%.*s\n", uwsgi.workers[0].cores[0].req.uh.pktsize, uwsgi.workers[0].cores[0].req.buffer);
 		break;

core/daemons.c

@@ -30,6 +30,16 @@ extern struct uwsgi_server uwsgi;
 */
 
 void uwsgi_daemons_smart_check() {
+	static time_t last_run = 0;
+
+	time_t now = uwsgi_now();
+
+	if (now - last_run <= 0) {
+		return;
+	}
+
+	last_run = now;
+
 	struct uwsgi_daemon *ud = uwsgi.daemons;
 	while (ud) {
 		if (ud->pidfile) {
@@ -41,14 +51,14 @@ void uwsgi_daemons_smart_check() {
 				}
 				else {
 					ud->pidfile_checks++;
-					if (ud->pidfile_checks >= (uint64_t) ud->freq) {
+					if (ud->pidfile_checks >= (unsigned int) ud->freq) {
 						uwsgi_log("[uwsgi-daemons] found changed pidfile for \"%s\" (old_pid: %d new_pid: %d)\n", ud->command, (int) ud->pid, (int) checked_pid);
 						uwsgi_spawn_daemon(ud);
 					}
 				}
 			}
 			else if (checked_pid != ud->pid) {
-				uwsgi_log("[uwsgi-daemons] found changed pidfile for \"%s\" (old_pid: %d new_pid: %d)\n", ud->command, (int) ud->pid, (int) checked_pid);
+				uwsgi_log("[uwsgi-daemons] found changed pid for \"%s\" (old_pid: %d new_pid: %d)\n", ud->command, (int) ud->pid, (int) checked_pid);
 				ud->pid = checked_pid;
 			}
 			// all ok, pidfile and process found
@@ -183,6 +193,7 @@ void uwsgi_spawn_daemon(struct uwsgi_daemon *ud) {
 	else {
 		// close uwsgi sockets
 		uwsgi_close_all_sockets();
+		uwsgi_close_all_fds();
 
 		if (ud->daemonize) {
 			/* refork... */
@@ -204,7 +215,7 @@ void uwsgi_spawn_daemon(struct uwsgi_daemon *ud) {
 			exit(1);
 		}
 		if (devnull != 0) {
-			if (dup2(devnull, 0)) {
+			if (dup2(devnull, 0) < 0) {
 				uwsgi_error("dup2()");
 				exit(1);
 			}

core/emperor.c

@@ -6,7 +6,6 @@ a supervisor for multiple uWSGI instances
 
 */
 #include "uwsgi.h"
-#include <glob.h>
 
 
 extern struct uwsgi_server uwsgi;
@@ -709,7 +708,7 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 			exit(1);
 		}
 		if (stdin_fd != 0) {
-			if (dup2(stdin_fd, 0)) {
+			if (dup2(stdin_fd, 0) < 0) {
 				uwsgi_error("dup2()");
 				exit(1);
 			}
@@ -784,6 +783,8 @@ void uwsgi_imperial_monitor_directory_init(struct uwsgi_emperor_scanner *ues) {
 		exit(1);
 	}
 
+	ues->arg = uwsgi.emperor_absolute_dir;
+
 }
 
 struct uwsgi_imperial_monitor *imperial_monitor_get_by_id(char *scheme) {
@@ -1021,7 +1022,7 @@ void emperor_loop() {
 					else if (byte == 30 && uwsgi.emperor_broodlord > 0 && uwsgi.emperor_broodlord_count < uwsgi.emperor_broodlord) {
 						uwsgi_log("[emperor] going in broodlord mode: launching zergs for %s\n", ui_current->name);
 						char *zerg_name = uwsgi_concat3(ui_current->name, ":", "zerg");
-						emperor_add(NULL, zerg_name, uwsgi_now(), NULL, 0, ui_current->uid, ui_current->gid);
+						emperor_add(ui_current->scanner, zerg_name, uwsgi_now(), NULL, 0, ui_current->uid, ui_current->gid);
 						free(zerg_name);
 					}
 				}
@@ -1322,13 +1323,21 @@ end:
 void uwsgi_emperor_start() {
 
 	if (!uwsgi.sockets && !ushared->gateways_cnt && !uwsgi.master_process) {
+		if (uwsgi.emperor_procname) {
+			uwsgi_set_processname(uwsgi.emperor_procname);
+		}
 		uwsgi_notify_ready();
 		emperor_loop();
 		// never here
 		exit(1);
 	}
 
-	uwsgi.emperor_pid = uwsgi_fork("uWSGI Emperor");
+	if (uwsgi.emperor_procname) {
+		uwsgi.emperor_pid = uwsgi_fork(uwsgi.emperor_procname);
+	}
+	else {
+		uwsgi.emperor_pid = uwsgi_fork("uWSGI Emperor");
+	}
 	if (uwsgi.emperor_pid < 0) {
 		uwsgi_error("pid()");
 		exit(1);

core/gateway.c

@@ -41,6 +41,10 @@ struct uwsgi_gateway *register_gateway(char *name, void (*loop) (int, void *), v
 	return ug;
 }
 
+static void gateway_brutal_end() {
+	_exit(UWSGI_END_CODE);
+}
+
 void gateway_respawn(int id) {
 
 	pid_t gw_pid;
@@ -65,6 +69,7 @@ void gateway_respawn(int id) {
 		}
 #endif
 		uwsgi.mypid = getpid();
+		atexit(gateway_brutal_end);
 		signal(SIGALRM, SIG_IGN);
 		signal(SIGHUP, SIG_IGN);
 		signal(SIGINT, end_me);
@@ -77,7 +82,7 @@ void gateway_respawn(int id) {
 
 		ug->loop(id, ug->data);
 		// never here !!! (i hope)
-		exit(1);
+		_exit(1);
 	}
 
 	ug->pid = gw_pid;

core/ini.c

@@ -92,6 +92,7 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 	char *section_asked = "uwsgi";
 	char *colon;
 
+
 	if (uwsgi_check_scheme(file)) {
 		colon = uwsgi_get_last_char(file, '/');
 		colon = uwsgi_get_last_char(colon, ':');

core/lock.c

@@ -45,6 +45,10 @@ static struct uwsgi_lock_item *uwsgi_register_lock(char *id, int rw) {
 
 #ifdef UWSGI_LOCK_USE_MUTEX
 
+#ifdef OBSOLETE_LINUX_KERNEL
+#undef EOWNERDEAD
+#endif
+
 #ifdef EOWNERDEAD
 #define UWSGI_LOCK_ENGINE_NAME "pthread robust mutexes"
 int uwsgi_pthread_robust_mutexes_enabled = 1;
@@ -60,6 +64,12 @@ int uwsgi_pthread_robust_mutexes_enabled = 1;
 #define UWSGI_RWLOCK_SIZE	sizeof(pthread_rwlock_t)
 #endif
 
+#ifndef PTHREAD_PRIO_INHERIT
+int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+                                          int __protocol);
+#define PTHREAD_PRIO_INHERIT 1
+#endif
+
 // REMEMBER lock must contains space for both pthread_mutex_t and pthread_mutexattr_t !!! 
 struct uwsgi_lock_item *uwsgi_lock_fast_init(char *id) {
 
@@ -81,8 +91,16 @@ retry:
 	}
 
 #ifdef EOWNERDEAD
+
+#ifndef PTHREAD_MUTEX_ROBUST
+#define PTHREAD_MUTEX_ROBUST PTHREAD_MUTEX_ROBUST_NP
+#endif
+	if (pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT)) {
+		uwsgi_log("unable to set PTHREAD_PRIO_INHERIT\n");
+		exit(1);
+	}
 	if (uwsgi_pthread_robust_mutexes_enabled) {
-		if (pthread_mutexattr_setrobust_np(&attr, PTHREAD_MUTEX_ROBUST_NP)) {
+		if (pthread_mutexattr_setrobust_np(&attr, PTHREAD_MUTEX_ROBUST)) {
 			uwsgi_log("unable to make the mutex 'robust'\n");
 			exit(1);
 		}
@@ -556,8 +574,10 @@ void uwsgi_setup_locking() {
 			uwsgi.lock_ops.rwunlock = uwsgi_rwunlock_ipcsem;
 			uwsgi.lock_size = 8;
 			uwsgi.rwlock_size = 8;
-			return;
+			goto ready;
 		}
+		uwsgi_log("unable to find lock engine \"%s\"\n", uwsgi.lock_engine);
+		exit(1);
 	}
 
 	uwsgi_log_initial("lock engine: %s\n", UWSGI_LOCK_ENGINE_NAME);
@@ -578,6 +598,7 @@ void uwsgi_setup_locking() {
 
 	// application generic lock
 	int i;
+ready:
 	uwsgi.user_lock = uwsgi_malloc(sizeof(void *) * (uwsgi.locks + 1));
 	for (i = 0; i < uwsgi.locks + 1; i++) {
 		uwsgi.user_lock[i] = uwsgi_lock_init(uwsgi_concat2("user ", uwsgi_num2str(i)));
@@ -608,6 +629,11 @@ void uwsgi_setup_locking() {
 		uwsgi.cron_table_lock = uwsgi_lock_init("cron");
 	}
 
+	if (uwsgi.use_thunder_lock) {
+		// process shared thunder lock
+		uwsgi.the_thunder_lock = uwsgi_lock_init("thunder");
+	}
+
 	uwsgi.rpc_table_lock = uwsgi_lock_init("rpc");
 
 }

core/logging.c

@@ -815,6 +815,7 @@ struct uwsgi_logger *uwsgi_get_logger_from_id(char *id) {
 void uwsgi_logit_lf(struct wsgi_request *wsgi_req) {
 	struct uwsgi_logchunk *logchunk = uwsgi.logchunks;
 	ssize_t rlen = 0;
+	const char *empty_var = "-";
 	while (logchunk) {
 		int pos = logchunk->vec;
 		// raw string
@@ -851,6 +852,11 @@ void uwsgi_logit_lf(struct wsgi_request *wsgi_req) {
 				uwsgi.logvectors[wsgi_req->async_id][pos].iov_len = 0;
 			}
 		}
+
+		if (uwsgi.logvectors[wsgi_req->async_id][pos].iov_len == 0 && logchunk->type != 0) {
+			uwsgi.logvectors[wsgi_req->async_id][pos].iov_base = (char *) empty_var;
+			uwsgi.logvectors[wsgi_req->async_id][pos].iov_len = 1; 
+		}
 		logchunk = logchunk->next;
 	}
 
@@ -862,7 +868,9 @@ void uwsgi_logit_lf(struct wsgi_request *wsgi_req) {
 	while (logchunk) {
 		if (logchunk->free) {
 			if (uwsgi.logvectors[wsgi_req->async_id][logchunk->vec].iov_len > 0) {
-				free(uwsgi.logvectors[wsgi_req->async_id][logchunk->vec].iov_base);
+				if (uwsgi.logvectors[wsgi_req->async_id][logchunk->vec].iov_base != empty_var) {
+					free(uwsgi.logvectors[wsgi_req->async_id][logchunk->vec].iov_base);
+				}
 			}
 		}
 		logchunk = logchunk->next;
@@ -923,17 +931,38 @@ void uwsgi_build_log_format(char *format) {
 
 }
 
-ssize_t uwsgi_lf_status(struct wsgi_request *wsgi_req, char **buf) {
+static ssize_t uwsgi_lf_status(struct wsgi_request *wsgi_req, char **buf) {
 	*buf = uwsgi_num2str(wsgi_req->status);
 	return strlen(*buf);
 }
 
-ssize_t uwsgi_lf_epoch(struct wsgi_request * wsgi_req, char **buf) {
+static ssize_t uwsgi_lf_rsize(struct wsgi_request *wsgi_req, char **buf) {
+        *buf = uwsgi_num2str(wsgi_req->response_size);
+        return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_hsize(struct wsgi_request *wsgi_req, char **buf) {
+        *buf = uwsgi_num2str(wsgi_req->headers_size);
+        return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_size(struct wsgi_request *wsgi_req, char **buf) {
+        *buf = uwsgi_num2str(wsgi_req->headers_size+wsgi_req->response_size);
+        return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_cl(struct wsgi_request *wsgi_req, char **buf) {
+        *buf = uwsgi_num2str(wsgi_req->post_cl);
+        return strlen(*buf);
+}
+
+
+static ssize_t uwsgi_lf_epoch(struct wsgi_request * wsgi_req, char **buf) {
 	*buf = uwsgi_num2str(uwsgi_now());
 	return strlen(*buf);
 }
 
-ssize_t uwsgi_lf_ctime(struct wsgi_request * wsgi_req, char **buf) {
+static ssize_t uwsgi_lf_ctime(struct wsgi_request * wsgi_req, char **buf) {
 	*buf = uwsgi_malloc(26);
 #ifdef __sun__
 	ctime_r((const time_t *) &wsgi_req->start_of_request_in_sec, *buf, 26);
@@ -943,23 +972,98 @@ ssize_t uwsgi_lf_ctime(struct wsgi_request * wsgi_req, char **buf) {
 	return 24;
 }
 
-ssize_t uwsgi_lf_time(struct wsgi_request * wsgi_req, char **buf) {
+static ssize_t uwsgi_lf_time(struct wsgi_request * wsgi_req, char **buf) {
 	*buf = uwsgi_num2str(wsgi_req->start_of_request / 1000000);
 	return strlen(*buf);
 }
 
+static ssize_t uwsgi_lf_ltime(struct wsgi_request * wsgi_req, char **buf) {
+        *buf = uwsgi_malloc(64);
+        time_t now = wsgi_req->start_of_request / 1000000;
+        size_t ret = strftime(*buf, 64, "%d/%b/%Y:%H:%M:%S %z", localtime(&now));
+        if (ret == 0) {
+                *buf[0] = 0;
+                return 0;
+        }
+        return ret;
+}
 
 
-ssize_t uwsgi_lf_micros(struct wsgi_request * wsgi_req, char **buf) {
+
+static ssize_t uwsgi_lf_micros(struct wsgi_request * wsgi_req, char **buf) {
 	*buf = uwsgi_num2str(wsgi_req->end_of_request - wsgi_req->start_of_request);
 	return strlen(*buf);
 }
 
-ssize_t uwsgi_lf_msecs(struct wsgi_request * wsgi_req, char **buf) {
+static ssize_t uwsgi_lf_msecs(struct wsgi_request * wsgi_req, char **buf) {
 	*buf = uwsgi_num2str((wsgi_req->end_of_request - wsgi_req->start_of_request) / 1000);
 	return strlen(*buf);
 }
 
+static ssize_t uwsgi_lf_pid(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(uwsgi.mypid);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_wid(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(uwsgi.mywid);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_switches(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->switches);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_vars(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->var_cnt);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_core(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->async_id);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_vsz(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(uwsgi.workers[uwsgi.mywid].vsz_size);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_rss(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(uwsgi.workers[uwsgi.mywid].rss_size);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_vszM(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(uwsgi.workers[uwsgi.mywid].vsz_size / 1024 / 1024);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_rssM(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(uwsgi.workers[uwsgi.mywid].rss_size / 1024 / 1024);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_pktsize(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->uh.pktsize);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_modifier1(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->uh.modifier1);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_modifier2(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->uh.modifier2);
+	return strlen(*buf);
+}
+
+static ssize_t uwsgi_lf_headers(struct wsgi_request * wsgi_req, char **buf) {
+	*buf = uwsgi_num2str(wsgi_req->header_cnt);
+	return strlen(*buf);
+}
 
 void uwsgi_add_logchunk(int variable, int pos, char *ptr, size_t len) {
 
@@ -1018,11 +1122,39 @@ void uwsgi_add_logchunk(int variable, int pos, char *ptr, size_t len) {
 			logchunk->pos = offsetof(struct wsgi_request, protocol);
 			logchunk->pos_len = offsetof(struct wsgi_request, protocol_len);
 		}
+		else if (!uwsgi_strncmp(ptr, len, "uagent", 6)) {
+                        logchunk->pos = offsetof(struct wsgi_request, user_agent);
+                        logchunk->pos_len = offsetof(struct wsgi_request, user_agent_len);
+                }
+                else if (!uwsgi_strncmp(ptr, len, "referer", 7)) {
+                        logchunk->pos = offsetof(struct wsgi_request, referer);
+                        logchunk->pos_len = offsetof(struct wsgi_request, referer_len);
+                }
 		else if (!uwsgi_strncmp(ptr, len, "status", 6)) {
 			logchunk->type = 3;
 			logchunk->func = uwsgi_lf_status;
 			logchunk->free = 1;
 		}
+		else if (!uwsgi_strncmp(ptr, len, "rsize", 5)) {
+                        logchunk->type = 3;
+                        logchunk->func = uwsgi_lf_rsize;
+                        logchunk->free = 1;
+                }
+                else if (!uwsgi_strncmp(ptr, len, "hsize", 5)) {
+                        logchunk->type = 3;
+                        logchunk->func = uwsgi_lf_hsize;
+                        logchunk->free = 1;
+                }
+                else if (!uwsgi_strncmp(ptr, len, "size", 4)) {
+                        logchunk->type = 3;
+                        logchunk->func = uwsgi_lf_size;
+                        logchunk->free = 1;
+                }
+                else if (!uwsgi_strncmp(ptr, len, "cl", 2)) {
+                        logchunk->type = 3;
+                        logchunk->func = uwsgi_lf_cl;
+                        logchunk->free = 1;
+                }
 		else if (!uwsgi_strncmp(ptr, len, "micros", 6)) {
 			logchunk->type = 3;
 			logchunk->func = uwsgi_lf_micros;
@@ -1038,6 +1170,11 @@ void uwsgi_add_logchunk(int variable, int pos, char *ptr, size_t len) {
 			logchunk->func = uwsgi_lf_time;
 			logchunk->free = 1;
 		}
+		else if (!uwsgi_strncmp(ptr, len, "ltime", 5)) {
+                        logchunk->type = 3;
+                        logchunk->func = uwsgi_lf_ltime;
+                        logchunk->free = 1;
+                }
 		else if (!uwsgi_strncmp(ptr, len, "ctime", 5)) {
 			logchunk->type = 3;
 			logchunk->func = uwsgi_lf_ctime;
@@ -1048,6 +1185,71 @@ void uwsgi_add_logchunk(int variable, int pos, char *ptr, size_t len) {
 			logchunk->func = uwsgi_lf_epoch;
 			logchunk->free = 1;
 		}
+		else if (!uwsgi_strncmp(ptr, len, "pid", 3)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_pid;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "wid", 3)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_wid;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "switches", 8)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_switches;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "vars", 4)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_vars;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "core", 4)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_core;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "vsz", 3)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_vsz;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "rss", 3)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_rss;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "vszM", 4)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_vszM;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "rssM", 4)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_rssM;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "pktsize", 7)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_pktsize;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "modifier1", 9)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_modifier1;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "modifier2", 9)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_modifier2;
+			logchunk->free = 1;
+		}
+		else if (!uwsgi_strncmp(ptr, len, "headers", 7)) {
+			logchunk->type = 3;
+			logchunk->func = uwsgi_lf_headers;
+			logchunk->free = 1;
+		}
 		// logvar
 		else {
 			logchunk->type = 2;

core/master.c

@@ -231,28 +231,28 @@ int uwsgi_master_check_mercy() {
 }
 
 
-void expire_rb_timeouts(struct rb_root *root) {
+void expire_rb_timeouts(struct uwsgi_rbtree *tree) {
 
-	time_t current = uwsgi_now();
+	uint64_t current = (uint64_t) uwsgi_now();
 	struct uwsgi_rb_timer *urbt;
 	struct uwsgi_signal_rb_timer *usrbt;
 
 	for (;;) {
 
-		urbt = uwsgi_min_rb_timer(root);
+		urbt = uwsgi_min_rb_timer(tree, NULL);
 
 		if (urbt == NULL)
 			return;
 
-		if (urbt->key <= current) {
+		if (urbt->value <= current) {
 			// remove the timeout and add another
 			usrbt = (struct uwsgi_signal_rb_timer *) urbt->data;
-			rb_erase(&usrbt->uwsgi_rb_timer->rbt, root);
-			free(usrbt->uwsgi_rb_timer);
+			uwsgi_del_rb_timer(tree, urbt);
+			free(urbt);
 			usrbt->iterations_done++;
 			uwsgi_route_signal(usrbt->sig);
 			if (!usrbt->iterations || usrbt->iterations_done < usrbt->iterations) {
-				usrbt->uwsgi_rb_timer = uwsgi_add_rb_timer(root, uwsgi_now() + usrbt->value, usrbt);
+				usrbt->uwsgi_rb_timer = uwsgi_add_rb_timer(tree, uwsgi_now() + usrbt->value, usrbt);
 			}
 			continue;
 		}
@@ -622,7 +622,7 @@ int master_loop(char **argv, char **environ) {
 	int check_interval = 1;
 
 	struct uwsgi_rb_timer *min_timeout;
-	struct rb_root *rb_timers = uwsgi_init_rb_timer();
+	struct uwsgi_rbtree *rb_timers = uwsgi_init_rb_timer();
 
 
 	if (uwsgi.procname_master) {
@@ -738,7 +738,7 @@ int master_loop(char **argv, char **environ) {
 	}
 
 
-	if (uwsgi.requested_stats_pushers) {
+	if (uwsgi.stats_pusher_instances) {
 		if (!uwsgi_thread_new(uwsgi_stats_pusher_loop)) {
 			uwsgi_log("!!! unable to spawn stats pusher thread !!!\n");
 			exit(1);
@@ -975,12 +975,12 @@ int master_loop(char **argv, char **environ) {
 			int interesting_fd = -1;
 
 			if (ushared->rb_timers_cnt > 0) {
-				min_timeout = uwsgi_min_rb_timer(rb_timers);
+				min_timeout = uwsgi_min_rb_timer(rb_timers, NULL);
 				if (min_timeout == NULL) {
 					check_interval = uwsgi.shared->options[UWSGI_OPTION_MASTER_INTERVAL];
 				}
 				else {
-					check_interval = min_timeout->key - uwsgi_now();
+					check_interval = min_timeout->value - uwsgi_now();
 					if (check_interval <= 0) {
 						expire_rb_timeouts(rb_timers);
 						check_interval = 0;
@@ -1461,6 +1461,12 @@ health_cycle:
 				continue;
 #endif
 
+			if (uwsgi.emperor_pid >= 0 && diedpid == uwsgi.emperor_pid) {
+				uwsgi_log_verbose("!!! Emperor died !!!\n");
+				uwsgi_emperor_start();
+				continue;
+			}
+
 			pid_found = 0;
 			for (i = 0; i < uwsgi.mules_cnt; i++) {
 				if (uwsgi.mules[i].pid == diedpid) {

core/master_utils.c

@@ -508,7 +508,8 @@ int uwsgi_respawn_worker(int wid) {
 
 	uwsgi.workers[wid].cheaped = 0;
 	uwsgi.workers[wid].busy = 0;
-	uwsgi.workers[wid].suspended = 0;
+	// SUSPENSION is managed by the user, not the master...
+	//uwsgi.workers[wid].suspended = 0;
 	uwsgi.workers[wid].sig = 0;
 
 	// this is required for various checks
@@ -555,6 +556,11 @@ int uwsgi_respawn_worker(int wid) {
 		// reset the apps count with a copy from the master 
 		uwsgi.workers[uwsgi.mywid].apps_cnt = uwsgi.workers[0].apps_cnt;
 
+		// reset wsgi_request structures
+                for(i=0;i<uwsgi.cores;i++) {
+                        memset(&uwsgi.workers[uwsgi.mywid].cores[i].req, 0, sizeof(struct wsgi_request));
+                }
+
 		uwsgi_fixup_fds(wid, 0, NULL);
 
 		uwsgi.my_signal_socket = uwsgi.workers[wid].signal_pipe[1];

core/mule.c

@@ -41,6 +41,17 @@ void uwsgi_mule(int id) {
 			uwsgi_error("prctl()");
 		}
 #endif
+
+		signal(SIGALRM, SIG_IGN);
+                signal(SIGHUP, SIG_IGN);
+                signal(SIGINT, end_me);
+                signal(SIGTERM, end_me);
+                signal(SIGUSR1, SIG_IGN);
+                signal(SIGUSR2, SIG_IGN);
+                signal(SIGPIPE, SIG_IGN);
+                signal(SIGSTOP, SIG_IGN);
+                signal(SIGTSTP, SIG_IGN);
+
 		uwsgi.muleid = id;
 		// avoid race conditions
 		uwsgi.mules[id - 1].id = id;
@@ -71,7 +82,7 @@ void uwsgi_mule(int id) {
 				if (uwsgi.p[i]->mule) {
 					if (uwsgi.p[i]->mule(uwsgi.mules[id - 1].patch) == 1) {
 						// never here
-						break;
+						end_me(1);
 					}
 				}
 			}

core/offload.c

@@ -107,7 +107,7 @@ error:
 	return -1;
 }
 
-static void uwsgi_offload_close(struct uwsgi_offload_request *uor) {
+static void uwsgi_offload_close(struct uwsgi_thread *ut, struct uwsgi_offload_request *uor) {
 	// close the socket and the file descriptor
 	close(uor->s);
 	close(uor->fd);
@@ -115,12 +115,12 @@ static void uwsgi_offload_close(struct uwsgi_offload_request *uor) {
 	struct uwsgi_offload_request *prev = uor->prev;
 	struct uwsgi_offload_request *next = uor->next;
 
-	if (uor == uwsgi.offload_requests_head) {
-		uwsgi.offload_requests_head = next;
+	if (uor == ut->offload_requests_head) {
+		ut->offload_requests_head = next;
 	}
 
-	if (uor == uwsgi.offload_requests_tail) {
-		uwsgi.offload_requests_tail = prev;
+	if (uor == ut->offload_requests_tail) {
+		ut->offload_requests_tail = prev;
 	}
 
 	if (prev) {
@@ -142,22 +142,22 @@ static void uwsgi_offload_close(struct uwsgi_offload_request *uor) {
 	free(uor);
 }
 
-static void uwsgi_offload_append(struct uwsgi_offload_request *uor) {
+static void uwsgi_offload_append(struct uwsgi_thread *ut, struct uwsgi_offload_request *uor) {
 
-	if (!uwsgi.offload_requests_head) {
-		uwsgi.offload_requests_head = uor;
+	if (!ut->offload_requests_head) {
+		ut->offload_requests_head = uor;
 	}
 
-	if (uwsgi.offload_requests_tail) {
-		uwsgi.offload_requests_tail->next = uor;
-		uor->prev = uwsgi.offload_requests_tail;
+	if (ut->offload_requests_tail) {
+		ut->offload_requests_tail->next = uor;
+		uor->prev = ut->offload_requests_tail;
 	}
 
-	uwsgi.offload_requests_tail = uor;
+	ut->offload_requests_tail = uor;
 }
 
-static struct uwsgi_offload_request *uwsgi_offload_get_by_fd(int s) {
-	struct uwsgi_offload_request *uor = uwsgi.offload_requests_head;
+static struct uwsgi_offload_request *uwsgi_offload_get_by_fd(struct uwsgi_thread *ut, int s) {
+	struct uwsgi_offload_request *uor = ut->offload_requests_head;
 	while (uor) {
 		if (uor->s == s || uor->fd == s) {
 			return uor;
@@ -187,20 +187,20 @@ static void uwsgi_offload_loop(struct uwsgi_thread *ut) {
 				}
 				// start monitoring socket for write
 				if (uor->func(ut, uor, -1)) {
-					uwsgi_offload_close(uor);
+					uwsgi_offload_close(ut, uor);
 					continue;
 				}
-				uwsgi_offload_append(uor);
+				uwsgi_offload_append(ut, uor);
 				continue;
 			}
 
 			// get the task from the interesting fd
-			struct uwsgi_offload_request *uor = uwsgi_offload_get_by_fd(interesting_fd);
+			struct uwsgi_offload_request *uor = uwsgi_offload_get_by_fd(ut, interesting_fd);
 			if (!uor)
 				continue;
 			// run the hook
 			if (uor->func(ut, uor, interesting_fd)) {
-				uwsgi_offload_close(uor);
+				uwsgi_offload_close(ut, uor);
 			}
 		}
 	}
@@ -234,6 +234,7 @@ static int uwsgi_offload_sendfile_transfer(struct uwsgi_thread *ut, struct uwsgi
                 if (uor->written >= uor->len) {
 			return -1;
 		}
+		return 0;
 	}
         else if (len < 0) {
 		uwsgi_offload_retry
@@ -330,7 +331,7 @@ static int uwsgi_offload_net_transfer(struct uwsgi_thread *ut, struct uwsgi_offl
 				}
 			}
 			else if (fd == uor->s) {
-				rlen = read(uor->fd, uor->buf, 4096);
+				rlen = read(uor->s, uor->buf, 4096);
 				if (rlen > 0) {
 					uor->to_write = rlen;
 					uor->pos = 0;

core/protocol.c

@@ -784,7 +784,8 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->method = ptrbuf;
 							wsgi_req->method_len = strsize;
 						}
-						else if (!uwsgi.log_x_forwarded_for && !uwsgi_strncmp("REMOTE_ADDR", 11, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+						else if ((!uwsgi.log_x_forwarded_for || uwsgi_strncmp("HTTP_X_FORWARDED_FOR", 20, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len))
+							&& !uwsgi_strncmp("REMOTE_ADDR", 11, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->remote_addr = ptrbuf;
 							wsgi_req->remote_addr_len = strsize;
 						}
@@ -882,6 +883,14 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->authorization = ptrbuf;
 							wsgi_req->authorization_len = strsize;
 						}
+						else if (!uwsgi_strncmp("HTTP_USER_AGENT", 15, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+                                                        wsgi_req->user_agent = ptrbuf;
+                                                        wsgi_req->user_agent_len = strsize;
+                                                }
+						else if (!uwsgi_strncmp("HTTP_REFERER", 12, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+                                                        wsgi_req->referer = ptrbuf;
+                                                        wsgi_req->referer_len = strsize;
+                                                }
 						else if (!uwsgi_strncmp("DOCUMENT_ROOT", 13, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->document_root = ptrbuf;
 							wsgi_req->document_root_len = strsize;
@@ -1082,7 +1091,7 @@ nextcs:
 	udd = uwsgi.static_maps;
 	while (udd) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("checking for %.*s <-> %.*s\n", wsgi_req->path_info_len, wsgi_req->path_info, udd->keylen, udd->key);
+		uwsgi_log("checking for %.*s <-> %.*s %.*s\n", (int)wsgi_req->path_info_len, wsgi_req->path_info, (int)udd->keylen, udd->key, (int) udd->vallen, udd->value);
 #endif
 		if (udd->status == 0) {
 #ifdef UWSGI_THREADING
@@ -1092,6 +1101,7 @@ nextcs:
 			char *real_docroot = uwsgi_malloc(PATH_MAX + 1);
 			if (!realpath(udd->value, real_docroot)) {
 				free(real_docroot);
+				real_docroot = NULL;
 				udd->value = NULL;
 			}
 #ifdef UWSGI_THREADING
@@ -1128,6 +1138,7 @@ nextsm:
 			char *real_docroot = uwsgi_malloc(PATH_MAX + 1);
 			if (!realpath(udd->value, real_docroot)) {
 				free(real_docroot);
+				real_docroot = NULL;
 				udd->value = NULL;
 			}
 #ifdef UWSGI_THREADING
@@ -1662,18 +1673,31 @@ char *uwsgi_req_append(struct wsgi_request *wsgi_req, char *key, uint16_t keylen
 		return NULL;
 	}
 
+	if (wsgi_req->var_cnt >= uwsgi.vec_size - (4 + 2)) {
+        	uwsgi_log("max vec size reached. skip this header.\n");
+		return NULL;
+	}
+
 	char *ptr = wsgi_req->buffer + wsgi_req->uh.pktsize;
 
 	*ptr++ = (uint8_t) (keylen & 0xff);
 	*ptr++ = (uint8_t) ((keylen >> 8) & 0xff);
 
 	memcpy(ptr, key, keylen);
+	wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptr;
+        wsgi_req->hvec[wsgi_req->var_cnt].iov_len = keylen;
+	wsgi_req->var_cnt++;
 	ptr += keylen;
 
+	
+
 	*ptr++ = (uint8_t) (vallen & 0xff);
 	*ptr++ = (uint8_t) ((vallen >> 8) & 0xff);
 
 	memcpy(ptr, val, vallen);
+	wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptr;
+        wsgi_req->hvec[wsgi_req->var_cnt].iov_len = vallen;
+	wsgi_req->var_cnt++;
 
 	wsgi_req->uh.pktsize += (2 + keylen + 2 + vallen);
 

core/rb_timers.c

@@ -1,65 +1,367 @@
 /*
 
-uWSGI timers implementation
+        uWSGI rbtree implementation based on nginx
 
-based on Linux hrtimers and nginx timeout management.
-
-rbtree with allowed duplicate keys is used
+        Copyright (C) Igor Sysoev
+        Copyright (C) Nginx, Inc.
+        Copyright (C) Unbit S.a.s.
 
+        The red-black tree code is based on the algorithm described in
+        the "Introduction to Algorithms" by Cormen, Leiserson and Rivest.
 */
 
-#include "uwsgi.h"
+#include <uwsgi.h>
 
-struct rb_root *uwsgi_init_rb_timer() {
+#define uwsgi_rbt_red(node)               ((node)->color = 1)
+#define uwsgi_rbt_black(node)             ((node)->color = 0)
+#define uwsgi_rbt_is_red(node)            ((node)->color)
+#define uwsgi_rbt_is_black(node)          (!uwsgi_rbt_is_red(node))
+#define uwsgi_rbt_copy_color(n1, n2)      (n1->color = n2->color)
 
-	struct rb_root *u_rb_root = uwsgi_malloc(sizeof(struct rb_root));
 
-	u_rb_root->rb_node = NULL;
+struct uwsgi_rbtree *uwsgi_init_rb_timer() {
 
-	return u_rb_root;
+	struct uwsgi_rbtree *tree = uwsgi_calloc(sizeof(struct uwsgi_rbtree));
+	struct uwsgi_rb_timer *sentinel = uwsgi_calloc(sizeof(struct uwsgi_rb_timer));
+	// no need to set it black, calloc already did it
+	//uwsgi_rbt_black(sentinel);
+	tree->root = sentinel;
+	tree->sentinel = sentinel;
+
+	return tree;
 }
 
-struct uwsgi_rb_timer *uwsgi_min_rb_timer(struct rb_root *root) {
+struct uwsgi_rb_timer *uwsgi_min_rb_timer(struct uwsgi_rbtree *tree, struct uwsgi_rb_timer *node) {
 
-	struct rb_node *node = root->rb_node;
+	if (!node)
+		node = tree->root;
+	struct uwsgi_rb_timer *sentinel = tree->sentinel;
 
-	if (node == NULL)
-		return NULL;
+	if (tree->root == sentinel) return NULL;
 
-	while (node->rb_left != NULL) {
-		node = node->rb_left;
+	while (node->left != sentinel) {
+		node = node->left;
 	}
 
-	return ((struct uwsgi_rb_timer *) node);
+	return node;
 }
 
-struct uwsgi_rb_timer *uwsgi_add_rb_timer(struct rb_root *root, time_t key, void *data) {
+static void uwsgi_rbtree_lr(struct uwsgi_rb_timer **root, struct uwsgi_rb_timer *sentinel, struct uwsgi_rb_timer *node) {
 
-	struct uwsgi_rb_timer *urbt = uwsgi_malloc(sizeof(struct uwsgi_rb_timer));
-	struct rb_node **p = &root->rb_node, *parent = NULL;
-	struct uwsgi_rb_timer *current_rb_timer;
+	struct uwsgi_rb_timer *temp;
 
-	memset(urbt, 0, sizeof(struct uwsgi_rb_timer));
+	temp = node->right;
+	node->right = temp->left;
 
-	urbt->key = key;
-	urbt->data = data;
+	if (temp->left != sentinel) {
+		temp->left->parent = node;
+	}
 
-	while (*p) {
-		parent = *p;
+	temp->parent = node->parent;
 
-		current_rb_timer = (struct uwsgi_rb_timer *) parent;
+	if (node == *root) {
+		*root = temp;
+
+	}
+	else if (node == node->parent->left) {
+		node->parent->left = temp;
+
+	}
+	else {
+		node->parent->right = temp;
+	}
+
+	temp->left = node;
+	node->parent = temp;
+}
+
+
+static void uwsgi_rbtree_rr(struct uwsgi_rb_timer **root, struct uwsgi_rb_timer *sentinel, struct uwsgi_rb_timer *node) {
+
+	struct uwsgi_rb_timer *temp;
+
+	temp = node->left;
+	node->left = temp->right;
+
+	if (temp->right != sentinel) {
+		temp->right->parent = node;
+	}
+
+	temp->parent = node->parent;
+
+	if (node == *root) {
+		*root = temp;
+
+	}
+	else if (node == node->parent->right) {
+		node->parent->right = temp;
+
+	}
+	else {
+		node->parent->left = temp;
+	}
+
+	temp->right = node;
+	node->parent = temp;
+}
+
+
+static void uwsgi_rbt_add(struct uwsgi_rb_timer *temp, struct uwsgi_rb_timer *node, struct uwsgi_rb_timer *sentinel) {
+        struct uwsgi_rb_timer **p;
+
+        for (;;) {
+
+                p = (node->value < temp->value) ? &temp->left : &temp->right;
+                if (*p == sentinel)
+                        break;
+                temp = *p;
+        }
+
+        *p = node;
+        node->parent = temp;
+        node->left = sentinel;
+        node->right = sentinel;
+        uwsgi_rbt_red(node);
+}
+
+
+struct uwsgi_rb_timer *uwsgi_add_rb_timer(struct uwsgi_rbtree *tree, uint64_t value, void *data) {
+
+	struct uwsgi_rb_timer *node = uwsgi_malloc(sizeof(struct uwsgi_rb_timer));
+	struct uwsgi_rb_timer *new_node = node;
+	node->value = value;
+	node->data = data;
+
+	struct uwsgi_rb_timer *temp = NULL;
+
+	/* a binary tree insert */
+
+	struct uwsgi_rb_timer **root = &tree->root;
+	struct uwsgi_rb_timer *sentinel = tree->sentinel;
+
+	if (*root == sentinel) {
+		node->parent = NULL;
+		node->left = sentinel;
+		node->right = sentinel;
+		uwsgi_rbt_black(node);
+		*root = node;
+		return new_node;
+	}
+
+	uwsgi_rbt_add(*root, node, sentinel);
+
+	/* re-balance tree */
+
+	while (node != *root && uwsgi_rbt_is_red(node->parent)) {
+
+		if (node->parent == node->parent->parent->left) {
+			temp = node->parent->parent->right;
+
+			if (uwsgi_rbt_is_red(temp)) {
+				uwsgi_rbt_black(node->parent);
+				uwsgi_rbt_black(temp);
+				uwsgi_rbt_red(node->parent->parent);
+				node = node->parent->parent;
+
+			}
+			else {
+				if (node == node->parent->right) {
+					node = node->parent;
+					uwsgi_rbtree_lr(root, sentinel, node);
+				}
+
+				uwsgi_rbt_black(node->parent);
+				uwsgi_rbt_red(node->parent->parent);
+				uwsgi_rbtree_rr(root, sentinel, node->parent->parent);
+			}
 
-		if (key <= current_rb_timer->key) {
-			p = &(*p)->rb_left;
 		}
 		else {
-			p = &(*p)->rb_right;
+			temp = node->parent->parent->left;
+
+			if (uwsgi_rbt_is_red(temp)) {
+				uwsgi_rbt_black(node->parent);
+				uwsgi_rbt_black(temp);
+				uwsgi_rbt_red(node->parent->parent);
+				node = node->parent->parent;
+
+			}
+			else {
+				if (node == node->parent->left) {
+					node = node->parent;
+					uwsgi_rbtree_rr(root, sentinel, node);
+				}
+
+				uwsgi_rbt_black(node->parent);
+				uwsgi_rbt_red(node->parent->parent);
+				uwsgi_rbtree_lr(root, sentinel, node->parent->parent);
+			}
 		}
 	}
 
-	rb_link_node((struct rb_node *) urbt, parent, p);
+	uwsgi_rbt_black(*root);
 
-	rb_insert_color((struct rb_node *) urbt, root);
+	return new_node;
+}
 
-	return urbt;
+void uwsgi_del_rb_timer(struct uwsgi_rbtree *tree, struct uwsgi_rb_timer *node) {
+	uint8_t red;
+	struct uwsgi_rb_timer **root, *sentinel, *subst, *temp, *w;
+
+	/* a binary tree delete */
+
+	root = &tree->root;
+	sentinel = tree->sentinel;
+
+	if (node->left == sentinel) {
+		temp = node->right;
+		subst = node;
+
+	}
+	else if (node->right == sentinel) {
+		temp = node->left;
+		subst = node;
+
+	}
+	else {
+		subst = uwsgi_min_rb_timer(tree, node->right);
+
+		if (subst->left != sentinel) {
+			temp = subst->left;
+		}
+		else {
+			temp = subst->right;
+		}
+	}
+
+	if (subst == *root) {
+		*root = temp;
+		uwsgi_rbt_black(temp);
+		return;
+	}
+
+	red = uwsgi_rbt_is_red(subst);
+
+	if (subst == subst->parent->left) {
+		subst->parent->left = temp;
+
+	}
+	else {
+		subst->parent->right = temp;
+	}
+
+	if (subst == node) {
+
+		temp->parent = subst->parent;
+
+	}
+	else {
+
+		if (subst->parent == node) {
+			temp->parent = subst;
+
+		}
+		else {
+			temp->parent = subst->parent;
+		}
+
+		subst->left = node->left;
+		subst->right = node->right;
+		subst->parent = node->parent;
+		uwsgi_rbt_copy_color(subst, node);
+
+		if (node == *root) {
+			*root = subst;
+
+		}
+		else {
+			if (node == node->parent->left) {
+				node->parent->left = subst;
+			}
+			else {
+				node->parent->right = subst;
+			}
+		}
+
+		if (subst->left != sentinel) {
+			subst->left->parent = subst;
+		}
+
+		if (subst->right != sentinel) {
+			subst->right->parent = subst;
+		}
+	}
+
+	if (red) {
+		return;
+	}
+
+	/* a delete fixup */
+
+	while (temp != *root && uwsgi_rbt_is_black(temp)) {
+
+		if (temp == temp->parent->left) {
+			w = temp->parent->right;
+
+			if (uwsgi_rbt_is_red(w)) {
+				uwsgi_rbt_black(w);
+				uwsgi_rbt_red(temp->parent);
+				uwsgi_rbtree_lr(root, sentinel, temp->parent);
+				w = temp->parent->right;
+			}
+
+			if (uwsgi_rbt_is_black(w->left) && uwsgi_rbt_is_black(w->right)) {
+				uwsgi_rbt_red(w);
+				temp = temp->parent;
+
+			}
+			else {
+				if (uwsgi_rbt_is_black(w->right)) {
+					uwsgi_rbt_black(w->left);
+					uwsgi_rbt_red(w);
+					uwsgi_rbtree_rr(root, sentinel, w);
+					w = temp->parent->right;
+				}
+
+				uwsgi_rbt_copy_color(w, temp->parent);
+				uwsgi_rbt_black(temp->parent);
+				uwsgi_rbt_black(w->right);
+				uwsgi_rbtree_lr(root, sentinel, temp->parent);
+				temp = *root;
+			}
+
+		}
+		else {
+			w = temp->parent->left;
+
+			if (uwsgi_rbt_is_red(w)) {
+				uwsgi_rbt_black(w);
+				uwsgi_rbt_red(temp->parent);
+				uwsgi_rbtree_rr(root, sentinel, temp->parent);
+				w = temp->parent->left;
+			}
+
+			if (uwsgi_rbt_is_black(w->left) && uwsgi_rbt_is_black(w->right)) {
+				uwsgi_rbt_red(w);
+				temp = temp->parent;
+
+			}
+			else {
+				if (uwsgi_rbt_is_black(w->left)) {
+					uwsgi_rbt_black(w->right);
+					uwsgi_rbt_red(w);
+					uwsgi_rbtree_lr(root, sentinel, w);
+					w = temp->parent->left;
+				}
+
+				uwsgi_rbt_copy_color(w, temp->parent);
+				uwsgi_rbt_black(temp->parent);
+				uwsgi_rbt_black(w->left);
+				uwsgi_rbtree_rr(root, sentinel, temp->parent);
+				temp = *root;
+			}
+		}
+	}
+
+	uwsgi_rbt_black(temp);
 }

core/regexp.c

@@ -62,40 +62,49 @@ int uwsgi_regexp_ovector(pcre * pattern, pcre_extra * pattern_extra) {
 
 char *uwsgi_regexp_apply_ovec(char *src, int src_n, char *dst, int dst_n, int *ovector, int n) {
 
-	int i;
-	int dollar = 0;
+        int i;
+        int dollar = 0;
 
-	char *res = uwsgi_malloc(dst_n + (src_n * n) + 1);
-	char *ptr = res;
+        size_t dollars = n;
 
-	for (i = 0; i < dst_n; i++) {
-		if (dollar) {
-			if (isdigit((int) dst[i])) {
-				int pos = (dst[i] - 48);
-				if (pos <= n) {
-					pos = pos * 2;
-					memcpy(ptr, src + ovector[pos], ovector[pos + 1] - ovector[pos]);
-					ptr += ovector[pos + 1] - ovector[pos];
-				}
-			}
-			else {
-				*ptr++ = dst[i];
-			}
-			dollar = 0;
-		}
-		else {
-			if (dst[i] == '$') {
-				dollar = 1;
-			}
-			else {
-				*ptr++ = dst[i];
-			}
-		}
-	}
+        for(i=0;i<dst_n;i++) {
+                if (dst[i] == '$') {
+                        dollars++;
+                }
+        }
 
-	*ptr++ = 0;
+        char *res = uwsgi_malloc(dst_n + (src_n * dollars) + 1);
+        char *ptr = res;
 
-	return res;
+        for (i = 0; i < dst_n; i++) {
+                if (dollar) {
+                        if (isdigit((int) dst[i])) {
+                                int pos = (dst[i] - 48);
+                                if (pos <= n) {
+                                        pos = pos * 2;
+                                        memcpy(ptr, src + ovector[pos], ovector[pos + 1] - ovector[pos]);
+                                        ptr += ovector[pos + 1] - ovector[pos];
+                                }
+                        }
+                        else {
+                                *ptr++ = '$';
+                                *ptr++ = dst[i];
+                        }
+                        dollar = 0;
+                }
+                else {
+                        if (dst[i] == '$') {
+                                dollar = 1;
+                        }
+                        else {
+                                *ptr++ = dst[i];
+                        }
+                }
+        }
+
+        *ptr++ = 0;
+
+        return res;
 }
 
 #endif

core/socket.c

@@ -564,14 +564,15 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 	}
 
 #ifdef __linux__
-#ifdef IP_FREEBIND
+#ifndef IP_FREEBIND
+#define IP_FREEBIND 15
+#endif
 	if (uwsgi.freebind) {
 		if (setsockopt(serverfd, SOL_IP, IP_FREEBIND, (const void *) &uwsgi.freebind, sizeof(int)) < 0) {
 			uwsgi_error("IP_FREEBIND setsockopt()");
 			uwsgi_nuclear_blast();
 		}
 	}
-#endif
 #endif
 
 	if (uwsgi.reuse_port) {
@@ -629,7 +630,7 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 	}
 
 #ifdef __linux__
-	long somaxconn = uwsgi_num_from_file("/proc/sys/net/core/somaxconn");
+	long somaxconn = uwsgi_num_from_file("/proc/sys/net/core/somaxconn", 1);
 	if (somaxconn > 0 && uwsgi.listen_queue > somaxconn) {
 		uwsgi_log("Listen queue size is greater than the system max net.core.somaxconn (%i).\n", somaxconn);
 		uwsgi_nuclear_blast();
@@ -717,7 +718,7 @@ int timed_connect(struct pollfd *fdpoll, const struct sockaddr *addr, int addr_s
 
 
 #if defined(__linux__) && defined(SOCK_NONBLOCK) && !defined(OBSOLETE_LINUX_KERNEL)
-	// hmm, nothing to do, as we are already non-blocking
+	uwsgi_socket_b(fdpoll->fd);
 #else
 	/* re-set blocking socket */
 	arg &= (~O_NONBLOCK);
@@ -1483,6 +1484,10 @@ void uwsgi_setup_shared_sockets() {
 	while (shared_sock) {
 		if (!uwsgi.is_a_reload) {
 			char *tcp_port = strrchr(shared_sock->name, ':');
+			int current_defer_accept = uwsgi.no_defer_accept;
+                        if (shared_sock->no_defer) {
+                        	uwsgi.no_defer_accept = 1;
+                        }
 			if (tcp_port == NULL) {
 				shared_sock->fd = bind_to_unix(shared_sock->name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
 				shared_sock->family = AF_UNIX;
@@ -1513,6 +1518,11 @@ void uwsgi_setup_shared_sockets() {
 				uwsgi_log("unable to create shared socket on: %s\n", shared_sock->name);
 				exit(1);
 			}
+ 
+			if (shared_sock->no_defer) {
+                                uwsgi.no_defer_accept = current_defer_accept;
+                        }
+
 		}
 		else {
 			for (i = 3; i < (int) uwsgi.max_fd; i++) {
@@ -1601,7 +1611,7 @@ void uwsgi_map_sockets() {
 				exit(1);
 			}
 			if (fd != uwsgi_sock->fd) {
-				if (dup2(fd, uwsgi_sock->fd)) {
+				if (dup2(fd, uwsgi_sock->fd) < 0) {
 					uwsgi_error("dup2()");
 					exit(1);
 				}
@@ -1692,14 +1702,14 @@ void uwsgi_bind_sockets() {
 		gsa.sa = (struct sockaddr *) &usa;
 		if (!uwsgi.skip_zero && !getsockname(0, gsa.sa, &socket_type_len)) {
 			if (gsa.sa->sa_family == AF_UNIX) {
-				uwsgi_sock = uwsgi_new_socket(usa.sa_un.sun_path);
+				uwsgi_sock = uwsgi_new_socket(uwsgi_getsockname(0));
 				uwsgi_sock->family = AF_UNIX;
 				uwsgi_sock->fd = 0;
 				uwsgi_sock->bound = 1;
 				uwsgi_log("uwsgi socket %d inherited UNIX address %s fd 0\n", uwsgi_get_socket_num(uwsgi_sock), uwsgi_sock->name);
 			}
 			else {
-				uwsgi_sock = uwsgi_new_socket(uwsgi_concat2("::", ""));
+				uwsgi_sock = uwsgi_new_socket(uwsgi_getsockname(0));
 				uwsgi_sock->family = AF_INET;
 				uwsgi_sock->fd = 0;
 				uwsgi_sock->bound = 1;
@@ -1713,7 +1723,7 @@ void uwsgi_bind_sockets() {
 				exit(1);
 			}
 			if (fd != 0) {
-				if (dup2(fd, 0)) {
+				if (dup2(fd, 0) < 0) {
 					uwsgi_error("dup2()");
 					exit(1);
 				}

core/spooler.c

@@ -97,8 +97,18 @@ pid_t spooler_start(struct uwsgi_spooler * uspool) {
 		exit(1);
 	}
 	else if (pid == 0) {
+
+		signal(SIGALRM, SIG_IGN);
+                signal(SIGHUP, SIG_IGN);
+                signal(SIGINT, end_me);
+                signal(SIGTERM, end_me);
 		// USR1 will be used to wake up the spooler
 		uwsgi_unix_signal(SIGUSR1, spooler_wakeup);
+                signal(SIGUSR2, SIG_IGN);
+                signal(SIGPIPE, SIG_IGN);
+                signal(SIGSTOP, SIG_IGN);
+                signal(SIGTSTP, SIG_IGN);
+
 		uwsgi.mywid = -1;
 		uwsgi.mypid = getpid();
 		uspool->pid = uwsgi.mypid;

core/stats.c

@@ -373,7 +373,7 @@ struct uwsgi_stats_pusher *uwsgi_stats_pusher_get(char *name) {
 	return usp;
 }
 
-void uwsgi_stats_pusher_add(struct uwsgi_stats_pusher *pusher, char *arg) {
+struct uwsgi_stats_pusher_instance * uwsgi_stats_pusher_add(struct uwsgi_stats_pusher *pusher, char *arg) {
 	struct uwsgi_stats_pusher_instance *old_uspi = NULL, *uspi = uwsgi.stats_pusher_instances;
 	while (uspi) {
 		old_uspi = uspi;
@@ -389,6 +389,8 @@ void uwsgi_stats_pusher_add(struct uwsgi_stats_pusher *pusher, char *arg) {
 	else {
 		uwsgi.stats_pusher_instances = uspi;
 	}
+
+	return uspi;
 }
 
 void uwsgi_stats_pusher_loop(struct uwsgi_thread *ut) {
@@ -413,12 +415,16 @@ void uwsgi_stats_pusher_loop(struct uwsgi_thread *ut) {
 		while (uspi) {
 			int delta = uspi->freq ? uspi->freq : uwsgi.stats_pusher_default_freq;
 			if ((uspi->last_run + delta) <= now) {
-				if (!us) {
-					us = uwsgi_master_generate_stats();
-					if (!us)
-						goto next;
+				if (uspi->raw) {
+					uspi->pusher->func(uspi, now, NULL, 0);
+				}
+				else {
+					if (!us) {
+						us = uwsgi_master_generate_stats();
+						if (!us) goto next;
+					}
+					uspi->pusher->func(uspi, now, us->base, us->pos);
 				}
-				uspi->pusher->func(uspi, us->base, us->pos);
 				uspi->last_run = now;
 			}
 next:
@@ -456,7 +462,7 @@ void uwsgi_stats_pusher_setup() {
 	}
 }
 
-void uwsgi_register_stats_pusher(char *name, void (*func) (struct uwsgi_stats_pusher_instance *, char *, size_t)) {
+struct uwsgi_stats_pusher *uwsgi_register_stats_pusher(char *name, void (*func) (struct uwsgi_stats_pusher_instance *, time_t, char *, size_t)) {
 
 	struct uwsgi_stats_pusher *pusher = uwsgi.stats_pushers, *old_pusher = NULL;
 
@@ -475,6 +481,8 @@ void uwsgi_register_stats_pusher(char *name, void (*func) (struct uwsgi_stats_pu
 	else {
 		uwsgi.stats_pushers = pusher;
 	}
+
+	return pusher;
 }
 
 struct uwsgi_stats_pusher_file_conf {
@@ -483,7 +491,7 @@ struct uwsgi_stats_pusher_file_conf {
 	char *separator;
 };
 
-void uwsgi_stats_pusher_file(struct uwsgi_stats_pusher_instance *uspi, char *json, size_t json_len) {
+void uwsgi_stats_pusher_file(struct uwsgi_stats_pusher_instance *uspi, time_t now, char *json, size_t json_len) {
 	struct uwsgi_stats_pusher_file_conf *uspic = (struct uwsgi_stats_pusher_file_conf *) uspi->data;
 	if (!uspi->configured) {
 		uspic = uwsgi_calloc(sizeof(struct uwsgi_stats_pusher_file_conf));

core/utils.c

@@ -385,10 +385,17 @@ void uwsgi_as_root() {
 			cap_free(caps);
 
 #ifdef __linux__
+#ifdef SECBIT_KEEP_CAPS
+			if (prctl(SECBIT_KEEP_CAPS, 1, 0, 0, 0) < 0) {
+				uwsgi_error("prctl()");
+				exit(1);
+			}
+#else
 			if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) < 0) {
 				uwsgi_error("prctl()");
 				exit(1);
 			}
+#endif
 #endif
 		}
 #endif
@@ -841,17 +848,19 @@ void uwsgi_linux_ksm_map(void) {
 #endif
 
 #ifdef __linux__
-long uwsgi_num_from_file(char *filename) {
+long uwsgi_num_from_file(char *filename, int quiet) {
 	char buf[16];
 	ssize_t len;
 	int fd = open(filename, O_RDONLY);
 	if (fd < 0) {
-		uwsgi_error_open(filename);
+		if (!quiet)
+			uwsgi_error_open(filename);
 		return -1L;
 	}
 	len = read(fd, buf, sizeof(buf));
 	if (len == 0) {
-		uwsgi_log("read error %s\n", filename);
+		if (!quiet)
+			uwsgi_log("read error %s\n", filename);
 		close(fd);
 		return -1L;
 	}
@@ -2023,6 +2032,24 @@ int uwsgi_logic_opt_for(char *key, char *value) {
 	return 1;
 }
 
+int uwsgi_logic_opt_for_glob(char *key, char *value) {
+
+	glob_t g;
+	int i;
+        if (glob(uwsgi.logic_opt_data, GLOB_MARK | GLOB_NOCHECK, NULL, &g)) {
+                uwsgi_error("uwsgi_logic_opt_for_glob()");
+                return 0;
+        }
+
+	for (i = 0; i < (int) g.gl_pathc; i++) {
+                add_exported_option(key, uwsgi_substitute(value, "%(_)", g.gl_pathv[i]), 0);
+        }
+
+	globfree(&g);
+
+        return 1;
+}
+
 void add_exported_option(char *key, char *value, int configured) {
 
 	struct uwsgi_string_list *blacklist = uwsgi.blacklist;
@@ -2684,15 +2711,10 @@ void init_magic_table(char *magic_table[]) {
 }
 
 char *uwsgi_get_last_char(char *what, char c) {
-	int i, j = 0;
+	int i;
 	char *ptr = NULL;
 
-	if (!strncmp("http://", what, 7))
-		j = 7;
-	if (!strncmp("emperor://", what, 10))
-		j = 10;
-
-	for (i = j; i < (int) strlen(what); i++) {
+	for (i = 0; i < (int) strlen(what); i++) {
 		if (what[i] == c) {
 			ptr = what + i;
 		}
@@ -2892,7 +2914,7 @@ size_t uwsgi_str_num(char *str, int len) {
 	int i;
 	size_t num = 0;
 
-	size_t delta = pow(10, len);
+	uint64_t delta = pow(10, len);
 
 	for (i = 0; i < len; i++) {
 		delta = delta / 10;
@@ -3101,6 +3123,7 @@ struct uwsgi_string_list *uwsgi_string_new_list(struct uwsgi_string_list **list,
 	}
 	uwsgi_string->next = NULL;
 	uwsgi_string->custom = 0;
+	uwsgi_string->custom2 = 0;
 
 	return uwsgi_string;
 }
@@ -3271,10 +3294,46 @@ pid_t uwsgi_run_command(char *command, int *stdin_fd, int stdout_fd) {
 	}
 
 	uwsgi_close_all_sockets();
+	//uwsgi_close_all_fds();
+	int i;
+	for (i = 3; i < (int) uwsgi.max_fd; i++) {
+		if (stdin_fd) {
+			if (i == stdin_fd[0] || i == stdin_fd[1]) {
+				continue;
+			} 
+		}
+		if (stdout_fd > -1) {
+			if (i == stdout_fd) {
+				continue;
+			}
+		}
+#ifdef __APPLE__
+                fcntl(i, F_SETFD, FD_CLOEXEC);
+#else
+                close(i);
+#endif
+        }
+
+	
 
 	if (stdin_fd) {
 		close(stdin_fd[1]);
 	}
+	else {
+		if (!uwsgi_valid_fd(0)) {
+			int in_fd = open("/dev/null", O_RDONLY);
+			if (in_fd < 0) {
+				uwsgi_error_open("/dev/null");
+			}
+			else {
+				if (in_fd != 0) {
+					if (dup2(in_fd, 0) < 0) {
+						uwsgi_error("dup2()");
+					}
+				}
+			}
+		}
+	}
 
 	if (stdout_fd > -1 && stdout_fd != 1) {
 		if (dup2(stdout_fd, 1) < 0) {
@@ -4068,31 +4127,53 @@ struct uwsgi_app *uwsgi_add_app(int id, uint8_t modifier1, char *mountpoint, int
 
 char *uwsgi_check_touches(struct uwsgi_string_list *touch_list) {
 
-	struct uwsgi_string_list *touch = touch_list;
-	while (touch) {
-		struct stat tr_st;
-		if (stat(touch->value, &tr_st)) {
-			uwsgi_log("unable to stat() %s, events will be triggered as soon as the file is created\n", touch->value);
-			touch->custom = 0;
-		}
-		else {
-			if (!touch->custom)
-				touch->custom = (uint64_t) tr_st.st_mtime;
-			if ((uint64_t) tr_st.st_mtime > touch->custom) {
-#ifdef UWSGI_DEBUG
-				uwsgi_log("[uwsgi-check-touches] modification detected on %s: %llu -> %llu\n", touch->value, (unsigned long long) touch->custom, (unsigned long long) tr_st.st_mtime);
-#endif
-				touch->custom = (uint64_t) tr_st.st_mtime;
-				return touch->value;
-			}
-			touch->custom = (uint64_t) tr_st.st_mtime;
-		}
-		touch = touch->next;
-	}
+        // touch->value   - file path
+        // touch->custom  - file timestamp
+        // touch->custom2 - 0 if file exists, 1 if it does not exists
 
-	return NULL;
+        struct uwsgi_string_list *touch = touch_list;
+        while (touch) {
+                struct stat tr_st;
+                if (stat(touch->value, &tr_st)) {
+                        if (touch->custom && !touch->custom2) {
+#ifdef UWSGI_DEBUG
+                                uwsgi_log("[uwsgi-check-touches] File %s was removed\n", touch->value);
+#endif
+                                touch->custom2 = 1;
+                                return touch->value;
+                        }
+                        else if (!touch->custom && !touch->custom2) {
+                                uwsgi_log("unable to stat() %s, events will be triggered as soon as the file is created\n", touch->value);
+                                touch->custom2 = 1;
+                        }
+                        touch->custom = 0;
+                }
+                else {
+                        if (!touch->custom && touch->custom2) {
+#ifdef UWSGI_DEBUG
+                                uwsgi_log("[uwsgi-check-touches] File was created: %s\n", touch->value);
+#endif
+                                touch->custom = (uint64_t) tr_st.st_mtime;
+                                touch->custom2 = 0;
+                                return touch->value;
+                        }
+                        else if (touch->custom && (uint64_t) tr_st.st_mtime > touch->custom) {
+#ifdef UWSGI_DEBUG
+                                uwsgi_log("[uwsgi-check-touches] modification detected on %s: %llu -> %llu\n", touch->value, (unsigned long long) touch->custom, (unsigned long long) tr_st.st_mtime);
+#endif
+                                touch->custom = (uint64_t) tr_st.st_mtime;
+                                return touch->value;
+                        }
+                        touch->custom = (uint64_t) tr_st.st_mtime;
+                }
+                touch = touch->next;
+        }
+
+        return NULL;
 }
 
+
+
 char *uwsgi_chomp(char *str) {
 	size_t i;
 	for (i = 0; i < strlen(str); i++) {
@@ -4798,7 +4879,7 @@ static void *uwsgi_thread_run(void *arg) {
 
 struct uwsgi_thread *uwsgi_thread_new(void (*func) (struct uwsgi_thread *)) {
 
-	struct uwsgi_thread *ut = uwsgi_malloc(sizeof(struct uwsgi_thread));
+	struct uwsgi_thread *ut = uwsgi_calloc(sizeof(struct uwsgi_thread));
 
 #if defined(SOCK_SEQPACKET) && defined(__linux__)
 	if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, ut->pipe)) {
@@ -5036,3 +5117,47 @@ end:
 	free(symbol_name);
 	return ret;
 }
+
+int uwsgi_valid_fd(int fd) {
+	int ret = fcntl(fd, F_GETFL);
+	if (ret == 0) {
+		return 1;
+	}
+	return 0;
+}
+
+void uwsgi_close_all_fds(void) {
+	int i;
+	for (i = 3; i < (int) uwsgi.max_fd; i++) {
+#ifdef __APPLE__
+        	fcntl(i, F_SETFD, FD_CLOEXEC);
+#else
+                close(i);
+#endif
+	}
+}
+
+
+
+/*
+        even if it is marked as non-blocking, so not use in request plugins as it uses poll() and not the hooks
+*/
+int uwsgi_write_nb(int fd, char *buf, size_t remains, int timeout) {
+        char *ptr = buf;
+        while(remains > 0) {
+                int ret = uwsgi_waitfd_write(fd, timeout);
+                if (ret > 0) {
+                        ssize_t len = write(fd, ptr, remains);
+                        if (len <= 0) {
+                                return -1;
+                        }
+                        ptr += len;
+                        remains -= len;
+                        continue;
+                }
+                return -1;
+        }
+
+        return 0;
+}
+

core/uwsgi.c

@@ -2,7 +2,7 @@
 
  *** uWSGI ***
 
- Copyright (C) 2009-2012 Unbit S.a.s. <info@unbit.it>
+ Copyright (C) 2009-2013 Unbit S.a.s. <info@unbit.it>
 
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
@@ -38,12 +38,16 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"socket", required_argument, 's', "bind to the specified UNIX/TCP socket using default protocol", uwsgi_opt_add_socket, NULL, 0},
 	{"uwsgi-socket", required_argument, 's', "bind to the specified UNIX/TCP socket using uwsgi protocol", uwsgi_opt_add_socket, "uwsgi", 0},
 	{"http-socket", required_argument, 0, "bind to the specified UNIX/TCP socket using HTTP protocol", uwsgi_opt_add_socket, "http", 0},
+	{"http-socket-modifier1", required_argument, 0, "force the specified modifier1 when using HTTP protocol", uwsgi_opt_set_64bit, &uwsgi.http_modifier1, 0},
+        {"http-socket-modifier2", required_argument, 0, "force the specified modifier2 when using HTTP protocol", uwsgi_opt_set_64bit, &uwsgi.http_modifier2, 0},
 	{"fastcgi-socket", required_argument, 0, "bind to the specified UNIX/TCP socket using FastCGI protocol", uwsgi_opt_add_socket, "fastcgi", 0},
 	{"protocol", required_argument, 0, "force the specified protocol for default sockets", uwsgi_opt_set_str, &uwsgi.protocol, 0},
 	{"socket-protocol", required_argument, 0, "force the specified protocol for default sockets", uwsgi_opt_set_str, &uwsgi.protocol, 0},
 	{"shared-socket", required_argument, 0, "create a shared sacket for advanced jailing or ipc", uwsgi_opt_add_shared_socket, NULL, 0},
+	{"undeferred-shared-socket", required_argument, 0, "create a shared sacket for advanced jailing or ipc (undeferred mode)", uwsgi_opt_add_shared_socket, NULL, 0},
 	{"processes", required_argument, 'p', "spawn the specified number of workers/processes", uwsgi_opt_set_int, &uwsgi.numproc, 0},
 	{"workers", required_argument, 'p', "spawn the specified number of workers/processes", uwsgi_opt_set_int, &uwsgi.numproc, 0},
+	{"thunder-lock", no_argument, 0, "serialize accept() usage (if possibie)", uwsgi_opt_true, &uwsgi.use_thunder_lock, 0},
 	{"harakiri", required_argument, 't', "set harakiri timeout", uwsgi_opt_set_dyn, (void *) UWSGI_OPTION_HARAKIRI, 0},
 	{"harakiri-verbose", no_argument, 0, "enable verbose mode for harakiri", uwsgi_opt_true, &uwsgi.harakiri_verbose, 0},
 	{"harakiri-no-arh", no_argument, 0, "do not enable harakiri during after-request-hook", uwsgi_opt_true, &uwsgi.harakiri_no_arh, 0},
@@ -62,6 +66,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"declare-option", required_argument, 0, "declare a new uWSGI custom option", uwsgi_opt_add_custom_option, NULL, UWSGI_OPT_IMMEDIATE},
 
 	{"for", required_argument, 0, "(opt logic) for cycle", uwsgi_opt_logic, (void *) uwsgi_logic_opt_for, UWSGI_OPT_IMMEDIATE},
+	{"for-glob", required_argument, 0, "(opt logic) for cycle (expand glob)", uwsgi_opt_logic, (void *) uwsgi_logic_opt_for_glob, UWSGI_OPT_IMMEDIATE},
 	{"endfor", optional_argument, 0, "(opt logic) end for cycle", uwsgi_opt_noop, NULL, UWSGI_OPT_IMMEDIATE},
 
 	{"if-opt", required_argument, 0, "(opt logic) check for option", uwsgi_opt_logic, (void *) uwsgi_logic_opt_if_opt, UWSGI_OPT_IMMEDIATE},
@@ -104,7 +109,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"suspend", required_argument, 0, "suspend an instance", uwsgi_opt_pidfile_signal, (void *) SIGTSTP, UWSGI_OPT_IMMEDIATE},
 	{"resume", required_argument, 0, "resume an instance", uwsgi_opt_pidfile_signal, (void *) SIGTSTP, UWSGI_OPT_IMMEDIATE},
 
-	{"connect-and-read", required_argument, 0, "connect to a scoekt and wait for data from it", uwsgi_opt_connect_and_read, NULL, UWSGI_OPT_IMMEDIATE},
+	{"connect-and-read", required_argument, 0, "connect to a socket and wait for data from it", uwsgi_opt_connect_and_read, NULL, UWSGI_OPT_IMMEDIATE},
+	{"extract", required_argument, 0, "fetch/dump any supported address to stdout", uwsgi_opt_extract, NULL, UWSGI_OPT_IMMEDIATE},
 
 	{"listen", required_argument, 'l', "set the socket listen queue size", uwsgi_opt_set_int, &uwsgi.listen_queue, 0},
 	{"max-vars", required_argument, 'v', "set the amount of internal iovec/vars structures", uwsgi_opt_max_vars, NULL, 0},
@@ -124,6 +130,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"map-socket", required_argument, 0, "map sockets to specific workers", uwsgi_opt_add_string_list, &uwsgi.map_socket, 0},
 #ifdef UWSGI_THREADING
 	{"enable-threads", no_argument, 'T', "enable threads", uwsgi_opt_true, &uwsgi.has_threads, 0},
+	{"no-threads-wait", no_argument, 0, "do not wait for threads cancellation on quit/reload", uwsgi_opt_true, &uwsgi.no_threads_wait, 0},
 #endif
 
 	{"auto-procname", no_argument, 0, "automatically set processes name to something meaningful", uwsgi_opt_true, &uwsgi.auto_procname, 0},
@@ -137,6 +144,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"need-app", no_argument, 0, "exit if no app can be loaded", uwsgi_opt_true, &uwsgi.need_app, 0},
 	{"master", no_argument, 'M', "enable master process", uwsgi_opt_true, &uwsgi.master_process, 0},
 	{"emperor", required_argument, 0, "run the Emperor", uwsgi_opt_add_string_list, &uwsgi.emperor, 0},
+	{"emperor-procname", required_argument, 0, "set the Emperor process name", uwsgi_opt_set_str, &uwsgi.emperor_procname, 0},
 	{"emperor-freq", required_argument, 0, "set the Emperor scan frequency (default 3 seconds)", uwsgi_opt_set_int, &uwsgi.emperor_freq, 0},
 	{"emperor-required-heartbeat", required_argument, 0, "set the Emperor tolerance about heartbeats", uwsgi_opt_set_int, &uwsgi.emperor_heartbeat, 0},
 	{"emperor-pidfile", required_argument, 0, "write the Emperor pid in the specified file", uwsgi_opt_set_str, &uwsgi.emperor_pidfile, 0},
@@ -375,6 +383,9 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"alarm", required_argument, 0, "create a new alarm, syntax: <alarm> <plugin:args>", uwsgi_opt_add_string_list, &uwsgi.alarm_list, UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
 	{"alarm-freq", required_argument, 0, "tune the anti-loop alam system (default 3 seconds)", uwsgi_opt_set_int, &uwsgi.alarm_freq, 0},
 	{"log-alarm", required_argument, 0, "raise the specified alarm when a log line matches the specified regexp, syntax: <alarm>[,alarm...] <regexp>", uwsgi_opt_add_string_list, &uwsgi.alarm_logs_list, UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
+	{"alarm-log", required_argument, 0, "raise the specified alarm when a log line matches the specified regexp, syntax: <alarm>[,alarm...] <regexp>", uwsgi_opt_add_string_list, &uwsgi.alarm_logs_list, UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
+	{"not-log-alarm", required_argument, 0, "skip the specified alarm when a log line matches the specified regexp, syntax: <alarm>[,alarm...] <regexp>", uwsgi_opt_add_string_list_custom, &uwsgi.alarm_logs_list, UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
+        {"not-alarm-log", required_argument, 0, "skip the specified alarm when a log line matches the specified regexp, syntax: <alarm>[,alarm...] <regexp>", uwsgi_opt_add_string_list_custom, &uwsgi.alarm_logs_list, UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
 	{"alarm-list", no_argument, 0, "list enabled alarms", uwsgi_opt_true, &uwsgi.alarms_list, 0},
 	{"alarms-list", no_argument, 0, "list enabled alarms", uwsgi_opt_true, &uwsgi.alarms_list, 0},
 #endif
@@ -469,6 +480,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 #endif
 
 	{"offload-threads", required_argument, 0, "set the number of offload threads to spawn (per-worker, default 0)", uwsgi_opt_set_int, &uwsgi.offload_threads, 0},
+	{"offload-thread", required_argument, 0, "set the number of offload threads to spawn (per-worker, default 0)", uwsgi_opt_set_int, &uwsgi.offload_threads, 0},
 
 	{"file-serve-mode", required_argument, 0, "set static file serving mode", uwsgi_opt_fileserve_mode, NULL, UWSGI_OPT_MIME},
 	{"fileserve-mode", required_argument, 0, "set static file serving mode", uwsgi_opt_fileserve_mode, NULL, UWSGI_OPT_MIME},
@@ -675,6 +687,17 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 	char *tmp = NULL;
 	char *fullname = filename;
 
+	magic_table['o'] = filename;
+
+	if (uwsgi_check_scheme(filename) || !strcmp(filename, "-")) {
+		return;
+	}
+
+        char *section = uwsgi_get_last_char(filename, ':');
+        if (section) {
+                *section = 0;
+	}
+
 	// we have a special case for symlinks
 	if (uwsgi_is_link(filename)) {
 		if (filename[0] != '/') {
@@ -684,19 +707,16 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 	else {
 
 		fullname = uwsgi_expand_path(filename, strlen(filename), NULL);
-		if (fullname) {
-			char *minimal_name = uwsgi_malloc(strlen(fullname) + 1);
-			memcpy(minimal_name, fullname, strlen(fullname));
-			minimal_name[strlen(fullname)] = 0;
-			free(fullname);
-			fullname = minimal_name;
-		}
-		else {
-			fullname = filename;
+		if (!fullname) {
+			exit(1);
 		}
+		char *minimal_name = uwsgi_malloc(strlen(fullname) + 1);
+		memcpy(minimal_name, fullname, strlen(fullname));
+		minimal_name[strlen(fullname)] = 0;
+		free(fullname);
+		fullname = minimal_name;
 	}
 
-	magic_table['o'] = filename;
 	magic_table['p'] = fullname;
 	magic_table['s'] = uwsgi_get_last_char(fullname, '/') + 1;
 	magic_table['d'] = uwsgi_concat2n(magic_table['p'], magic_table['s'] - magic_table['p'], "", 0);
@@ -730,6 +750,11 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 		magic_table['e'] = uwsgi_get_last_char(filename, '.') + 1;
 	if (uwsgi_get_last_char(magic_table['s'], '.'))
 		magic_table['n'] = uwsgi_concat2n(magic_table['s'], uwsgi_get_last_char(magic_table['s'], '.') - magic_table['s'], "", 0);
+
+	if (section) {
+		magic_table['x'] = section+1;
+		*section = ':';
+	}
 }
 
 int find_worker_id(pid_t pid) {
@@ -759,6 +784,9 @@ void warn_pipe() {
 void wait_for_threads() {
 	int i, ret;
 
+	// on some platform thread cancellation is REALLY flaky
+	if (uwsgi.no_threads_wait) return;
+
 	int sudden_death = 0;
 
 	pthread_mutex_lock(&uwsgi.six_feet_under_lock);
@@ -1641,6 +1669,14 @@ int main(int argc, char *argv[], char *envp[]) {
 
 	struct utsname uuts;
 
+	// signal mask is inherited, and sme process manager could make a real mess...
+        sigset_t smask;
+        sigfillset(&smask);
+        if (sigprocmask(SIG_UNBLOCK, &smask, NULL)) {
+                uwsgi_error("sigprocmask()");
+        }
+
+	signal(SIGCHLD, SIG_DFL);
 	signal(SIGSEGV, uwsgi_segfault);
 	signal(SIGFPE, uwsgi_fpe);
 	signal(SIGHUP, SIG_IGN);
@@ -2308,9 +2344,9 @@ int uwsgi_start(void *v_argv) {
 #endif
 
 #ifdef UWSGI_UDP
-	if (!uwsgi.sockets && !ushared->gateways_cnt && !uwsgi.no_server && !uwsgi.udp_socket && !uwsgi.emperor && !uwsgi.command_mode) {
+	if (!uwsgi.sockets && !ushared->gateways_cnt && !uwsgi.no_server && !uwsgi.udp_socket && !uwsgi.emperor && !uwsgi.command_mode && !uwsgi.daemons_cnt) {
 #else
-	if (!uwsgi.sockets && !ushared->gateways_cnt && !uwsgi.no_server && !uwsgi.emperor && !uwsgi.command_mode) {
+	if (!uwsgi.sockets && !ushared->gateways_cnt && !uwsgi.no_server && !uwsgi.emperor && !uwsgi.command_mode && !uwsgi.daemons_cnt) {
 #endif
 		uwsgi_log("The -s/--socket option is missing and stdin is not a socket.\n");
 		exit(1);
@@ -2671,7 +2707,7 @@ next2:
 		}
 
 		if (uwsgi.sockets->fd != 0) {
-			if (dup2(uwsgi.sockets->fd, 0)) {
+			if (dup2(uwsgi.sockets->fd, 0) < 0) {
 				uwsgi_error("dup2()");
 			}
 		}
@@ -2869,7 +2905,7 @@ wait_for_call_of_duty:
 		uwsgi_ignition();
 	}
 	// never here
-	pthread_exit(NULL);
+	end_me(0);
 }
 
 /*
@@ -3275,6 +3311,35 @@ void uwsgi_opt_add_string_list(char *opt, char *value, void *list) {
 	uwsgi_string_new_list(ptr, value);
 }
 
+void uwsgi_opt_add_addr_list(char *opt, char *value, void *list) {
+       struct uwsgi_string_list **ptr = (struct uwsgi_string_list **) list;
+       int af = AF_INET;
+#ifdef UWSGI_IPV6
+       void *ip = uwsgi_malloc(16);
+       if (strchr(value, ':')) {
+               af = AF_INET6;
+       }
+#else
+       void *ip = uwsgi_malloc(4);
+#endif
+       
+       if (inet_pton(af, value, ip) <= 0) {
+               uwsgi_log("%s: invalid address\n", opt);
+               uwsgi_error("uwsgi_opt_add_addr_list()");
+               exit(1);
+       }
+
+        struct uwsgi_string_list *usl = uwsgi_string_new_list(ptr, ip);
+       usl->custom = af;
+       usl->custom_ptr = value;
+}
+
+void uwsgi_opt_add_string_list_custom(char *opt, char *value, void *list) {
+        struct uwsgi_string_list **ptr = (struct uwsgi_string_list **) list;
+        struct uwsgi_string_list *usl = uwsgi_string_new_list(ptr, value);
+        usl->custom = 1;
+}
+
 #ifdef UWSGI_PCRE
 void uwsgi_opt_add_regexp_list(char *opt, char *value, void *list) {
 	struct uwsgi_regexp_list **ptr = (struct uwsgi_regexp_list **) list;
@@ -3294,7 +3359,10 @@ void uwsgi_opt_add_regexp_custom_list(char *opt, char *value, void *list) {
 #endif
 
 void uwsgi_opt_add_shared_socket(char *opt, char *value, void *protocol) {
-	uwsgi_new_shared_socket(generate_socket_name(value));
+	struct uwsgi_socket *us = uwsgi_new_shared_socket(generate_socket_name(value));
+	if (!strcmp(opt, "undeferred-shared-socket")) {
+		us->no_defer = 1;
+	}
 }
 
 void uwsgi_opt_add_socket(char *opt, char *value, void *protocol) {
@@ -3857,3 +3925,18 @@ void uwsgi_opt_connect_and_read(char *opt, char *address, void *foobar) {
 		uwsgi_log("%.*s", (int) len, buf);
 	}
 }
+
+void uwsgi_opt_extract(char *opt, char *address, void *foobar) {
+
+	int len = 0;
+	char *buf;
+
+	buf = uwsgi_open_and_read(address, &len, 0, NULL);
+	if (len > 0) {
+		if (write(1, buf, len) != len) {
+			uwsgi_error("write()");
+			exit(1);
+		};
+	};
+	exit(0);
+}

core/yaml.c

@@ -137,7 +137,7 @@ void uwsgi_yaml_config(char *file, char *magic_table[]) {
 		exit(1);
 	}
 
-	yaml_parser_set_input_string(&parser, (const unsigned char *) yaml, (size_t) len - 1);
+	yaml_parser_set_input_string(&parser, (unsigned char *) yaml, (size_t) len - 1);
 
 	while (parsing) {
 		if (!yaml_parser_scan(&parser, &token)) {

ext/uwsgi/extconf.rb

@@ -0,0 +1,15 @@
+require 'net/http'
+
+Net::HTTP.start("uwsgi.it") do |http|
+  resp = http.get("/install")
+  open("install.sh", "wb") do |file|
+      file.write(resp.body)
+  end
+end
+
+system("bash install.sh rack #{Dir.pwd}/uwsgi.ruby")
+
+open("Makefile", "w") do |file|
+  file.write("all:\n")
+  file.write("\t\n")
+end

lib/rbtree.c

@@ -1,309 +0,0 @@
-/*
-
-  *** uWSGI, stripped down version of Linux rbtree ***
-
-
-  Red Black Trees
-  (C) 1999  Andrea Arcangeli <andrea@suse.de>
-  (C) 2002  David Woodhouse <dwmw2@infradead.org>
-  
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
-
-*/
-
-#include "../uwsgi.h"
-
-static inline void rb_set_parent(struct rb_node *rb, struct rb_node *p)
-{
-        rb->rb_parent_color = (rb->rb_parent_color & 3) | (unsigned long)p;
-}
-static inline void rb_set_color(struct rb_node *rb, int color)
-{
-        rb->rb_parent_color = (rb->rb_parent_color & ~1) | color;
-}
-
-
-static void __rb_rotate_left(struct rb_node *node, struct rb_root *root)
-{
-	struct rb_node *right = node->rb_right;
-	struct rb_node *parent = rb_parent(node);
-
-	if ((node->rb_right = right->rb_left))
-		rb_set_parent(right->rb_left, node);
-	right->rb_left = node;
-
-	rb_set_parent(right, parent);
-
-	if (parent)
-	{
-		if (node == parent->rb_left)
-			parent->rb_left = right;
-		else
-			parent->rb_right = right;
-	}
-	else
-		root->rb_node = right;
-	rb_set_parent(node, right);
-}
-
-static void __rb_rotate_right(struct rb_node *node, struct rb_root *root)
-{
-	struct rb_node *left = node->rb_left;
-	struct rb_node *parent = rb_parent(node);
-
-	if ((node->rb_left = left->rb_right))
-		rb_set_parent(left->rb_right, node);
-	left->rb_right = node;
-
-	rb_set_parent(left, parent);
-
-	if (parent)
-	{
-		if (node == parent->rb_right)
-			parent->rb_right = left;
-		else
-			parent->rb_left = left;
-	}
-	else
-		root->rb_node = left;
-	rb_set_parent(node, left);
-}
-
-void rb_insert_color(struct rb_node *node, struct rb_root *root)
-{
-	struct rb_node *parent, *gparent;
-
-	while ((parent = rb_parent(node)) && rb_is_red(parent))
-	{
-		gparent = rb_parent(parent);
-
-		if (parent == gparent->rb_left)
-		{
-			{
-				register struct rb_node *uncle = gparent->rb_right;
-				if (uncle && rb_is_red(uncle))
-				{
-					rb_set_black(uncle);
-					rb_set_black(parent);
-					rb_set_red(gparent);
-					node = gparent;
-					continue;
-				}
-			}
-
-			if (parent->rb_right == node)
-			{
-				register struct rb_node *tmp;
-				__rb_rotate_left(parent, root);
-				tmp = parent;
-				parent = node;
-				node = tmp;
-			}
-
-			rb_set_black(parent);
-			rb_set_red(gparent);
-			__rb_rotate_right(gparent, root);
-		} else {
-			{
-				register struct rb_node *uncle = gparent->rb_left;
-				if (uncle && rb_is_red(uncle))
-				{
-					rb_set_black(uncle);
-					rb_set_black(parent);
-					rb_set_red(gparent);
-					node = gparent;
-					continue;
-				}
-			}
-
-			if (parent->rb_left == node)
-			{
-				register struct rb_node *tmp;
-				__rb_rotate_right(parent, root);
-				tmp = parent;
-				parent = node;
-				node = tmp;
-			}
-
-			rb_set_black(parent);
-			rb_set_red(gparent);
-			__rb_rotate_left(gparent, root);
-		}
-	}
-
-	rb_set_black(root->rb_node);
-}
-
-static void __rb_erase_color(struct rb_node *node, struct rb_node *parent,
-			     struct rb_root *root)
-{
-	struct rb_node *other;
-
-	while ((!node || rb_is_black(node)) && node != root->rb_node)
-	{
-		if (parent->rb_left == node)
-		{
-			other = parent->rb_right;
-			if (rb_is_red(other))
-			{
-				rb_set_black(other);
-				rb_set_red(parent);
-				__rb_rotate_left(parent, root);
-				other = parent->rb_right;
-			}
-			if ((!other->rb_left || rb_is_black(other->rb_left)) &&
-			    (!other->rb_right || rb_is_black(other->rb_right)))
-			{
-				rb_set_red(other);
-				node = parent;
-				parent = rb_parent(node);
-			}
-			else
-			{
-				if (!other->rb_right || rb_is_black(other->rb_right))
-				{
-					rb_set_black(other->rb_left);
-					rb_set_red(other);
-					__rb_rotate_right(other, root);
-					other = parent->rb_right;
-				}
-				rb_set_color(other, rb_color(parent));
-				rb_set_black(parent);
-				rb_set_black(other->rb_right);
-				__rb_rotate_left(parent, root);
-				node = root->rb_node;
-				break;
-			}
-		}
-		else
-		{
-			other = parent->rb_left;
-			if (rb_is_red(other))
-			{
-				rb_set_black(other);
-				rb_set_red(parent);
-				__rb_rotate_right(parent, root);
-				other = parent->rb_left;
-			}
-			if ((!other->rb_left || rb_is_black(other->rb_left)) &&
-			    (!other->rb_right || rb_is_black(other->rb_right)))
-			{
-				rb_set_red(other);
-				node = parent;
-				parent = rb_parent(node);
-			}
-			else
-			{
-				if (!other->rb_left || rb_is_black(other->rb_left))
-				{
-					rb_set_black(other->rb_right);
-					rb_set_red(other);
-					__rb_rotate_left(other, root);
-					other = parent->rb_left;
-				}
-				rb_set_color(other, rb_color(parent));
-				rb_set_black(parent);
-				rb_set_black(other->rb_left);
-				__rb_rotate_right(parent, root);
-				node = root->rb_node;
-				break;
-			}
-		}
-	}
-	if (node)
-		rb_set_black(node);
-}
-
-void rb_erase(struct rb_node *node, struct rb_root *root)
-{
-	struct rb_node *child, *parent;
-	int color;
-
-	if (!node->rb_left)
-		child = node->rb_right;
-	else if (!node->rb_right)
-		child = node->rb_left;
-	else
-	{
-		struct rb_node *old = node, *left;
-
-		node = node->rb_right;
-		while ((left = node->rb_left) != NULL)
-			node = left;
-
-		if (rb_parent(old)) {
-			if (rb_parent(old)->rb_left == old)
-				rb_parent(old)->rb_left = node;
-			else
-				rb_parent(old)->rb_right = node;
-		} else
-			root->rb_node = node;
-
-		child = node->rb_right;
-		parent = rb_parent(node);
-		color = rb_color(node);
-
-		if (parent == old) {
-			parent = node;
-		} else {
-			if (child)
-				rb_set_parent(child, parent);
-			parent->rb_left = child;
-
-			node->rb_right = old->rb_right;
-			rb_set_parent(old->rb_right, node);
-		}
-
-		node->rb_parent_color = old->rb_parent_color;
-		node->rb_left = old->rb_left;
-		rb_set_parent(old->rb_left, node);
-
-		goto color;
-	}
-
-	parent = rb_parent(node);
-	color = rb_color(node);
-
-	if (child)
-		rb_set_parent(child, parent);
-	if (parent)
-	{
-		if (parent->rb_left == node)
-			parent->rb_left = child;
-		else
-			parent->rb_right = child;
-	}
-	else
-		root->rb_node = child;
-
- color:
-	if (color == RB_BLACK)
-		__rb_erase_color(child, parent, root);
-}
-
-#ifdef __clang__
-void rb_link_node(struct rb_node * node, struct rb_node * parent,
-                                struct rb_node ** rb_link)
-#else
-inline void rb_link_node(struct rb_node * node, struct rb_node * parent,
-                                struct rb_node ** rb_link)
-#endif
-{
-        node->rb_parent_color = (unsigned long )parent;
-        node->rb_left = node->rb_right = NULL;
-
-        *rb_link = node;
-}
-

plugins/alarm_xmpp/gloox.cc

@@ -1,5 +1,6 @@
 #include "../../uwsgi.h"
 #include <gloox/client.h>
+#include <gloox/error.h>
 #include <gloox/message.h>
 #include <gloox/connectionlistener.h>
 #include <gloox/connectiontcpclient.h>
@@ -51,11 +52,14 @@ class Jabbo : public ConnectionListener{
 		event_queue_add_fd_read(u_thread->queue, fd);
 		event_queue_add_fd_read(u_thread->queue, u_thread->pipe[1]);
 		u_connected = 1;
+		uwsgi_log("[uwsgi-xmpp] connected to the XMPP server\n");
     	}
 
     	virtual void onDisconnect(ConnectionError e) {
+		uwsgi_log("[uwsgi-xmpp] trying reconnect to the XMPP server...\n");
 		if (u_connected) {
-			event_queue_del_fd(u_thread->queue, fd, event_queue_read());
+			// no need to remove it as it is already closed...
+			//event_queue_del_fd(u_thread->queue, fd, event_queue_read());
 			event_queue_del_fd(u_thread->queue, u_thread->pipe[1], event_queue_read());
 		}
         	sleep(1);
@@ -64,6 +68,16 @@ class Jabbo : public ConnectionListener{
         	fd = static_cast<ConnectionTCPClient*>( client->connectionImpl() )->socket();
     	}
 
+	virtual void onResourceBindError(const Error *error) {
+		uwsgi_log("[uwsgi-xmpp] onResourceBindError(): %s\n", error->text().c_str());
+		client->disconnect();
+	}
+
+	virtual void onSessionCreateError(const Error *error) {
+		uwsgi_log("[uwsgi-xmpp] onSessionCreateError(): %s\n", error->text().c_str());
+		client->disconnect();
+	}
+
 	virtual bool onTLSConnect(const CertInfo& info) {
 		return true;
 	}

plugins/carbon/carbon.c

@@ -1,4 +1,10 @@
-#include "../../uwsgi.h"
+#include <uwsgi.h>
+
+/*
+
+	Author:	Łukasz Mierzwa
+
+*/
 
 extern struct uwsgi_server uwsgi;
 
@@ -18,14 +24,19 @@ struct uwsgi_carbon {
 	int no_workers;
 	unsigned long long *last_busyness_values;
 	unsigned long long *current_busyness_values;
+	int *was_busy;
 	int need_retry;
 	time_t last_update;
 	time_t next_retry;
 	int max_retries;
 	int retry_delay;
+	char *root_node;
+	char *hostname_dot_replacement;
+	char *hostname;
+	struct uwsgi_stats_pusher *pusher;
 } u_carbon;
 
-struct uwsgi_option carbon_options[] = {
+static struct uwsgi_option carbon_options[] = {
 	{"carbon", required_argument, 0, "push statistics to the specified carbon server", uwsgi_opt_add_string_list, &u_carbon.servers, UWSGI_OPT_MASTER},
 	{"carbon-timeout", required_argument, 0, "set carbon connection timeout in seconds (default 3)", uwsgi_opt_set_int, &u_carbon.timeout, 0},
 	{"carbon-freq", required_argument, 0, "set carbon push frequency in seconds (default 60)", uwsgi_opt_set_int, &u_carbon.freq, 0},
@@ -33,12 +44,13 @@ struct uwsgi_option carbon_options[] = {
 	{"carbon-no-workers", no_argument, 0, "disable generation of single worker metrics", uwsgi_opt_true, &u_carbon.no_workers, 0},
 	{"carbon-max-retry", required_argument, 0, "set maximum number of retries in case of connection errors (default 1)", uwsgi_opt_set_int, &u_carbon.max_retries, 0},
 	{"carbon-retry-delay", required_argument, 0, "set connection retry delay in seconds (default 7)", uwsgi_opt_set_int, &u_carbon.retry_delay, 0},
+	{"carbon-root", required_argument, 0, "set carbon metrics root node (default 'uwsgi')", uwsgi_opt_set_str, &u_carbon.root_node, 0},
+	{"carbon-hostname-dots", required_argument, 0, "set char to use as a replacement for dots in hostname (dots are not replaced by default)", uwsgi_opt_set_str, &u_carbon.hostname_dot_replacement, 0},
 	{0, 0, 0, 0, 0, 0, 0},
 
 };
 
-
-void carbon_post_init() {
+static void carbon_post_init() {
 
 	int i;
 	struct uwsgi_string_list *usl = u_carbon.servers;
@@ -59,6 +71,11 @@ void carbon_post_init() {
 		usl = usl->next;
 	}
 
+	if (!u_carbon.root_node) u_carbon.root_node = "uwsgi.";
+	if (strlen(u_carbon.root_node) && !uwsgi_endswith(u_carbon.root_node, ".")) {
+		u_carbon.root_node = uwsgi_concat2(u_carbon.root_node, ".");
+	}
+
 	if (u_carbon.freq < 1) u_carbon.freq = 60;
 	if (u_carbon.timeout < 1) u_carbon.timeout = 3;
 	if (u_carbon.max_retries <= 0) u_carbon.max_retries = 1;
@@ -71,22 +88,39 @@ void carbon_post_init() {
 		}
 	}
 
+	u_carbon.hostname = uwsgi_str(uwsgi.hostname);
+	if (u_carbon.hostname_dot_replacement) {
+		for(i=0;i<(int)strlen(u_carbon.hostname);i++) {
+			if (u_carbon.hostname[i] == '.') u_carbon.hostname[i] = u_carbon.hostname_dot_replacement[0];
+		}
+	}
+
 	if (!u_carbon.last_busyness_values) {
 		u_carbon.last_busyness_values = uwsgi_calloc(sizeof(unsigned long long) * uwsgi.numproc);
+		
 	}
 
 	if (!u_carbon.current_busyness_values) {
 		u_carbon.current_busyness_values = uwsgi_calloc(sizeof(unsigned long long) * uwsgi.numproc);
 	}
 
+	if (!u_carbon.was_busy) {
+		u_carbon.was_busy = uwsgi_calloc(sizeof(int) * uwsgi.numproc);
+	}
+
 	// set next update to now()+retry_delay, this way we will have first flush just after start
 	u_carbon.last_update = uwsgi_now() - u_carbon.freq + u_carbon.retry_delay;
 
-	uwsgi_log("[carbon] carbon plugin started, %is frequency, %is timeout, max retries %i, retry delay %is",
+	uwsgi_log("[carbon] carbon plugin started, %is frequency, %is timeout, max retries %i, retry delay %is\n",
 		u_carbon.freq, u_carbon.timeout, u_carbon.max_retries, u_carbon.retry_delay);
+
+	struct uwsgi_stats_pusher_instance *uspi = uwsgi_stats_pusher_add(u_carbon.pusher, NULL);
+	uspi->freq = u_carbon.freq;
+	// no need to generate the json
+	uspi->raw=1;
 }
 
-int carbon_write(int *fd, char *fmt,...) {
+static int carbon_write(int fd, char *fmt,...) {
 	va_list ap;
 	va_start(ap, fmt);
 
@@ -94,18 +128,19 @@ int carbon_write(int *fd, char *fmt,...) {
 	int rlen;
 
 	rlen = vsnprintf(ptr, 4096, fmt, ap);
+	va_end(ap);
 
 	if (rlen < 1) return 0;
 
-	if (write(*fd, ptr, rlen) <= 0) {
-		uwsgi_error("write()");
+	if (uwsgi_write_nb(fd, ptr, rlen, u_carbon.timeout)) {
+		uwsgi_error("carbon_write()");
 		return 0;
 	}
 
 	return 1;
 }
 
-void carbon_push_stats(int retry_cycle) {
+static void carbon_push_stats(int retry_cycle, time_t now) {
 	struct carbon_server_list *usl = u_carbon.servers_data;
 	int i;
 	int fd;
@@ -114,6 +149,7 @@ void carbon_push_stats(int retry_cycle) {
 	for (i = 0; i < uwsgi.numproc; i++) {
 		u_carbon.current_busyness_values[i] = uwsgi.workers[i+1].running_time - u_carbon.last_busyness_values[i];
 		u_carbon.last_busyness_values[i] = uwsgi.workers[i+1].running_time;
+		u_carbon.was_busy[i-1] += uwsgi.workers[i+1].busy;
 	}
 
 	u_carbon.need_retry = 0;
@@ -137,7 +173,7 @@ void carbon_push_stats(int retry_cycle) {
 				u_carbon.need_retry = 1;
 				u_carbon.next_retry = uwsgi_now() + u_carbon.retry_delay;
 			} else {
-				uwsgi_log("[carbon] Maximum number of retries for %s (1)\n",
+				uwsgi_log("[carbon] Maximum number of retries for %s (%d)\n",
 					usl->value, u_carbon.max_retries);
 				usl->healthy = 0;
 				usl->errors = 0;
@@ -160,11 +196,13 @@ void carbon_push_stats(int retry_cycle) {
 		unsigned long long worker_busyness = 0;
 		unsigned long long total_harakiri = 0;
 
-		wok = carbon_write(&fd, "uwsgi.%s.%s.requests %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) uwsgi.workers[0].requests, (unsigned long long) uwsgi.current_time);
+		wok = carbon_write(fd, "%s%s.%s.requests %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) uwsgi.workers[0].requests, (unsigned long long) now);
 		if (!wok) goto clear;
 
 		for(i=1;i<=uwsgi.numproc;i++) {
 			total_tx += uwsgi.workers[i].tx;
+			total_harakiri += uwsgi.workers[i].harakiri_count;
+
 			if (uwsgi.workers[i].cheaped) {
 				// also if worker is cheaped than we report its average response time as zero, sending last value might be confusing
 				avg_rt = 0;
@@ -177,53 +215,63 @@ void carbon_push_stats(int retry_cycle) {
 				total_avg_rt += uwsgi.workers[i].avg_response_time;
 
 				// calculate worker busyness
-				worker_busyness = ((u_carbon.current_busyness_values[i-1]*100) / (u_carbon.freq*1000000));
-				if (worker_busyness > 100) worker_busyness = 100;
+				if (u_carbon.current_busyness_values[i-1] == 0 && u_carbon.was_busy[i-1]) {
+					worker_busyness = 100;
+				}
+				else {
+					worker_busyness = ((u_carbon.current_busyness_values[i-1]*100) / (u_carbon.freq*1000000));
+					if (worker_busyness > 100) worker_busyness = 100;
+				}
 				total_busyness += worker_busyness;
+				u_carbon.was_busy[i-1] = 0;
 
-				// only running workers are counted in total memory stats
-				total_rss += uwsgi.workers[i].rss_size;
-				total_vsz += uwsgi.workers[i].vsz_size;
-
-				total_harakiri += uwsgi.workers[i].harakiri_count;
+				if (uwsgi.shared->options[UWSGI_OPTION_MEMORY_DEBUG] == 1 || uwsgi.force_get_memusage) {
+					// only running workers are counted in total memory stats and if memory-report option is enabled
+					total_rss += uwsgi.workers[i].rss_size;
+					total_vsz += uwsgi.workers[i].vsz_size;
+				}
 			}
 
 			//skip per worker metrics when disabled
 			if (u_carbon.no_workers) continue;
 
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.requests %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].requests, (unsigned long long) uwsgi.current_time);
+			wok = carbon_write(fd, "%s%s.%s.worker%d.requests %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].requests, (unsigned long long) now);
 			if (!wok) goto clear;
 
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.rss_size %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].rss_size, (unsigned long long) uwsgi.current_time);
+			if (uwsgi.shared->options[UWSGI_OPTION_MEMORY_DEBUG] == 1 || uwsgi.force_get_memusage) {
+				wok = carbon_write(fd, "%s%s.%s.worker%d.rss_size %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].rss_size, (unsigned long long) now);
+				if (!wok) goto clear;
+
+				wok = carbon_write(fd, "%s%s.%s.worker%d.vsz_size %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].vsz_size, (unsigned long long) now);
+				if (!wok) goto clear;
+			}
+
+			wok = carbon_write(fd, "%s%s.%s.worker%d.avg_rt %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) avg_rt, (unsigned long long) now);
 			if (!wok) goto clear;
 
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.vsz_size %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].vsz_size, (unsigned long long) uwsgi.current_time);
+			wok = carbon_write(fd, "%s%s.%s.worker%d.tx %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].tx, (unsigned long long) now);
 			if (!wok) goto clear;
 
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.avg_rt %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) avg_rt, (unsigned long long) uwsgi.current_time);
+			wok = carbon_write(fd, "%s%s.%s.worker%d.busyness %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) worker_busyness, (unsigned long long) now);
 			if (!wok) goto clear;
 
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.tx %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].tx, (unsigned long long) uwsgi.current_time);
-			if (!wok) goto clear;
-
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.busyness %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) worker_busyness, (unsigned long long) uwsgi.current_time);
-			if (!wok) goto clear;
-
-			wok = carbon_write(&fd, "uwsgi.%s.%s.worker%d.harakiri %llu %llu\n", uwsgi.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].harakiri_count, (unsigned long long) uwsgi.current_time);
+			wok = carbon_write(fd, "%s%s.%s.worker%d.harakiri %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, i, (unsigned long long) uwsgi.workers[i].harakiri_count, (unsigned long long) now);
 			if (!wok) goto clear;
 
 		}
 
-		wok = carbon_write(&fd, "uwsgi.%s.%s.rss_size %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) total_rss, (unsigned long long) uwsgi.current_time);
+		if (uwsgi.shared->options[UWSGI_OPTION_MEMORY_DEBUG] == 1 || uwsgi.force_get_memusage) {
+			wok = carbon_write(fd, "%s%s.%s.rss_size %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) total_rss, (unsigned long long) now);
+			if (!wok) goto clear;
+
+			wok = carbon_write(fd, "%s%s.%s.vsz_size %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) total_vsz, (unsigned long long) now);
+			if (!wok) goto clear;
+		}
+
+		wok = carbon_write(fd, "%s%s.%s.avg_rt %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) (active_workers ? total_avg_rt / active_workers : 0), (unsigned long long) now);
 		if (!wok) goto clear;
 
-		wok = carbon_write(&fd, "uwsgi.%s.%s.vsz_size %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) total_vsz, (unsigned long long) uwsgi.current_time);
-		if (!wok) goto clear;
-
-		wok = carbon_write(&fd, "uwsgi.%s.%s.avg_rt %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) (active_workers ? total_avg_rt / active_workers : 0), (unsigned long long) uwsgi.current_time);
-		if (!wok) goto clear;
-
-		wok = carbon_write(&fd, "uwsgi.%s.%s.tx %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) total_tx, (unsigned long long) uwsgi.current_time);
+		wok = carbon_write(fd, "%s%s.%s.tx %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) total_tx, (unsigned long long) now);
 		if (!wok) goto clear;
 
 		if (active_workers > 0) {
@@ -232,18 +280,18 @@ void carbon_push_stats(int retry_cycle) {
 		} else {
 			total_avg_busyness = 0;
 		}
-		wok = carbon_write(&fd, "uwsgi.%s.%s.busyness %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) total_avg_busyness, (unsigned long long) uwsgi.current_time);
+		wok = carbon_write(fd, "%s%s.%s.busyness %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) total_avg_busyness, (unsigned long long) now);
 		if (!wok) goto clear;
 
-		wok = carbon_write(&fd, "uwsgi.%s.%s.active_workers %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) active_workers, (unsigned long long) uwsgi.current_time);
+		wok = carbon_write(fd, "%s%s.%s.active_workers %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) active_workers, (unsigned long long) now);
 		if (!wok) goto clear;
 
 		if (uwsgi.cheaper) {
-			wok = carbon_write(&fd, "uwsgi.%s.%s.cheaped_workers %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) uwsgi.numproc - active_workers, (unsigned long long) uwsgi.current_time);
+			wok = carbon_write(fd, "%s%s.%s.cheaped_workers %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) uwsgi.numproc - active_workers, (unsigned long long) now);
 			if (!wok) goto clear;
 		}
 
-		wok = carbon_write(&fd, "uwsgi.%s.%s.harakiri %llu %llu\n", uwsgi.hostname, u_carbon.id, (unsigned long long) total_harakiri, (unsigned long long) uwsgi.current_time);
+		wok = carbon_write(fd, "%s%s.%s.harakiri %llu %llu\n", u_carbon.root_node, u_carbon.hostname, u_carbon.id, (unsigned long long) total_harakiri, (unsigned long long) now);
 		if (!wok) goto clear;
 
 		usl->healthy = 1;
@@ -260,28 +308,34 @@ nxt:
 		u_carbon.last_update -= u_carbon.timeout;
 }
 
-void carbon_master_cycle() {
+static void carbon_push(struct uwsgi_stats_pusher_instance *uspi, time_t now, char *json, size_t json_len) {
 
-	if (!u_carbon.servers) return;
-
-	if (uwsgi.current_time - u_carbon.last_update >= u_carbon.freq || uwsgi.cleaning) {
+	if (u_carbon.need_retry && now >= u_carbon.next_retry) {
+		carbon_push_stats(1, now);
+	}
+	else {
 		// update
 		u_carbon.need_retry = 0;
-		carbon_push_stats(0);
-	} else if (u_carbon.need_retry && (uwsgi.current_time >= u_carbon.next_retry)) {
-		// retry failed servers
-		carbon_push_stats(1);
+		carbon_push_stats(0, now);
+
 	}
 }
 
+static void carbon_cleanup() {
+	carbon_push_stats(0, uwsgi_now());
+}
+
+static void carbon_register() {
+	u_carbon.pusher = uwsgi_register_stats_pusher("carbon", carbon_push);
+}
 
 struct uwsgi_plugin carbon_plugin = {
 
 	.name = "carbon",
 	
-	.master_cleanup = carbon_master_cycle,
+	.master_cleanup = carbon_cleanup,
 
 	.options = carbon_options,
-	.master_cycle = carbon_master_cycle,
+	.on_load = carbon_register,
 	.post_init = carbon_post_init,
 };

plugins/cgi/cgi_plugin.c

@@ -838,9 +838,15 @@ clear2:
 			uwsgi_error("setenv()");
 		}
 
-		
-		if (setenv("PATH_TRANSLATED", uwsgi_concat3n(docroot, docroot_len, path_info, pi_len, "", 0) , 1)) {
-			uwsgi_error("setenv()");
+		if (wsgi_req->document_root_len > 0) {
+			if (setenv("PATH_TRANSLATED", uwsgi_concat3n(wsgi_req->document_root, wsgi_req->document_root_len, path_info, pi_len, "", 0) , 1)) {
+				uwsgi_error("setenv()");
+			}
+		}
+		else {
+			if (setenv("PATH_TRANSLATED", uwsgi_concat3n(docroot, docroot_len, path_info, pi_len, "", 0) , 1)) {
+				uwsgi_error("setenv()");
+			}
 		}
 
 	}

plugins/cheaper_busyness/cheaper_busyness.c

@@ -78,7 +78,7 @@ void set_next_cheap_time(void) {
 		// to have quicker recovery from big but short load spikes
 		// otherwise we might wait a lot before cheaping all emergency workers
 		if (uwsgi_cheaper_busyness_global.verbose)
-			uwsgi_log("[busyness] %d emergency worker(s) running, using %d seconds cheaper timer\n",
+			uwsgi_log("[busyness] %d emergency worker(s) running, using %llu seconds cheaper timer\n",
 				uwsgi_cheaper_busyness_global.emergency_workers, uwsgi.cheaper_overload*uwsgi_cheaper_busyness_global.backlog_multi);
 		uwsgi_cheaper_busyness_global.next_cheap = now + uwsgi.cheaper_overload*uwsgi_cheaper_busyness_global.backlog_multi*1000000;
 	} else {
@@ -95,7 +95,7 @@ void decrease_multi(void) {
 	// will decrease multiplier but only down to initial value
 	if (uwsgi_cheaper_busyness_global.cheap_multi > uwsgi_cheaper_busyness_global.min_multi) {
 		uwsgi_cheaper_busyness_global.cheap_multi--;
-		uwsgi_log("[busyness] decreasing cheaper multiplier to %d\n", uwsgi_cheaper_busyness_global.cheap_multi);
+		uwsgi_log("[busyness] decreasing cheaper multiplier to %llu\n", uwsgi_cheaper_busyness_global.cheap_multi);
 	}
 }
 
@@ -157,7 +157,7 @@ int cheaper_busyness_algo(void) {
 		// store initial multiplier so we don't loose its initial value
 		uwsgi_cheaper_busyness_global.min_multi = uwsgi_cheaper_busyness_global.cheap_multi;
 		// since this is first run we will print current values
-		uwsgi_log("[busyness] settings: min=%d%%, max=%d%%, overload=%d, multiplier=%d, respawn penalty=%d\n",
+		uwsgi_log("[busyness] settings: min=%llu%%, max=%llu%%, overload=%llu, multiplier=%llu, respawn penalty=%llu\n",
 			uwsgi_cheaper_busyness_global.busyness_min, uwsgi_cheaper_busyness_global.busyness_max,
 			uwsgi.cheaper_overload, uwsgi_cheaper_busyness_global.cheap_multi, uwsgi_cheaper_busyness_global.penalty);
 #ifdef __linux__
@@ -171,7 +171,7 @@ int cheaper_busyness_algo(void) {
 
 	if (uwsgi_cheaper_busyness_global.next_cheap == 0) set_next_cheap_time();
 
-	int64_t active_workers = 0;
+	int active_workers = 0;
 	uint64_t total_busyness = 0;
 	uint64_t avg_busyness = 0;
 
@@ -195,7 +195,7 @@ int cheaper_busyness_algo(void) {
 				if (percent > 100) percent = 100;
 				total_busyness += percent;
 				if (uwsgi_cheaper_busyness_global.verbose && active_workers > 1)
-					uwsgi_log("[busyness] worker nr %d %ds average busyness is at %d%%\n",
+					uwsgi_log("[busyness] worker nr %d %llus average busyness is at %llu%%\n",
 						i+1, uwsgi.cheaper_overload, percent);
 			}
 			uwsgi_cheaper_busyness_global.last_values[i] = uwsgi.workers[i+1].running_time;
@@ -204,7 +204,7 @@ int cheaper_busyness_algo(void) {
 		avg_busyness = (active_workers ? total_busyness / active_workers : 0);
 		if (uwsgi_cheaper_busyness_global.verbose)
 			uwsgi_log("[busyness] %ds average busyness of %d worker(s) is at %d%%\n",
-				uwsgi.cheaper_overload, active_workers, avg_busyness);
+				(int) uwsgi.cheaper_overload, (int) active_workers, (int) avg_busyness);
 
 		if (avg_busyness > uwsgi_cheaper_busyness_global.busyness_max) {
 
@@ -229,7 +229,7 @@ int cheaper_busyness_algo(void) {
 					// worker was cheaped and then spawned back in less than current multiplier*cheaper_overload seconds
 					// we will increase the multiplier so that next time worker will need to wait longer before being cheaped
 					uwsgi_cheaper_busyness_global.cheap_multi += uwsgi_cheaper_busyness_global.penalty;
-					uwsgi_log("[busyness] worker(s) respawned to fast, increasing chpeaper multiplier to %d (+%d)\n",
+					uwsgi_log("[busyness] worker(s) respawned to fast, increasing chpeaper multiplier to %llu (+%llu)\n",
 						uwsgi_cheaper_busyness_global.cheap_multi, uwsgi_cheaper_busyness_global.penalty);
 				} else {
 					decrease_multi();
@@ -237,10 +237,10 @@ int cheaper_busyness_algo(void) {
 
 				set_next_cheap_time();
 
-				uwsgi_log("[busyness] %ds average busyness is at %d%%, will spawn %d new worker(s)\n",
+				uwsgi_log("[busyness] %llus average busyness is at %llu%%, will spawn %d new worker(s)\n",
 					uwsgi.cheaper_overload, avg_busyness, decheaped);
 			} else {
-				uwsgi_log("[busyness] %ds average busyness is at %d%% but we already started maximum number of workers (%d)\n",
+				uwsgi_log("[busyness] %llus average busyness is at %llu%% but we already started maximum number of workers (%d)\n",
 					uwsgi.cheaper_overload, avg_busyness, uwsgi.numproc);
 			}
 
@@ -267,8 +267,8 @@ int cheaper_busyness_algo(void) {
 					if (uwsgi_cheaper_busyness_global.last_action == 2) decrease_multi();
 					set_next_cheap_time();
 
-					uwsgi_log("[busyness] %ds average busyness is at %d%%, cheap one of %d running workers\n",
-						uwsgi.cheaper_overload, avg_busyness, active_workers);
+					uwsgi_log("[busyness] %llus average busyness is at %llu%%, cheap one of %d running workers\n",
+						uwsgi.cheaper_overload, avg_busyness, (int) active_workers);
 					// store timestamp
 					uwsgi_cheaper_busyness_global.last_cheaped = uwsgi_micros();
 
@@ -280,7 +280,7 @@ int cheaper_busyness_algo(void) {
 
 					return -1;
 				} else if (uwsgi_cheaper_busyness_global.verbose)
-					uwsgi_log("[busyness] need to wait %d more second(s) to cheap worker\n", (uwsgi_cheaper_busyness_global.next_cheap - now)/1000000);
+					uwsgi_log("[busyness] need to wait %llu more second(s) to cheap worker\n", (uwsgi_cheaper_busyness_global.next_cheap - now)/1000000);
 			}
 
 		} else {
@@ -301,14 +301,14 @@ int cheaper_busyness_algo(void) {
 				// time needed to cheap them, than a lot min<busy<max when we do not reset timer
 				// and then another idle cycle than would trigger cheaping
 				if (uwsgi_cheaper_busyness_global.verbose)
-					uwsgi_log("[busyness] %ds average busyness is at %d%%, %d non-idle cycle(s), reseting cheaper timer\n",
+					uwsgi_log("[busyness] %llus average busyness is at %llu%%, %llu non-idle cycle(s), reseting cheaper timer\n",
 						uwsgi.cheaper_overload, avg_busyness, uwsgi_cheaper_busyness_global.tolerance_counter);
 				set_next_cheap_time();
 			} else {
 				// we had < 3 idle cycles in a row so we won't reset idle timer yet since this might be just short load spike
 				// but we need to add cheaper-overload seconds to the cheaper timer so this cycle isn't counted as idle
 				if (uwsgi_cheaper_busyness_global.verbose)
-					uwsgi_log("[busyness] %ds average busyness is at %d%%, %d non-idle cycle(s), adjusting cheaper timer\n",
+					uwsgi_log("[busyness] %llus average busyness is at %llu%%, %llu non-idle cycle(s), adjusting cheaper timer\n",
 						uwsgi.cheaper_overload, avg_busyness, uwsgi_cheaper_busyness_global.tolerance_counter);
 				uwsgi_cheaper_busyness_global.next_cheap += uwsgi.cheaper_overload*1000000;
 			}

plugins/corerouter/corerouter.c

@@ -22,6 +22,13 @@ void uwsgi_opt_corerouter(char *opt, char *value, void *cr) {
         ucr->has_sockets++;
 }
 
+void uwsgi_opt_undeferred_corerouter(char *opt, char *value, void *cr) {
+	struct uwsgi_corerouter *ucr = (struct uwsgi_corerouter *) cr;
+        struct uwsgi_gateway_socket *ugs = uwsgi_new_gateway_socket(value, ucr->name);
+	ugs->no_defer = 1;
+        ucr->has_sockets++;
+}
+
 void uwsgi_opt_corerouter_use_socket(char *opt, char *value, void *cr) {
 	struct uwsgi_corerouter *ucr = (struct uwsgi_corerouter *) cr;
         ucr->use_socket = 1;
@@ -195,19 +202,14 @@ void corerouter_close_session(struct uwsgi_corerouter *ucr, struct corerouter_se
 
 		if (cr_session->soopt) {
 			if (!ucr->quiet)
-				uwsgi_log("unable to connect() to uwsgi instance \"%.*s\": %s\n", (int) cr_session->instance_address_len, cr_session->instance_address, strerror(cr_session->soopt));
+				uwsgi_log("[uwsgi-%s] unable to connect() to node \"%.*s\": %s\n", ucr->short_name, (int) cr_session->instance_address_len, cr_session->instance_address, strerror(cr_session->soopt));
 		}
 		else if (cr_session->timed_out) {
 			if (cr_session->instance_address_len > 0) {
-/*
-				if (cr_session->status == COREROUTER_STATUS_CONNECTING) {
+				if (cr_session->connecting) {
 					if (!ucr->quiet)
-						uwsgi_log("unable to connect() to uwsgi instance \"%.*s\": timeout\n", (int) cr_session->instance_address_len, cr_session->instance_address);
+						uwsgi_log("[uwsgi-%s] unable to connect() to node \"%.*s\": timeout\n", ucr->short_name, (int) cr_session->instance_address_len, cr_session->instance_address);
 				}
-				else if (cr_session->status  == COREROUTER_STATUS_RESPONSE) {
-					uwsgi_log("timeout waiting for instance \"%.*s\"\n", (int) cr_session->instance_address_len, cr_session->instance_address);
-				}
-*/
 			}
 		}
 
@@ -239,6 +241,29 @@ void corerouter_close_session(struct uwsgi_corerouter *ucr, struct corerouter_se
 			cr_session->tmp_socket_name = NULL;
 		}
 
+		if (!cr_session->retry) goto end;
+		// check for max retries
+		if (cr_session->retries >= (size_t) ucr->max_retries) goto end;
+
+		cr_session->retries++;
+
+		// reset error and timeout
+		cr_session->instance_failed = 0;
+		cr_session->timeout = corerouter_reset_timeout(ucr, cr_session);
+		cr_session->timed_out = 0;
+		cr_session->soopt = 0;
+
+		// reset nodes
+		cr_session->un = NULL;
+		cr_session->static_node = NULL;
+                cr_session->instance_fd = -1;
+
+		// reset hooks (safe as fd is closed)
+		cr_session->event_hook_read = NULL;
+		cr_session->event_hook_write = NULL;
+		cr_session->event_hook_instance_read = NULL;
+		cr_session->event_hook_instance_write = NULL;
+
 		if (ucr->fallback) {
 			// ok let's try with the fallback nodes
 			if (!cr_session->fallback) {
@@ -252,35 +277,18 @@ void corerouter_close_session(struct uwsgi_corerouter *ucr, struct corerouter_se
 			cr_session->instance_address = cr_session->fallback->value;
 			cr_session->instance_address_len = cr_session->fallback->len;
 
-			// reset error and timeout
-			cr_session->timeout = corerouter_reset_timeout(ucr, cr_session);
-			cr_session->timed_out = 0;
-			cr_session->soopt = 0;
-
-			// reset nodes
-			cr_session->un = NULL;
-			cr_session->static_node = NULL;
-
-			cr_session->pass_fd = is_unix(cr_session->instance_address, cr_session->instance_address_len);
-
-
-                	cr_session->instance_fd = uwsgi_connectn(cr_session->instance_address, cr_session->instance_address_len, 0, 1);
-
-                	if (cr_session->instance_fd < 0) {
-                		cr_session->instance_failed = 1;
-				cr_session->soopt = errno;
-                        	corerouter_close_session(ucr, cr_session);
-				return;
+			if (cr_session->retry(ucr, cr_session)) {
+				if (!cr_session->instance_failed) goto end;
 			}
-  
-			ucr->cr_table[cr_session->instance_fd] = cr_session;
-
-                	//cr_session->status = COREROUTER_STATUS_CONNECTING;
-                	ucr->cr_table[cr_session->instance_fd] = cr_session;
-                	event_queue_add_fd_write(ucr->queue, cr_session->instance_fd);
 			return;
-
 		}
+
+		cr_session->instance_address = NULL;
+		cr_session->instance_address_len = 0;
+		if (cr_session->retry(ucr, cr_session)) {
+                        if (!cr_session->instance_failed) goto end;
+                }
+                return;
 	}
 
 end:
@@ -319,35 +327,22 @@ static struct uwsgi_rb_timer *corerouter_reset_timeout(struct uwsgi_corerouter *
 
 static void corerouter_expire_timeouts(struct uwsgi_corerouter *ucr) {
 
-	time_t current = uwsgi_now();
+	uint64_t current = (uint64_t) uwsgi_now();
 	struct uwsgi_rb_timer *urbt;
 	struct corerouter_session *cr_session;
 
 	for (;;) {
-		urbt = uwsgi_min_rb_timer(ucr->timeouts);
+		urbt = uwsgi_min_rb_timer(ucr->timeouts, NULL);
 		if (urbt == NULL)
 			return;
 
-		if (urbt->key <= current) {
+		if (urbt->value <= current) {
 			cr_session = (struct corerouter_session *) urbt->data;
 			cr_session->timed_out = 1;
-			if (cr_session->retry) {
-				cr_session->retry = 0;
-/*
-				TODO allows retry
-				ucr->switch_events(ucr, cr_session, -1);
-*/
-				if (cr_session->retry) {
-					cr_del_timeout(ucr, cr_session);
-					cr_session->timeout = cr_add_fake_timeout(ucr, cr_session);
-				}
-				else {
-					cr_session->timeout = corerouter_reset_timeout(ucr, cr_session);
-				}
-			}
-			else {
-				corerouter_close_session(ucr, cr_session);
+			if (cr_session->connecting) {
+				cr_session->instance_failed = 1;
 			}
+			corerouter_close_session(ucr, cr_session);
 			continue;
 		}
 
@@ -572,7 +567,7 @@ struct corerouter_session *corerouter_alloc_session(struct uwsgi_corerouter *ucr
         ucr->cr_table[new_connection]->fd = new_connection;
         ucr->cr_table[new_connection]->instance_fd = -1;
 
-	// map courerouter and socket
+	// map corerouter and socket
 	ucr->cr_table[new_connection]->corerouter = ucr;
 	ucr->cr_table[new_connection]->ugs = ugs;
 
@@ -713,12 +708,12 @@ void uwsgi_corerouter_loop(int id, void *data) {
 	for (;;) {
 
 		// set timeouts and harakiri
-		min_timeout = uwsgi_min_rb_timer(ucr->timeouts);
+		min_timeout = uwsgi_min_rb_timer(ucr->timeouts, NULL);
 		if (min_timeout == NULL) {
 			delta = -1;
 		}
 		else {
-			delta = min_timeout->key - uwsgi_now();
+			delta = min_timeout->value - uwsgi_now();
 			if (delta <= 0) {
 				corerouter_expire_timeouts(ucr);
 				delta = 0;
@@ -771,7 +766,11 @@ void uwsgi_corerouter_loop(int id, void *data) {
 #endif
 #endif
 
-						corerouter_alloc_session(ucr, ugs, new_connection, (struct sockaddr *) &cr_addr, cr_addr_len);
+						struct corerouter_session *cr = corerouter_alloc_session(ucr, ugs, new_connection, (struct sockaddr *) &cr_addr, cr_addr_len);
+						//something wrong in the allocation
+						if (cr->instance_failed) {
+							corerouter_close_session(ucr, cr);
+						}
 					}
 					else if (ugs->subscription) {
 						uwsgi_corerouter_manage_subscription(ucr, id, ugs);
@@ -834,12 +833,8 @@ void uwsgi_corerouter_loop(int id, void *data) {
                                         }
 				}
 
-				if (!hook) {
-					uwsgi_log("[uwsgi-corerouter] BUG, unexpected event received !!!\n");
-					corerouter_close_session(ucr, cr_session);
-					continue;
-				}
-
+				// not having a hook could mean a previous event in the loop cleared it...
+				if (!hook) continue;
 				// reset errno (as we use it for internal signalling)
 				errno = 0;
 				ssize_t ret = hook(cr_session);
@@ -860,7 +855,7 @@ void uwsgi_corerouter_loop(int id, void *data) {
 
 }
 
-int uwsgi_courerouter_has_has_backends(struct uwsgi_corerouter *ucr) {
+int uwsgi_corerouter_has_backends(struct uwsgi_corerouter *ucr) {
 
 	if (ucr->has_backends) return 1;
 
@@ -896,8 +891,11 @@ int uwsgi_corerouter_init(struct uwsgi_corerouter *ucr) {
 		if (!ucr->nevents)
 			ucr->nevents = 64;
 
+		if (!ucr->max_retries)
+			ucr->max_retries = 3;
+	
 
-		ucr->has_backends = uwsgi_courerouter_has_has_backends(ucr);
+		ucr->has_backends = uwsgi_corerouter_has_backends(ucr);
 
 
 		uwsgi_corerouter_setup_sockets(ucr);
@@ -921,7 +919,7 @@ int uwsgi_corerouter_init(struct uwsgi_corerouter *ucr) {
 
 struct uwsgi_plugin corerouter_plugin = {
 
-	.name = "courerouter",
+	.name = "corerouter",
 };
 
 void corerouter_send_stats(struct uwsgi_corerouter *ucr) {
@@ -968,6 +966,29 @@ void corerouter_send_stats(struct uwsgi_corerouter *ucr) {
 	if (uwsgi_stats_list_close(us)) goto end0;
 	if (uwsgi_stats_comma(us)) goto end0;
 
+	if (ucr->static_nodes) {
+		if (uwsgi_stats_key(us , "static_nodes")) goto end0;
+                if (uwsgi_stats_list_open(us)) goto end0;
+
+		struct uwsgi_string_list *usl = ucr->static_nodes;
+		while(usl) {
+			if (uwsgi_stats_object_open(us)) goto end0;
+			if (uwsgi_stats_keyvaln_comma(us, "name", usl->value, usl->len)) goto end0;
+
+			if (uwsgi_stats_keylong_comma(us, "hits", (unsigned long long) usl->custom2)) goto end0;
+			if (uwsgi_stats_keylong(us, "grace", (unsigned long long) usl->custom)) goto end0;
+
+			if (uwsgi_stats_object_close(us)) goto end0;
+			usl = usl->next;
+			if (usl) {
+				if (uwsgi_stats_comma(us)) goto end0;
+			}
+		}
+
+		if (uwsgi_stats_list_close(us)) goto end0;
+                if (uwsgi_stats_comma(us)) goto end0;
+        }
+
 	if (ucr->has_subscription_sockets) {
 		if (uwsgi_stats_key(us , "subscriptions")) goto end0;
 		if (uwsgi_stats_list_open(us)) goto end0;

plugins/corerouter/cr.h

@@ -6,8 +6,8 @@
 #define cr_add_timeout(u, x) uwsgi_add_rb_timer(u->timeouts, time(NULL)+u->socket_timeout, x)
 #define cr_add_fake_timeout(u, x) uwsgi_add_rb_timer(u->timeouts, time(NULL)+1, x)
 #define cr_add_check_timeout(x) uwsgi_add_rb_timer(timeouts, time(NULL)+x, NULL)
-#define cr_del_check_timeout(x) rb_erase(&x->rbt, timeouts);
-#define cr_del_timeout(u, x) rb_erase(&x->timeout->rbt, u->timeouts); free(x->timeout);
+#define cr_del_check_timeout(x) uwsgi_del_rb_timer(timeouts, x);
+#define cr_del_timeout(u, x) uwsgi_del_rb_timer(u->timeouts, x->timeout); free(x->timeout);
 
 #define cr_try_again if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINPROGRESS) {\
                      	errno = EINPROGRESS;\
@@ -33,11 +33,13 @@ struct uwsgi_corerouter {
         int processes;
         int quiet;
 
-        struct rb_root *timeouts;
+        struct uwsgi_rbtree *timeouts;
 
         int use_cache;
         int nevents;
 
+	int max_retries;
+
 	char *magic_table[256];
 
         int queue;
@@ -102,14 +104,13 @@ struct corerouter_session {
         uint16_t hostname_len;
 
         int has_key;
-        int retry;
+        int connecting;
 
         char *instance_address;
         uint64_t instance_address_len;
 
         struct uwsgi_subscribe_node *un;
         struct uwsgi_string_list *static_node;
-        int pass_fd;
         int soopt;
         int timed_out;
 
@@ -139,6 +140,8 @@ struct corerouter_session {
 	ssize_t (*event_hook_instance_write)(struct corerouter_session *);
 
 	void (*close)(struct corerouter_session *);
+	int (*retry)(struct uwsgi_corerouter *, struct corerouter_session *);
+	size_t retries;
 
 	struct uwsgi_buffer *buffer;
         size_t buffer_len;
@@ -151,6 +154,7 @@ struct corerouter_session {
 };
 
 void uwsgi_opt_corerouter(char *, char *, void *);
+void uwsgi_opt_undeferred_corerouter(char *, char *, void *);
 void uwsgi_opt_corerouter_use_socket(char *, char *, void *);
 void uwsgi_opt_corerouter_use_base(char *, char *, void *);
 void uwsgi_opt_corerouter_use_pattern(char *, char *, void *);
@@ -181,7 +185,7 @@ int uwsgi_cr_map_use_cs(struct uwsgi_corerouter *, struct corerouter_session *);
 int uwsgi_cr_map_use_to(struct uwsgi_corerouter *, struct corerouter_session *);
 int uwsgi_cr_map_use_static_nodes(struct uwsgi_corerouter *, struct corerouter_session *);
 
-int uwsgi_courerouter_has_has_backends(struct uwsgi_corerouter *);
+int uwsgi_corerouter_has_backends(struct uwsgi_corerouter *);
 
 int uwsgi_cr_hook_read(struct corerouter_session *, ssize_t (*)(struct corerouter_session *));
 int uwsgi_cr_hook_write(struct corerouter_session *, ssize_t (*)(struct corerouter_session *));

plugins/corerouter/cr_common.c

@@ -41,6 +41,10 @@ void uwsgi_corerouter_setup_sockets(struct uwsgi_corerouter *ucr) {
 				}
 				else {
 					ugs->port = strchr(ugs->name, ':');
+					int current_defer_accept = uwsgi.no_defer_accept;
+					if (ugs->no_defer) {
+                        			uwsgi.no_defer_accept = 1;
+					}
 					if (ugs->fd == -1) {
 						if (ugs->port) {
 							ugs->fd = bind_to_tcp(ugs->name, uwsgi.listen_queue, ugs->port);
@@ -51,7 +55,18 @@ void uwsgi_corerouter_setup_sockets(struct uwsgi_corerouter *ucr) {
 							ugs->fd = bind_to_unix(ugs->name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
 						}
 					}
+					if (ugs->no_defer) {
+                        			uwsgi.no_defer_accept = current_defer_accept;
+					}
 				}
+				// fix SERVER_PORT
+                                if (!ugs->port || !ugs->port_len) {
+                                        ugs->port = strchr(ugs->name, ':');
+                                        if (ugs->port) {
+                                                ugs->port++;
+                                                ugs->port_len = strlen(ugs->port);
+                                        }
+                                }
 				// put socket in non-blocking mode
 				uwsgi_socket_nb(ugs->fd);
 				uwsgi_log("%s bound on %s fd %d\n", ucr->name, ugs->name, ugs->fd);

plugins/fastrouter/fastrouter.c

@@ -233,6 +233,8 @@ ssize_t fr_instance_send_request_header(struct corerouter_session * cs) {
 
 ssize_t fr_instance_connected(struct corerouter_session * cs) {
 
+	cs->connecting = 0;
+
 	socklen_t solen = sizeof(int);
 
 	// first check for errors
@@ -250,6 +252,7 @@ ssize_t fr_instance_connected(struct corerouter_session * cs) {
 	cs->buffer_pos = 0;
 
 	// ok instance is connected, wait for write again
+	if (cs->static_node) cs->static_node->custom2++;
 	if (cs->un) cs->un->requests++;
 	uwsgi_cr_hook_instance_write(cs, fr_instance_send_request_header);
 	// return a value > 0
@@ -304,6 +307,7 @@ ssize_t fr_recv_uwsgi_vars(struct corerouter_session * cs) {
 		// map the instance
 		cs->corerouter->cr_table[cs->instance_fd] = cs;
 		// wait for connection
+		cs->connecting = 1;
 		uwsgi_cr_hook_instance_write(cs, fr_instance_connected);
 	}
 

plugins/gevent/gevent.c

@@ -230,7 +230,7 @@ ssize_t uwsgi_gevent_hook_input_read(struct wsgi_request *wsgi_req, char *tmp_bu
         	}
         	Py_DECREF(ret);
 
-        	ret = PyObject_CallMethod(timer, "start", "OO", current, timer);
+        	ret = PyObject_CallMethod(timer, "again", "OO", current, timer);
         	if (!ret) {
                 	stop_the_watchers_and_clear
                 	return -1;
@@ -253,6 +253,8 @@ ssize_t uwsgi_gevent_hook_input_read(struct wsgi_request *wsgi_req, char *tmp_bu
 		UWSGI_RELEASE_GIL;	
                 ssize_t rlen = read(wsgi_req->poll.fd, tmp_buf+*tmp_pos, remains);
                 if (rlen <= 0) {
+			if (rlen < 0)
+				uwsgi_error("[uwsgi-gevent] read()");
                         UWSGI_GET_GIL
 			stop_the_watchers_and_clear
                         return -1;
@@ -263,6 +265,11 @@ ssize_t uwsgi_gevent_hook_input_read(struct wsgi_request *wsgi_req, char *tmp_bu
 		stop_the_watchers
         }
 
+	Py_DECREF(current);
+	Py_DECREF(current_greenlet);
+	Py_DECREF(watcher);
+	Py_DECREF(timer);
+
         return *tmp_pos;
 
 }
@@ -291,7 +298,7 @@ ssize_t uwsgi_gevent_hook_input_readline(struct wsgi_request *wsgi_req, char *re
         }
         Py_DECREF(ret);
 
-        ret = PyObject_CallMethod(timer, "start", "OO", current, timer);
+        ret = PyObject_CallMethod(timer, "again", "OO", current, timer);
         if (!ret) {
         	stop_the_watchers_and_clear
 		return -1;
@@ -328,6 +335,10 @@ void uwsgi_gevent_nb_write(struct wsgi_request *wsgi_req, PyObject *str) {
 	PyObject *ret;
 	char *content = PyString_AsString(str);
 	size_t content_len = PyString_Size(str);
+
+	// do not try to write empty chunks
+	if (content_len == 0) return;
+
 	/// create a watcher for writes
 	PyObject *watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", wsgi_req->poll.fd, 2);
 	if (!watcher) goto error;
@@ -353,7 +364,7 @@ void uwsgi_gevent_nb_write(struct wsgi_request *wsgi_req, PyObject *str) {
 		}
 		Py_DECREF(ret);
 
-		ret = PyObject_CallMethod(timer, "start", "OO", current, timer);
+		ret = PyObject_CallMethod(timer, "again", "OO", current, timer);
 		if (!ret) {
 			stop_the_watchers_and_clear
 			goto error;
@@ -420,7 +431,7 @@ PyObject *uwsgi_gevent_wait(PyObject *watcher, PyObject *timer, PyObject *curren
 	Py_DECREF(ret);
 
 	// start the timeout handler
-	ret = PyObject_CallMethod(timer, "start", "OO", current, timer);
+	ret = PyObject_CallMethod(timer, "again", "OO", current, timer);
 	if (!ret) return NULL;
 	Py_DECREF(ret);
 

plugins/http/http.c

@@ -24,6 +24,7 @@ struct uwsgi_http {
 #ifdef UWSGI_SSL
 	int https_export_cert;
 #endif
+	struct uwsgi_string_list *stud_prefix;
 
 } uhttp;
 
@@ -134,6 +135,7 @@ struct uwsgi_option http_options[] = {
 	{"http-stats-server", required_argument, 0, "run the http router stats server", uwsgi_opt_set_str, &uhttp.cr.stats_server, 0},
 	{"http-ss", required_argument, 0, "run the http router stats server", uwsgi_opt_set_str, &uhttp.cr.stats_server, 0},
 	{"http-harakiri", required_argument, 0, "enable http router harakiri", uwsgi_opt_set_int, &uhttp.cr.harakiri, 0},
+	{"http-stud-prefix", required_argument, 0, "expect a stud prefix (1byte family + 4/16 bytes address) on connections from the specified address", uwsgi_opt_add_addr_list, &uhttp.stud_prefix, 0},
 	{0, 0, 0, 0, 0, 0, 0},
 };
 
@@ -175,6 +177,11 @@ struct http_session {
         size_t post_buf_len;
         off_t post_buf_pos;
 
+	// 1 (family) + 4/16 (addr)
+	char stud_prefix[17];
+	size_t stud_prefix_remains;
+	size_t stud_prefix_pos;
+
 
 };
 
@@ -354,6 +361,11 @@ int http_parse(struct http_session *h_session, size_t http_req_len) {
 	// UWSGI_ROUTER
 	if (http_add_uwsgi_var(h_session, "UWSGI_ROUTER", 12, "http", 4)) return -1;
 
+	// stud HTTPS
+	if (h_session->stud_prefix_pos > 0) {
+		if (http_add_uwsgi_var(h_session, "HTTPS", 5, "on", 2)) return -1;
+	}
+
 #ifdef UWSGI_SSL
 	// HTTPS (adapted from nginx)
 	if (h_session->cs.ugs->mode == UWSGI_HTTP_SSL) {
@@ -399,9 +411,9 @@ int http_parse(struct http_session *h_session, size_t http_req_len) {
 	while (ptr < watermark) {
 		if (*ptr == '\r') {
 			if (ptr + 1 >= watermark)
-				return 0;
+				break;
 			if (*(ptr + 1) != '\n')
-				return 0;
+				break;
 			// multiline header ?
 			if (ptr + 2 < watermark) {
 				if (*(ptr + 2) == ' ' || *(ptr + 2) == '\t') {
@@ -514,9 +526,17 @@ ssize_t hr_read_ssl_body(struct corerouter_session * cs) {
         struct http_session *hs = (struct http_session *) cs;
         int ret = SSL_read(hs->ssl, hs->post_buf->buf, hs->post_buf_max);
         if (ret > 0) {
-                // fix waiting
-                if (cs->event_hook_write) {
-                        uwsgi_cr_hook_write(cs, NULL);
+		int ret2 = SSL_pending(hs->ssl);
+                if (ret2 > 0) {
+			if (uwsgi_buffer_fix(hs->post_buf, hs->post_buf->len + ret2 )) {
+				uwsgi_log("[uwsgi-https] cannot fix the buffer to %d\n", hs->post_buf->len + ret2);
+				return -1;
+			}
+                        if (SSL_read(hs->ssl, hs->post_buf->buf + ret, ret2) != ret2) {
+				uwsgi_log("[uwsgi-https] SSL_read() on %d bytes of pending data failed\n", ret2);
+                                return -1;
+                        }
+                        ret += ret2;
                 }
 		hs->post_buf_len = ret;
         	hs->post_buf_pos = 0;
@@ -531,8 +551,8 @@ ssize_t hr_read_ssl_body(struct corerouter_session * cs) {
         if (err == SSL_ERROR_WANT_READ) {
                 if (cs->event_hook_write) {
                         uwsgi_cr_hook_write(cs, NULL);
-                        uwsgi_cr_hook_read(cs, hr_read_ssl_body);
                 }
+                uwsgi_cr_hook_read(cs, hr_read_ssl_body);
                 errno = EINPROGRESS;
                 return -1;
         }
@@ -540,8 +560,8 @@ ssize_t hr_read_ssl_body(struct corerouter_session * cs) {
         else if (err == SSL_ERROR_WANT_WRITE) {
                 if (cs->event_hook_read) {
                         uwsgi_cr_hook_read(cs, NULL);
-                        uwsgi_cr_hook_write(cs, hr_read_ssl_body);
                 }
+                uwsgi_cr_hook_write(cs, hr_read_ssl_body);
                 errno = EINPROGRESS;
                 return -1;
         }
@@ -591,9 +611,6 @@ ssize_t hr_write_ssl_response(struct corerouter_session * cs) {
 
 	if (ret > 0) {
         	cs->buffer_pos += ret;
-		if (cs->event_hook_read) {
-			uwsgi_cr_hook_read(cs, NULL);
-		}
 		// could be a partial write
 		uwsgi_cr_hook_write(cs, hr_write_ssl_response);
         	// ok this response chunk is sent, let's wait for another one
@@ -608,16 +625,16 @@ ssize_t hr_write_ssl_response(struct corerouter_session * cs) {
         if (err == SSL_ERROR_WANT_READ) {
 		if (cs->event_hook_write) {
 			uwsgi_cr_hook_write(cs, NULL);
-			uwsgi_cr_hook_read(cs, hr_write_ssl_response);
 		}
+		uwsgi_cr_hook_read(cs, hr_write_ssl_response);
                 errno = EINPROGRESS;
                 return -1;
         }
         else if (err == SSL_ERROR_WANT_WRITE) {
 		if (cs->event_hook_read) {
 			uwsgi_cr_hook_read(cs, NULL);
-			uwsgi_cr_hook_write(cs, hr_write_ssl_response);
 		}
+		uwsgi_cr_hook_write(cs, hr_write_ssl_response);
                 errno = EINPROGRESS;
                 return -1;
         }
@@ -762,6 +779,12 @@ ssize_t hr_instance_send_request(struct corerouter_session * cs) {
 
 
 ssize_t hr_instance_send_request_header(struct corerouter_session * cs) {
+#ifdef __BIG_ENDIAN__
+	// on the first round fix endianess
+	if (cs->buffer_pos == 0) {
+		cs->uh.pktsize = uwsgi_swap16(cs->uh.pktsize);
+	}
+#endif
         ssize_t len = write(cs->instance_fd, &cs->uh + cs->buffer_pos, 4 - cs->buffer_pos);
         if (len < 0) {
                 cr_try_again;
@@ -775,6 +798,10 @@ ssize_t hr_instance_send_request_header(struct corerouter_session * cs) {
         // for response
         if (cs->buffer_pos == 4) {
                 cs->buffer_pos = 0;
+#ifdef __BIG_ENDIAN__
+	// on the last round restore endianess
+		cs->uh.pktsize = uwsgi_swap16(cs->uh.pktsize);
+#endif
                 uwsgi_cr_hook_instance_write(cs, hr_instance_send_request);
         }
 
@@ -804,9 +831,6 @@ ssize_t hr_send_expect_continue(struct corerouter_session * cs) {
 		if (ret > 0) {
 			len = ret;
 			cs->buffer_pos += ret;
-			if (cs->event_hook_read) {
-                        	uwsgi_cr_hook_read(cs, NULL);
-                	}
                 	// could be a partial write
                 	uwsgi_cr_hook_write(cs, hr_send_expect_continue);
 			goto done;
@@ -815,16 +839,16 @@ ssize_t hr_send_expect_continue(struct corerouter_session * cs) {
         	if (err == SSL_ERROR_WANT_READ) {
                 	if (cs->event_hook_write) {
                         	uwsgi_cr_hook_write(cs, NULL);
-                        	uwsgi_cr_hook_read(cs, hr_write_ssl_response);
                 	}
+                        uwsgi_cr_hook_read(cs, hr_write_ssl_response);
                 	errno = EINPROGRESS;
                 	return -1;
         	}
         	else if (err == SSL_ERROR_WANT_WRITE) {
                 	if (cs->event_hook_read) {
                         	uwsgi_cr_hook_read(cs, NULL);
-                        	uwsgi_cr_hook_write(cs, hr_write_ssl_response);
                 	}
+                        uwsgi_cr_hook_write(cs, hr_write_ssl_response);
                 	errno = EINPROGRESS;
                 	return -1;
         	}
@@ -856,6 +880,8 @@ done:
 }
 
 ssize_t hr_instance_connected(struct corerouter_session * cs) {
+
+	cs->connecting = 0;
 	socklen_t solen = sizeof(int);
 
         // first check for errors
@@ -882,6 +908,7 @@ ssize_t hr_instance_connected(struct corerouter_session * cs) {
 		return 1;
 	}
         // ok instance is connected, wait for write again
+	if (cs->static_node) cs->static_node->custom2++;
         if (cs->un) cs->un->requests++;
         uwsgi_cr_hook_instance_write(cs, hr_instance_send_request_header);
         // return a value > 0
@@ -895,19 +922,21 @@ ssize_t hr_recv_http_ssl(struct corerouter_session * cs) {
 	// be sure buffer does not grow over 64k
         cs->buffer->limit = UMAX16;
         // try to always leave 4k available
-        if (uwsgi_buffer_ensure(cs->buffer, uwsgi.page_size)) return -1;
+        if (uwsgi_buffer_ensure(cs->buffer, uwsgi.page_size))  {
+		uwsgi_log("[uwsgi-https] cannot ensure the buffer (size: %d)\n", cs->buffer->len);	 
+		return -1;
+	}
 	struct http_session *hs = (struct http_session *) cs;
 	int ret = SSL_read(hs->ssl, cs->buffer->buf + cs->buffer_pos, cs->buffer->len - cs->buffer_pos);
 	if (ret > 0) {
-		// fix waiting
-		if (cs->event_hook_write) {
-			uwsgi_cr_hook_write(cs, NULL);
-			uwsgi_cr_hook_read(cs, hr_recv_http_ssl);
-		}
 		int ret2 = SSL_pending(hs->ssl);
 		if (ret2 > 0) {
-			if (uwsgi_buffer_fix(cs->buffer, cs->buffer->len + ret2 )) return -1;
+			if (uwsgi_buffer_fix(cs->buffer, cs->buffer->len + ret2 )) {
+				uwsgi_log("[uwsgi-https] cannot fix the buffer to %d\n", cs->buffer->len + ret2 );
+				return -1;
+			}
 			if (SSL_read(hs->ssl, cs->buffer->buf + cs->buffer_pos + ret, ret2) != ret2) {
+				uwsgi_log("[uwsgi-https] SSL_read() on %d bytes of pending data failed\n", ret2);
 				return -1;
 			}
 			ret += ret2;
@@ -920,8 +949,8 @@ ssize_t hr_recv_http_ssl(struct corerouter_session * cs) {
 	if (err == SSL_ERROR_WANT_READ) {
                 if (cs->event_hook_write) {
                         uwsgi_cr_hook_write(cs, NULL);
-                        uwsgi_cr_hook_read(cs, hr_recv_http_ssl);
                 }
+                uwsgi_cr_hook_read(cs, hr_recv_http_ssl);
                 errno = EINPROGRESS;
                 return -1;
         }
@@ -929,8 +958,8 @@ ssize_t hr_recv_http_ssl(struct corerouter_session * cs) {
         else if (err == SSL_ERROR_WANT_WRITE) {
                 if (cs->event_hook_read) {
                         uwsgi_cr_hook_read(cs, NULL);
-                        uwsgi_cr_hook_write(cs, hr_recv_http_ssl);
                 }
+                uwsgi_cr_hook_write(cs, hr_recv_http_ssl);
                 errno = EINPROGRESS;
                 return -1;
         }
@@ -1024,6 +1053,7 @@ ssize_t hs_http_manage(struct corerouter_session * cs, ssize_t len) {
                 	// map the instance
                 	cs->corerouter->cr_table[cs->instance_fd] = cs;
                 	// wait for connection
+			cs->connecting = 1;
                 	uwsgi_cr_hook_instance_write(cs, hr_instance_connected);
 			break;
 		}
@@ -1049,6 +1079,31 @@ void hr_session_close(struct corerouter_session *cs) {
 	}
 }
 
+static ssize_t hr_recv_stud4(struct corerouter_session * cs) {
+	struct http_session *hs = (struct http_session *) cs;
+	ssize_t len = read(cs->fd, hs->stud_prefix + hs->stud_prefix_pos, hs->stud_prefix_remains - hs->stud_prefix_pos);
+	if (len < 0) {
+                cr_try_again;
+                uwsgi_error("hr_recv_stud4()");
+                return -1;
+        }
+
+	hs->stud_prefix_pos += len;
+
+        if (hs->stud_prefix_pos == hs->stud_prefix_remains) {
+		if (hs->stud_prefix[0] != AF_INET) {
+			uwsgi_log("[uwsgi-http] invalid stud prefix\n");
+			return -1;
+		}
+		// set the passed ip address
+		memcpy(&hs->ip_addr, hs->stud_prefix + 1, 4);
+		uwsgi_cr_hook_read(cs, hr_recv_http);
+        }
+
+        return len;
+
+}
+
 #ifdef UWSGI_SSL
 void hr_session_ssl_close(struct corerouter_session *cs) {
 	hr_session_close(cs);
@@ -1079,6 +1134,17 @@ void http_alloc_session(struct uwsgi_corerouter *ucr, struct uwsgi_gateway_socke
 	cs->modifier1 = uhttp.modifier1;
 	if (sa && sa->sa_family == AF_INET) {
 		hs->ip_addr = ((struct sockaddr_in *) sa)->sin_addr.s_addr;
+
+		struct uwsgi_string_list *usl = uhttp.stud_prefix;
+		while(usl) {
+			if (!memcmp(&hs->ip_addr, usl->value, 4)) {
+				hs->stud_prefix_remains = 5;
+				uwsgi_cr_hook_read(cs, hr_recv_stud4);
+				break;
+			}
+			usl = usl->next;
+		}
+
 	}
 
 	hs->rnrn = 0;
@@ -1100,7 +1166,9 @@ void http_alloc_session(struct uwsgi_corerouter *ucr, struct uwsgi_gateway_socke
 	}
 	else {
 #endif
-		uwsgi_cr_hook_read(cs, hr_recv_http);
+		if (!cs->event_hook_read) {
+			uwsgi_cr_hook_read(cs, hr_recv_http);
+		}
 		cs->close = hr_session_close;
 #ifdef UWSGI_SSL
 	}
@@ -1117,7 +1185,7 @@ int http_init() {
 
 	uhttp.cr.session_size = sizeof(struct http_session);
 	uhttp.cr.alloc_session = http_alloc_session;
-	if (uhttp.cr.has_sockets && !uwsgi.sockets && !uwsgi_courerouter_has_has_backends(&uhttp.cr)) {
+	if (uhttp.cr.has_sockets && !uwsgi.sockets && !uwsgi_corerouter_has_backends(&uhttp.cr)) {
 		uwsgi_new_socket(uwsgi_concat2("127.0.0.1:0", ""));
 		uhttp.cr.use_socket = 1;
 		uhttp.cr.socket_num = 0;

plugins/lua/lua_plugin.c

@@ -291,6 +291,57 @@ static int uwsgi_api_req_fd(lua_State *L) {
 	return 1;
 }
 
+static int uwsgi_api_lock(lua_State *L) {
+
+	int lock_num = 0;
+
+	// the spooler cannot lock resources
+#ifdef UWSGI_SPOOLER
+	if (uwsgi.i_am_a_spooler) {
+		lua_pushstring(L, "The spooler cannot lock/unlock resources");
+		lua_error(L);
+	}
+#endif
+
+	if (lua_gettop(L) > 0) {
+		lock_num = lua_isnumber(L, 1) ? lua_tonumber(L, 1) : -1;
+		if (lock_num < 0 || lock_num > uwsgi.locks) {
+			lua_pushstring(L, "Invalid lock number");
+	    		lua_error(L);
+	  	}
+	}
+	
+	uwsgi_lock(uwsgi.user_lock[lock_num]);
+
+	return 0;
+}
+
+
+static int uwsgi_api_unlock(lua_State *L) {
+
+	int lock_num = 0;
+
+	// the spooler cannot lock resources
+#ifdef UWSGI_SPOOLER
+	if (uwsgi.i_am_a_spooler) {
+		lua_pushstring(L, "The spooler cannot lock/unlock resources");
+		lua_error(L);
+	}
+#endif
+
+	if (lua_gettop(L) > 0) {
+		lock_num = lua_isnumber(L, 1) ? lua_tonumber(L, 1) : -1;
+		if (lock_num < 0 || lock_num > uwsgi.locks) {
+			lua_pushstring(L, "Invalid lock number");
+	    		lua_error(L);
+	  	}
+	}
+	
+	uwsgi_unlock(uwsgi.user_lock[lock_num]);
+
+	return 0;
+}
+
 static const luaL_reg uwsgi_api[] = {
   {"log", uwsgi_api_log},
   {"cl", uwsgi_api_cl},
@@ -300,6 +351,8 @@ static const luaL_reg uwsgi_api[] = {
   {"cache_set", uwsgi_api_cache_set},
   {"register_signal", uwsgi_api_register_signal},
   {"register_rpc", uwsgi_api_register_rpc},
+  {"lock", uwsgi_api_lock},
+  {"unlock", uwsgi_api_unlock},
   {NULL, NULL}
 };
 
@@ -308,6 +361,8 @@ static const luaL_reg uwsgi_api[] = {
 static int uwsgi_lua_input(lua_State *L) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
+	int fd = wsgi_req->async_post ?
+	  fileno(wsgi_req->async_post) : wsgi_req->poll.fd;
 	ssize_t sum, len, total;
 	char *buf, *ptr;
 
@@ -330,7 +385,7 @@ static int uwsgi_lua_input(lua_State *L) {
 
 	ptr = buf;
 	while(total) {
-		len = read(wsgi_req->poll.fd, ptr, total);
+		len = read(fd, ptr, total);
 		ptr += len;
 		total -= len;
 	}

plugins/mono/mono_plugin.c

@@ -1,35 +0,0 @@
-#include "../../uwsgi.h"
-
-struct uwsgi_mono {
-
-	char *assembly_name ;
-	
-} um;
-
-int uwsgi_mono_init() {
-
-
-	MonoDomain *domain;
-
-	MonoAssembly *assembly;
-        MonoImage *image, *corlib;
-
-	domain = mono_jit_init("uwsgi");
-
-	corlib = mono_get_corlib();
-        if (!corlib) {
-		uwsgi_log("unable to initialize MONO engine\n");
-		exit(1);
-        }
-
-
-	image = mono_assembly_get_image(assembly);
-
-}
-
-
-struct uwsgi_plugin mono_plugin = {
-
-	.name = "mono",
-	.init = uwsgi_mono_init,
-};

plugins/php/php_plugin.c

@@ -22,8 +22,11 @@ struct uwsgi_php {
 	struct uwsgi_string_list *index;
 	struct uwsgi_string_list *set;
 	struct uwsgi_string_list *append_config;
+	struct uwsgi_string_list *vars;
 	char *docroot;
 	char *app;
+	char *app_qs;
+	char *fallback;
 	size_t ini_size;
 	int dump_config;
 	char *server_software;
@@ -49,6 +52,9 @@ struct uwsgi_option uwsgi_php_options[] = {
         {"php-allowed-script", required_argument, 0, "list the allowed php scripts (require absolute path)", uwsgi_opt_add_string_list, &uphp.allowed_scripts, 0},
         {"php-server-software", required_argument, 0, "force php SERVER_SOFTWARE", uwsgi_opt_set_str, &uphp.server_software, 0},
         {"php-app", required_argument, 0, "force the php file to run at each request", uwsgi_opt_set_str, &uphp.app, 0},
+        {"php-var", required_argument, 0, "add/overwrite a CGI variable at each request", uwsgi_opt_add_string_list, &uphp.vars, 0},
+        {"php-app-qs", required_argument, 0, "when in app mode force QUERY_STRING to the specified value + PATH_INFO", uwsgi_opt_set_str, &uphp.app_qs, 0},
+	{"php-fallback", required_argument, 0, "run the specified php script when the request one does not exist", uwsgi_opt_set_str, &uphp.fallback, 0},
         {"php-dump-config", no_argument, 0, "dump php config (if modified via --php-set or append options)", uwsgi_opt_true, &uphp.dump_config, 0},
         {0, 0, 0, 0, 0, 0, 0},
 
@@ -285,6 +291,9 @@ static void sapi_uwsgi_register_variables(zval *track_vars_array TSRMLS_DC)
         }
 
 	php_register_variable_safe("PATH_INFO", wsgi_req->path_info, wsgi_req->path_info_len, track_vars_array TSRMLS_CC);
+	if (wsgi_req->query_string_len > 0) {
+		php_register_variable_safe("QUERY_STRING", wsgi_req->query_string, wsgi_req->query_string_len, track_vars_array TSRMLS_CC);
+	}
 
 	php_register_variable_safe("SCRIPT_NAME", wsgi_req->script_name, wsgi_req->script_name_len, track_vars_array TSRMLS_CC);
 	php_register_variable_safe("SCRIPT_FILENAME", wsgi_req->file, wsgi_req->file_len, track_vars_array TSRMLS_CC);
@@ -304,6 +313,16 @@ static void sapi_uwsgi_register_variables(zval *track_vars_array TSRMLS_DC)
 
 	php_register_variable_safe("PHP_SELF", wsgi_req->script_name, wsgi_req->script_name_len, track_vars_array TSRMLS_CC);
 
+	struct uwsgi_string_list *usl = uphp.vars;
+	while(usl) {
+		char *equal = strchr(usl->value, '=');
+		if (equal) {
+			php_register_variable_safe( estrndup(usl->value, equal-usl->value),
+				equal+1, strlen(equal+1), track_vars_array TSRMLS_CC);
+		}
+		usl = usl->next;
+	}
+
 
 }
 
@@ -658,6 +677,16 @@ int uwsgi_php_init(void) {
 		uwsgi_log("--- end of PHP custom config ---\n");
 	}
 
+	// fix docroot
+        if (uphp.docroot) {
+		char *orig_docroot = uphp.docroot;
+		uphp.docroot = uwsgi_expand_path(uphp.docroot, strlen(uphp.docroot), NULL);
+		if (!uphp.docroot) {
+			uwsgi_log("unable to set php docroot to %s\n", orig_docroot);
+			exit(1);
+		}
+	}
+
 	uwsgi_sapi_module.startup(&uwsgi_sapi_module);
 
 	// filling http status codes
@@ -690,7 +719,6 @@ int uwsgi_php_walk(struct wsgi_request *wsgi_req, char *full_path, char *docroot
                         *(dst+part_size-1) = 0;
 
                         if (stat(full_path, &st)) {
-				uwsgi_php_404(wsgi_req);
                                 return -1;
                         }
 
@@ -700,7 +728,6 @@ int uwsgi_php_walk(struct wsgi_request *wsgi_req, char *full_path, char *docroot
                                 if (i < (wsgi_req->path_info_len)-1) {
                                         *path_info = ptr + i;
                                 }
-
                                 return 0;
                         }
 
@@ -766,6 +793,27 @@ int uwsgi_php_request(struct wsgi_request *wsgi_req) {
 
 	if (uphp.app) {
 		strcpy(real_filename, uphp.app);	
+		if (wsgi_req->path_info_len == 1 && wsgi_req->path_info[0] == '/') {
+			goto appready;
+		}
+		if (uphp.app_qs) {
+			size_t app_qs_len = strlen(uphp.app_qs);
+			size_t qs_len = wsgi_req->path_info_len + app_qs_len;
+			if (wsgi_req->query_string_len > 0) {
+				qs_len += 1 + wsgi_req->query_string_len;
+			}
+			char *qs = ecalloc(1, qs_len+1);
+			memcpy(qs, uphp.app_qs, app_qs_len);
+			memcpy(qs+app_qs_len, wsgi_req->path_info, wsgi_req->path_info_len);
+			if (wsgi_req->query_string_len > 0) {
+				char *ptr = qs+app_qs_len+wsgi_req->path_info_len;
+				*ptr = '&';
+				memcpy(ptr+1, wsgi_req->query_string, wsgi_req->query_string_len);
+			}
+			wsgi_req->query_string = qs;
+			wsgi_req->query_string_len = qs_len;
+		}
+appready:
 		wsgi_req->path_info = "";
 		wsgi_req->path_info_len = 0;
 		goto secure2;
@@ -775,9 +823,16 @@ int uwsgi_php_request(struct wsgi_request *wsgi_req) {
 
 	if (uwsgi_php_walk(wsgi_req, filename, wsgi_req->document_root, wsgi_req->document_root_len, &path_info)) {
 		free(filename);
-		return -1;
+		if (uphp.fallback) {
+			filename = uwsgi_str(uphp.fallback);
+		}
+		else {
+			uwsgi_php_404(wsgi_req);
+			return -1;
+		}
 	}
 
+
 	char *orig_path_info = wsgi_req->path_info;
 	uint16_t orig_path_info_len = wsgi_req->path_info_len;
 
@@ -891,7 +946,6 @@ secure2:
 
 secure3:
 
-
 	if (wsgi_req->document_root[wsgi_req->document_root_len-1] == '/') {
 		wsgi_req->script_name = real_filename + (wsgi_req->document_root_len-1);
 	}

plugins/psgi/psgi.h

@@ -23,6 +23,9 @@ struct uwsgi_perl {
 	int no_die_catch;
 	int stacktrace_available;
 
+	char *argv_items;
+	struct uwsgi_string_list *argv_item;
+
 	// this is a pointer to the main list of interpreters (required for signals, rpc....);
         PerlInterpreter **main;
 
@@ -37,6 +40,9 @@ struct uwsgi_perl {
 
 	CV **tmp_psgix_logger;
 	CV **tmp_stream_responder;
+	
+	SV *postfork;
+	SV *atexit;
 };
 
 void init_perl_embedded_module(void);
@@ -51,3 +57,5 @@ int uwsgi_perl_obj_can(SV *, char *, size_t);
 int uwsgi_perl_obj_isa(SV *, char *);
 int init_psgi_app(struct wsgi_request *, char *, uint16_t, PerlInterpreter **);
 PerlInterpreter *uwsgi_perl_new_interpreter(void);
+int uwsgi_perl_mule(char *);
+void uwsgi_perl_run_hook(SV *);

plugins/psgi/psgi_loader.c

@@ -21,7 +21,12 @@ XS(XS_error) {
 
         psgi_check_args(0);
 
-        ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->error)[wsgi_req->async_id]);
+	if (uwsgi.threads > 1) {
+        	ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->error)[wsgi_req->async_id]);
+	}
+	else {
+        	ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->error)[0]);
+	}
         XSRETURN(1);
 }
 
@@ -32,7 +37,12 @@ XS(XS_input) {
 	struct uwsgi_app *wi = &uwsgi_apps[wsgi_req->app_id];
         psgi_check_args(0);
 
-        ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->input)[wsgi_req->async_id]);
+	if (uwsgi.threads > 1) {
+        	ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->input)[wsgi_req->async_id]);
+	}
+	else {
+        	ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->input)[0]);
+	}
         XSRETURN(1);
 }
 
@@ -66,7 +76,12 @@ XS(XS_stream)
 		while (psgi_response(wsgi_req, response) != UWSGI_OK);
 
 		SvREFCNT_dec(response);
-                ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->stream)[wsgi_req->async_id]);
+		if (uwsgi.threads > 1) {
+                	ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->stream)[wsgi_req->async_id]);
+		}
+		else {
+                	ST(0) = sv_bless(newRV(sv_newmortal()), ((HV **)wi->stream)[0]);
+		}
                 XSRETURN(1);
 	}
 	else {
@@ -233,6 +248,8 @@ xs_init(pTHX)
         /* DynaLoader is a special case */
         newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
 
+	if (!uperl.tmp_input_stash) goto nonworker;
+
         newXS("uwsgi::input::new", XS_input, "uwsgi::input");
         newXS("uwsgi::input::read", XS_input_read, "uwsgi::input");
         newXS("uwsgi::input::seek", XS_input_seek, "uwsgi::input");
@@ -253,6 +270,8 @@ xs_init(pTHX)
 
         uperl.tmp_streaming_stash[uperl.tmp_current_i] = gv_stashpv("uwsgi::streaming", 0);
 
+nonworker:
+
 #ifdef UWSGI_EMBEDDED
         init_perl_embedded_module();
 #endif
@@ -409,6 +428,23 @@ int init_psgi_app(struct wsgi_request *wsgi_req, char *app, uint16_t app_len, Pe
 			}
 		}
 
+		if (uperl.argv_items || uperl.argv_item) {
+			AV *uperl_argv = GvAV(PL_argvgv);
+			if (uperl.argv_items) {
+				char *argv_list = uwsgi_str(uperl.argv_items);
+				char *p = strtok(argv_list, " ");
+				while(p) {
+					av_push(uperl_argv, newSVpv(p, 0));
+					p = strtok(NULL, " ");
+				}
+			}
+			struct uwsgi_string_list *usl = uperl.argv_item;
+			while(usl) {
+				av_push(uperl_argv, newSVpv(usl->value, usl->len));
+				usl = usl->next;
+			}
+		}
+
 		SV *dollar_zero = get_sv("0", GV_ADD);
 		sv_setsv(dollar_zero, newSVpv(app, app_len));
 
@@ -496,3 +532,19 @@ void uwsgi_psgi_app() {
 
 }
 
+int uwsgi_perl_mule(char *opt) {
+
+        if (uwsgi_endswith(opt, ".pl")) {
+                PERL_SET_CONTEXT(uperl.main[0]);
+                uperl.embedding[1] = opt;
+                if (perl_parse(uperl.main[0], xs_init, 2, uperl.embedding, NULL)) {
+                        return 0;
+                }
+                perl_run(uperl.main[0]);
+                return 1;
+        }
+
+        return 0;
+
+}
+

plugins/psgi/psgi_plugin.c

@@ -16,6 +16,11 @@ struct uwsgi_option uwsgi_perl_options[] = {
         {"psgi", required_argument, 0, "load a psgi app", uwsgi_opt_set_str, &uperl.psgi, 0},
         {"perl-no-die-catch", no_argument, 0, "do not catch $SIG{__DIE__}", uwsgi_opt_true, &uperl.no_die_catch, 0},
         {"perl-local-lib", required_argument, 0, "set perl locallib path", uwsgi_opt_set_str, &uperl.locallib, 0},
+#ifdef PERL_VERSION_STRING
+        {"perl-version", no_argument, 0, "print perl version", uwsgi_opt_print, PERL_VERSION_STRING, UWSGI_OPT_IMMEDIATE},
+#endif
+	{"perl-args", required_argument, 0, "add items (space separated) to @ARGV", uwsgi_opt_set_str, &uperl.argv_items, 0},
+	{"perl-arg", required_argument, 0, "add an item to @ARGV", uwsgi_opt_add_string_list, &uperl.argv_item, 0},
         {0, 0, 0, 0, 0, 0, 0},
 
 };
@@ -57,7 +62,12 @@ SV *uwsgi_perl_call_stream(SV *func) {
         ENTER;
         SAVETMPS;
         PUSHMARK(SP);
-        XPUSHs( sv_2mortal(newRV((SV*) ((SV **)wi->responder0)[wsgi_req->async_id])));
+	if (uwsgi.threads > 1) {
+        	XPUSHs( sv_2mortal(newRV((SV*) ((SV **)wi->responder0)[wsgi_req->async_id])));
+	}
+	else {
+        	XPUSHs( sv_2mortal(newRV((SV*) ((SV **)wi->responder0)[0])));
+	}
         PUTBACK;
 
 	call_sv( func, G_SCALAR | G_EVAL);
@@ -291,7 +301,12 @@ SV *build_psgi_env(struct wsgi_request *wsgi_req) {
 	
 	if (!hv_store(env, "psgix.input.buffered", 20, newSViv(wsgi_req->body_as_file), 0)) goto clear;
 
-	if (!hv_store(env, "psgix.logger", 12,newRV((SV*) ((SV **)wi->responder1)[wsgi_req->async_id]) ,0)) goto clear;
+	if (uwsgi.threads > 1) {
+		if (!hv_store(env, "psgix.logger", 12,newRV((SV*) ((SV **)wi->responder1)[wsgi_req->async_id]) ,0)) goto clear;
+	}
+	else {
+		if (!hv_store(env, "psgix.logger", 12,newRV((SV*) ((SV **)wi->responder1)[0]) ,0)) goto clear;
+	}
 
 	if (uwsgi.master_process) {
 		if (!hv_store(env, "psgix.harakiri", 14, newSViv(1), 0)) goto clear;
@@ -426,8 +441,15 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 	struct uwsgi_app *wi = &uwsgi_apps[wsgi_req->app_id];
 	wi->requests++;
 
-	if (((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id] != uperl.main[wsgi_req->async_id]) {
-		PERL_SET_CONTEXT(((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id]);
+	if (uwsgi.threads < 2) {
+		if (((PerlInterpreter **)wi->interpreter)[0] != uperl.main[0]) {
+			PERL_SET_CONTEXT(((PerlInterpreter **)wi->interpreter)[0]);
+		}
+	}
+	else {
+		if (((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id] != uperl.main[wsgi_req->async_id]) {
+			PERL_SET_CONTEXT(((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id]);
+		}
 	}
 
 	ENTER;
@@ -436,7 +458,12 @@ int uwsgi_perl_request(struct wsgi_request *wsgi_req) {
 	wsgi_req->async_environ = build_psgi_env(wsgi_req);
 	if (!wsgi_req->async_environ) goto clear;
 
-	wsgi_req->async_result = psgi_call(wsgi_req, ((SV **)wi->callable)[wsgi_req->async_id], wsgi_req->async_environ);
+	if (uwsgi.threads > 1) {
+		wsgi_req->async_result = psgi_call(wsgi_req, ((SV **)wi->callable)[wsgi_req->async_id], wsgi_req->async_environ);
+	}
+	else {
+		wsgi_req->async_result = psgi_call(wsgi_req, ((SV **)wi->callable)[0], wsgi_req->async_environ);
+	}
 	if (!wsgi_req->async_result) goto clear;
 
 	if (SvTYPE((AV *)wsgi_req->async_result) == SVt_PVCV) {
@@ -469,8 +496,15 @@ clear:
 	LEAVE;
 
 	// restore main interpreter if needed
-	if (((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id] != uperl.main[wsgi_req->async_id]) {
-		PERL_SET_CONTEXT(uperl.main[wsgi_req->async_id]);
+	if (uwsgi.threads > 1) {
+		if (((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id] != uperl.main[wsgi_req->async_id]) {
+			PERL_SET_CONTEXT(uperl.main[wsgi_req->async_id]);
+		}
+	}
+	else {
+		if (((PerlInterpreter **)wi->interpreter)[0] != uperl.main[0]) {
+			PERL_SET_CONTEXT(uperl.main[0]);
+		}
 	}
 
 	return UWSGI_OK;
@@ -554,6 +588,10 @@ void uwsgi_perl_post_fork() {
 		sv_setiv(GvSV(tmpgv), (IV)getpid());
 		SvREADONLY_on(GvSV(tmpgv));
 	}
+
+	if (uperl.postfork) {
+		uwsgi_perl_run_hook(uperl.postfork);
+	}
 }
 
 int uwsgi_perl_mount_app(char *mountpoint, char *app) {
@@ -595,6 +633,77 @@ void uwsgi_perl_enable_threads(void) {
 #endif
 }
 
+int uwsgi_perl_signal_handler(uint8_t sig, void *handler) {
+
+	int ret = 0;
+
+	dSP;
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs( sv_2mortal(newSViv(sig)));
+        PUTBACK;
+
+        call_sv( SvRV((SV*)handler), G_DISCARD);
+
+	if(SvTRUE(ERRSV)) {
+                uwsgi_log("[uwsgi-perl error] %s\n", SvPV_nolen(ERRSV));
+		ret = -1;
+        }
+
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+	return ret;
+}
+
+void uwsgi_perl_run_hook(SV *hook) {
+	dSP;
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs( hook );
+        PUTBACK;
+
+        call_sv( SvRV(hook), G_DISCARD);
+
+        if(SvTRUE(ERRSV)) {
+                uwsgi_log("[uwsgi-perl error] %s\n", SvPV_nolen(ERRSV));
+		return;
+        }
+
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+}
+
+static void uwsgi_perl_atexit() {
+	if (uwsgi.mywid == -1) goto realstuff;
+
+        // if hijacked do not run atexit hooks
+        if (uwsgi.workers[uwsgi.mywid].hijacked)
+                return;
+
+        // if busy do not run atexit hooks
+        if (uwsgi.workers[uwsgi.mywid].busy)
+                return;
+
+#ifdef UWSGI_ASYNC
+        // managing atexit in async mode is a real pain...skip it for now
+        if (uwsgi.async > 1)
+                return;
+#endif
+
+realstuff:
+
+	if (uperl.atexit) {
+		uwsgi_perl_run_hook(uperl.atexit);
+	}
+}
+
 struct uwsgi_plugin psgi_plugin = {
 
 	.name = "psgi",
@@ -606,11 +715,16 @@ struct uwsgi_plugin psgi_plugin = {
 	.mount_app = uwsgi_perl_mount_app,
 
 	.init_thread = uwsgi_perl_init_thread,
+	.signal_handler = uwsgi_perl_signal_handler,
+
+	.mule = uwsgi_perl_mule,
 
 	.post_fork = uwsgi_perl_post_fork,
 	.request = uwsgi_perl_request,
 	.after_request = uwsgi_perl_after_request,
 	.enable_threads = uwsgi_perl_enable_threads,
 
+	.atexit = uwsgi_perl_atexit,
+
 	.magic = uwsgi_perl_magic,
 };

plugins/psgi/psgi_response.c

@@ -46,7 +46,6 @@ int psgi_response(struct wsgi_request *wsgi_req, AV *response) {
                 		if (SvTRUE(*harakiri)) wsgi_req->async_plagued = 1;
         		}
 
-			SvREFCNT_dec(wsgi_req->async_environ);
         		SvREFCNT_dec(wsgi_req->async_result);
 
 			return UWSGI_OK;
@@ -59,6 +58,11 @@ int psgi_response(struct wsgi_request *wsgi_req, AV *response) {
 	}
 #endif
 
+	if (SvTYPE(response) != SVt_PVAV) {
+		uwsgi_log("invalid PSGI response type\n");
+		return UWSGI_OK;
+	}
+
 	status_code = av_fetch(response, 0, 0);
 	if (!status_code) { uwsgi_log("invalid PSGI status code\n"); return UWSGI_OK;}
 

plugins/psgi/uwsgi_plmodule.c

@@ -1,6 +1,8 @@
 #include "psgi.h"
 
 extern struct uwsgi_server uwsgi;
+extern struct uwsgi_plugin psgi_plugin;
+extern struct uwsgi_perl uperl;
 
 #ifdef UWSGI_ASYNC
 
@@ -149,6 +151,49 @@ clear:
 	
 }
 
+XS(XS_register_signal) {
+	dXSARGS;
+
+	if (!uwsgi.master_process) {
+		XSRETURN_NO;
+	}
+
+	psgi_check_args(3);
+
+	uint8_t signum = SvIV(ST(0));
+	STRLEN kindlen;
+	char *kind = SvPV(ST(1), kindlen);
+
+	if (uwsgi_register_signal(signum, kind, (void *) newRV_inc(ST(2)), psgi_plugin.modifier1)) {
+		XSRETURN_NO;
+        }
+
+	XSRETURN_YES;
+	
+}
+
+XS(XS_postfork) {
+        dXSARGS;
+
+        psgi_check_args(1);
+
+	uperl.postfork = newRV_inc(ST(0));
+
+        XSRETURN_YES;
+}
+
+XS(XS_atexit) {
+        dXSARGS;
+
+        psgi_check_args(1);
+
+        uperl.atexit = newRV_inc(ST(0));
+
+        XSRETURN_YES;
+}
+
+
+
 XS(XS_log) {
 
 	dXSARGS;
@@ -219,6 +264,68 @@ XS(XS_suspend) {
 	XSRETURN_UNDEF;
 }
 
+XS(XS_signal_wait) {
+
+	dXSARGS;
+
+	psgi_check_args(0);
+
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+        int received_signal = -1;
+
+        wsgi_req->signal_received = -1;
+
+	if (items > 0) {
+                received_signal = uwsgi_signal_wait(SvIV(ST(0)));
+        }
+        else {
+                received_signal = uwsgi_signal_wait(-1);
+        }
+
+        if (received_signal < 0) {
+		XSRETURN_NO;
+        }
+
+        wsgi_req->signal_received = received_signal;
+	XSRETURN_YES;
+}
+
+XS(XS_add_timer) {
+
+        dXSARGS;
+
+        psgi_check_args(2);
+
+        uint8_t uwsgi_signal = SvIV(ST(0));
+        int seconds = SvIV(ST(1));
+
+        if (uwsgi_add_timer(uwsgi_signal, seconds)) {
+                croak("unable to register timer");
+                XSRETURN_UNDEF;
+        }
+
+        XSRETURN(1);
+}
+
+XS(XS_add_rb_timer) {
+
+        dXSARGS;
+
+        psgi_check_args(2);
+
+        uint8_t uwsgi_signal = SvIV(ST(0));
+        int seconds = SvIV(ST(1));
+
+        if (uwsgi_signal_add_rb_timer(uwsgi_signal, seconds, 0)) {
+                croak("unable to register rb timer");
+                XSRETURN_UNDEF;
+        }
+
+        XSRETURN(1);
+}
+
+
+
 void init_perl_embedded_module() {
 	psgi_xs(reload);
 	psgi_xs(cache_set);
@@ -231,5 +338,11 @@ void init_perl_embedded_module() {
 	psgi_xs(async_connect);
 	psgi_xs(suspend);
 	psgi_xs(signal);
+	psgi_xs(register_signal);
+	psgi_xs(signal_wait);
+	psgi_xs(postfork);
+	psgi_xs(atexit);
+	psgi_xs(add_timer);
+	psgi_xs(add_rb_timer);
 }
 

plugins/python/python_plugin.c

@@ -46,6 +46,23 @@ void uwsgi_opt_pyrun(char *opt, char *value, void *foobar) {
 	up.pyrun = value;
 }
 
+void uwsgi_opt_pyver(char *opt, char *foo, void *bar) {
+#ifndef UWSGI_PYPY
+	const char *version = Py_GetVersion();
+#else
+	const char *version = PYPY_VERSION;
+#endif
+	const char *space = strchr(version, ' ');
+	if (space) {
+        	fprintf(stdout, "%.*s\n", (int) (space-version), version);
+	}
+	else {
+        	fprintf(stdout, "%s\n", version);
+	}
+	exit(0);
+}
+
+
 #ifdef UWSGI_INI
 void uwsgi_opt_ini_paste(char *opt, char *value, void *foobar) {
 
@@ -142,6 +159,8 @@ struct uwsgi_option uwsgi_python_options[] = {
 	{"wsgi-env-behavior", required_argument, 0, "set the strategy for allocating/deallocating the WSGI env", uwsgi_opt_set_str, &up.wsgi_env_behaviour, 0},
 	{"start_response-nodelay", no_argument, 0, "send WSGI http headers as soon as possible (PEP violation)", uwsgi_opt_true, &up.start_response_nodelay, 0},
 
+	{"python-version", no_argument, 0, "report python version", uwsgi_opt_pyver, NULL, UWSGI_OPT_IMMEDIATE},
+
 	{0, 0, 0, 0, 0, 0, 0},
 };
 
@@ -1754,9 +1773,7 @@ int uwsgi_python_mule(char *opt) {
 
 	if (uwsgi_endswith(opt, ".py")) {
 		UWSGI_GET_GIL;
-		if (uwsgi_pyimport_by_filename("__main__", opt) == NULL) {
-			return 0;
-		}
+		uwsgi_pyimport_by_filename("__main__", opt);
 		UWSGI_RELEASE_GIL;
 		return 1;
 	}

plugins/python/uwsgi_pymodule.c

@@ -2763,7 +2763,6 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 	
 
 		PyDict_SetItemString(worker_dict, "apps", apps_tuple);
-		Py_DECREF(apps_tuple);
 
 	}
 

plugins/python/uwsgiplugin.py

@@ -2,9 +2,16 @@ import os,sys
 
 from distutils import sysconfig
 
+def get_python_version():
+    version = sysconfig.get_config_var('VERSION')
+    try:
+        version = version + sys.abiflags
+    except:
+        pass
+    return version
+
 NAME='python'
 GCC_LIST = ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter', 'tracebacker']
-#OBJ_LIST = ['/usr/lib/libpython2.6.a']
 
 CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True) ] 
 
@@ -15,8 +22,26 @@ LDFLAGS = []
 
 if not 'UWSGI_PYTHON_NOLIB' in os.environ:
     LIBS = sysconfig.get_config_var('LIBS').split() + sysconfig.get_config_var('SYSLIBS').split()
+    # check if it is a non-shared build (but please, add --enable-shared to your python's ./configure script)
     if not sysconfig.get_config_var('Py_ENABLE_SHARED'):
-        LIBS.append('-L' + sysconfig.get_config_var('LIBPL'))
+        libdir = sysconfig.get_config_var('LIBPL')
+        # libdir does not exists, try to get it from the venv
+        version = get_python_version()
+        if not os.path.exists(libdir):
+            libdir = '%s/lib/python%s/config' % (sys.prefix, version)
+        # try skipping abiflag
+        if not os.path.exists(libdir) and version.endswith('m'):
+            version = version[:-1]
+            libdir = '%s/lib/python%s/config' % (sys.prefix, version)
+        # try 3.x style config dir
+        if not os.path.exists(libdir):
+            libdir = '%s/lib/python%s/config-%s' % (sys.prefix, version, get_python_version())
+        libpath = '%s/%s' % (libdir, sysconfig.get_config_var('LDLIBRARY'))
+        if not os.path.exists(libpath): 
+            libpath = '%s/%s' % (libdir, sysconfig.get_config_var('LIBRARY'))
+        if not os.path.exists(libpath): 
+            libpath = '%s/libpython%s.a' % (libdir, version)
+        LIBS.append(libpath)
     else:
         try:
             LDFLAGS.append("-L%s" % sysconfig.get_config_var('LIBDIR'))
@@ -25,16 +50,6 @@ if not 'UWSGI_PYTHON_NOLIB' in os.environ:
             LDFLAGS.append("-L%s/lib" % sysconfig.PREFIX)
             os.environ['LD_RUN_PATH'] = "%s/lib" % sysconfig.PREFIX
 
-
-    version = sysconfig.get_config_var('VERSION')
-    try:
-        version = version + sys.abiflags
-    except:
-        pass
-    LIBS.append('-lpython' + version)
+        LIBS.append('-lpython%s' % get_python_version())
 else:
     LIBS = []
-
-#if str(PYLIB_PATH) != '':
-#                libs.insert(0,'-L' + PYLIB_PATH)
-#                os.environ['LD_RUN_PATH'] = PYLIB_PATH

plugins/python/wsgi_handlers.c

@@ -180,11 +180,11 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
 	ssize_t rlen = up.hook_wsgi_input_read(self->wsgi_req, tmp_buf, remains, &tmp_pos);
 	if (rlen < 0) {
                 free(tmp_buf);
-        	return PyErr_Format(PyExc_IOError, "error reading for wsgi.input data: Content-Length %llu requested %llu received %llu", (unsigned long long) self->wsgi_req->post_cl, (unsigned long long)  (remains + tmp_pos), (unsigned long long) tmp_pos);
+        	return PyErr_Format(PyExc_IOError, "error reading for wsgi.input data: Content-Length %llu requested %llu received %llu pos %llu+%llu", (unsigned long long) self->wsgi_req->post_cl, (unsigned long long)  remains, (unsigned long long) tmp_pos, (unsigned long long) self->pos, (unsigned long long) tmp_pos);
 	}
-	else if (tmp_pos == 0) {
+	else if (rlen == 0) {
                 free(tmp_buf);
-        	return PyErr_Format(PyExc_IOError, "error waiting for wsgi.input data: Content-Length %llu requested %llu received %llu", (unsigned long long) self->wsgi_req->post_cl, (unsigned long long)  (remains + tmp_pos), (unsigned long long) tmp_pos);
+        	return PyErr_Format(PyExc_IOError, "error waiting for wsgi.input data: Content-Length %llu requested %llu received %llu pos %llu+%llu", (unsigned long long) self->wsgi_req->post_cl, (unsigned long long)  remains, (unsigned long long) tmp_pos, (unsigned long long) self->pos, (unsigned long long) tmp_pos);
 	}
 
 	self->pos += tmp_pos;

plugins/rack/rack_plugin.c

@@ -254,8 +254,10 @@ VALUE rb_uwsgi_io_rewind(VALUE obj, VALUE args) {
 }
 
 #ifdef RUBY19
+#ifdef RUBY_GLOBAL_SETUP
 RUBY_GLOBAL_SETUP
 #endif
+#endif
 
 VALUE uwsgi_require_file(VALUE arg) {
     return rb_funcall(rb_cObject, rb_intern("require"), 1, arg);
@@ -1024,10 +1026,21 @@ VALUE init_rack_app( VALUE script ) {
         VALUE rack = rb_const_get(rb_cObject, rb_intern("Rack"));
 
 #ifdef RUBY19
-	if (rb_eval_string("module Rack;class BodyProxy;def each(&block);@body.each(&block);end;end;end")) {
-		if (uwsgi.mywid <= 1) {
-			uwsgi_log("Rack::BodyProxy successfully patched for ruby 1.9.x\n");
-		}	
+	if (rb_funcall(rack, rb_intern("const_defined?"), 1, ID2SYM(rb_intern("BodyProxy"))) == Qtrue) {
+		VALUE bodyproxy = rb_const_get(rack, rb_intern("BodyProxy"));
+		// get the list of available instance_methods
+		VALUE argv = Qfalse;
+		VALUE methods_list = rb_class_instance_methods(1, &argv, bodyproxy);
+#ifdef UWSGI_DEBUG
+		uwsgi_log("%s\n", RSTRING_PTR(rb_inspect(methods_list)));
+#endif
+		if (rb_ary_includes(methods_list, ID2SYM(rb_intern("each"))) == Qfalse) {
+			if (rb_eval_string("module Rack;class BodyProxy;def each(&block);@body.each(&block);end;end;end")) {
+				if (uwsgi.mywid <= 1) {
+					uwsgi_log("Rack::BodyProxy successfully patched for ruby 1.9.x\n");
+				}
+			}
+		}
 	}
 #endif
 

plugins/rack/uwsgiplugin.py

@@ -14,7 +14,7 @@ v = version.split('.')
 
 GCC_LIST = ['rack_plugin', 'rack_api']
 
-if v[0] == '1' and v[1] == '9':
+if (v[0] == '1' and v[1] == '9') or v[0] >= '2':
     CFLAGS = os.popen(RUBYPATH + " -e \"require 'rbconfig';print RbConfig::CONFIG['CFLAGS']\"").read().rstrip().split()
     CFLAGS.append('-DRUBY19')
     CFLAGS.append('-Wno-unused-parameter')
@@ -34,10 +34,18 @@ else:
     CFLAGS.append('-I' + archdir + '/' + arch)
     CFLAGS.append('-I' + includedir + '/' + arch)
 
+
 LDFLAGS = os.popen(RUBYPATH + " -e \"require 'rbconfig';print %s::CONFIG['LDFLAGS']\"" % rbconfig).read().rstrip().split()
-
 libpath = os.popen(RUBYPATH + " -e \"require 'rbconfig';print %s::CONFIG['libdir']\"" % rbconfig).read().rstrip()
-LDFLAGS.append('-L' + libpath )
-os.environ['LD_RUN_PATH'] = libpath
-LIBS = os.popen(RUBYPATH + " -e \"require 'rbconfig';print '-l' + %s::CONFIG['RUBY_SO_NAME']\"" % rbconfig).read().rstrip().split()
+
+has_shared = os.popen(RUBYPATH + " -e \"require 'rbconfig';print %s::CONFIG['ENABLE_SHARED']\"" % rbconfig).read().rstrip()
+
+LIBS = os.popen(RUBYPATH + " -e \"require 'rbconfig';print %s::CONFIG['LIBS']\"" % rbconfig).read().rstrip().split()
+
+if has_shared == 'yes':
+    LDFLAGS.append('-L' + libpath )
+    os.environ['LD_RUN_PATH'] = libpath
+    LIBS.append(os.popen(RUBYPATH + " -e \"require 'rbconfig';print '-l' + %s::CONFIG['RUBY_SO_NAME']\"" % rbconfig).read().rstrip())
+else:
+    GCC_LIST.append("%s/%s" % (libpath, os.popen(RUBYPATH + " -e \"require 'rbconfig';print %s::CONFIG['LIBRUBY_A']\"" % rbconfig).read().rstrip()))
 

plugins/rawrouter/rawrouter.c

@@ -2,65 +2,335 @@
 
    uWSGI rawrouter
 
-   requires:
-
-   - async
-   - caching
-   - pcre (optional)
-
 */
 
 #include "../../uwsgi.h"
+#include "../corerouter/cr.h"
+
+struct uwsgi_rawrouter {
+	struct uwsgi_corerouter cr;
+	int xclient;
+} urr;
 
 extern struct uwsgi_server uwsgi;
 
-#include "rr.h"
-
-struct uwsgi_rawrouter urr;
-
+struct rawrouter_session {
+	struct corerouter_session crs;
+	in_addr_t ip_addr;
+	// XCLIENT ADDR=xxx\r\n
+	char xclient[13+INET_ADDRSTRLEN+2];
+	size_t xclient_len;
+	off_t xclient_pos;
+	size_t xclient_remains;
+	// placeholder for \r\n
+	size_t xclient_rn;
+};
 
 struct uwsgi_option rawrouter_options[] = {
-	{"rawrouter", required_argument, 0, "run the rawrouter on the specified port", uwsgi_opt_corerouter, &urr, 0},
+	{"rawrouter", required_argument, 0, "run the rawrouter on the specified port", uwsgi_opt_undeferred_corerouter, &urr, 0},
 	{"rawrouter-processes", required_argument, 0, "prefork the specified number of rawrouter processes", uwsgi_opt_set_int, &urr.cr.processes, 0},
 	{"rawrouter-workers", required_argument, 0, "prefork the specified number of rawrouter processes", uwsgi_opt_set_int, &urr.cr.processes, 0},
-	{"rawrouter-zerg", required_argument, 0, "attach the rawrouter to a zerg server", uwsgi_opt_corerouter_zerg, &urr, 0 },
-	{"rawrouter-use-cache", no_argument, 0, "use uWSGI cache as address->server mapper for the rawrouter", uwsgi_opt_true, &urr.cr.use_cache, 0},
+	{"rawrouter-zerg", required_argument, 0, "attach the rawrouter to a zerg server", uwsgi_opt_corerouter_zerg, &urr, 0},
+	{"rawrouter-use-cache", no_argument, 0, "use uWSGI cache as hostname->server mapper for the rawrouter", uwsgi_opt_true, &urr.cr.use_cache, 0},
 
-	{"rawrouter-use-pattern", required_argument, 0, "use a pattern for rawrouter address->server mapping", uwsgi_opt_corerouter_use_pattern, &urr, 0},
-	{"rawrouter-use-base", required_argument, 0, "use a base dir for rawrouter address->server mapping", uwsgi_opt_corerouter_use_base, &urr, 0},
+	{"rawrouter-use-pattern", required_argument, 0, "use a pattern for rawrouter hostname->server mapping", uwsgi_opt_corerouter_use_pattern, &urr, 0},
+	{"rawrouter-use-base", required_argument, 0, "use a base dir for rawrouter hostname->server mapping", uwsgi_opt_corerouter_use_base, &urr, 0},
 
 	{"rawrouter-fallback", required_argument, 0, "fallback to the specified node in case of error", uwsgi_opt_add_string_list, &urr.cr.fallback, 0},
-	
+
 	{"rawrouter-use-cluster", no_argument, 0, "load balance to nodes subscribed to the cluster", uwsgi_opt_true, &urr.cr.use_cluster, 0},
 
-	{"rawrouter-use-code-string", required_argument, 0, "use code string as address->server mapper for the rawrouter", uwsgi_opt_corerouter_cs, &urr, 0},
+	{"rawrouter-use-code-string", required_argument, 0, "use code string as hostname->server mapper for the rawrouter", uwsgi_opt_corerouter_cs, &urr, 0},
 	{"rawrouter-use-socket", optional_argument, 0, "forward request to the specified uwsgi socket", uwsgi_opt_corerouter_use_socket, &urr, 0},
 	{"rawrouter-to", required_argument, 0, "forward requests to the specified uwsgi server (you can specify it multiple times for load balancing)", uwsgi_opt_add_string_list, &urr.cr.static_nodes, 0},
 	{"rawrouter-gracetime", required_argument, 0, "retry connections to dead static nodes after the specified amount of seconds", uwsgi_opt_set_int, &urr.cr.static_node_gracetime, 0},
 	{"rawrouter-events", required_argument, 0, "set the maximum number of concurrent events", uwsgi_opt_set_int, &urr.cr.nevents, 0},
+	{"rawrouter-max-retries", required_argument, 0, "set the maximum number of retries/fallbacks to other nodes", uwsgi_opt_set_int, &urr.cr.max_retries, 0},
 	{"rawrouter-quiet", required_argument, 0, "do not report failed connections to instances", uwsgi_opt_true, &urr.cr.quiet, 0},
 	{"rawrouter-cheap", no_argument, 0, "run the rawrouter in cheap mode", uwsgi_opt_true, &urr.cr.cheap, 0},
 	{"rawrouter-subscription-server", required_argument, 0, "run the rawrouter subscription server on the spcified address", uwsgi_opt_corerouter_ss, &urr, 0},
+	{"rawrouter-subscription-slot", required_argument, 0, "*** deprecated ***", uwsgi_opt_deprecated, (void *) "useless thanks to the new implementation", 0},
 
 	{"rawrouter-timeout", required_argument, 0, "set rawrouter timeout", uwsgi_opt_set_int, &urr.cr.socket_timeout, 0},
 
 	{"rawrouter-stats", required_argument, 0, "run the rawrouter stats server", uwsgi_opt_set_str, &urr.cr.stats_server, 0},
 	{"rawrouter-stats-server", required_argument, 0, "run the rawrouter stats server", uwsgi_opt_set_str, &urr.cr.stats_server, 0},
 	{"rawrouter-ss", required_argument, 0, "run the rawrouter stats server", uwsgi_opt_set_str, &urr.cr.stats_server, 0},
+	{"rawrouter-harakiri", required_argument, 0, "enable rawrouter harakiri", uwsgi_opt_set_int, &urr.cr.harakiri, 0},
+
+	{"rawrouter-xclient", no_argument, 0, "use the xclient protocol to pass the client addres", uwsgi_opt_true, &urr.xclient, 0},
 
-	{"rawrouter-harakiri", required_argument, 0, "enable rawrouter harakiri", uwsgi_opt_set_int, &urr.cr.harakiri, 0 },
 	{0, 0, 0, 0, 0, 0, 0},
 };
 
+ssize_t rr_instance_read(struct corerouter_session *);
+ssize_t rr_read(struct corerouter_session *);
+
+// write to backend
+ssize_t rr_instance_write(struct corerouter_session * cs) {
+	ssize_t len = write(cs->instance_fd, cs->buffer->buf + cs->buffer_pos, cs->buffer_len - cs->buffer_pos);
+	if (len < 0) {
+		cr_try_again;
+		uwsgi_error("fr_instance_write()");
+		return -1;
+	}
+
+	cs->buffer_pos += len;
+
+	// the chunk has been sent, start (again) reading from client and instance
+	if (cs->buffer_pos == (ssize_t) cs->buffer_len) {
+		uwsgi_cr_hook_instance_write(cs, NULL);
+		uwsgi_cr_hook_instance_read(cs, rr_instance_read);
+		uwsgi_cr_hook_read(cs, rr_read);
+	}
+
+	return len;
+}
+
+// write to client
+ssize_t rr_write(struct corerouter_session * cs) {
+	ssize_t len = write(cs->fd, cs->buffer->buf + cs->buffer_pos, cs->buffer_len - cs->buffer_pos);
+	if (len < 0) {
+		cr_try_again;
+		uwsgi_error("rr_write()");
+		return -1;
+	}
+
+	cs->buffer_pos += len;
+
+	// ok this response chunk is sent, let's wait for another one
+	if (cs->buffer_pos == (ssize_t) cs->buffer_len) {
+		uwsgi_cr_hook_write(cs, NULL);
+		uwsgi_cr_hook_instance_read(cs, rr_instance_read);
+	}
+
+	return len;
+}
+
+ssize_t rr_instance_read(struct corerouter_session * cs) {
+	ssize_t len = read(cs->instance_fd, cs->buffer->buf, cs->buffer->len);
+	if (len < 0) {
+		cr_try_again;
+		uwsgi_error("rr_instance_read()");
+		return -1;
+	}
+
+	// end of the response
+	if (len == 0) {
+		return 0;
+	}
+
+	cs->buffer_pos = 0;
+	cs->buffer_len = len;
+	// ok stop reading from the instance, and start writing to the client
+	uwsgi_cr_hook_instance_read(cs, NULL);
+	uwsgi_cr_hook_write(cs, rr_write);
+	return len;
+}
+
+ssize_t rr_xclient_write(struct corerouter_session *);
+
+ssize_t rr_xclient_read(struct corerouter_session * cs) {
+	struct rawrouter_session *rr = (struct rawrouter_session *) cs;
+	cs->buffer_len = cs->buffer->len;
+        ssize_t len = read(cs->instance_fd, cs->buffer->buf + cs->buffer_pos, cs->buffer_len - cs->buffer_pos);
+	if (len < 0) {
+                cr_try_again;
+                uwsgi_error("rr_xclient_read()");
+                return -1;
+        }
+	if (len == 0) return 0;
+
+	char *ptr = cs->buffer->buf + cs->buffer_pos;
+	ssize_t i;
+	for(i=0;i<len;i++) {
+		if (rr->xclient_rn == 1) {
+			if (ptr[i] != '\n') {
+				return -1;
+			}
+			// banner received
+			cs->buffer_pos = len - (i+1);
+			uwsgi_cr_hook_instance_read(cs, NULL);
+			uwsgi_cr_hook_instance_write(cs, rr_xclient_write);
+			return len;
+		}
+		else if (ptr[i] == '\r') {
+			rr->xclient_rn = 1;
+		}
+	}
+
+	cs->buffer_pos += len;
+	return len;
+}
+
+ssize_t rr_xclient_write(struct corerouter_session * cs) {
+	struct rawrouter_session *rr = (struct rawrouter_session *) cs;
+	ssize_t len = write(cs->instance_fd, rr->xclient + rr->xclient_pos, rr->xclient_len - rr->xclient_pos);
+	if (len < 0) {
+                cr_try_again;
+                uwsgi_error("rr_xclient_write()");
+                return -1;
+        }
+
+	rr->xclient_pos += len;
+	if (rr->xclient_pos == (ssize_t) rr->xclient_len) {
+		uwsgi_cr_hook_instance_write(cs, NULL);
+		if (cs->buffer_pos > 0) {
+			// send remaining data...
+			uwsgi_cr_hook_write(cs, rr_write);	
+		}
+		else {
+			uwsgi_cr_hook_instance_read(cs, rr_instance_read);
+			uwsgi_cr_hook_read(cs, rr_read);
+		}
+	}
+
+	return len;
+}
+
+ssize_t rr_instance_connected(struct corerouter_session * cs) {
+
+	cs->connecting = 0;
+
+	socklen_t solen = sizeof(int);
+
+	// first check for errors
+	if (getsockopt(cs->instance_fd, SOL_SOCKET, SO_ERROR, (void *) (&cs->soopt), &solen) < 0) {
+		uwsgi_error("rr_instance_connected()/getsockopt()");
+		cs->instance_failed = 1;
+		return -1;
+	}
+
+	if (cs->soopt) {
+		cs->instance_failed = 1;
+		return -1;
+	}
+
+	cs->buffer_pos = 0;
+
+	// ok instance is connected, begin...
+	if (cs->static_node) cs->static_node->custom2++;
+	if (cs->un) cs->un->requests++;
+
+	uwsgi_cr_hook_instance_write(cs, NULL);
+	if (urr.xclient) {
+		uwsgi_cr_hook_instance_read(cs, rr_xclient_read);
+		return 1;
+	}
+	uwsgi_cr_hook_instance_read(cs, rr_instance_read);
+	uwsgi_cr_hook_read(cs, rr_read);
+	// return a value > 0
+	return 1;
+}
+
+ssize_t rr_read(struct corerouter_session * cs) {
+	ssize_t len = read(cs->fd, cs->buffer->buf, cs->buffer->len);
+	if (len < 0) {
+		cr_try_again;
+		uwsgi_error("rr_recv()");
+		return -1;
+	}
+
+	if (len == 0) return 0;
+
+	cs->buffer_pos = 0;
+	cs->buffer_len = len;
+
+        uwsgi_cr_hook_read(cs, NULL);
+        uwsgi_cr_hook_instance_read(cs, NULL);
+        uwsgi_cr_hook_instance_write(cs, rr_instance_write);
+
+	return len;
+}
+
+int rr_retry(struct uwsgi_corerouter *ucr, struct corerouter_session *cs) {
+
+	if (cs->instance_address_len > 0) goto retry;
+
+	if (ucr->mapper(ucr, cs)) {
+                        cs->instance_failed = 1;
+                        return -1;
+                }
+
+                if (cs->instance_address_len == 0) {
+                        cs->instance_failed = 1;
+                        return -1;
+                }
+
+retry:
+                // start async connect
+                cs->instance_fd = uwsgi_connectn(cs->instance_address, cs->instance_address_len, 0, 1);
+                if (cs->instance_fd < 0) {
+                        cs->instance_failed = 1;
+                        cs->soopt = errno;
+                        return -1;
+                }
+        // map the instance
+        cs->corerouter->cr_table[cs->instance_fd] = cs;
+        // wait for connection
+        cs->connecting = 1;
+	// wait for connection
+        uwsgi_cr_hook_instance_write(cs, rr_instance_connected);
+	return 0;
+}
+
 void rawrouter_alloc_session(struct uwsgi_corerouter *ucr, struct uwsgi_gateway_socket *ugs, struct corerouter_session *cs, struct sockaddr *sa, socklen_t s_len) {
+
+	// use the address as hostname
+        cs->hostname = cs->ugs->name;
+        cs->hostname_len = cs->ugs->name_len;
+
+	if (sa && sa->sa_family == AF_INET) {
+		struct rawrouter_session *rr = (struct rawrouter_session *) cs;
+                rr->ip_addr = ((struct sockaddr_in *) sa)->sin_addr.s_addr;
+		if (urr.xclient) {
+			if (!inet_ntop(AF_INET, &rr->ip_addr, rr->xclient+13, INET_ADDRSTRLEN)) {
+                		uwsgi_error("rawrouter_alloc_session() -> inet_ntop()");
+				cs->instance_failed = 1;
+				return;
+        		}
+			// fix string
+			size_t ip_addr_len = strlen(rr->xclient+13);
+			memcpy(rr->xclient,"XCLIENT ADDR=", 13);
+			rr->xclient[13+ip_addr_len] = '\r';
+			rr->xclient[13+ip_addr_len+1] = '\n';
+			rr->xclient_len = 13 + ip_addr_len + 2;
+		}
+        }
+
+        // the mapper hook
+        if (ucr->mapper(ucr, cs)) {
+			cs->instance_failed = 1;
+			return;
+		}
+
+                if (cs->instance_address_len == 0) {
+                        cs->instance_failed = 1;
+                        return;
+                }
+
+		// ok, now we could retry
+		cs->retry = rr_retry;
+
+                // start async connect
+                cs->instance_fd = uwsgi_connectn(cs->instance_address, cs->instance_address_len, 0, 1);
+                if (cs->instance_fd < 0) {
+                        cs->instance_failed = 1;
+                        cs->soopt = errno;
+                        return;
+                }
+        // map the instance
+        cs->corerouter->cr_table[cs->instance_fd] = cs;
+        // wait for connection
+	cs->connecting = 1;
+        uwsgi_cr_hook_instance_write(cs, rr_instance_connected);
 }
 
 int rawrouter_init() {
 
 	urr.cr.session_size = sizeof(struct rawrouter_session);
-	urr.cr.switch_events = uwsgi_rawrouter_switch_events;
 	urr.cr.alloc_session = rawrouter_alloc_session;
-	uwsgi_corerouter_init((struct uwsgi_corerouter *) &urr);	
+	uwsgi_corerouter_init((struct uwsgi_corerouter *) &urr);
 
 	return 0;
 }

plugins/rawrouter/rr.h

@@ -1,16 +0,0 @@
-#include "../corerouter/cr.h"
-
-
-struct uwsgi_rawrouter {
-
-	struct uwsgi_corerouter cr;
-
-};
-
-struct rawrouter_session {
-
-	struct corerouter_session crs;
-};
-
-void uwsgi_rawrouter_switch_events(struct uwsgi_corerouter *, struct corerouter_session *, int interesting_fd);
-

plugins/rawrouter/rr_events.c

@@ -1,145 +0,0 @@
-#include "../../uwsgi.h"
-
-#include "rr.h"
-
-extern struct uwsgi_server uwsgi;
-extern struct uwsgi_rawrouter urr;
-
-void uwsgi_rawrouter_switch_events(struct uwsgi_corerouter *ucr, struct corerouter_session *cs, int interesting_fd) {
-
-	socklen_t solen = sizeof(int);
-	ssize_t len;
-	char buf[8192];
-
-	switch (cs->status) {
-
-		case COREROUTER_STATUS_RECV_HDR:
-#ifdef UWSGI_EVENT_USE_PORT
-			event_queue_add_fd_read(ucr->queue, cs->fd);
-#endif
-			// use the address as hostname
-			cs->hostname = cs->ugs->name;
-			cs->hostname_len = cs->ugs->name_len;
-
-			// the mapper hook
-			if (ucr->mapper(ucr, cs))
-				break;
-
-			// no address found
-			if (!cs->instance_address_len) {
-				// if fallback nodes are configured, trigger them
-				if (ucr->fallback) {
-					cs->instance_failed = 1;
-				}
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-			cs->instance_fd = uwsgi_connectn(cs->instance_address, cs->instance_address_len, 0, 1);
-
-			if (cs->instance_fd < 0) {
-				cs->instance_failed = 1;
-				cs->soopt = errno;
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-
-			cs->status = COREROUTER_STATUS_CONNECTING;
-			ucr->cr_table[cs->instance_fd] = cs;
-			event_queue_add_fd_write(ucr->queue, cs->instance_fd);
-			break;
-
-
-
-	case COREROUTER_STATUS_CONNECTING:
-
-		if (interesting_fd == cs->instance_fd) {
-
-			if (getsockopt(cs->instance_fd, SOL_SOCKET, SO_ERROR, (void *) (&cs->soopt), &solen) < 0) {
-				uwsgi_error("getsockopt()");
-				cs->instance_failed = 1;
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-			if (cs->soopt) {
-				cs->instance_failed = 1;
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-			// increment node requests counter
-                        if (cs->un)
-                                cs->un->requests++;	
-
-			event_queue_fd_write_to_read(ucr->queue, cs->instance_fd);
-			cs->status = COREROUTER_STATUS_RESPONSE;
-		}
-
-		break;
-
-	case COREROUTER_STATUS_RESPONSE:
-
-		// data from instance
-		if (interesting_fd == cs->instance_fd) {
-			len = recv(cs->instance_fd, buf, 8192, 0);
-#ifdef UWSGI_EVENT_USE_PORT
-                        event_queue_add_fd_read(ucr->queue, cs->instance_fd);
-#endif
-			if (len <= 0) {
-				if (len < 0)
-					uwsgi_error("recv()");
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-			len = send(cs->fd, buf, len, 0);
-
-			if (len <= 0) {
-				if (len < 0)
-					uwsgi_error("send()");
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-			// update transfer statistics
-			if (cs->un)
-				cs->un->transferred += len;
-		}
-		// body from client
-		else if (interesting_fd == cs->fd) {
-
-			//uwsgi_log("receiving body...\n");
-			len = recv(cs->fd, buf, 8192, 0);
-#ifdef UWSGI_EVENT_USE_PORT
-                        event_queue_add_fd_read(ucr->queue, cs->fd);
-#endif
-			if (len <= 0) {
-				if (len < 0)
-					uwsgi_error("recv()");
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-
-
-			len = send(cs->instance_fd, buf, len, 0);
-
-			if (len <= 0) {
-				if (len < 0)
-					uwsgi_error("send()");
-				corerouter_close_session(ucr, cs);
-				break;
-			}
-		}
-
-		break;
-
-		// fallback to destroy !!!
-	default:
-		uwsgi_log("unknown event: closing session\n");
-		corerouter_close_session(ucr, cs);
-		break;
-
-	}
-}

plugins/rawrouter/uwsgiplugin.py

@@ -6,4 +6,4 @@ LIBS = []
 
 REQUIRES = ['corerouter']
 
-GCC_LIST = ['rawrouter', 'rr_events']
+GCC_LIST = ['rawrouter']

plugins/router_http/router_http.c

@@ -12,13 +12,24 @@ int uwsgi_routing_func_http(struct wsgi_request *wsgi_req, struct uwsgi_route *u
 	// get the http address from the route
 	char *addr = ur->data;
 
+	char *uri = NULL;
+	uint16_t uri_len = 0;
+	if (ur->data3_len) {
+		uri = uwsgi_regexp_apply_ovec(wsgi_req->uri, wsgi_req->uri_len, ur->data3, ur->data3_len, ur->ovector, ur->ovn);
+		uri_len = strlen(uri);
+	}
+
+
 	// convert the wsgi_request to an http proxy request
-	struct uwsgi_buffer *ub = uwsgi_to_http(wsgi_req, ur->data2, ur->data2_len);	
+	struct uwsgi_buffer *ub = uwsgi_to_http(wsgi_req, ur->data2, ur->data2_len, uri, uri_len);	
 	if (!ub) {
+		if (uri) free(uri);
 		uwsgi_log("unable to generate http request for %s\n", addr);
                 return UWSGI_ROUTE_NEXT;
 	}
 
+	if (uri) free(uri);
+
 	// ok now if have offload threads, directly use them
 	if (wsgi_req->socket->can_offload) {
         	if (!uwsgi_offload_request_net_do(wsgi_req, addr, ub)) {
@@ -86,6 +97,12 @@ int uwsgi_router_http(struct uwsgi_route *ur, char *args) {
 		*comma = 0;
 		ur->data_len = strlen(ur->data);
 		ur->data2 = comma+1;
+		comma = strchr(ur->data2, ',');
+		if (comma) {
+			*comma = 0;
+			ur->data3 = comma+1;
+			ur->data3_len = strlen(ur->data3);
+		}
 		ur->data2_len = strlen(ur->data2);
 	}
 	return 0;

plugins/router_rewrite/router_rewrite.c

@@ -5,6 +5,8 @@ extern struct uwsgi_server uwsgi;
 
 int uwsgi_routing_func_rewrite(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
 
+	char *tmp_qs = NULL;
+
 	char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
         uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
 
@@ -18,28 +20,26 @@ int uwsgi_routing_func_rewrite(struct wsgi_request *wsgi_req, struct uwsgi_route
 		path_info_len = query_string - path_info;
 		query_string++;
 		query_string_len = strlen(query_string);
-	
+		if (wsgi_req->query_string_len > 0) {
+			tmp_qs = uwsgi_concat4n(query_string, query_string_len, "&", 1, wsgi_req->query_string, wsgi_req->query_string_len, "", 0);
+			query_string = tmp_qs;
+			query_string_len = strlen(query_string);
+		}	
 	}
+	// over engineering, could be requiredin the future...
 	else {
-		query_string = "";
+		if (wsgi_req->query_string_len > 0) {
+			query_string = wsgi_req->query_string;
+			query_string_len = wsgi_req->query_string_len;
+		}
+		else {
+			query_string = "";
+		}
 	}
 
 	char *ptr = uwsgi_req_append(wsgi_req, "PATH_INFO", 9, path_info, path_info_len);
         if (!ptr) goto clear;
 
-        // fill iovec
-        if (wsgi_req->var_cnt + 2 >= uwsgi.vec_size - (4 + 1)) {
-		uwsgi_log("not enough io vectors for rewriting url\n");
-		goto clear;
-	}
-
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptr - (2 + 9);
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_len = 9;
-        wsgi_req->var_cnt++;
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptr;
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_len = path_info_len;
-        wsgi_req->var_cnt++;
-
 	// set new path_info
 	wsgi_req->path_info = ptr;
 	wsgi_req->path_info_len = path_info_len;
@@ -47,31 +47,19 @@ int uwsgi_routing_func_rewrite(struct wsgi_request *wsgi_req, struct uwsgi_route
 	ptr = uwsgi_req_append(wsgi_req, "QUERY_STRING", 12, query_string, query_string_len);
 	if (!ptr) goto clear;
 
-        // fill iovec
-        if (wsgi_req->var_cnt + 2 >= uwsgi.vec_size - (4 + 1)) {
-		uwsgi_log("not enough io vectors for rewriting url\n");
-		goto clear;
-	}
-
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptr - (2 + 12);
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_len = 12;
-        wsgi_req->var_cnt++;
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptr;
-        wsgi_req->hvec[wsgi_req->var_cnt].iov_len = query_string_len;
-        wsgi_req->var_cnt++;
-
-
 	// set new query_string
 	wsgi_req->query_string = ptr;
 	wsgi_req->query_string_len = query_string_len;
 
 	free(path_info);
+	if (tmp_qs) free(tmp_qs);
 	if (ur->custom)
 		return UWSGI_ROUTE_CONTINUE;
 	return UWSGI_ROUTE_NEXT;
 
 clear:
 	free(path_info);
+	if (tmp_qs) free(tmp_qs);
 	return UWSGI_ROUTE_BREAK;
 }
 

plugins/stats_pusher_mongodb/plugin.c

@@ -1,6 +1,6 @@
 #include "../../uwsgi.h"
 
-void stats_pusher_mongodb(struct uwsgi_stats_pusher_instance *, char *, size_t);
+void stats_pusher_mongodb(struct uwsgi_stats_pusher_instance *, time_t, char *, size_t);
 
 static void stats_pusher_mongodb_init(void) {
         uwsgi_register_stats_pusher("mongodb", stats_pusher_mongodb);

plugins/stats_pusher_mongodb/stats_pusher_mongodb.cc

@@ -12,7 +12,7 @@ struct stats_pusher_mongodb_conf {
 };
 
 
-extern "C" void stats_pusher_mongodb(struct uwsgi_stats_pusher_instance *uspi, char *json, size_t json_len) {
+extern "C" void stats_pusher_mongodb(struct uwsgi_stats_pusher_instance *uspi, time_t now, char *json, size_t json_len) {
 
 	struct stats_pusher_mongodb_conf *spmc = (struct stats_pusher_mongodb_conf *) uspi->data;
 	if (!uspi->configured) {

proto/http.c

@@ -270,7 +270,7 @@ int uwsgi_proto_http_parser(struct wsgi_request *wsgi_req) {
 	char post_buf[8192];
 	char *post_tail = NULL;
 
-	// first round ? this memory area will be freed by async_loop
+	// first round ? 
 	if (!wsgi_req->proto_parser_buf) {
 		wsgi_req->proto_parser_buf = uwsgi_malloc(uwsgi.buffer_size);
 	}
@@ -281,12 +281,15 @@ int uwsgi_proto_http_parser(struct wsgi_request *wsgi_req) {
 			remains = UMIN(remains, 8192);
 			len = read(wsgi_req->poll.fd, post_buf, remains);
 			if (len <= 0) {
-				if (len < 0)
+				if (len < 0) {
+					free(wsgi_req->proto_parser_buf);
 					uwsgi_error("read()");
+				}
 				return -1;
 			}
 
 			if (!fwrite(post_buf, len, 1, wsgi_req->async_post)) {
+				free(wsgi_req->proto_parser_buf);
 				uwsgi_error("fwrite()");
 				return -1;
 			}
@@ -296,6 +299,7 @@ int uwsgi_proto_http_parser(struct wsgi_request *wsgi_req) {
 				return UWSGI_AGAIN;
 
 		}
+		free(wsgi_req->proto_parser_buf);
 		rewind(wsgi_req->async_post);
 		wsgi_req->body_as_file = 1;
 		return UWSGI_OK;
@@ -334,11 +338,14 @@ int uwsgi_proto_http_parser(struct wsgi_request *wsgi_req) {
 				memcpy(post_tail, ptr, remains);
 			}
 			http_parse(wsgi_req, ptr);
+			wsgi_req->uh.modifier1 = uwsgi.http_modifier1;
+			wsgi_req->uh.modifier2 = uwsgi.http_modifier2;
 			//is there a Content_Length ?
 			if (wsgi_req->post_cl > 0) {
 				wsgi_req->async_post = tmpfile();
 				if (!wsgi_req->async_post) {
 					free(wsgi_req->proto_parser_buf);
+					if (post_tail) free(post_tail);
 					uwsgi_error("tmpfile()");
 					return -1;
 				}
@@ -393,14 +400,19 @@ void uwsgi_httpize_var(char *buf, size_t len) {
 	}
 }
 
-struct uwsgi_buffer *uwsgi_to_http(struct wsgi_request *wsgi_req, char *host, uint16_t host_len) {
+struct uwsgi_buffer *uwsgi_to_http(struct wsgi_request *wsgi_req, char *host, uint16_t host_len, char *uri, uint16_t uri_len) {
 
         struct uwsgi_buffer *ub = uwsgi_buffer_new(4096);
 
         if (uwsgi_buffer_append(ub, wsgi_req->method, wsgi_req->method_len)) goto clear;
         if (uwsgi_buffer_append(ub, " ", 1)) goto clear;
 
-        if (uwsgi_buffer_append(ub, wsgi_req->uri, wsgi_req->uri_len)) goto clear;
+	if (uri_len && uri) {
+        	if (uwsgi_buffer_append(ub, uri, uri_len)) goto clear;
+	}
+	else {
+        	if (uwsgi_buffer_append(ub, wsgi_req->uri, wsgi_req->uri_len)) goto clear;
+	}
 
         if (uwsgi_buffer_append(ub, " HTTP/1.0\r\n", 11)) goto clear;
 
@@ -447,11 +459,22 @@ next:
 		if (uwsgi_buffer_append(ub, "\r\n", 2)) goto clear;
 	}
 
+	if (wsgi_req->content_type_len > 0) {
+		if (uwsgi_buffer_append(ub, "Content-Type: ", 14)) goto clear;
+		if (uwsgi_buffer_append(ub, wsgi_req->content_type, wsgi_req->content_type_len)) goto clear;
+		if (uwsgi_buffer_append(ub, "\r\n", 2)) goto clear;
+	}
+
+	if (wsgi_req->post_cl > 0) {
+		if (uwsgi_buffer_append(ub, "Content-Length: ", 16)) goto clear;
+		if (uwsgi_buffer_num64(ub, (int64_t) wsgi_req->post_cl)) goto clear;
+		if (uwsgi_buffer_append(ub, "\r\n", 2)) goto clear;
+	}
+
 	// append required headers
 	if (uwsgi_buffer_append(ub, "Connection: close\r\n", 19)) goto clear;
 	if (uwsgi_buffer_append(ub, "X-Forwarded-For: ", 17)) goto clear;
 
-
 	if (x_forwarded_for_len > 0) {
 		if (uwsgi_buffer_append(ub, x_forwarded_for, x_forwarded_for_len)) goto clear;
 		if (uwsgi_buffer_append(ub, ", ", 2)) goto clear;

test.psgi

@@ -19,14 +19,33 @@ my $two = sub {
 	print "two\n";
 };
 
+my $four = sub {
+	my $signum = shift;
+	print "i am signal ".$signum."\n" ;
+};
+
+uwsgi::register_signal(17, '', $four);
+uwsgi::register_signal(30, '', $two);
+
 my $three = sub {
 	my $env = shift;
 	sleep(1);
 	print "three\n";
 };
 
+uwsgi::postfork(sub {
+	print "forked !!!\n";
+});
+
+uwsgi::atexit(sub {
+	print "exited\n";
+});
+
 my $app = sub {
 	my $env = shift;
+	uwsgi::signal(17);
+	uwsgi::signal(30);
+
 	if ($env->{'psgix.cleanup'}) {
 		print "cleanup supported\n";
 		push @{$env->{'psgix.cleanup.handlers'}}, $one;

tests/sleeping_async.py

@@ -3,7 +3,7 @@ import uwsgi
 sleepvalue = 5
 
 def application(env, start_response):
-        start_response('200 Ok', [('Content-type', 'text/html')])
+    start_response('200 Ok', [('Content-type', 'text/html')])
     yield uwsgi.async_sleep(sleepvalue)
     #print "TIMEOUT: ", env['x-wsgiorg.fdevent.timeout']
     yield "<h1>Hello World after %d seconds</h1>" % sleepvalue

uwsgi.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name        = 'uwsgi'
+  s.license     = 'GPL-2'
+  s.version     = `python -c "import uwsgiconfig as uc; print uc.uwsgi_version"`.sub(/-dev-.*/,'')
+  s.date        = '2013-03-02'
+  s.summary     = "uWSGI"
+  s.description = "The uWSGI server for Ruby/Rack"
+  s.authors     = ["Unbit"]
+  s.email       = 'info@unbit.it'
+  s.extensions  = ['ext/uwsgi/extconf.rb']
+  s.files       = []
+  s.require_paths = ['.']
+  s.executables << 'uwsgi'
+  s.homepage    = 'http://projects.unbit.it/uwsgi'
+end

uwsgi.h

@@ -34,10 +34,25 @@ extern "C" {
 
 #define wsgi_req_time ((wsgi_req->end_of_request-wsgi_req->start_of_request)/1000)
 
-#define thunder_lock if (uwsgi.threads > 1 && !uwsgi.is_et) {pthread_mutex_lock(&uwsgi.thunder_mutex);}
-#define thunder_unlock if (uwsgi.threads > 1 && !uwsgi.is_et) {pthread_mutex_unlock(&uwsgi.thunder_mutex);}
+#define thunder_lock if (!uwsgi.is_et) {\
+                        if (uwsgi.use_thunder_lock) {\
+                                uwsgi_lock(uwsgi.the_thunder_lock);\
+                        }\
+                        else if (uwsgi.threads > 1) {\
+                                pthread_mutex_lock(&uwsgi.thunder_mutex);\
+                        }\
+                    }
 
-#define uwsgi_check_scheme(file) (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) || !uwsgi_startswith(file, "fd://", 5) || !uwsgi_startswith(file, "exec://", 7) || !uwsgi_startswith(file, "section://", 10))
+#define thunder_unlock if (!uwsgi.is_et) {\
+                        if (uwsgi.use_thunder_lock) {\
+                                uwsgi_unlock(uwsgi.the_thunder_lock);\
+                        }\
+                        else if (uwsgi.threads > 1) {\
+                                pthread_mutex_unlock(&uwsgi.thunder_mutex);\
+                        }\
+                        }
+
+#define uwsgi_check_scheme(file) (!uwsgi_startswith(file, "emperor://", 10) || !uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) || !uwsgi_startswith(file, "fd://", 5) || !uwsgi_startswith(file, "exec://", 7) || !uwsgi_startswith(file, "section://", 10))
 
 #define ushared uwsgi.shared
 
@@ -295,6 +310,8 @@ extern int pivot_root(const char *new_root, const char *put_old);
 #include <openssl/err.h>
 #endif
 
+#include <glob.h>
+
 
 struct uwsgi_buffer {
 	char *buf;
@@ -308,6 +325,8 @@ struct uwsgi_string_list {
 	char *value;
 	size_t len;
 	uint64_t custom;
+	uint64_t custom2;
+	void *custom_ptr;
 	struct uwsgi_string_list *next;
 };
 
@@ -393,6 +412,25 @@ struct uwsgi_regexp_list {
 };
 #endif
 
+struct uwsgi_rbtree {
+        struct uwsgi_rb_timer *root;
+        struct uwsgi_rb_timer *sentinel;
+};
+
+struct uwsgi_rb_timer {
+        uint8_t color;
+        struct uwsgi_rb_timer *parent;
+        struct uwsgi_rb_timer *left;
+        struct uwsgi_rb_timer *right;
+        uint64_t value;
+        void *data;
+};
+
+struct uwsgi_rbtree *uwsgi_init_rb_timer(void);
+struct uwsgi_rb_timer *uwsgi_min_rb_timer(struct uwsgi_rbtree *, struct uwsgi_rb_timer *);
+struct uwsgi_rb_timer *uwsgi_add_rb_timer(struct uwsgi_rbtree *, uint64_t, void *);
+void uwsgi_del_rb_timer(struct uwsgi_rbtree *, struct uwsgi_rb_timer *);
+
 
 union uwsgi_sockaddr {
 	struct sockaddr sa;
@@ -441,6 +479,8 @@ struct uwsgi_gateway_socket {
 	char *port;
 	int port_len;
 
+	int no_defer;
+
 	void *data;
 	// this requires UDP
 	int subscription;
@@ -638,6 +678,7 @@ struct uwsgi_socket {
 	void *ctx;
 
 	int queue;
+	int no_defer;
 
 	int auto_port;
 	// true if connection must be initialized for each core
@@ -846,6 +887,9 @@ struct uwsgi_route {
 	void *data2;
 	size_t data2_len;
 
+	void *data3;
+	size_t data3_len;
+
 	// 64bit value for custom usage
 	uint64_t custom;
 
@@ -901,6 +945,7 @@ struct uwsgi_alarm_ll {
 struct uwsgi_alarm_log {
 	pcre *pattern;
         pcre_extra *pattern_extra;
+	int negate;
 	struct uwsgi_alarm_ll *alarms;
 	struct uwsgi_alarm_log *next;
 };
@@ -987,6 +1032,12 @@ struct wsgi_request {
 	char *authorization;
 	uint16_t authorization_len;
 
+	char *user_agent;
+	uint16_t user_agent_len;
+
+	char *referer;
+	uint16_t referer_len;
+
 	char *script;
 	uint16_t script_len;
 	char *module;
@@ -1214,6 +1265,7 @@ struct uwsgi_server {
 
 	// enable threads
 	int has_threads;
+	int no_threads_wait;
 
 	// default app id
 	int default_app;
@@ -1257,6 +1309,9 @@ struct uwsgi_server {
 
 	int reuse_port;
 
+	uint64_t http_modifier1;
+	uint64_t http_modifier2;
+
 	// enable lazy mode
 	int lazy;
 	// enable lazy-apps mode
@@ -1284,6 +1339,7 @@ struct uwsgi_server {
 
 	// true if run under the emperor
 	int has_emperor;
+	char *emperor_procname;
 	int emperor_fd;
 	int emperor_queue;
 	int emperor_tyrant;
@@ -1524,10 +1580,6 @@ struct uwsgi_server {
 
 	int check_static_docroot;
 
-	// linked list for offloaded requests
-	struct uwsgi_offload_request *offload_requests_head;
-	struct uwsgi_offload_request *offload_requests_tail;
-
 	char *daemonize;
 	char *daemonize2;
 	int do_not_change_umask;
@@ -1545,7 +1597,7 @@ struct uwsgi_server {
 	struct uwsgi_async_request *async_runqueue_last;
 	int async_runqueue_cnt;
 
-	struct rb_root *rb_async_timeouts;
+	struct uwsgi_rbtree *rb_async_timeouts;
 
 	int async_queue_unused_ptr;
 	struct wsgi_request **async_queue_unused;
@@ -1669,9 +1721,12 @@ struct uwsgi_server {
 
 #ifdef UWSGI_THREADING
 	// avoid thundering herd in threaded modes
+	pthread_mutex_t thunder_mutex;
 	pthread_mutex_t six_feet_under_lock;
 	pthread_mutex_t lock_static;
 #endif
+	int use_thunder_lock;
+	struct uwsgi_lock_item *the_thunder_lock;
 
 
 	/* the list of workers */
@@ -1855,8 +1910,6 @@ struct uwsgi_server {
 	size_t queue_filesize;
 	int queue_store_sync;
 
-	pthread_mutex_t thunder_mutex;
-
 	int locks;
 
 	struct uwsgi_lock_item *cache_lock;
@@ -2586,74 +2639,6 @@ struct uwsgi_subscribe_req {
 	uint16_t base_len;
 };
 
-#ifndef _NO_UWSGI_RB
-
-/*
-
-  *** uWSGI, stripped down version of Linux rbtree ***
-
-
-  Red Black Trees
-  (C) 1999  Andrea Arcangeli <andrea@suse.de>
-  
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
-
-*/
-
-struct rb_node
-{
-        unsigned long  rb_parent_color;
-#define RB_RED          0
-#define RB_BLACK        1
-        struct rb_node *rb_right;
-        struct rb_node *rb_left;
-} __attribute__((aligned(sizeof(long))));
-    /* The alignment might seem pointless, but allegedly CRIS needs it */
-
-struct rb_root
-{
-        struct rb_node *rb_node;
-};
-
-#define rb_parent(r)   ((struct rb_node *)((r)->rb_parent_color & ~3))
-#define rb_color(r)   ((r)->rb_parent_color & 1)
-#define rb_is_red(r)   (!rb_color(r))
-#define rb_is_black(r) rb_color(r)
-#define rb_set_red(r)  do { (r)->rb_parent_color &= ~1; } while (0)
-#define rb_set_black(r)  do { (r)->rb_parent_color |= 1; } while (0)
-
-void rb_insert_color(struct rb_node *, struct rb_root *);
-void rb_erase(struct rb_node *, struct rb_root *);
-
-void rb_link_node(struct rb_node *, struct rb_node *,
-                                struct rb_node **);
-
-struct uwsgi_rb_timer {
-
-	struct rb_node rbt;
-
-	time_t key;
-	void *data;
-};
-
-struct rb_root *uwsgi_init_rb_timer(void);
-struct uwsgi_rb_timer *uwsgi_add_rb_timer(struct rb_root *, time_t, void *);
-struct uwsgi_rb_timer *uwsgi_min_rb_timer(struct rb_root *);
-
-#endif
-
 void uwsgi_nuclear_blast();
 
 void uwsgi_unix_signal(int, void (*)(int));
@@ -2807,7 +2792,7 @@ int uwsgi_get_shared_socket_num(struct uwsgi_socket *);
 
 #ifdef __linux__
 void uwsgi_set_cgroup(void);
-long uwsgi_num_from_file(char *);
+long uwsgi_num_from_file(char *, int);
 #endif
 
 void uwsgi_add_sockets_to_queue(int, int);
@@ -2992,6 +2977,8 @@ void uwsgi_opt_set_str(char *, char *, void *);
 void uwsgi_opt_set_logger(char *, char *, void *);
 void uwsgi_opt_set_str_spaced(char *, char *, void *);
 void uwsgi_opt_add_string_list(char *, char *, void *);
+void uwsgi_opt_add_string_list_custom(char *, char *, void *);
+void uwsgi_opt_add_addr_list(char *, char *, void *);
 void uwsgi_opt_add_dyn_dict(char *, char *, void *);
 #ifdef UWSGI_PCRE
 void uwsgi_opt_pcre_jit(char *, char *, void *);
@@ -3072,6 +3059,7 @@ void uwsgi_opt_noop(char *, char *, void *);
 
 void uwsgi_opt_logic(char *, char *, void *);
 int uwsgi_logic_opt_for(char *, char *);
+int uwsgi_logic_opt_for_glob(char *, char *);
 int uwsgi_logic_opt_if_env(char *, char *);
 int uwsgi_logic_opt_if_not_env(char *, char *);
 int uwsgi_logic_opt_if_opt(char *, char *);
@@ -3167,7 +3155,7 @@ struct uwsgi_stats_pusher_instance;
 
 struct uwsgi_stats_pusher {
 	char *name;
-	void (*func)(struct uwsgi_stats_pusher_instance *, char *, size_t);
+	void (*func)(struct uwsgi_stats_pusher_instance *, time_t, char *, size_t);
 	struct uwsgi_stats_pusher *next;
 };
 
@@ -3175,6 +3163,7 @@ struct uwsgi_stats_pusher_instance {
 	struct uwsgi_stats_pusher *pusher;
 	char *arg;
 	void *data;
+	int raw;
 	int configured;
 	int freq;
 	time_t last_run;
@@ -3183,13 +3172,14 @@ struct uwsgi_stats_pusher_instance {
 
 struct uwsgi_thread;
 void uwsgi_stats_pusher_loop(struct uwsgi_thread *);
-void uwsgi_stats_pusher_file(struct uwsgi_stats_pusher_instance *, char *, size_t);
-void uwsgi_stats_pusher_socket(struct uwsgi_stats_pusher_instance *, char *, size_t);
+void uwsgi_stats_pusher_file(struct uwsgi_stats_pusher_instance *, time_t, char *, size_t);
+void uwsgi_stats_pusher_socket(struct uwsgi_stats_pusher_instance *, time_t, char *, size_t);
 
 void uwsgi_stats_pusher_setup(void);
 void uwsgi_send_stats(int, struct uwsgi_stats * (*func)(void));
 struct uwsgi_stats *uwsgi_master_generate_stats(void);
-void uwsgi_register_stats_pusher(char *, void(*) (struct uwsgi_stats_pusher_instance *, char *, size_t));
+struct uwsgi_stats_pusher *uwsgi_register_stats_pusher(char *, void(*) (struct uwsgi_stats_pusher_instance *, time_t, char *, size_t));
+struct uwsgi_stats_pusher_instance *uwsgi_stats_pusher_add(struct uwsgi_stats_pusher *, char *);
 
 struct uwsgi_stats *uwsgi_stats_new(size_t);
 int uwsgi_stats_symbol(struct uwsgi_stats *, char);
@@ -3215,6 +3205,7 @@ void manage_cluster_message(char *, int);
 void uwsgi_opt_add_custom_option(char *, char *, void *);
 void uwsgi_opt_cflags(char *, char *, void *);
 void uwsgi_opt_connect_and_read(char *, char *, void *);
+void uwsgi_opt_extract(char *, char *, void *);
 
 struct uwsgi_string_list *uwsgi_string_list_has_item(struct uwsgi_string_list *, char *, size_t);
 
@@ -3362,9 +3353,10 @@ int uwsgi_buffer_append(struct uwsgi_buffer *, char *, size_t);
 int uwsgi_buffer_fix(struct uwsgi_buffer *, size_t);
 int uwsgi_buffer_ensure(struct uwsgi_buffer *, size_t);
 void uwsgi_buffer_destroy(struct uwsgi_buffer *);
+int uwsgi_buffer_num64(struct uwsgi_buffer *, int64_t);
 
 void uwsgi_httpize_var(char *, size_t);
-struct uwsgi_buffer *uwsgi_to_http(struct wsgi_request *, char *, uint16_t);
+struct uwsgi_buffer *uwsgi_to_http(struct wsgi_request *, char *, uint16_t, char *, uint16_t);
 
 ssize_t uwsgi_pipe(int, int, int);
 ssize_t uwsgi_pipe_sized(int, int, size_t, int);
@@ -3404,6 +3396,9 @@ struct uwsgi_thread {
 	uint64_t custom1;
 	uint64_t custom2;
 	uint64_t custom3;
+	// linked list for offloaded requests
+        struct uwsgi_offload_request *offload_requests_head;
+        struct uwsgi_offload_request *offload_requests_tail;
 	void (*func)(struct uwsgi_thread *);
 };
 struct uwsgi_thread *uwsgi_thread_new(void (*)(struct uwsgi_thread *));
@@ -3475,6 +3470,10 @@ void uwsgi_user_lock(int);
 void uwsgi_user_unlock(int);
 
 void simple_loop_run_int(int);
+int uwsgi_valid_fd(int);
+void uwsgi_close_all_fds(void);
+
+int uwsgi_write_nb(int, char *, size_t, int);
 
 void uwsgi_check_emperor(void);
 #ifdef UWSGI_AS_SHARED_LIBRARY

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '1.4-rc2'
+uwsgi_version = '1.4.8'
 
 import os
 import re
@@ -33,15 +33,20 @@ if not GCC:
 
 CPP = os.environ.get('CPP', 'cpp')
 
-CPUCOUNT = 1
 try:
-    import multiprocessing
-    CPUCOUNT = multiprocessing.cpu_count()
+    CPUCOUNT = int(os.environ.get('CPUCOUNT', -1))
 except:
+    CPUCOUNT = -1
+
+if CPUCOUNT < 1:
     try:
-        CPUCOUNT = int(os.sysconf('SC_NPROCESSORS_ONLN'))
+        import multiprocessing
+        CPUCOUNT = multiprocessing.cpu_count()
     except:
-        pass
+        try:
+            CPUCOUNT = int(os.sysconf('SC_NPROCESSORS_ONLN'))
+        except:
+            CPUCOUNT = 1
 
 binary_list = []
 
@@ -340,12 +345,16 @@ def build_uwsgi(uc, print_only=False):
                     pass
 
                 for cfile in up.GCC_LIST:
-                    if not cfile.endswith('.a'):
+                    if cfile.endswith('.a'):
+                        gcc_list.append(cfile)
+                    elif not cfile.endswith('.c') and not cfile.endswith('.cc') and not cfile.endswith('.m'):
                         compile(' '.join(uniq_warnings(p_cflags)), last_cflags_ts,
                             path + '/' + cfile + '.o', path + '/' + cfile + '.c')
                         gcc_list.append('%s/%s' % (path, cfile))
                     else:
-                        gcc_list.append(cfile)
+                        compile(' '.join(uniq_warnings(p_cflags)), last_cflags_ts,
+                            path + '/' + cfile + '.o', path + '/' + cfile)
+                        gcc_list.append('%s/%s' % (path, cfile))
 
                 libs += up.LIBS
 
@@ -448,7 +457,7 @@ class uConf(object):
             'core/setup_utils', 'core/clock', 'core/init', 'core/buffer',
             'core/plugins', 'core/lock', 'core/cache', 'core/daemons',
             'core/queue', 'core/event', 'core/signal', 'core/cluster',
-            'core/rpc', 'core/gateway', 'core/loop', 'lib/rbtree', 'core/rb_timers', 'core/uwsgi']
+            'core/rpc', 'core/gateway', 'core/loop', 'core/rb_timers', 'core/uwsgi']
         # add protocols
         self.gcc_list.append('proto/base')
         self.gcc_list.append('proto/uwsgi')

uwsgidecorators.py

@@ -1,4 +1,5 @@
 import uwsgi
+import sys
 from threading import Thread
 
 try:
@@ -170,7 +171,12 @@ class mule_brain(object):
 
     def __call__(self):
         if uwsgi.mule_id() == self.num:
-            self.f()
+            try:
+                self.f()
+            except:
+                exc = sys.exc_info()
+                sys.excepthook(exc[0], exc[1], exc[2])
+                sys.exit(1)
 
 
 class mule_brainloop(mule_brain):
@@ -178,7 +184,12 @@ class mule_brainloop(mule_brain):
     def __call__(self):
         if uwsgi.mule_id() == self.num:
             while True:
-                self.f()
+                try:
+                    self.f()
+                except:
+                    exc = sys.exc_info()
+                    sys.excepthook(exc[0], exc[1], exc[2])
+                    sys.exit(1)
 
 
 class mule(object):