uWSGI 1.3

.hgtags

@@ -54,3 +54,4 @@ e1568fd16b7b586cc72deb4dfccbbe64ae0b84df 1.1
 c3cdecbf2bac591336baddd14f9ac22e18d6e200 1.2
 14524da00a8b382dffb1d16a0e70cdf4a946f369 1.3-rc2
 883b946db9038372cb1d76cb1d328a3093140e7b 1.3-rc3
+aeea5a5d2e8b62ad55e23d539e1be02f2b6962af 1.3-rc4

ChangeLog

@@ -10,12 +10,27 @@
 - merged routers codebase (fastrouter, http, rawrouter)
 - https support in the http router
 - config report at the end of uWSGI build process
-- support for keepalive in the http router
 - improved subscription system (multicast and unix socket)
 - custom options
 - graceful reloads on shared sockets
 - configurable log-master buffer size
 - extreme-optimizations for the stats subsystem
+- redislog and mongodblog plugins
+- added python logger
+- mongodb and postgres imperial monitors
+- implemented psgix.logger and psgix.cleanup
+- full rack spec compliance
+- preliminary ipv6 support
+- gevent graceful reloads
+- support for multiple loggers and logformat
+- lazy-apps to load apps after fork() but without changing reloading subsystem
+- emperor heartbeat subsystem
+- cheaper busyness plugin
+- pluggable clock sources
+- added router_rewrite and router_http plugins
+- external spoolers
+- support for section:// and fd:// loaders
+- alarm subsystem (with curl and xmpp plugins)
 
 
 *** april 2012 ***

Makefile

@@ -3,3 +3,6 @@ all:
 
 clean:
 	python uwsgiconfig.py --clean
+
+check:
+	python uwsgiconfig.py --check

buildconf/base.ini

@@ -18,6 +18,7 @@ async = true
 ldap = auto
 pcre = auto
 routing = auto
+alarm = auto
 ipv6 = false
 debug = false
 unbit = false

buildconf/pyrb.ini

@@ -1,30 +0,0 @@
-[uwsgi]
-xml = true
-ini = true
-snmp = true
-erlang = false
-spooler = true
-embedded = true
-udp = true
-multicast = true
-threading = true
-sendfile = true
-proxy = true
-minterpreters = true
-async = true
-http = true
-evdis = false
-ldap = false
-routing = false
-stackless = false
-debug = false
-unbit = false
-xml_implementation = libxml2
-plugins =
-bin_name = uwsgi
-plugin_dir = .
-embedded_plugins = python, ping, nagios, rack
-
-[python]
-paste = true
-web3 = true

buildconf/rackp.ini

@@ -1,29 +0,0 @@
-[uwsgi]
-xml = true
-ini = true
-yaml = true
-snmp = true
-erlang = false
-spooler = false
-embedded = false
-udp = true
-multicast = false
-threading = true
-sendfile = true
-nagios = true
-proxy = true
-minterpreters = true
-async = true
-ugreen = false
-http = true
-evdis = false
-ldap = false
-routing = false
-stackless = false
-debug = false
-unbit = false
-xml_implementation = libxml2
-plugins = rack
-bin_name = uwsgi
-plugin_dir = .
-embedded_plugins =

buildconf/unbit.ini

@@ -17,6 +17,7 @@ async = true
 ldap = true
 pcre = true
 routing = true
+alarm = true
 debug = false
 unbit = true
 xml_implementation = expat

buildconf/upcode.ini

@@ -1,44 +0,0 @@
-[uwsgi]
-xml = false
-ini = true
-yaml = false
-json = false
-sqlite3 = false
-zeromq = false
-snmp = false
-spooler = true
-embedded = true
-udp = true
-multicast = false
-threading = true
-sendfile = true
-minterpreters = true
-async = true
-evdis = false
-ldap = false
-pcre = true
-routing = true
-debug = false
-unbit = false
-xml_implementation = libxml2
-yaml_implementation = auto
-malloc_implementation = libc
-extras = 
-plugins =
-bin_name = uwsgi
-append_version =
-plugin_dir = .
-embedded_plugins =
-as_shared_library = false
-
-locking = auto
-event = auto
-timer = auto
-filemonitor = auto
-
-blacklist =
-whitelist =
-
-embed_files =
-
-embed_config =

core/alarm.c

@@ -0,0 +1,266 @@
+#include "../uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+
+// generate a uwsgi signal on alarm
+void uwsgi_alarm_init_signal(struct uwsgi_alarm_instance *uai) {
+	uai->data8 = atoi(uai->arg);
+}
+
+void uwsgi_alarm_func_signal(struct uwsgi_alarm_instance *uai, char *msg, size_t len) {
+	uwsgi_route_signal(uai->data8);
+}
+
+// run a command on alarm
+void uwsgi_alarm_init_cmd(struct uwsgi_alarm_instance *uai) {
+	uai->data_ptr = uai->arg;
+}
+
+void uwsgi_alarm_func_cmd(struct uwsgi_alarm_instance *uai, char *msg, size_t len) {
+	int pipe[2];
+	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe)) {
+		return;
+        }
+        uwsgi_socket_nb(pipe[0]);
+        uwsgi_socket_nb(pipe[1]);	
+	if (write(pipe[1], msg, len) != (ssize_t) len) {
+		close(pipe[0]);
+		close(pipe[1]);
+		return;
+	}
+	uwsgi_run_command(uai->data_ptr, pipe, -1);
+	close(pipe[0]);
+	close(pipe[1]);
+}
+
+// pass the log line to a mule
+
+void uwsgi_alarm_init_mule(struct uwsgi_alarm_instance *uai) {
+        uai->data32 = atoi(uai->arg);
+	if (uai->data32 > (uint32_t) uwsgi.mules_cnt) {
+		uwsgi_log_alarm("] invalid mule_id (%d mules available), fallback to 0\n", uwsgi.mules_cnt);
+		uai->data32 = 0;
+	}
+}
+
+void uwsgi_alarm_func_mule(struct uwsgi_alarm_instance *uai, char *msg, size_t len) {
+	// skip if mules are not available
+	if (uwsgi.mules_cnt == 0) return;
+	int fd = uwsgi.shared->mule_queue_pipe[0];
+	if (uai->data32 > 0) {
+		int mule_id = uai->data32-1;
+        	fd = uwsgi.mules[mule_id].queue_pipe[0];
+	}
+	mule_send_msg(fd, msg, len);
+}
+
+
+// register a new alarm
+void uwsgi_register_alarm(char *name, void (*init)(struct uwsgi_alarm_instance *), void (*func)(struct uwsgi_alarm_instance *, char *, size_t)) {
+	struct uwsgi_alarm *old_ua=NULL,*ua = uwsgi.alarms;
+	while(ua) {
+		// skip already initialized alarms
+		if (!strcmp(ua->name, name)) {
+			return;
+                }
+		old_ua = ua;
+		ua = ua->next;
+	}
+
+	ua = uwsgi_calloc(sizeof(struct uwsgi_alarm));
+	ua->name = name;
+	ua->init = init;
+	ua->func = func;
+
+	if (old_ua) {
+		old_ua->next = ua;
+	}
+	else {
+		uwsgi.alarms = ua;
+	}
+}
+
+// register embedded alarms
+void uwsgi_register_embedded_alarms() {
+	uwsgi_register_alarm("signal", uwsgi_alarm_init_signal, uwsgi_alarm_func_signal);
+	uwsgi_register_alarm("cmd", uwsgi_alarm_init_cmd, uwsgi_alarm_func_cmd);
+	uwsgi_register_alarm("mule", uwsgi_alarm_init_mule, uwsgi_alarm_func_mule);
+}
+
+static int uwsgi_alarm_add(char *name, char *plugin, char *arg) {
+	struct uwsgi_alarm *ua = uwsgi.alarms;
+	while(ua) {
+		if (!strcmp(ua->name, plugin)) {
+			break;
+		}
+		ua = ua->next;
+	}
+
+	if (!ua) return -1;
+
+	struct uwsgi_alarm_instance *old_uai = NULL, *uai = uwsgi.alarm_instances;
+	while(uai) {
+		old_uai = uai;
+		uai = uai->next;
+	}
+
+	uai = uwsgi_calloc(sizeof(struct uwsgi_alarm_instance));
+	uai->name = name;
+	uai->alarm = ua;
+	uai->arg = arg;
+	uai->last_msg = uwsgi_malloc(uwsgi.log_master_bufsize);
+
+	if (old_uai) {
+		old_uai->next = uai;
+	}
+	else {
+		uwsgi.alarm_instances = uai;
+	}
+	
+	ua->init(uai);
+	return 0;
+}
+
+// get an alarm instance by its name
+static struct uwsgi_alarm_instance *uwsgi_alarm_get_instance(char *name) {
+	struct uwsgi_alarm_instance *uai = uwsgi.alarm_instances;
+	while(uai) {
+		if (!strcmp(name, uai->name)) {
+			return uai;
+		}
+		uai = uai->next;
+	}
+	return NULL;
+}
+
+
+static int uwsgi_alarm_log_add(char *alarms, char *regexp) {
+
+	struct uwsgi_alarm_log *old_ual = NULL, *ual = uwsgi.alarm_logs;
+	while(ual) {
+		old_ual = ual;
+		ual = ual->next;
+	}
+
+	ual = uwsgi_calloc(sizeof(struct uwsgi_alarm_log));
+	if (uwsgi_regexp_build(regexp, &ual->pattern, &ual->pattern_extra)) {
+		return -1;
+        }
+
+	if (old_ual) {
+		old_ual->next = ual;
+	}
+	else {
+		uwsgi.alarm_logs = ual;
+	}
+
+	// map instances to the log
+	char *list = uwsgi_str(alarms);
+	char *p = strtok(list, ",");
+	while(p) {
+		struct uwsgi_alarm_instance *uai = uwsgi_alarm_get_instance(p);
+		if (!uai) return -1;
+		struct uwsgi_alarm_ll *old_uall=NULL,*uall = ual->alarms;
+		while(uall) {
+			old_uall = uall;
+			uall = uall->next;
+		}
+
+		uall = uwsgi_calloc(sizeof(struct uwsgi_alarm_ll));
+		uall->alarm = uai;
+		if (old_uall) {
+			old_uall->next = uall;
+		}
+		else {
+			ual->alarms = uall;
+		}
+		p = strtok(NULL, ",");
+	}
+	return 0;
+}
+
+// initialize alarms, instances and log regexps
+void uwsgi_alarms_init() {
+
+	// first of all, create instance of alarms
+	struct uwsgi_string_list *usl = uwsgi.alarm_list;
+	while(usl) {
+		char *line = uwsgi_str(usl->value);
+		char *space = strchr(line, ' ');
+		if (!space) {
+			uwsgi_log("invalid alarm syntax: %s\n", usl->value);
+			exit(1);
+		}
+		*space = 0;
+		char *plugin = space+1;
+		char *colon = strchr(plugin, ':');
+		if (!colon) {
+			uwsgi_log("invalid alarm syntax: %s\n", usl->value);
+			exit(1);
+		}
+		*colon = 0;
+		char *arg = colon+1;
+		// here the alarm is mapped to a name and initialized
+		if (uwsgi_alarm_add(line, plugin, arg)) {
+			uwsgi_log("invalid alarm: %s\n", usl->value);
+			exit(1);
+		}
+		usl = usl->next;
+	}
+
+	// then map log-alarm
+	usl = uwsgi.alarm_logs_list;
+	while(usl) {
+		char *line = uwsgi_str(usl->value);
+		char *space = strchr(line, ' ');
+                if (!space) {
+                        uwsgi_log("invalid log-alarm syntax: %s\n", usl->value);
+                        exit(1);
+                }
+                *space = 0;
+                char *regexp = space+1;
+                // here the log-alarm is created
+                if (uwsgi_alarm_log_add(line, regexp)) {
+                        uwsgi_log("invalid log-alarm: %s\n", usl->value);
+                        exit(1);
+                }
+
+		usl = usl->next;
+	}
+}
+
+// check if a log should raise an alarm
+void uwsgi_alarm_log_check(char *msg, size_t len) {
+	if (!uwsgi_strncmp(msg, len, "[uwsgi-alarm", 12)) return;
+	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);
+                }
+                ual = ual->next;
+	}
+}
+
+// call the alarm func
+void uwsgi_alarm_run(struct uwsgi_alarm_instance *uai, char *msg, size_t len) {
+	time_t now = uwsgi_now();
+	// avoid alarm storming/loop if last message is the same
+	if (!uwsgi_strncmp(msg, len, uai->last_msg, uai->last_msg_size)) {	
+		if (now - uai->last_run < uwsgi.alarm_freq) return;
+	}
+	uai->alarm->func(uai, msg, len);
+	uai->last_run = uwsgi_now();
+	memcpy(uai->last_msg, msg, len);
+	uai->last_msg_size = len;
+}
+
+// call the alarms mapped to a log line
+void uwsgi_alarm_log_run(struct uwsgi_alarm_log *ual, char *msg, size_t len) {
+	struct uwsgi_alarm_ll *uall = ual->alarms;
+	while(uall) {
+		uwsgi_alarm_run(uall->alarm, msg, len);
+		uall = uall->next;
+	}
+}
+
+

core/cache.c

@@ -3,7 +3,6 @@
 extern struct uwsgi_server uwsgi;
 
 void uwsgi_init_cache() {
-	int i;
 
 	if (!uwsgi.cache_blocksize)
         	uwsgi.cache_blocksize = UMAX16;
@@ -64,6 +63,7 @@ void uwsgi_init_cache() {
                 }
                 else {
                         uwsgi.cache_items = (struct uwsgi_cache_item *) mmap(NULL, (sizeof(struct uwsgi_cache_item) * uwsgi.cache_max_items) + (uwsgi.cache_blocksize * uwsgi.cache_max_items), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+			int i;
                         for (i = 0; i < (int) uwsgi.cache_max_items; i++) {
                                 memset(&uwsgi.cache_items[i], 0, sizeof(struct uwsgi_cache_item));
                         }
@@ -243,7 +243,6 @@ int uwsgi_cache_set(char *key, uint16_t keylen, char *val, uint64_t vallen, uint
 	struct uwsgi_cache_item *uci, *ucii;
 
 	int ret = -1;
-	int slot;
 
 	if (!keylen || !vallen) return -1;
 
@@ -283,7 +282,7 @@ int uwsgi_cache_set(char *key, uint16_t keylen, char *val, uint64_t vallen, uint
 		uci->keysize = keylen;	
 		ret = 0;
 		// now put the value in the 16bit hashtable
-		slot = uci->djbhash % 0xffff;
+		int slot = uci->djbhash % 0xffff;
 		// reset values
 		uci->prev = 0;
 		uci->next = 0;

core/event.c

@@ -104,7 +104,6 @@ int event_queue_wait_multi(int eq, int timeout, void *events, int nevents) {
         int ret;
 	uint_t nget = 1;
 	timespec_t ts;
-	port_event_t *pe;
 
 	if (timeout >= 0) {
                 ts.tv_sec = timeout;
@@ -123,8 +122,6 @@ int event_queue_wait_multi(int eq, int timeout, void *events, int nevents) {
                 return 0;
         }
 
-	pe = (port_event_t *) events;
-
         return nget;
 }
 

core/init.c

@@ -74,6 +74,15 @@ void uwsgi_init_default() {
         uwsgi.subscriptions_sign_check_tolerance = 3600 * 24;
 #endif
 
+#ifdef UWSGI_ALARM
+	uwsgi.alarm_freq = 3;
+#endif
+
+
+#ifdef UWSGI_MULTICAST
+	uwsgi.multicast_ttl = 1;
+#endif
+
 }
 
 void uwsgi_setup_reload() {

core/master.c

@@ -265,6 +265,9 @@ int uwsgi_master_log(void) {
 
 	ssize_t rlen = read(uwsgi.shared->worker_log_pipe[0], uwsgi.log_master_buf, uwsgi.log_master_bufsize);
 	if (rlen > 0) {
+#ifdef UWSGI_ALARM
+		uwsgi_alarm_log_check(uwsgi.log_master_buf, rlen);
+#endif
 #ifdef UWSGI_PCRE
 		struct uwsgi_regexp_list *url = uwsgi.log_drain_rules;
 		while(url) {
@@ -644,6 +647,11 @@ int master_loop(char **argv, char **environ) {
 				uwsgi.threaded_logger = 0;
 			}
 		}
+
+#ifdef UWSGI_ALARM
+		// initialize the alarm subsystem
+		uwsgi_alarms_init();
+#endif
 	}
 
 	if (uwsgi.cache_max_items > 0 && !uwsgi.cache_no_expire) {

core/signal.c

@@ -4,13 +4,13 @@ extern struct uwsgi_server uwsgi;
 
 int uwsgi_signal_handler(uint8_t sig) {
 
-	struct uwsgi_signal_entry *use = NULL; 
+	struct uwsgi_signal_entry *use = NULL;
 
 	use = &uwsgi.shared->signal_table[sig];
 
 	if (!uwsgi.p[use->modifier1]->signal_handler) {
 		return -1;
-	}	
+	}
 
 	// check for COW
 	if (uwsgi.master_process) {
@@ -34,52 +34,52 @@ int uwsgi_signal_handler(uint8_t sig) {
 		}
 	}
 
-        // set harakiri here (if required and if i am a worker)
-	
+	// set harakiri here (if required and if i am a worker)
+
 	if (uwsgi.mywid > 0) {
-                uwsgi.workers[uwsgi.mywid].sig = 1;
-                uwsgi.workers[uwsgi.mywid].signum = sig;
+		uwsgi.workers[uwsgi.mywid].sig = 1;
+		uwsgi.workers[uwsgi.mywid].signum = sig;
 		uwsgi.workers[uwsgi.mywid].signals++;
-		if(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI] > 0) {
-                	set_harakiri(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI]);
+		if (uwsgi.shared->options[UWSGI_OPTION_HARAKIRI] > 0) {
+			set_harakiri(uwsgi.shared->options[UWSGI_OPTION_HARAKIRI]);
 		}
-        }
+	}
 	else if (uwsgi.muleid > 0) {
-                uwsgi.mules[uwsgi.muleid-1].sig = 1;
-                uwsgi.mules[uwsgi.muleid-1].signum = sig;
-		uwsgi.mules[uwsgi.muleid-1].signals++;
-		if(uwsgi.shared->options[UWSGI_OPTION_MULE_HARAKIRI] > 0) {
-                	set_mule_harakiri(uwsgi.shared->options[UWSGI_OPTION_MULE_HARAKIRI]);
+		uwsgi.mules[uwsgi.muleid - 1].sig = 1;
+		uwsgi.mules[uwsgi.muleid - 1].signum = sig;
+		uwsgi.mules[uwsgi.muleid - 1].signals++;
+		if (uwsgi.shared->options[UWSGI_OPTION_MULE_HARAKIRI] > 0) {
+			set_mule_harakiri(uwsgi.shared->options[UWSGI_OPTION_MULE_HARAKIRI]);
 		}
 	}
 #ifdef UWSGI_SPOOLER
-        else if (uwsgi.i_am_a_spooler && (getpid() == uwsgi.i_am_a_spooler->pid)) {
-		if(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
-                        set_spooler_harakiri(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI]);
-                }
-        }
+	else if (uwsgi.i_am_a_spooler && (getpid() == uwsgi.i_am_a_spooler->pid)) {
+		if (uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
+			set_spooler_harakiri(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI]);
+		}
+	}
 #endif
 
 	int ret = uwsgi.p[use->modifier1]->signal_handler(sig, use->handler);
 
 	if (uwsgi.mywid > 0) {
-                uwsgi.workers[uwsgi.mywid].sig = 0;
-		if(uwsgi.workers[uwsgi.mywid].harakiri > 0) {
-                	set_harakiri(0);
+		uwsgi.workers[uwsgi.mywid].sig = 0;
+		if (uwsgi.workers[uwsgi.mywid].harakiri > 0) {
+			set_harakiri(0);
 		}
-        }
+	}
 	else if (uwsgi.muleid > 0) {
-                uwsgi.mules[uwsgi.muleid-1].sig = 0;
-		if(uwsgi.mules[uwsgi.muleid-1].harakiri > 0) {
-                	set_mule_harakiri(0);
+		uwsgi.mules[uwsgi.muleid - 1].sig = 0;
+		if (uwsgi.mules[uwsgi.muleid - 1].harakiri > 0) {
+			set_mule_harakiri(0);
 		}
-        }
+	}
 #ifdef UWSGI_SPOOLER
 	else if (uwsgi.i_am_a_spooler && (getpid() == uwsgi.i_am_a_spooler->pid)) {
-		if(uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
-                        set_spooler_harakiri(0);
-                }
-        }
+		if (uwsgi.shared->options[UWSGI_OPTION_SPOOLER_HARAKIRI] > 0) {
+			set_spooler_harakiri(0);
+		}
+	}
 #endif
 
 	return ret;
@@ -97,7 +97,8 @@ int uwsgi_register_signal(uint8_t sig, char *receiver, void *handler, uint8_t mo
 
 	struct uwsgi_signal_entry *use = NULL;
 
-	if (strlen(receiver) > 63) return -1;
+	if (strlen(receiver) > 63)
+		return -1;
 
 	uwsgi_lock(uwsgi.signal_table_lock);
 
@@ -109,7 +110,7 @@ int uwsgi_register_signal(uint8_t sig, char *receiver, void *handler, uint8_t mo
 		return -1;
 	}
 
-	strncpy(use->receiver, receiver, strlen(receiver)+1);
+	strncpy(use->receiver, receiver, strlen(receiver) + 1);
 	use->handler = handler;
 	use->modifier1 = modifier1;
 	use->wid = uwsgi.mywid;
@@ -129,7 +130,7 @@ int uwsgi_register_signal(uint8_t sig, char *receiver, void *handler, uint8_t mo
 
 int uwsgi_add_file_monitor(uint8_t sig, char *filename) {
 
-	if (strlen(filename) > (0xff-1)) {
+	if (strlen(filename) > (0xff - 1)) {
 		uwsgi_log("uwsgi_add_file_monitor: invalid filename length\n");
 		return -1;
 	}
@@ -140,9 +141,9 @@ int uwsgi_add_file_monitor(uint8_t sig, char *filename) {
 
 		// fill the fmon table, the master will use it to add items to the event queue
 		memcpy(ushared->files_monitored[ushared->files_monitored_cnt].filename, filename, strlen(filename));
-                ushared->files_monitored[ushared->files_monitored_cnt].registered = 0;
+		ushared->files_monitored[ushared->files_monitored_cnt].registered = 0;
 		ushared->files_monitored[ushared->files_monitored_cnt].sig = sig;
-	
+
 		ushared->files_monitored_cnt++;
 	}
 	else {
@@ -157,31 +158,31 @@ int uwsgi_add_file_monitor(uint8_t sig, char *filename) {
 
 }
 
-struct uwsgi_probe *uwsgi_probe_register(struct uwsgi_probe **up, char *name, int (*func)(int, struct uwsgi_signal_probe *)) {
+struct uwsgi_probe *uwsgi_probe_register(struct uwsgi_probe **up, char *name, int (*func) (int, struct uwsgi_signal_probe *)) {
 
-        struct uwsgi_probe *uwsgi_up = *up, *old_up;
+	struct uwsgi_probe *uwsgi_up = *up, *old_up;
 
-        if (!uwsgi_up) {
-                *up = uwsgi_malloc(sizeof(struct uwsgi_probe));
-                uwsgi_up = *up;
-        }
-        else {
-                while(uwsgi_up) {
-                        old_up = uwsgi_up;
-                        uwsgi_up = uwsgi_up->next;
-                }
+	if (!uwsgi_up) {
+		*up = uwsgi_malloc(sizeof(struct uwsgi_probe));
+		uwsgi_up = *up;
+	}
+	else {
+		while (uwsgi_up) {
+			old_up = uwsgi_up;
+			uwsgi_up = uwsgi_up->next;
+		}
 
-                uwsgi_up = uwsgi_malloc(sizeof(struct uwsgi_probe));
-                old_up->next = uwsgi_up;
-        }
+		uwsgi_up = uwsgi_malloc(sizeof(struct uwsgi_probe));
+		old_up->next = uwsgi_up;
+	}
 
-        uwsgi_up->name = name;
-        uwsgi_up->func = func;
-        uwsgi_up->next = NULL;
+	uwsgi_up->name = name;
+	uwsgi_up->func = func;
+	uwsgi_up->next = NULL;
 
 	uwsgi_log("registered new probe \"%s\" at %p\n", name, uwsgi_up);
 
-        return uwsgi_up;
+	return uwsgi_up;
 }
 
 
@@ -189,10 +190,10 @@ int uwsgi_add_probe(uint8_t sig, char *kind, char *args, int timeout, int freq)
 
 	uwsgi_lock(uwsgi.probe_table_lock);
 
-        if (ushared->probes_cnt < MAX_PROBES) {
+	if (ushared->probes_cnt < MAX_PROBES) {
 
 		struct uwsgi_probe *up = uwsgi.probes;
-		while(up) {
+		while (up) {
 			if (!strcmp(up->name, kind)) {
 				break;
 			}
@@ -201,15 +202,15 @@ int uwsgi_add_probe(uint8_t sig, char *kind, char *args, int timeout, int freq)
 
 		if (!up) {
 			uwsgi_log("unable to find probe \"%s\" !!!\n", kind);
-                	uwsgi_unlock(uwsgi.probe_table_lock);
-                	return -1;
+			uwsgi_unlock(uwsgi.probe_table_lock);
+			return -1;
 		}
 
-                // fill the probe table
-                ushared->probes[ushared->probes_cnt].func = up->func;
-		strncpy(ushared->probes[ushared->probes_cnt].args, args, 1024-1);
-                ushared->probes[ushared->probes_cnt].registered = 0;
-                ushared->probes[ushared->probes_cnt].sig = sig;
+		// fill the probe table
+		ushared->probes[ushared->probes_cnt].func = up->func;
+		strncpy(ushared->probes[ushared->probes_cnt].args, args, 1024 - 1);
+		ushared->probes[ushared->probes_cnt].registered = 0;
+		ushared->probes[ushared->probes_cnt].sig = sig;
 		ushared->probes[ushared->probes_cnt].fd = -1;
 		ushared->probes[ushared->probes_cnt].state = 0;
 		ushared->probes[ushared->probes_cnt].last_event = 0;
@@ -225,15 +226,15 @@ int uwsgi_add_probe(uint8_t sig, char *kind, char *args, int timeout, int freq)
 			freq = 1;
 		}
 		ushared->probes[ushared->probes_cnt].freq = freq;
-                ushared->probes_cnt++;
-        }
-        else {
-                uwsgi_log("you can register max %d probes !!!\n", MAX_PROBES);
-                uwsgi_unlock(uwsgi.probe_table_lock);
-                return -1;
-        }
+		ushared->probes_cnt++;
+	}
+	else {
+		uwsgi_log("you can register max %d probes !!!\n", MAX_PROBES);
+		uwsgi_unlock(uwsgi.probe_table_lock);
+		return -1;
+	}
 
-        uwsgi_unlock(uwsgi.probe_table_lock);
+	uwsgi_unlock(uwsgi.probe_table_lock);
 
 	return 0;
 }
@@ -267,107 +268,109 @@ void uwsgi_opt_add_cron(char *opt, char *value, void *foobar) {
 	int i;
 
 	struct uwsgi_cron *old_uc, *uc = uwsgi.crons;
-                if (!uc) {
-                        uc = uwsgi_malloc(sizeof(struct uwsgi_cron));
-                        uwsgi.crons = uc;
-                }
-                else {
-                        old_uc = uc;
-                        while(uc->next) {
-                                uc = uc->next;
-                                old_uc = uc;
-                        }
+	if (!uc) {
+		uc = uwsgi_malloc(sizeof(struct uwsgi_cron));
+		uwsgi.crons = uc;
+	}
+	else {
+		old_uc = uc;
+		while (uc->next) {
+			uc = uc->next;
+			old_uc = uc;
+		}
 
-                        old_uc->next = uwsgi_malloc(sizeof(struct uwsgi_cron));
-                        uc = old_uc->next;
-                }
+		old_uc->next = uwsgi_malloc(sizeof(struct uwsgi_cron));
+		uc = old_uc->next;
+	}
 
-                memset(uc, 0, sizeof(struct uwsgi_cron));
+	memset(uc, 0, sizeof(struct uwsgi_cron));
 
-                if (sscanf(value, "%d %d %d %d %d %n", &uc->minute, &uc->hour, &uc->day, &uc->month, &uc->week, &i) != 5) {
-                        uwsgi_log("invalid cron syntax\n");
-                        exit(1);
-                }
-                uc->command = value+i;
+	if (sscanf(value, "%d %d %d %d %d %n", &uc->minute, &uc->hour, &uc->day, &uc->month, &uc->week, &i) != 5) {
+		uwsgi_log("invalid cron syntax\n");
+		exit(1);
+	}
+	uc->command = value + i;
 }
 
 int uwsgi_signal_add_cron(uint8_t sig, int minute, int hour, int day, int month, int week) {
 
-	if (!uwsgi.master_process) return -1;
+	if (!uwsgi.master_process)
+		return -1;
 
 	uwsgi_lock(uwsgi.cron_table_lock);
 
-        if (ushared->cron_cnt < MAX_CRONS) {
+	if (ushared->cron_cnt < MAX_CRONS) {
 
-                ushared->cron[ushared->cron_cnt].sig = sig;
-                ushared->cron[ushared->cron_cnt].minute = minute;
-                ushared->cron[ushared->cron_cnt].hour = hour;
-                ushared->cron[ushared->cron_cnt].day = day;
-                ushared->cron[ushared->cron_cnt].month = month;
-                ushared->cron[ushared->cron_cnt].week = week;
-                ushared->cron_cnt++;
-        }
-        else {
-                uwsgi_log("you can register max %d cron !!!\n", MAX_CRONS);
-                uwsgi_unlock(uwsgi.cron_table_lock);
-                return -1;
-        }
+		ushared->cron[ushared->cron_cnt].sig = sig;
+		ushared->cron[ushared->cron_cnt].minute = minute;
+		ushared->cron[ushared->cron_cnt].hour = hour;
+		ushared->cron[ushared->cron_cnt].day = day;
+		ushared->cron[ushared->cron_cnt].month = month;
+		ushared->cron[ushared->cron_cnt].week = week;
+		ushared->cron_cnt++;
+	}
+	else {
+		uwsgi_log("you can register max %d cron !!!\n", MAX_CRONS);
+		uwsgi_unlock(uwsgi.cron_table_lock);
+		return -1;
+	}
 
-        uwsgi_unlock(uwsgi.cron_table_lock);
+	uwsgi_unlock(uwsgi.cron_table_lock);
 
-        return 0;
+	return 0;
 }
 
 int uwsgi_signal_add_rb_timer(uint8_t sig, int secs, int iterations) {
 
-	if (!uwsgi.master_process) return -1;
+	if (!uwsgi.master_process)
+		return -1;
 
-        uwsgi_lock(uwsgi.rb_timer_table_lock);
+	uwsgi_lock(uwsgi.rb_timer_table_lock);
 
-        if (ushared->rb_timers_cnt < 64) {
+	if (ushared->rb_timers_cnt < 64) {
 
-                // fill the timer table, the master will use it to add items to the event queue
-                ushared->rb_timers[ushared->rb_timers_cnt].value = secs;
-                ushared->rb_timers[ushared->rb_timers_cnt].registered = 0;
-                ushared->rb_timers[ushared->rb_timers_cnt].iterations = iterations;
-                ushared->rb_timers[ushared->rb_timers_cnt].iterations_done = 0;
-                ushared->rb_timers[ushared->rb_timers_cnt].sig = sig;
-                ushared->rb_timers_cnt++;
-        }
-        else {
-                uwsgi_log("you can register max 64 rb_timers !!!\n");
-                uwsgi_unlock(uwsgi.rb_timer_table_lock);
-                return -1;
-        }
+		// fill the timer table, the master will use it to add items to the event queue
+		ushared->rb_timers[ushared->rb_timers_cnt].value = secs;
+		ushared->rb_timers[ushared->rb_timers_cnt].registered = 0;
+		ushared->rb_timers[ushared->rb_timers_cnt].iterations = iterations;
+		ushared->rb_timers[ushared->rb_timers_cnt].iterations_done = 0;
+		ushared->rb_timers[ushared->rb_timers_cnt].sig = sig;
+		ushared->rb_timers_cnt++;
+	}
+	else {
+		uwsgi_log("you can register max 64 rb_timers !!!\n");
+		uwsgi_unlock(uwsgi.rb_timer_table_lock);
+		return -1;
+	}
 
-        uwsgi_unlock(uwsgi.rb_timer_table_lock);
+	uwsgi_unlock(uwsgi.rb_timer_table_lock);
 
-        return 0;
+	return 0;
 
 }
 
 void create_signal_pipe(int *sigpipe) {
 
 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, sigpipe)) {
-        	uwsgi_error("socketpair()\n");
-        	exit(1);
-        }
-        uwsgi_socket_nb(sigpipe[0]);
-        uwsgi_socket_nb(sigpipe[1]);
+		uwsgi_error("socketpair()\n");
+		exit(1);
+	}
+	uwsgi_socket_nb(sigpipe[0]);
+	uwsgi_socket_nb(sigpipe[1]);
 
 	if (uwsgi.signal_bufsize) {
-		if (setsockopt(sigpipe[0],  SOL_SOCKET, SO_SNDBUF, &uwsgi.signal_bufsize, sizeof(int))) {
-                        	uwsgi_error("setsockopt()");
+		if (setsockopt(sigpipe[0], SOL_SOCKET, SO_SNDBUF, &uwsgi.signal_bufsize, sizeof(int))) {
+			uwsgi_error("setsockopt()");
 		}
-		if (setsockopt(sigpipe[0],  SOL_SOCKET, SO_RCVBUF, &uwsgi.signal_bufsize, sizeof(int))) {
-                        	uwsgi_error("setsockopt()");
+		if (setsockopt(sigpipe[0], SOL_SOCKET, SO_RCVBUF, &uwsgi.signal_bufsize, sizeof(int))) {
+			uwsgi_error("setsockopt()");
 		}
 
-		if (setsockopt(sigpipe[1],  SOL_SOCKET, SO_SNDBUF, &uwsgi.signal_bufsize, sizeof(int))) {
-                        	uwsgi_error("setsockopt()");
+		if (setsockopt(sigpipe[1], SOL_SOCKET, SO_SNDBUF, &uwsgi.signal_bufsize, sizeof(int))) {
+			uwsgi_error("setsockopt()");
 		}
-		if (setsockopt(sigpipe[1],  SOL_SOCKET, SO_RCVBUF, &uwsgi.signal_bufsize, sizeof(int))) {
-                        	uwsgi_error("setsockopt()");
+		if (setsockopt(sigpipe[1], SOL_SOCKET, SO_RCVBUF, &uwsgi.signal_bufsize, sizeof(int))) {
+			uwsgi_error("setsockopt()");
 		}
 	}
 }
@@ -379,9 +382,10 @@ int uwsgi_remote_signal_send(char *addr, uint8_t sig) {
 	uh.modifier1 = 110;
 	uh.pktsize = 0;
 	uh.modifier2 = sig;
-	
+
 	int fd = uwsgi_connect(addr, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT], 0);
-        if (fd < 0) return -1;
+	if (fd < 0)
+		return -1;
 
 	if (write(fd, (char *) &uh, 4) != 4) {
 		uwsgi_error("uwsgi_remote_signal_send()");
@@ -403,16 +407,16 @@ int uwsgi_signal_send(int fd, uint8_t sig) {
 
 	if (write(fd, &sig, 1) != 1) {
 		if (errno == EAGAIN || errno == EWOULDBLOCK) {
-                	if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &so_bufsize, &so_bufsize_len)) {
-                        	uwsgi_error("getsockopt()");
-                	}
-                	uwsgi_log("*** SIGNAL QUEUE IS FULL: buffer size %d bytes (you can tune it with --signal-bufsize) ***\n", so_bufsize);
+			if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &so_bufsize, &so_bufsize_len)) {
+				uwsgi_error("getsockopt()");
+			}
+			uwsgi_log("*** SIGNAL QUEUE IS FULL: buffer size %d bytes (you can tune it with --signal-bufsize) ***\n", so_bufsize);
 		}
 		else {
 			uwsgi_error("uwsgi_signal_send()");
 		}
 		return -1;
-        }
+	}
 	return 0;
 
 }
@@ -430,7 +434,7 @@ void uwsgi_route_signal(uint8_t sig) {
 	}
 	// send to all workers
 	else if (!strcmp(use->receiver, "workers")) {
-		for(i=1;i<=uwsgi.numproc;i++) {
+		for (i = 1; i <= uwsgi.numproc; i++) {
 			if (uwsgi_signal_send(uwsgi.workers[i].signal_pipe[0], sig)) {
 				uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
 			}
@@ -438,13 +442,13 @@ void uwsgi_route_signal(uint8_t sig) {
 	}
 	// route to specific worker
 	else if (!strncmp(use->receiver, "worker", 6)) {
-		i = atoi(use->receiver+6);
+		i = atoi(use->receiver + 6);
 		if (i > uwsgi.numproc) {
 			uwsgi_log("invalid signal target: %s\n", use->receiver);
 		}
 		if (uwsgi_signal_send(uwsgi.workers[i].signal_pipe[0], sig)) {
-                	uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
-                }
+			uwsgi_log("could not deliver signal %d to worker %d\n", sig, i);
+		}
 	}
 	// route to subscribed
 	else if (!strcmp(use->receiver, "subscribed")) {
@@ -454,54 +458,54 @@ void uwsgi_route_signal(uint8_t sig) {
 	else if (!strcmp(use->receiver, "spooler")) {
 		if (ushared->worker_signal_pipe[0] != -1) {
 			if (uwsgi_signal_send(ushared->spooler_signal_pipe[0], sig)) {
-                        	uwsgi_log("could not deliver signal %d to the spooler\n", sig);
-                	}
+				uwsgi_log("could not deliver signal %d to the spooler\n", sig);
+			}
 		}
 	}
 #endif
 	else if (!strcmp(use->receiver, "mules")) {
-		for(i=0;i<uwsgi.mules_cnt;i++) {
+		for (i = 0; i < uwsgi.mules_cnt; i++) {
 			if (uwsgi_signal_send(uwsgi.mules[i].signal_pipe[0], sig)) {
-                                uwsgi_log("could not deliver signal %d to mule %d\n", sig, i+1);
-                        }
+				uwsgi_log("could not deliver signal %d to mule %d\n", sig, i + 1);
+			}
 		}
 	}
 	else if (!strncmp(use->receiver, "mule", 4)) {
-		i = atoi(use->receiver+4);
+		i = atoi(use->receiver + 4);
 		if (i > uwsgi.mules_cnt) {
 			uwsgi_log("invalid signal target: %s\n", use->receiver);
 		}
 		else if (i == 0) {
 			if (uwsgi_signal_send(ushared->mule_signal_pipe[0], sig)) {
-                                uwsgi_log("could not deliver signal %d to a mule\n", sig);
-                        }
+				uwsgi_log("could not deliver signal %d to a mule\n", sig);
+			}
 		}
 		else {
-			if (uwsgi_signal_send(uwsgi.mules[i-1].signal_pipe[0], sig)) {
-                                uwsgi_log("could not deliver signal %d to mule %d\n", sig, i);
-                        }
+			if (uwsgi_signal_send(uwsgi.mules[i - 1].signal_pipe[0], sig)) {
+				uwsgi_log("could not deliver signal %d to mule %d\n", sig, i);
+			}
 		}
 	}
 	else if (!strncmp(use->receiver, "farm_", 5)) {
-		char *name = use->receiver+5;
+		char *name = use->receiver + 5;
 		struct uwsgi_farm *uf = get_farm_by_name(name);
 		if (!uf) {
 			uwsgi_log("unknown farm: %s\n", name);
 			return;
 		}
 		if (uwsgi_signal_send(uf->signal_pipe[0], sig)) {
-                        uwsgi_log("could not deliver signal %d to farm %d (%s)\n", sig, uf->id, uf->name);
-                }
+			uwsgi_log("could not deliver signal %d to farm %d (%s)\n", sig, uf->id, uf->name);
+		}
 	}
 	else if (!strncmp(use->receiver, "farm", 4)) {
-		i = atoi(use->receiver+4);
+		i = atoi(use->receiver + 4);
 		if (i > uwsgi.farms_cnt || i <= 0) {
 			uwsgi_log("invalid signal target: %s\n", use->receiver);
 		}
 		else {
-			if (uwsgi_signal_send(uwsgi.farms[i-1].signal_pipe[0], sig)) {
-                                uwsgi_log("could not deliver signal %d to farm %d (%s)\n", sig, i, uwsgi.farms[i-1].name);
-                        }
+			if (uwsgi_signal_send(uwsgi.farms[i - 1].signal_pipe[0], sig)) {
+				uwsgi_log("could not deliver signal %d to farm %d (%s)\n", sig, i, uwsgi.farms[i - 1].name);
+			}
 		}
 	}
 
@@ -512,51 +516,56 @@ void uwsgi_route_signal(uint8_t sig) {
 
 }
 
-uint8_t uwsgi_signal_wait(int signum) {
+int uwsgi_signal_wait(int signum) {
 
-        int wait_for_specific_signal = 0;
-        uint8_t uwsgi_signal = 0;
-        uint8_t received_signal;
-        int ret;
-        struct pollfd pfd[2];
+	int wait_for_specific_signal = 0;
+	uint8_t uwsgi_signal = 0;
+	int received_signal = -1;
+	int ret;
+	struct pollfd pfd[2];
 
 	if (signum > -1) {
-                wait_for_specific_signal = 1;
-        }
+		wait_for_specific_signal = 1;
+	}
+
+	pfd[0].fd = uwsgi.signal_socket;
+	pfd[0].events = POLLIN;
+	pfd[1].fd = uwsgi.my_signal_socket;
+	pfd[1].events = POLLIN;
 
-        pfd[0].fd = uwsgi.signal_socket;
-        pfd[0].events = POLLIN;
-        pfd[1].fd = uwsgi.my_signal_socket;
-        pfd[1].events = POLLIN;
 cycle:
-        ret = poll(pfd, 2, -1);
-        if (ret > 0) {
-        	if (pfd[0].revents == POLLIN) {
-                          if (read(uwsgi.signal_socket, &received_signal, 1) != 1) {
-                          	uwsgi_error("read()");
-                          }
-                          else {
-                          	(void)uwsgi_signal_handler(received_signal);
-                                if (wait_for_specific_signal) {
-                                	if (received_signal != uwsgi_signal) goto cycle;
-                                }
-                           }
+	ret = poll(pfd, 2, -1);
+	if (ret > 0) {
+		if (pfd[0].revents == POLLIN) {
+			if (read(uwsgi.signal_socket, &uwsgi_signal, 1) != 1) {
+				uwsgi_error("read()");
+			}
+			else {
+				(void) uwsgi_signal_handler(uwsgi_signal);
+				if (wait_for_specific_signal) {
+					if (signum != uwsgi_signal)
+						goto cycle;
+				}
+				received_signal = uwsgi_signal;
+			}
+		}
+		if (pfd[1].revents == POLLIN) {
+			if (read(uwsgi.my_signal_socket, &uwsgi_signal, 1) != 1) {
+				uwsgi_error("read()");
+			}
+			else {
+				(void) uwsgi_signal_handler(uwsgi_signal);
+				if (wait_for_specific_signal) {
+					if (signum != uwsgi_signal)
+						goto cycle;
+				}
+			}
+			received_signal = uwsgi_signal;
 		}
-                if (pfd[1].revents == POLLIN) {
-                               if (read(uwsgi.my_signal_socket, &received_signal, 1) != 1) {
-                                       uwsgi_error("read()");
-                               }
-                               else {
-                                       (void)uwsgi_signal_handler(received_signal);
-                                       if (wait_for_specific_signal) {
-                                               if (received_signal != uwsgi_signal) goto cycle;
-                                       }
-                               }
-                        }
 
-                }
+	}
 
-        return received_signal;
+	return received_signal;
 }
 
 void uwsgi_receive_signal(int fd, char *name, int id) {
@@ -565,27 +574,27 @@ void uwsgi_receive_signal(int fd, char *name, int id) {
 
 	ssize_t ret = read(fd, &uwsgi_signal, 1);
 
-        if (ret == 0) {
+	if (ret == 0) {
 		goto destroy;
-        }
-        else if (ret < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
-                uwsgi_error("[uwsgi-signal] read()");
+	}
+	else if (ret < 0 && errno != EAGAIN && errno != EWOULDBLOCK) {
+		uwsgi_error("[uwsgi-signal] read()");
 		goto destroy;
-        }
-        else if (ret > 0) {
+	}
+	else if (ret > 0) {
 #ifdef UWSGI_DEBUG
-                uwsgi_log_verbose("master sent signal %d to %s %d\n", uwsgi_signal, name, id);
+		uwsgi_log_verbose("master sent signal %d to %s %d\n", uwsgi_signal, name, id);
 #endif
-                if (uwsgi_signal_handler(uwsgi_signal)) {
-                        uwsgi_log_verbose("error managing signal %d on %s %d\n", uwsgi_signal, name, id);
-                }
-        }
+		if (uwsgi_signal_handler(uwsgi_signal)) {
+			uwsgi_log_verbose("error managing signal %d on %s %d\n", uwsgi_signal, name, id);
+		}
+	}
 
 	return;
 
 destroy:
 	// better to kill the whole worker...
-        uwsgi_log_verbose("uWSGI %s %d screams: UAAAAAAH my master disconnected: i will kill myself !!!\n", name, id);
+	uwsgi_log_verbose("uWSGI %s %d screams: UAAAAAAH my master disconnected: i will kill myself !!!\n", name, id);
 	end_me(0);
 
 }

core/socket.c

@@ -174,6 +174,7 @@ int bind_to_udp(char *socket_name, int multicast, int broadcast) {
 	struct sockaddr_in uws_addr;
 	char *udp_port;
 	int bcast = 1;
+	int reuse = 1;
 
 #ifdef UWSGI_MULTICAST
 	struct ip_mreq mc;
@@ -231,6 +232,10 @@ int bind_to_udp(char *socket_name, int multicast, int broadcast) {
 		return -1;
 	}
 
+	if (setsockopt(serverfd, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse, sizeof(int)) < 0) {
+                uwsgi_error("setsockopt()");
+        }
+
 #ifdef UWSGI_MULTICAST
 	if (multicast) {
 		// if multicast is enabled remember to bind to INADDR_ANY
@@ -265,6 +270,10 @@ int bind_to_udp(char *socket_name, int multicast, int broadcast) {
 			uwsgi_error("setsockopt()");
 		}
 
+		if (setsockopt(serverfd, IPPROTO_IP, IP_MULTICAST_TTL, &uwsgi.multicast_ttl, sizeof(uwsgi.multicast_ttl))) {
+                        uwsgi_error("setsockopt()");
+                }
+
 	}
 #endif
 
@@ -595,7 +604,7 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 
 	if (bind(serverfd, (struct sockaddr *) &uws_addr, sizeof(uws_addr)) != 0) {
 		if (errno == EADDRINUSE) {
-			uwsgi_log("probably another instance of uWSGI is running on the same address.\n");
+			uwsgi_log("probably another instance of uWSGI is running on the same address (%s).\n", socket_name);
 		}
 		uwsgi_error("bind()");
 		uwsgi_nuclear_blast();

core/utils.c

@@ -2154,6 +2154,8 @@ void *uwsgi_malloc(size_t size) {
 	char *ptr = malloc(size);
 	if (ptr == NULL) {
 		uwsgi_error("malloc()");
+		uwsgi_log("!!! tried memory allocation of %llu bytes !!!\n", (unsigned long long) size);
+		uwsgi_backtrace(uwsgi.backtrace_depth);
 		exit(1);
 	}
 
@@ -4385,7 +4387,7 @@ SSL_CTX *uwsgi_ssl_new_server_context(char *name, char *crt, char *key, char *ci
 	SSL_CTX_set_mode(ctx, SSL_MODE_RELEASE_BUFFERS);
 #endif
 
-	if (SSL_CTX_use_certificate_file(ctx, crt, SSL_FILETYPE_PEM) <= 0) {
+	if (SSL_CTX_use_certificate_chain_file(ctx, crt) <= 0) {
 		uwsgi_log("unable to assign ssl certificate %s\n", crt);
 		exit(1);
 	}
@@ -4846,3 +4848,49 @@ clear:
 	return output;
 }
 #endif
+
+static void *uwsgi_thread_run(void *arg) {
+	struct uwsgi_thread *ut = (struct uwsgi_thread *) arg;
+        // block all signals
+        sigset_t smask;
+        sigfillset(&smask);
+        pthread_sigmask(SIG_BLOCK, &smask, NULL);
+
+	ut->queue = event_queue_init();
+	event_queue_add_fd_read(ut->queue, ut->pipe[1]);	
+
+	ut->func(ut);
+	return NULL;
+}
+
+struct uwsgi_thread *uwsgi_thread_new(void (*func)(struct uwsgi_thread *)) {
+
+	struct uwsgi_thread *ut = uwsgi_malloc(sizeof(struct uwsgi_thread));
+
+#if defined(SOCK_SEQPACKET) && defined(__linux__)
+        if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, ut->pipe)) {
+#else
+        if (socketpair(AF_UNIX, SOCK_DGRAM, 0, ut->pipe)) {
+#endif
+		free(ut);
+                return NULL;
+        }
+
+        uwsgi_socket_nb(ut->pipe[0]);
+        uwsgi_socket_nb(ut->pipe[1]);
+
+	ut->func = func;
+
+	if (pthread_create(&ut->tid, NULL, uwsgi_thread_run, ut)) {
+                uwsgi_error("pthread_create()");
+		goto error;
+	}
+
+	return ut;
+error:
+	close(ut->pipe[0]);
+	close(ut->pipe[1]);
+	free(ut);
+	return NULL;
+}
+

core/uwsgi.c

@@ -302,6 +302,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"stats-server", required_argument, 0, "enable the stats server on the specified address", uwsgi_opt_set_str, &uwsgi.stats, UWSGI_OPT_MASTER},
 #ifdef UWSGI_MULTICAST
 	{"multicast", required_argument, 0, "subscribe to specified multicast group", uwsgi_opt_set_str, &uwsgi.multicast_group, UWSGI_OPT_MASTER},
+	{"multicast-ttl", required_argument, 0, "set multicast ttl", uwsgi_opt_set_int, &uwsgi.multicast_ttl, 0},
 	{"cluster", required_argument, 0, "join specified uWSGI cluster", uwsgi_opt_set_str, &uwsgi.cluster, UWSGI_OPT_MASTER},
 	{"cluster-nodes", required_argument, 0, "get nodes list from the specified cluster", uwsgi_opt_true, &uwsgi.cluster_nodes, UWSGI_OPT_MASTER | UWSGI_OPT_CLUSTER},
 	{"cluster-reload", required_argument, 0, "send a reload message to the cluster", uwsgi_opt_cluster_reload, NULL, UWSGI_OPT_IMMEDIATE},
@@ -352,6 +353,13 @@ static struct uwsgi_option uwsgi_base_options[] = {
 #ifdef UWSGI_PCRE
 	{"log-drain", required_argument, 0, "drain (do not show) log lines matching the specified regexp", uwsgi_opt_add_regexp_list, &uwsgi.log_drain_rules, UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
 #endif
+#ifdef UWSGI_ALARM
+	{"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-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
 #ifdef UWSGI_ZEROMQ
 	{"log-zeromq", required_argument, 0, "send logs to a zeromq server", uwsgi_opt_set_logger, "zeromq", UWSGI_OPT_MASTER | UWSGI_OPT_LOG_MASTER},
 #endif
@@ -1529,6 +1537,18 @@ static void clocks_list(void) {
 	uwsgi_log("--- end of clocks list ---\n\n");
 }
 
+#ifdef UWSGI_ALARM
+static void alarms_list(void) {
+        struct uwsgi_alarm *alarms = uwsgi.alarms;
+        uwsgi_log("\n*** uWSGI loaded alarms ***\n");
+        while(alarms) {
+                uwsgi_log("%s\n", alarms->name);
+                alarms = alarms->next;
+        }
+        uwsgi_log("--- end of alarms list ---\n\n");
+}
+#endif
+
 static time_t uwsgi_unix_seconds() {
 	return time(NULL);
 }
@@ -1743,6 +1763,13 @@ int main(int argc, char *argv[], char *envp[]) {
 	uwsgi_register_imperial_monitor("dir", uwsgi_imperial_monitor_directory_init, uwsgi_imperial_monitor_directory);
         uwsgi_register_imperial_monitor("glob", uwsgi_imperial_monitor_glob_init, uwsgi_imperial_monitor_glob);
 
+
+#ifdef UWSGI_ALARM
+	// register embedded alarms
+	uwsgi_register_embedded_alarms();
+#endif
+
+
 	/* uWSGI IS CONFIGURED !!! */
 
 	if (uwsgi.dump_options) {
@@ -1782,6 +1809,11 @@ int main(int argc, char *argv[], char *envp[]) {
 	if (uwsgi.clock_list)
 		clocks_list();
 
+#ifdef UWSGI_ALARM
+	if (uwsgi.alarms_list)
+		alarms_list();
+#endif
+
 	// set the clock
 	if (uwsgi.requested_clock)
 		uwsgi_set_clock(uwsgi.requested_clock);
@@ -2896,7 +2928,7 @@ void uwsgi_stdin_sendto(char *socket_name, uint8_t modifier1, uint8_t modifier2)
 #endif
 		ptr += rlen;
 		delta -= rlen;
-		if (delta <= 0)
+		if (delta == 0)
 			break;
 		rlen = read(0, ptr, delta);
 	}

plugins/alarm_curl/alarm_curl_plugin.c

@@ -0,0 +1,203 @@
+#include "../../uwsgi.h"
+#include <curl/curl.h>
+
+extern struct uwsgi_server uwsgi;
+
+struct uwsgi_alarm_curl_config {
+	int first;
+	char *arg;
+	char *subject;
+	char *to;
+};
+
+struct uwsgi_alarm_curl_opt {
+	char *name;
+	CURLoption option;
+	void (*func)(CURL *, CURLoption, char *, struct uwsgi_alarm_curl_config*);
+};
+
+
+static void uwsgi_alarm_curl_to(CURL *curl, CURLoption option, char *arg, struct uwsgi_alarm_curl_config *uacc) {
+	uacc->to = arg;
+	struct curl_slist *list = NULL;
+	char *items = uwsgi_str(arg);
+	char *ctx = NULL;
+	char *p = strtok_r(items, ",", &ctx);
+	while(p) {
+		list = curl_slist_append(list, p);
+		p = strtok_r(NULL, ",", &ctx);
+	}
+	curl_easy_setopt(curl, option, list);
+}
+
+static void uwsgi_alarm_curl_ssl(CURL *curl, CURLoption option, char *arg, struct uwsgi_alarm_curl_config *uacc) {
+	curl_easy_setopt(curl, option, (long)CURLUSESSL_ALL);
+}
+
+static void uwsgi_alarm_curl_int(CURL *curl, CURLoption option, char *arg, struct uwsgi_alarm_curl_config *uacc) {
+        curl_easy_setopt(curl, option, atoi(arg));
+}
+
+static void uwsgi_alarm_curl_set_subject(CURL *curl, CURLoption option, char *arg, struct uwsgi_alarm_curl_config *uacc) {
+	uacc->subject = arg;	
+}
+
+static struct uwsgi_alarm_curl_opt uaco[] = {
+	{"url", CURLOPT_URL, NULL},
+	{"mail_to", CURLOPT_MAIL_RCPT, uwsgi_alarm_curl_to },
+	{"mail_from", CURLOPT_MAIL_FROM, NULL},
+	{"subject", 0, uwsgi_alarm_curl_set_subject},
+	{"ssl", CURLOPT_USE_SSL, uwsgi_alarm_curl_ssl},
+	{"auth_user", CURLOPT_USERNAME, NULL},
+	{"auth_pass", CURLOPT_PASSWORD, NULL},
+	{"method", CURLOPT_CUSTOMREQUEST, NULL},
+	{"timeout", CURLOPT_TIMEOUT, uwsgi_alarm_curl_int},
+	{"conn_timeout", CURLOPT_CONNECTTIMEOUT, uwsgi_alarm_curl_int},
+	{NULL, 0, NULL},
+};
+
+static void uwsgi_alarm_curl_setopt(CURL *curl, char *opt, struct uwsgi_alarm_curl_config *uacc) {
+	struct uwsgi_alarm_curl_opt *o = uaco;
+	char *equal = strchr(opt,'=');
+	if (!equal) {
+		if (!uacc->first) {
+			curl_easy_setopt(curl, CURLOPT_URL, opt);
+			uacc->first = 1;
+		}
+		return;
+	}
+	uacc->first = 1;
+	*equal = 0;
+	while(o->name) {
+		if (!strcmp(o->name, opt)) {
+			if (o->func) {
+				o->func(curl, o->option, equal+1, uacc);
+			}
+			else {
+				curl_easy_setopt(curl, o->option, equal+1);
+			}
+			goto end;
+		}
+		o++;
+	}
+end:
+	*equal = '=';
+}
+
+static size_t uwsgi_alarm_curl_read_callback(void *ptr, size_t size, size_t nmemb, void *userp) {
+	struct uwsgi_thread *ut = (struct uwsgi_thread *) userp;
+	size_t full_size = size * nmemb;
+	size_t remains = ut->len - ut->pos;
+	struct uwsgi_alarm_curl_config *uacc = ut->data;
+
+	if (remains == 0) return 0;
+
+	if (ut->custom0 == 0) {
+		size_t newline = 0;
+		size_t required = 1;
+		char *addr = ptr;
+		if (uacc->to) required += 4 + strlen(uacc->to) + 1;
+		if (uacc->subject) required += 9 + strlen(uacc->subject) + 1;
+		if (required > full_size) goto skip;
+
+
+		if (uacc->to) {
+			memcpy(addr, "To: ", 4); addr+=4;
+			memcpy(addr, uacc->to, strlen(uacc->to)); addr += strlen(uacc->to);
+			*addr ++= '\n';
+			newline = 1;
+		}
+
+		if (uacc->subject) {
+			memcpy(addr, "Subject: ", 9); addr+=9;
+			memcpy(addr, uacc->subject, strlen(uacc->subject)); addr += strlen(uacc->subject);
+			*addr ++= '\n';
+			newline = 1;
+		}
+skip:
+		if (newline > 0) {
+			*addr = '\n';
+		}
+		ut->custom0 = 1;
+		return required;
+	}
+
+	if (full_size < remains) {
+		remains = full_size;
+	}
+
+	memcpy(ptr, ut->buf + ut->pos, remains);
+	ut->pos += remains;
+
+	return remains;	
+}
+
+static void uwsgi_alarm_curl_loop(struct uwsgi_thread *ut) {
+	int interesting_fd;
+	ut->buf = uwsgi_malloc(uwsgi.log_master_bufsize);
+
+	CURL *curl = curl_easy_init();
+	// ARGH !!!
+	if (!curl) return;
+
+	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+	curl_easy_setopt(curl, CURLOPT_TIMEOUT, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+	curl_easy_setopt(curl, CURLOPT_READFUNCTION, uwsgi_alarm_curl_read_callback);
+	curl_easy_setopt(curl, CURLOPT_READDATA, ut);
+	curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
+	curl_easy_setopt(curl, CURLOPT_POST, 1L);
+	struct curl_slist *expect = NULL; expect = curl_slist_append(expect, "Expect:");
+	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, expect);
+
+	struct uwsgi_alarm_curl_config *uacc = (struct uwsgi_alarm_curl_config *) ut->data;
+	char *opts = uwsgi_str(uacc->arg);
+
+	// fill curl options
+	char *ctx = NULL;
+	char *p = strtok_r(opts, ";", &ctx);
+	while(p) {
+		uwsgi_alarm_curl_setopt(curl, uwsgi_str(p), uacc);
+		p = strtok_r(NULL, ";", &ctx);
+	}
+
+	for(;;) {
+		int ret = event_queue_wait(ut->queue, -1, &interesting_fd);	
+		if (ret <= 0) continue;
+		if (interesting_fd != ut->pipe[1]) continue;
+		ssize_t rlen = read(ut->pipe[1], ut->buf, uwsgi.log_master_bufsize);
+		if (rlen <= 0) continue;
+		ut->pos = 0;
+		ut->len = (size_t) rlen;
+		ut->custom0 = 0;
+		curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t) ut->len);
+		CURLcode res = curl_easy_perform(curl);
+		if (res != CURLE_OK) {
+			uwsgi_log_alarm("-curl] curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
+		}
+		
+	}
+}
+
+static void uwsgi_alarm_curl_init(struct uwsgi_alarm_instance *uai) {
+	struct uwsgi_thread *ut = uwsgi_thread_new(uwsgi_alarm_curl_loop);
+	if (!ut) return;
+	uai->data_ptr = ut;
+	struct uwsgi_alarm_curl_config *uacc = uwsgi_calloc(sizeof(struct uwsgi_alarm_curl_config));
+	uacc->arg = uai->arg;
+	ut->data = uacc;
+}
+
+// pipe the message into the thread;
+static void uwsgi_alarm_curl_func(struct uwsgi_alarm_instance *uai, char *msg, size_t len) {
+	struct uwsgi_thread *ut = (struct uwsgi_thread *) uai->data_ptr;
+	ut->rlen = write(ut->pipe[0], msg, len);
+}
+
+static void uwsgi_alarm_curl_load(void) {
+	uwsgi_register_alarm("curl", uwsgi_alarm_curl_init, uwsgi_alarm_curl_func);
+}
+
+struct uwsgi_plugin alarm_curl_plugin = {
+	.name = "alarm_curl",
+	.on_load = uwsgi_alarm_curl_load,
+};

plugins/alarm_curl/uwsgiplugin.py

@@ -0,0 +1,6 @@
+NAME='alarm_curl'
+
+CFLAGS = []
+LDFLAGS = []
+LIBS = ['-lcurl']
+GCC_LIST = ['alarm_curl_plugin']

plugins/alarm_xmpp/alarm_xmpp_plugin.c

@@ -0,0 +1,26 @@
+#include "../../uwsgi.h"
+
+void uwsgi_alarm_xmpp_loop(struct uwsgi_thread *);
+
+static void uwsgi_alarm_xmpp_init(struct uwsgi_alarm_instance *uai) {
+
+	struct uwsgi_thread *ut = uwsgi_thread_new(uwsgi_alarm_xmpp_loop);
+	if (!ut) return;
+	uai->data_ptr = ut;
+	ut->data = uai->arg;
+}
+
+// pipe the message into the thread;
+static void uwsgi_alarm_xmpp_func(struct uwsgi_alarm_instance *uai, char *msg, size_t len) {
+	struct uwsgi_thread *ut = (struct uwsgi_thread *) uai->data_ptr;
+	ut->rlen = write(ut->pipe[0], msg, len);
+}
+
+static void uwsgi_alarm_xmpp_load(void) {
+	uwsgi_register_alarm("xmpp", uwsgi_alarm_xmpp_init, uwsgi_alarm_xmpp_func);
+}
+
+struct uwsgi_plugin alarm_xmpp_plugin = {
+	.name = "alarm_xmpp",
+	.on_load = uwsgi_alarm_xmpp_load,
+};

plugins/alarm_xmpp/gloox.cc

@@ -0,0 +1,139 @@
+#include "../../uwsgi.h"
+#include <gloox/client.h>
+#include <gloox/message.h>
+#include <gloox/connectionlistener.h>
+#include <gloox/connectiontcpclient.h>
+
+extern struct uwsgi_server uwsgi;
+
+using namespace gloox;
+
+class Jabbo : public ConnectionListener{
+
+	public:
+
+	Jabbo(struct uwsgi_thread *ut, char *jab_username, char *jab_password, char *dests) {
+
+		u_thread = ut;
+		dest = NULL;
+
+		char *ctx = NULL;
+		char *p = strtok_r(dests, ",", &ctx);
+		while(p) {
+			uwsgi_string_new_list(&dest, p);
+			p = strtok_r(NULL, ",", &ctx);
+		}
+
+        	JID jid(jab_username);
+        	client = new Client( jid, jab_password );
+        	client->registerConnectionListener(this);
+		u_connected = 0;
+        	client->connect(false);
+        	fd = static_cast<ConnectionTCPClient*>( client->connectionImpl() )->socket();
+	}
+
+	~Jabbo() {
+        	delete client;
+	}
+
+	void send(char *buf, size_t len) {
+		struct uwsgi_string_list *usl = dest;
+		while(usl) {
+			JID jid(usl->value);
+			std::string text(buf, len);
+			Message msg(Message::Chat, jid, text);
+			client->send(msg);
+			usl = usl->next;
+		}
+	}
+
+	virtual void onConnect() {
+		event_queue_add_fd_read(u_thread->queue, fd);
+		u_connected = 1;
+    	}
+
+    	virtual void onDisconnect(ConnectionError e) {
+		if (fd >= 0) {
+			event_queue_del_fd(u_thread->queue, fd, event_queue_read());
+		}
+        	sleep(1);
+		u_connected = 0;
+        	client->connect(false);
+        	fd = static_cast<ConnectionTCPClient*>( client->connectionImpl() )->socket();
+    	}
+
+	virtual bool onTLSConnect(const CertInfo& info) {
+		return true;
+	}
+
+	Client* client;
+	int fd;
+	int u_connected;
+	struct uwsgi_thread *u_thread;
+	struct uwsgi_string_list *dest;
+};
+
+
+extern "C" void uwsgi_alarm_xmpp_loop(struct uwsgi_thread *ut) {
+
+        int interesting_fd;
+
+        ut->buf = (char *) uwsgi_malloc(uwsgi.log_master_bufsize);
+
+	char *xmpp_username = (char *) "";
+	char *xmpp_password = (char *) "";
+	char *xmpp_dests = (char *) "";
+
+        // 0 -> username, 1 -> password, 2-> dest list
+        int opt_state = 0;
+        // fill xmpp options
+        char *ctx = NULL;
+        char *opts = uwsgi_str((char *)ut->data);
+        char *p = strtok_r(opts, ";", &ctx);
+        while(p) {
+                switch(opt_state) {
+                        case 0:
+                                xmpp_username = p;
+                                opt_state = 1;
+                                break;
+                        case 1:
+                                xmpp_password = p;
+                                opt_state = 2;
+                                break;
+                        case 2:
+                                xmpp_dests = p;
+                                opt_state = 3;
+                                break;
+                        default:
+                                break;
+                }
+                p = strtok_r(NULL, ";", &ctx);
+        }
+
+	Jabbo j(ut, xmpp_username, xmpp_password, xmpp_dests);	
+
+	int timeout = 0;
+
+        for(;;) {
+		if (j.u_connected) {
+			timeout = -1;
+		}
+		else {
+			timeout = 0;
+		}
+                int ret = event_queue_wait(ut->queue, timeout, &interesting_fd);           
+                if (ret < 0) continue;
+
+                if (ret > 0 && interesting_fd == ut->pipe[1]) {
+                        ssize_t rlen = read(ut->pipe[1], ut->buf, uwsgi.log_master_bufsize);
+                        if (rlen <= 0) continue;
+			if (j.u_connected) {
+				j.send(ut->buf, rlen);
+			}
+                }
+		else if (ret == 0 || (ret > 0 && j.fd > -1 && interesting_fd == j.fd)) {
+			j.client->recv();
+		}
+        }
+}
+

plugins/alarm_xmpp/uwsgiplugin.py

@@ -0,0 +1,6 @@
+NAME='alarm_xmpp'
+
+CFLAGS = []
+LDFLAGS = []
+LIBS = ['-lgloox']
+GCC_LIST = ['alarm_xmpp_plugin', 'gloox.cc']

plugins/php/php_plugin.c

@@ -208,7 +208,7 @@ static int sapi_uwsgi_send_headers(sapi_headers_struct *sapi_headers)
 static int sapi_uwsgi_read_post(char *buffer, uint count_bytes TSRMLS_DC)
 {
 	uint read_bytes = 0;
-	size_t len;
+	ssize_t len;
 	int fd = -1;
 	
 	struct wsgi_request *wsgi_req = (struct wsgi_request *) SG(server_context);

plugins/python/uwsgi_pymodule.c

@@ -10,7 +10,7 @@ PyObject *py_uwsgi_signal_wait(PyObject * self, PyObject * args) {
         struct wsgi_request *wsgi_req = current_wsgi_req();
 	int wait_for_specific_signal = 0;
 	uint8_t uwsgi_signal = 0;
-	uint8_t received_signal;
+	int received_signal;
 
 	wsgi_req->signal_received = -1;
 
@@ -30,6 +30,11 @@ PyObject *py_uwsgi_signal_wait(PyObject * self, PyObject * args) {
 		received_signal = uwsgi_signal_wait(-1);
 	}
 
+	if (received_signal < 0) {
+		UWSGI_GET_GIL;
+		return PyErr_Format(PyExc_SystemError, "error waiting for signal");
+	}
+
         wsgi_req->signal_received = received_signal;
 
 	UWSGI_GET_GIL;

plugins/rack/rack_api.c

@@ -488,6 +488,7 @@ VALUE rack_uwsgi_add_file_monitor(VALUE *class, VALUE rbsignum, VALUE rbfilename
 }
 
 
+#ifdef UWSGI_ASYNC
 VALUE uwsgi_ruby_wait_fd_read(VALUE *class, VALUE arg1, VALUE arg2) {
 
 	Check_Type(arg1, T_FIXNUM);
@@ -522,6 +523,7 @@ VALUE uwsgi_ruby_wait_fd_write(VALUE *class, VALUE arg1, VALUE arg2) {
 
         return Qtrue;
 }
+#endif
 
 
 
@@ -535,6 +537,7 @@ VALUE uwsgi_ruby_async_connect(VALUE *class, VALUE arg) {
 }
 
 
+#ifdef UWSGI_ASYNC
 VALUE uwsgi_ruby_async_sleep(VALUE *class, VALUE arg) {
 
 	Check_Type(arg, T_FIXNUM);
@@ -548,6 +551,7 @@ VALUE uwsgi_ruby_async_sleep(VALUE *class, VALUE arg) {
 
         return Qtrue;
 }
+#endif
 
 VALUE uwsgi_ruby_masterpid(VALUE *class) {
 
@@ -573,7 +577,7 @@ VALUE uwsgi_ruby_signal_wait(int argc, VALUE *argv, VALUE *class) {
         struct wsgi_request *wsgi_req = current_wsgi_req();
         int wait_for_specific_signal = 0;
         uint8_t uwsgi_signal = 0;
-        uint8_t received_signal;
+        int received_signal;
 
         wsgi_req->signal_received = -1;
 
@@ -590,7 +594,12 @@ VALUE uwsgi_ruby_signal_wait(int argc, VALUE *argv, VALUE *class) {
                 received_signal = uwsgi_signal_wait(-1);
         }
 
-        wsgi_req->signal_received = received_signal;
+	if (received_signal < 0) {
+		rb_raise(rb_eRuntimeError, "unable to call rpc function");
+	}
+	else {
+        	wsgi_req->signal_received = received_signal;
+	}
 
         return Qnil;
 }
@@ -868,9 +877,11 @@ void uwsgi_rack_init_api() {
 	VALUE rb_uwsgi_embedded = rb_define_module("UWSGI");
         uwsgi_rack_api("suspend", uwsgi_ruby_suspend, 0);
         uwsgi_rack_api("masterpid", uwsgi_ruby_masterpid, 0);
+#ifdef UWSGI_ASYNC
         uwsgi_rack_api("async_sleep", uwsgi_ruby_async_sleep, 1);
         uwsgi_rack_api("wait_fd_read", uwsgi_ruby_wait_fd_read, 2);
         uwsgi_rack_api("wait_fd_write", uwsgi_ruby_wait_fd_write, 2);
+#endif
         uwsgi_rack_api("async_connect", uwsgi_ruby_async_connect, 1);
         uwsgi_rack_api("signal", uwsgi_ruby_signal, -1);
         uwsgi_rack_api("register_signal", uwsgi_ruby_register_signal, 3);

plugins/rack/rack_plugin.c

@@ -29,7 +29,6 @@ struct uwsgi_option uwsgi_rack_options[] = {
         {"rb-threads", required_argument, 0, "set the number of ruby threads to run", uwsgi_opt_set_int, &ur.rb_threads, 0},
         {"rbthreads", required_argument, 0, "set the number of ruby threads to run", uwsgi_opt_set_int, &ur.rb_threads, 0},
         {"ruby-threads", required_argument, 0, "set the number of ruby threads to run", uwsgi_opt_set_int, &ur.rb_threads, 0},
-	{"rb-patch-rack-bodyproxy", no_argument, 0, "some specific (old) combos of ruby 1.9+rack could require that hack...", uwsgi_opt_true, &ur.patch_bodyproxy, 0},
 #endif
 
         {0, 0, 0, 0, 0, 0 ,0},
@@ -129,7 +128,7 @@ VALUE rb_uwsgi_io_read(VALUE obj, VALUE args) {
 	struct wsgi_request *wsgi_req;
 	Data_Get_Struct(obj, struct wsgi_request, wsgi_req);
 	VALUE chunk;
-	unsigned int chunk_size;
+	long chunk_size;
 
 /*
 	When EOF is reached, this method returns nil if length is given and not nil, or "" if length is not given or is nil.
@@ -154,7 +153,16 @@ VALUE rb_uwsgi_io_read(VALUE obj, VALUE args) {
 		}
 		// size specified
 		else if (RARRAY_LEN(args) > 0) {
-			chunk_size = NUM2UINT(RARRAY_PTR(args)[0]);
+			if (RARRAY_PTR(args)[0] == Qnil) {
+				chunk_size = wsgi_req->post_cl;
+			}
+			else {
+				chunk_size = NUM2LONG(RARRAY_PTR(args)[0]);
+				// hack to tolerate broken middlewares
+				if (chunk_size <= 0) {
+					chunk_size = wsgi_req->post_cl;
+				}
+			}
 			char *tmp_chunk = uwsgi_malloc(chunk_size);
 			size_t rlen = fread(tmp_chunk, 1, chunk_size, (FILE *) wsgi_req->async_post);
 			// error, return Qnil
@@ -165,8 +173,6 @@ VALUE rb_uwsgi_io_read(VALUE obj, VALUE args) {
 			// push in the specified buffer
 			if (RARRAY_LEN(args) > 1) {
                         	rb_str_cat(RARRAY_PTR(args)[1], tmp_chunk, rlen);
-				free(tmp_chunk);
-                        	return RARRAY_PTR(args)[1];
 			}
 			// return a new string
 			chunk = rb_str_new(tmp_chunk, rlen);
@@ -197,14 +203,21 @@ VALUE rb_uwsgi_io_read(VALUE obj, VALUE args) {
 		return chunk;
 	}
 	else if (RARRAY_LEN(args) > 0) {
-		chunk_size = NUM2UINT(RARRAY_PTR(args)[0]);
+		if (RARRAY_PTR(args)[0] == Qnil) {
+			chunk_size = wsgi_req->post_cl;
+		}
+		else {
+			chunk_size = NUM2LONG(RARRAY_PTR(args)[0]);
+			// hack to tolerate broken middlewares
+			if (chunk_size <= 0) {
+				chunk_size = wsgi_req->post_cl;
+			}
+		}
 		if (wsgi_req->buf_pos+chunk_size > wsgi_req->post_cl) {
 			chunk_size = wsgi_req->post_cl-wsgi_req->buf_pos;
 		}
 		if (RARRAY_LEN(args) > 1) {
 			rb_str_cat(RARRAY_PTR(args)[1], wsgi_req->post_buffering_buf+wsgi_req->buf_pos, chunk_size);
-			wsgi_req->buf_pos+=chunk_size;
-			return RARRAY_PTR(args)[1];
 		}
 		chunk = rb_str_new(wsgi_req->post_buffering_buf+wsgi_req->buf_pos, chunk_size);
 		wsgi_req->buf_pos+=chunk_size;
@@ -975,44 +988,6 @@ void uwsgi_rack_resume(struct wsgi_request *wsgi_req) {
 	uwsgi_log("RESUMING RUBY\n");
 }
 
-#ifdef RUBY19
-VALUE uwsgi_call_block(VALUE body, VALUE block) {
-
-	return rb_funcall(block, rb_intern("call"), 1, body );
-}
-
-VALUE uwsgi_rack_patch_body_proxy_each(int argc, VALUE *argv, VALUE self) {
-
-	VALUE block = Qnil;
-	rb_scan_args(argc, argv, "0&", &block);
-
-	if(!RTEST(block)) {
-		rb_raise(rb_eArgError, "a block is required");
-		return Qnil;
-	}
-
-	VALUE original_body = rb_iv_get(self, "@body");
-	if (original_body != Qnil) {
-		return rb_block_call(original_body, rb_intern("each"), 0, 0, uwsgi_call_block, block);
-	}
-
-	return Qnil;
-}
-
-VALUE uwsgi_rack_patch_body_proxy(VALUE foo) {
-
-	VALUE rack = rb_const_get(rb_cObject, rb_intern("Rack"));
-	VALUE rack_body_proxy = rb_const_get(rack, rb_intern("BodyProxy"));	
-
-	if (!rb_respond_to(rack_body_proxy, rb_intern("each"))) {
-		rb_define_method(rack_body_proxy, "each", uwsgi_rack_patch_body_proxy_each, -1);
-		return Qtrue;
-	}
-
-	return Qnil;
-}
-#endif
-
 VALUE init_rack_app( VALUE script ) {
 
 	int error;
@@ -1029,11 +1004,10 @@ VALUE init_rack_app( VALUE script ) {
         VALUE rack = rb_const_get(rb_cObject, rb_intern("Rack"));
 
 #ifdef RUBY19
-	if (ur.patch_bodyproxy) {
-		VALUE ret = rb_protect(uwsgi_rack_patch_body_proxy, rack, &error);
-		if (!error && ret != Qnil) {
+	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/uwsgi_rack.h

@@ -72,9 +72,6 @@ struct uwsgi_rack {
 	char *gemset;
 
 	int rb_threads;
-#ifdef RUBY19
-	int patch_bodyproxy;
-#endif
 
 };
 

uwsgi.h

@@ -15,6 +15,9 @@ extern "C" {
 #define uwsgi_log_safe(x)  if (uwsgi.original_log_fd != 2) dup2(uwsgi.original_log_fd, 2) ; uwsgi_log(x);
 #define uwsgi_error_safe(x)  if (uwsgi.original_log_fd != 2) dup2(uwsgi.original_log_fd, 2) ; uwsgi_log("%s: %s [%s line %d]\n", x, strerror(errno), __FILE__, __LINE__);
 #define uwsgi_log_initial if (!uwsgi.no_initial_output) uwsgi_log
+#ifdef UWSGI_ALARM
+#define uwsgi_log_alarm(x, ...) uwsgi_log("[uwsgi-alarm" x, __VA_ARGS__)
+#endif
 #define uwsgi_fatal_error(x) uwsgi_error(x); exit(1);
 #define uwsgi_error_open(x)  uwsgi_log("open(\"%s\"): %s [%s line %d]\n", x, strerror(errno), __FILE__, __LINE__);
 #define uwsgi_req_error(x)  if (wsgi_req->uri_len > 0 && wsgi_req->method_len > 0 && wsgi_req->remote_addr_len > 0) uwsgi_log_verbose("%s: %s [%s line %d] during %.*s %.*s (%.*s)\n", x, strerror(errno), __FILE__, __LINE__,\
@@ -838,6 +841,46 @@ struct uwsgi_router {
 
 #endif
 
+#ifdef UWSGI_ALARM
+struct uwsgi_alarm;
+struct uwsgi_alarm_instance {
+	char *name;
+	char *arg;
+	void *data_ptr;
+	uint8_t data8;
+	uint16_t data16;
+	uint32_t data32;
+	uint64_t data64;
+
+	time_t last_run;
+
+	char *last_msg;
+	size_t last_msg_size;
+
+	struct uwsgi_alarm *alarm;
+	struct uwsgi_alarm_instance *next;
+};
+
+struct uwsgi_alarm {
+	char *name;
+	void (*init)(struct uwsgi_alarm_instance *);
+	void (*func)(struct uwsgi_alarm_instance *, char *, size_t);
+	struct uwsgi_alarm *next;
+};
+
+struct uwsgi_alarm_ll {
+	struct uwsgi_alarm_instance *alarm;
+	struct uwsgi_alarm_ll *next;
+};
+
+struct uwsgi_alarm_log {
+	pcre *pattern;
+        pcre_extra *pattern_extra;
+	struct uwsgi_alarm_ll *alarms;
+	struct uwsgi_alarm_log *next;
+};
+#endif
+
 struct __attribute__ ((packed)) uwsgi_header {
 	uint8_t modifier1;
 	uint16_t pktsize;
@@ -1282,6 +1325,9 @@ struct uwsgi_server {
 	int loggers_list;
 	int loop_list;
 	int clock_list;
+#ifdef UWSGI_ALARM
+	int alarms_list;
+#endif
 
 	struct wsgi_request *wsgi_req;
 
@@ -1399,6 +1445,15 @@ struct uwsgi_server {
 	struct uwsgi_regexp_list *log_drain_rules;
 #endif
 
+#ifdef UWSGI_ALARM
+	int alarm_freq;
+	struct uwsgi_string_list *alarm_list;
+	struct uwsgi_string_list *alarm_logs_list;
+	struct uwsgi_alarm *alarms;
+	struct uwsgi_alarm_instance *alarm_instances;
+	struct uwsgi_alarm_log *alarm_logs;
+#endif
+
 	int threaded_logger;
 	pthread_mutex_t threaded_logger_lock;
 
@@ -1493,6 +1548,7 @@ struct uwsgi_server {
 #endif
 
 #ifdef UWSGI_MULTICAST
+	int multicast_ttl;
 	char *multicast_group;
 #endif
 
@@ -2830,7 +2886,7 @@ struct uwsgi_subscribe_node *uwsgi_add_subscribe_node(struct uwsgi_subscribe_slo
 
 ssize_t uwsgi_mule_get_msg(int, int, char *, size_t, int);
 
-uint8_t uwsgi_signal_wait(int);
+int uwsgi_signal_wait(int);
 struct uwsgi_app *uwsgi_add_app(int, uint8_t, char *, int, void *, void *);
 int uwsgi_signal_send(int, uint8_t);
 int uwsgi_remote_signal_send(char *, uint8_t); 
@@ -3247,6 +3303,32 @@ void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *, char *, char *, tim
 char *uwsgi_elf_section(char *, char *, size_t *);
 #endif
 
+#ifdef UWSGI_ALARM
+void uwsgi_alarm_log_check(char *, size_t);
+void uwsgi_alarm_run(struct uwsgi_alarm_instance *, char *, size_t);
+void uwsgi_alarm_log_run(struct uwsgi_alarm_log *, char *, size_t);
+void uwsgi_register_alarm(char *, void (*)(struct uwsgi_alarm_instance *), void (*)(struct uwsgi_alarm_instance *, char *, size_t));
+void uwsgi_register_embedded_alarms();
+void uwsgi_alarms_init();
+#endif
+
+struct uwsgi_thread {
+	pthread_t tid;
+	int pipe[2];
+	int queue;
+	ssize_t rlen;
+	void *data;
+	char *buf;
+	off_t pos;
+	size_t len;
+	uint64_t custom0;
+	uint64_t custom1;
+	uint64_t custom2;
+	uint64_t custom3;
+	void (*func)(struct uwsgi_thread *);
+};
+struct uwsgi_thread *uwsgi_thread_new(void (*)(struct uwsgi_thread *));
+
 void uwsgi_check_emperor(void);
 #ifdef UWSGI_AS_SHARED_LIBRARY
 int uwsgi_init(int, char **, char **);

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '1.3-rc4'
+uwsgi_version = '1.3'
 
 import os
 import re
@@ -42,6 +42,7 @@ report['filemonitor'] = False
 report['udp'] = False
 report['pcre'] = False
 report['routing'] = False
+report['alarm'] = False
 report['capabilities'] = False
 report['async'] = False
 report['minterpreters'] = False
@@ -725,7 +726,7 @@ class uConf(object):
             report['pcre'] = True
 
         if self.get('routing'):
-            if self.get('pcre') == 'auto':
+            if self.get('routing') == 'auto':
                 if has_pcre:
                     self.gcc_list.append('core/routing')
                     self.cflags.append("-DUWSGI_ROUTING") 
@@ -735,6 +736,17 @@ class uConf(object):
                 self.cflags.append("-DUWSGI_ROUTING")
                 report['routing'] = True
 
+        if self.get('alarm'):
+            if self.get('alarm') == 'auto':
+                if has_pcre:
+                    self.gcc_list.append('core/alarm')
+                    self.cflags.append("-DUWSGI_ALARM") 
+                    report['alarm'] = True
+            else:
+                self.gcc_list.append('core/alarm')
+                self.cflags.append("-DUWSGI_ALARM")
+                report['alarm'] = True
+
 
         if self.has_include('sys/capability.h') and uwsgi_os == 'Linux':
             self.cflags.append("-DUWSGI_CAP")
@@ -1190,6 +1202,8 @@ if __name__ == "__main__":
         os.system("rm -f lib/*.o")
         os.system("rm -f plugins/*/*.o")
         os.system("rm -f build/*.o")
+    elif cmd == '--check':
+        os.system("cppcheck --max-configs=1000 --enable=all -q core/ plugins/ proto/ lib/ apache2/")
 
     else:
         print("unknown uwsgiconfig command")