fixed signal copy on write

allow connecting to carbon server using hostname resolved on every cycle...

buildconf/base.ini

@@ -1,18 +1,13 @@
 [uwsgi]
 xml = auto
-ini = true
 yaml = true
 json = auto
 sqlite3 = auto
 zeromq = auto
-snmp = true
 ssl = auto
-async = true
 ldap = auto
 pcre = auto
 routing = auto
-alarm = auto
-ipv6 = false
 debug = false
 unbit = false
 xml_implementation = libxml2

buildconf/ppa.ini

@@ -0,0 +1,34 @@
+[uwsgi]
+xml = true
+yaml = true
+json = true
+sqlite3 = true
+zeromq = true
+ssl = true
+ldap = true
+pcre = true
+routing = true
+debug = false
+unbit = false
+xml_implementation = libxml2
+yaml_implementation = libyaml
+malloc_implementation = libc
+extras =
+plugins =
+bin_name = /usr/lib/libuwsgi.so
+append_version = ubuntu
+plugin_dir = /usr/lib/uwsgi
+embedded_plugins =
+as_shared_library = true
+
+locking = auto
+event = auto
+timer = auto
+filemonitor = auto
+
+blacklist =
+whitelist =
+
+embed_files =
+
+embed_config =

buildconf/pyring.ini

@@ -0,0 +1,6 @@
+[uwsgi]
+main_plugin = python,gevent
+inherit = base
+plugins = jvm,ring
+plugin_dir = .
+

buildconf/unbit.ini

@@ -1,26 +1,34 @@
 [uwsgi]
 xml = true
-ini = true
 yaml = true
 json = false
 sqlite3 = false
 zeromq = false
-ldap = true
+ssl = true
+ldap = false
 pcre = true
 routing = true
-alarm = true
 debug = false
 unbit = true
 xml_implementation = expat
 yaml_implementation = auto
 malloc_implementation = libc
+extras =
 plugins =
-bin_name = /opt/unbit/bin/uwsgi
+bin_name = /opt/unbit/uwsgi19/lib/libuwsgi.so
 append_version = unbit
-plugin_dir = /opt/unbit/uwsgi_plugins
+plugin_dir = /opt/unbit/uwsgi19/plugins
 embedded_plugins =
+as_shared_library = true
 
 locking = auto
 event = auto
 timer = auto
 filemonitor = auto
+
+blacklist =
+whitelist =
+
+embed_files =
+
+embed_config =

buildconf/unbitstaff.ini

@@ -1,6 +1,5 @@
 [uwsgi]
 inherit = unbit
-json = false
 embedded_plugins = python
 bin_name = ../bin/uwsgi
 plugin_dir = ../bin/uwsgi_plugins

contrib/cryptologger.rb

@@ -0,0 +1,24 @@
+require 'socket'
+require 'openssl'
+
+secret = 'ciaociao'
+iv = ''
+address = '127.0.0.1'
+port  = 1717
+algo = 'bf-cbc'
+
+s = UDPSocket.new
+s.bind(address, port)
+cipher = OpenSSL::Cipher.new(algo)
+cipher.decrypt
+cipher.key = secret + ("\0" * (cipher.key_len - secret.length))
+cipher.iv = iv + ("0" * (cipher.iv_len - iv.length))
+
+loop do
+  msg, sender = s.recvfrom(8192)
+  cipher.reset
+  begin
+    puts cipher.update(msg) + cipher.final
+  rescue
+  end
+end

core/emperor.c

@@ -135,6 +135,77 @@ int uwsgi_emperor_is_valid(char *name) {
 	return 0;
 }
 
+static char *emperor_check_on_demand_socket(char *filename) {
+	size_t len = 0;
+	if (uwsgi.emperor_on_demand_extension) {
+		char *tmp = uwsgi_concat2(filename, uwsgi.emperor_on_demand_extension);
+		int fd = open(tmp, O_RDONLY);
+		free(tmp);
+		if (fd < 0) return NULL;
+		char *ret = uwsgi_read_fd(fd, &len, 1);
+		close(fd);
+		// change the first non prinabel character to 0
+		size_t i;
+		for(i=0;i<len;i++) {
+			if (ret[i] < 32) {
+				ret[i] = 0;
+				break;
+			}
+		}
+		if (ret[0] == 0) {
+			free(ret);
+			return NULL;
+		}
+		return ret;
+	}
+	else if (uwsgi.emperor_on_demand_directory) {
+		// we need to build the socket path automagically
+		char *start_of_vassal_name = uwsgi_get_last_char(filename, '/');
+		if (!start_of_vassal_name) {
+			start_of_vassal_name = filename;
+		}
+		else {
+			start_of_vassal_name++;
+		}
+		char *last_dot = uwsgi_get_last_char(filename, '.');
+		if (!last_dot) return NULL;
+
+		return uwsgi_concat4n(uwsgi.emperor_on_demand_directory, strlen(uwsgi.emperor_on_demand_directory), "/", 1, start_of_vassal_name, last_dot - start_of_vassal_name, ".socket", 7);
+	}
+	else if (uwsgi.emperor_on_demand_exec) {
+		int cpipe[2];
+                if (pipe(cpipe)) {
+                        uwsgi_error("emperor_check_on_demand_socket()pipe()");
+			return NULL;
+                }
+		char *cmd = uwsgi_concat4(uwsgi.emperor_on_demand_exec, " \"", filename, "\"");
+                int r = uwsgi_run_command(cmd, NULL, cpipe[1]);
+		free(cmd);
+		if (r < 0) {
+                	close(cpipe[0]);
+                	close(cpipe[1]);
+			return NULL;
+		}
+                char *ret = uwsgi_read_fd(cpipe[0], &len, 1);
+                close(cpipe[0]);
+                close(cpipe[1]);
+		// change the first non prinabel character to 0
+                size_t i;
+                for(i=0;i<len;i++) {
+                        if (ret[i] < 32) {
+                                ret[i] = 0;
+                                break;
+                        }
+                }
+		if (ret[0] == 0) {
+			free(ret);
+			return NULL;
+		}
+		return ret;
+	}
+	return NULL;
+}
+
 // this is the monitor for non-glob directories
 void uwsgi_imperial_monitor_directory(struct uwsgi_emperor_scanner *ues) {
 	struct uwsgi_instance *ui_current;
@@ -175,7 +246,9 @@ void uwsgi_imperial_monitor_directory(struct uwsgi_emperor_scanner *ues) {
 			}
 		}
 		else {
-			emperor_add(ues, de->d_name, st.st_mtime, NULL, 0, st.st_uid, st.st_gid);
+			char *socket_name = emperor_check_on_demand_socket(de->d_name);
+			emperor_add(ues, de->d_name, st.st_mtime, NULL, 0, st.st_uid, st.st_gid, socket_name);
+			if (socket_name) free(socket_name);
 		}
 	}
 	closedir(dir);
@@ -250,7 +323,9 @@ void uwsgi_imperial_monitor_glob(struct uwsgi_emperor_scanner *ues) {
 			}
 		}
 		else {
-			emperor_add(ues, g.gl_pathv[i], st.st_mtime, NULL, 0, st.st_uid, st.st_gid);
+			char *socket_name = emperor_check_on_demand_socket(g.gl_pathv[i]);
+			emperor_add(ues, g.gl_pathv[i], st.st_mtime, NULL, 0, st.st_uid, st.st_gid, socket_name);
+			if (socket_name) free(socket_name);
 		}
 
 	}
@@ -377,6 +452,22 @@ struct uwsgi_instance *emperor_get_by_fd(int fd) {
 	return NULL;
 }
 
+struct uwsgi_instance *emperor_get_by_socket_fd(int fd) {
+
+        struct uwsgi_instance *c_ui = ui;
+
+        while (c_ui->ui_next) {
+                c_ui = c_ui->ui_next;
+
+		// over engineering...
+                if (c_ui->on_demand_fd != -1 && c_ui->on_demand_fd == fd) {
+                        return c_ui;
+                }
+        }
+        return NULL;
+}
+
+
 
 struct uwsgi_instance *emperor_get(char *name) {
 
@@ -430,6 +521,10 @@ void emperor_del(struct uwsgi_instance *c_ui) {
 		uwsgi.emperor_broodlord_count--;
 	}
 
+	if (c_ui->socket_name) {
+		free(c_ui->socket_name);
+	}
+
 	free(c_ui);
 
 }
@@ -478,17 +573,10 @@ void emperor_respawn(struct uwsgi_instance *c_ui, time_t mod) {
 	uwsgi_log("[emperor] reload the uwsgi instance %s\n", c_ui->name);
 }
 
-void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, char *config, uint32_t config_size, uid_t uid, gid_t gid) {
+void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, char *config, uint32_t config_size, uid_t uid, gid_t gid, char *socket_name) {
 
 	struct uwsgi_instance *c_ui = ui;
 	struct uwsgi_instance *n_ui = NULL;
-	pid_t pid;
-	char **vassal_argv;
-	char *uef;
-	char **uenvs;
-	int counter;
-	char *colon = NULL;
-	int i;
 	struct timeval tv;
 
 #ifdef UWSGI_DEBUG
@@ -544,8 +632,7 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		c_ui = c_ui->ui_next;
 	}
 
-	n_ui = uwsgi_malloc(sizeof(struct uwsgi_instance));
-	memset(n_ui, 0, sizeof(struct uwsgi_instance));
+	n_ui = uwsgi_calloc(sizeof(struct uwsgi_instance));
 
 	if (config) {
 		n_ui->use_config = 1;
@@ -576,10 +663,60 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 
 	n_ui->first_run = uwsgi_now();
 	n_ui->last_run = n_ui->first_run;
+	n_ui->on_demand_fd = -1;
+	if (socket_name) {
+		n_ui->socket_name = uwsgi_str(socket_name);
+	}
+
+	n_ui->pid = -1;
+
+	// ok here we check if we need to bind to the specified socket or continue with the activation
+	if (socket_name) {
+		char *tcp_port = strchr(socket_name, ':');
+                if (tcp_port) {
+                        // disable deferred accept for this socket
+                        int current_defer_accept = uwsgi.no_defer_accept;
+                        uwsgi.no_defer_accept = 1;
+                        n_ui->on_demand_fd = bind_to_tcp(socket_name, uwsgi.listen_queue, tcp_port);
+                        uwsgi.no_defer_accept = current_defer_accept;
+                }
+                else {
+                        n_ui->on_demand_fd = bind_to_unix(socket_name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+                }
+
+		if (n_ui->on_demand_fd < 0) {
+			uwsgi_error("emperor_add()/bind()");
+			free(n_ui);
+			c_ui->ui_next = NULL;
+			return;
+		}
+
+                event_queue_add_fd_read(uwsgi.emperor_queue, n_ui->on_demand_fd);
+		uwsgi_log("[uwsgi-emperor] %s -> \"on demand\" instance detected, waiting for connections on socket \"%s\" ...\n", name, socket_name);
+		return;
+	}
+	
+	if (uwsgi_emperor_vassal_start(n_ui)) {
+		// clear the vassal
+		free(n_ui);
+		c_ui->ui_next = NULL;
+	}
+}
+
+
+int uwsgi_emperor_vassal_start(struct uwsgi_instance *n_ui) {
+
+	int i;
+	char *colon = NULL;
+	int counter;
+	char **uenvs;
+	char *uef;
+	char **vassal_argv;
+	pid_t pid;
 
 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, n_ui->pipe)) {
 		uwsgi_error("socketpair()");
-		goto clear;
+		return -1;
 	}
 
 	event_queue_add_fd_read(uwsgi.emperor_queue, n_ui->pipe[0]);
@@ -587,7 +724,7 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 	if (n_ui->use_config) {
 		if (socketpair(AF_UNIX, SOCK_STREAM, 0, n_ui->pipe_config)) {
 			uwsgi_error("socketpair()");
-			goto clear;
+			return -1;
 		}
 	}
 
@@ -606,6 +743,11 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		n_ui->pid = pid;
 		// close the right side of the pipe
 		close(n_ui->pipe[1]);
+		// close the "on demand" socket
+		if (n_ui->on_demand_fd > -1) {
+			close(n_ui->on_demand_fd);
+			n_ui->on_demand_fd = -1;
+		}
 		if (n_ui->use_config) {
 			close(n_ui->pipe_config[1]);
 		}
@@ -625,13 +767,13 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
                 	}
 
 		}
-		return;
+		return 0;
 	}
 	else {
 
 		if (uwsgi.emperor_tyrant) {
-			uwsgi_log("[emperor-tyrant] dropping privileges to %d %d for instance %s\n", (int) uid, (int) gid, name);
-			if (setgid(gid)) {
+			uwsgi_log("[emperor-tyrant] dropping privileges to %d %d for instance %s\n", (int) n_ui->uid, (int) n_ui->gid, n_ui->name);
+			if (setgid(n_ui->gid)) {
 				uwsgi_error("setgid()");
 				exit(1);
 			}
@@ -640,7 +782,7 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 				exit(1);
 			}
 
-			if (setuid(uid)) {
+			if (setuid(n_ui->uid)) {
 				uwsgi_error("setuid()");
 				exit(1);
 			}
@@ -720,7 +862,7 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		vassal_argv[0] = uwsgi.binary_path;
 
 		if (uwsgi.emperor_broodlord) {
-			colon = strchr(name, ':');
+			colon = strchr(n_ui->name, ':');
 			if (colon) {
 				colon[0] = 0;
 			}
@@ -728,17 +870,17 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		// initialize to a default value
 		vassal_argv[1] = "--inherit";
 
-		if (!strcmp(name + (strlen(name) - 4), ".xml"))
+		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 4), ".xml"))
 			vassal_argv[1] = "--xml";
-		if (!strcmp(name + (strlen(name) - 4), ".ini"))
+		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 4), ".ini"))
 			vassal_argv[1] = "--ini";
-		if (!strcmp(name + (strlen(name) - 4), ".yml"))
+		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 4), ".yml"))
 			vassal_argv[1] = "--yaml";
-		if (!strcmp(name + (strlen(name) - 5), ".yaml"))
+		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 5), ".yaml"))
 			vassal_argv[1] = "--yaml";
-		if (!strcmp(name + (strlen(name) - 3), ".js"))
+		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 3), ".js"))
 			vassal_argv[1] = "--json";
-		if (!strcmp(name + (strlen(name) - 5), ".json"))
+		if (!strcmp(n_ui->name + (strlen(n_ui->name) - 5), ".json"))
 			vassal_argv[1] = "--json";
 
 		if (colon) {
@@ -746,16 +888,16 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		}
 
 
-		vassal_argv[2] = name;
+		vassal_argv[2] = n_ui->name;
 		if (uwsgi.emperor_magic_exec) {
-			if (!access(name, R_OK | X_OK)) {
-				vassal_argv[2] = uwsgi_concat2("exec://", name);
+			if (!access(n_ui->name, R_OK | X_OK)) {
+				vassal_argv[2] = uwsgi_concat2("exec://", n_ui->name);
 			}
 
 		}
 
 		if (n_ui->use_config) {
-			vassal_argv[2] = uwsgi_concat2("emperor://", name);
+			vassal_argv[2] = uwsgi_concat2("emperor://", n_ui->name);
 		}
 
 		counter = 3;
@@ -768,18 +910,29 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		}
 		vassal_argv[counter] = NULL;
 
-		// disable stdin
-		int stdin_fd = open("/dev/null", O_RDONLY);
-		if (stdin_fd < 0) {
-			uwsgi_error_open("/dev/null");
-			exit(1);
+		// disable stdin OR map it to the "on demand" socket
+		if (n_ui->on_demand_fd > -1) {
+			if (n_ui->on_demand_fd != 0) {
+				if (dup2(n_ui->on_demand_fd, 0) < 0) {
+                                        uwsgi_error("dup2()");
+                                        exit(1);
+                                }
+                                close(n_ui->on_demand_fd);
+			}
 		}
-		if (stdin_fd != 0) {
-			if (dup2(stdin_fd, 0) < 0) {
-				uwsgi_error("dup2()");
+		else {
+			int stdin_fd = open("/dev/null", O_RDONLY);
+			if (stdin_fd < 0) {
+				uwsgi_error_open("/dev/null");
 				exit(1);
 			}
-			close(stdin_fd);
+			if (stdin_fd != 0) {
+				if (dup2(stdin_fd, 0) < 0) {
+					uwsgi_error("dup2()");
+					exit(1);
+				}
+				close(stdin_fd);
+			}
 		}
 
 		// close all of the unneded fd
@@ -813,11 +966,7 @@ void emperor_add(struct uwsgi_emperor_scanner *ues, char *name, time_t born, cha
 		exit(UWSGI_EXILE_CODE);
 	}
 
-clear:
-
-	free(n_ui);
-	c_ui->ui_next = NULL;
-
+	return -1;
 }
 
 void uwsgi_imperial_monitor_glob_init(struct uwsgi_emperor_scanner *ues) {
@@ -975,6 +1124,8 @@ void emperor_loop() {
 	char notification_message[64];
 	struct rlimit rl;
 
+	uwsgi.disable_nuclear_blast = 1;
+
 	uwsgi.emperor_stats_fd = -1;
 
 	if (uwsgi.emperor_pidfile) {
@@ -1087,14 +1238,24 @@ 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(ui_current->scanner, zerg_name, uwsgi_now(), NULL, 0, ui_current->uid, ui_current->gid);
+						// here we discard socket name as broodlord/zerg cannot be on demand
+						emperor_add(ui_current->scanner, zerg_name, uwsgi_now(), NULL, 0, ui_current->uid, ui_current->gid, NULL);
 						free(zerg_name);
 					}
 				}
 			}
 			else {
-				uwsgi_log("[emperor] unrecognized vassal event on fd %d\n", interesting_fd);
-				close(interesting_fd);
+				ui_current = emperor_get_by_socket_fd(interesting_fd);
+				if (ui_current) {
+					event_queue_del_fd(uwsgi.emperor_queue, ui_current->on_demand_fd, event_queue_read());
+					if (uwsgi_emperor_vassal_start(ui_current)) {
+						emperor_del(ui_current);
+					}
+				}
+				else {
+					uwsgi_log("[emperor] unrecognized vassal event on fd %d\n", interesting_fd);
+					close(interesting_fd);
+				}
 			}
 
 		}
@@ -1120,7 +1281,9 @@ void emperor_loop() {
 		has_children = 0;
 		while (ui_current->ui_next) {
 			ui_current = ui_current->ui_next;
-			has_children++;
+			if (ui_current->pid > -1) {
+				has_children++;
+			}
 		}
 
 		if (uwsgi.notify) {
@@ -1172,7 +1335,7 @@ void emperor_loop() {
 					}
 					else {
 						// UNSAFE
-						emperor_add(ui_current->scanner, ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len, ui_current->uid, ui_current->gid);
+						emperor_add(ui_current->scanner, ui_current->name, ui_current->last_mod, ui_current->config, ui_current->config_len, ui_current->uid, ui_current->gid, ui_current->socket_name);
 						emperor_del(ui_current);
 					}
 					break;
@@ -1266,7 +1429,7 @@ void emperor_send_stats(int fd) {
 		if (uwsgi_stats_keyval_comma(us, "id", c_ui->name))
 			goto end0;
 
-		if (uwsgi_stats_keylong_comma(us, "pid", (unsigned long long) c_ui->pid))
+		if (uwsgi_stats_keyslong_comma(us, "pid", (long long) c_ui->pid))
 			goto end0;
 		if (uwsgi_stats_keylong_comma(us, "born", (unsigned long long) c_ui->born))
 			goto end0;
@@ -1285,6 +1448,9 @@ void emperor_send_stats(int fd) {
 		if (uwsgi_stats_keylong_comma(us, "zerg", (unsigned long long) c_ui->zerg))
 			goto end0;
 
+		if (uwsgi_stats_keyval_comma(us, "on_demand", c_ui->socket_name ? c_ui->socket_name : ""))
+			goto end0;
+
 		if (uwsgi_stats_keylong_comma(us, "uid", (unsigned long long) c_ui->uid))
 			goto end0;
 		if (uwsgi_stats_keylong_comma(us, "gid", (unsigned long long) c_ui->gid))
@@ -1403,6 +1569,7 @@ void uwsgi_emperor_start() {
 	else {
 		uwsgi.emperor_pid = uwsgi_fork("uWSGI Emperor");
 	}
+
 	if (uwsgi.emperor_pid < 0) {
 		uwsgi_error("pid()");
 		exit(1);
@@ -1436,7 +1603,7 @@ void uwsgi_check_emperor() {
 
 }
 
-void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char *config, time_t ts, uid_t uid, gid_t gid) {
+void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char *config, time_t ts, uid_t uid, gid_t gid, char *socket_name) {
 
 	if (!uwsgi_emperor_is_valid(name))
 		return;
@@ -1473,6 +1640,6 @@ void uwsgi_emperor_simple_do(struct uwsgi_emperor_scanner *ues, char *name, char
 			new_config = uwsgi_str(config);
 			new_config_len = strlen(new_config);
 		}
-		emperor_add(ues, name, ts, new_config, new_config_len, uid, gid);
+		emperor_add(ues, name, ts, new_config, new_config_len, uid, gid, socket_name);
 	}
 }

core/ini.c

@@ -1,6 +1,4 @@
-#ifdef UWSGI_INI
-
-#include "uwsgi.h"
+#include <uwsgi.h>
 
 extern struct uwsgi_server uwsgi;
 
@@ -157,5 +155,3 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 
 
 }
-
-#endif

core/legion.c

@@ -81,6 +81,37 @@ void uwsgi_parse_legion(char *key, uint16_t keylen, char *value, uint16_t vallen
 	}
 }
 
+// this function is called when a node is added or removed (heavy locking is needed)
+static void legion_rebuild_scrolls(struct uwsgi_legion *ul) {
+	uint64_t max_size = ul->scrolls_max_size;
+
+	// first, try to add myself
+	if (ul->scroll_len + (uint64_t) 2 > max_size) {
+		uwsgi_log("[DANGER] you have configured a too much tiny buffer for the scrolls list !!! tune it with --legion-scroll-list-max-size\n");
+		ul->scroll_len = 0;
+		return;
+	}
+
+	char *ptr = ul->scrolls;
+	*ptr ++= (uint8_t) (ul->scroll_len & 0xff);
+	*ptr ++= (uint8_t) ((ul->scroll_len >> 8) &0xff);
+	memcpy(ptr, ul->scroll, ul->scroll_len); ptr += ul->scroll_len;
+	ul->scrolls_len = 2 + ul->scroll_len;
+	// ok start adding nodes;
+	struct uwsgi_legion_node *uln = ul->nodes_head;
+	while(uln) {
+		if (ul->scrolls_len + 2 + uln->scroll_len > max_size) {
+			uwsgi_log("[DANGER] you have configured a too much tiny buffer for the scrolls list !!! tune it with --legion-scroll-list-max-size\n");
+			return;
+		}
+		*ptr ++= (uint8_t) (uln->scroll_len & 0xff);
+        	*ptr ++= (uint8_t) ((uln->scroll_len >> 8) &0xff);
+        	memcpy(ptr, uln->scroll, uln->scroll_len); ptr += uln->scroll_len;
+        	ul->scrolls_len += 2 + uln->scroll_len;
+		uln = uln->next;
+	}
+}
+
 // critical section (remember to lock when you use it)
 struct uwsgi_legion_node *uwsgi_legion_add_node(struct uwsgi_legion *ul, uint16_t valor, char *name, uint16_t name_len, char *uuid) {
 
@@ -104,6 +135,7 @@ struct uwsgi_legion_node *uwsgi_legion_add_node(struct uwsgi_legion *ul, uint16_
 		ul->nodes_head = node;
 	}
 
+
 	return node;
 
 
@@ -141,6 +173,8 @@ void uwsgi_legion_remove_node(struct uwsgi_legion *ul, struct uwsgi_legion_node
 	}
 
 	free(node);
+
+	legion_rebuild_scrolls(ul);
 }
 
 struct uwsgi_legion_node *uwsgi_legion_get_node(struct uwsgi_legion *ul, uint64_t valor, char *name, uint16_t name_len, char *uuid) {
@@ -521,6 +555,8 @@ static void *legion_loop(void *foobar) {
 					node->scroll_len = legion_msg.scroll_len;
 					memcpy(node->scroll, legion_msg.scroll, node->scroll_len);
 				}
+				// we are still locked (and safe), let's rebuild the scrolls list
+				legion_rebuild_scrolls(ul);
 				uwsgi_rwunlock(ul->lock);
 				uwsgi_log("[uwsgi-legion] node: %.*s valor: %llu uuid: %.*s joined Legion %s\n", node->name_len, node->name, node->valor, 36, node->uuid, ul->legion);
 			}
@@ -937,8 +973,14 @@ void uwsgi_opt_legion(char *opt, char *value, void *foobar) {
 		uwsgi.legion_scroll_max_size = 4096;
 	}
 
+	if (!uwsgi.legion_scroll_list_max_size) {
+		uwsgi.legion_scroll_list_max_size = 32768;
+	}
+
 	ul->lord_scroll_size = uwsgi.legion_scroll_max_size;
 	ul->lord_scroll = uwsgi_calloc_shared(ul->lord_scroll_size);
+	ul->scrolls_max_size = uwsgi.legion_scroll_list_max_size;
+	ul->scrolls = uwsgi_calloc_shared(ul->scrolls_max_size);
 
 	uwsgi_legion_add(ul);
 }
@@ -1020,3 +1062,15 @@ char *uwsgi_legion_lord_scroll(char *name, uint16_t *rlen) {
 	uwsgi_rwunlock(legion->lock);
 	return buf;
 }
+
+char *uwsgi_legion_scrolls(char *name, uint64_t *rlen) {
+	char *buf = NULL;
+        struct uwsgi_legion *legion = uwsgi_legion_get_by_name(name);
+        if (!legion) return NULL;
+	uwsgi_rlock(legion->lock);
+	buf = uwsgi_malloc(legion->scrolls_len);
+	memcpy(buf, legion->scrolls, legion->scrolls_len);
+	*rlen = legion->scrolls_len;
+	uwsgi_rwunlock(legion->lock);
+	return buf;
+}

core/logging.c

@@ -642,12 +642,8 @@ void uwsgi_logit_simple(struct wsgi_request *wsgi_req) {
 	}
 
 	if (uwsgi.shared->options[UWSGI_OPTION_MEMORY_DEBUG] == 1) {
-#ifndef UNBIT
-		rlen = snprintf(mempkt, 4096, "{address space usage: %lld bytes/%lluMB} {rss usage: %llu bytes/%lluMB} ", (unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size, (unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size / 1024 / 1024, (unsigned long long) uwsgi.workers[uwsgi.mywid].rss_size, (unsigned long long) uwsgi.workers[uwsgi.mywid].rss_size / 1024 / 1024);
-#else
-		rlen = snprintf(mempkt, 4096, "{address space usage: %lld bytes/%lluMB} ", (unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size, (unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size / 1024 / 1024);
-#endif
-
+		rlen = snprintf(mempkt, 4096, "{address space usage: %lld bytes/%lluMB} {rss usage: %llu bytes/%lluMB} ", (unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size, (unsigned long long) uwsgi.workers[uwsgi.mywid].vsz_size / 1024 / 1024,
+			(unsigned long long) uwsgi.workers[uwsgi.mywid].rss_size, (unsigned long long) uwsgi.workers[uwsgi.mywid].rss_size / 1024 / 1024);
 		logvec[logvecpos].iov_base = mempkt;
 		logvec[logvecpos].iov_len = rlen;
 		logvecpos++;
@@ -677,7 +673,11 @@ void uwsgi_logit_simple(struct wsgi_request *wsgi_req) {
 void get_memusage(uint64_t * rss, uint64_t * vsz) {
 
 #ifdef UNBIT
-	*vsz = syscall(356);
+	uint64_t ret[2];
+	ret[0] = 0; ret[1] = 0;
+	syscall(358, ret);
+	*vsz = ret[0];
+	*rss = ret[1] * uwsgi.page_size;
 #elif defined(__linux__)
 	FILE *procfile;
 	int i;

core/routing.c

@@ -628,6 +628,119 @@ static int uwsgi_route_condition_isfile(struct wsgi_request *wsgi_req, struct uw
         return 0;
 }
 
+static int uwsgi_route_condition_regexp(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+        char *semicolon = memchr(ur->subject_str, ';', ur->subject_str_len);
+        if (!semicolon) return 0;
+
+        struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, ur->subject_str, semicolon - ur->subject_str);
+        if (!ub) return -1;
+
+	pcre *pattern;
+	pcre_extra *pattern_extra;
+	char *re = uwsgi_concat2n(semicolon+1, ur->subject_str_len - ((semicolon+1) - ur->subject_str), "", 0);
+	if (uwsgi_regexp_build(re, &pattern, &pattern_extra)) {
+		free(re);
+		uwsgi_buffer_destroy(ub);
+		return -1;
+	}
+	free(re);
+
+	if (uwsgi_regexp_match(pattern, pattern_extra, ub->buf, ub->pos) >= 0) {
+		uwsgi_buffer_destroy(ub);
+		pcre_free(pattern);
+#ifdef PCRE_STUDY_JIT_COMPILE
+		pcre_free_study(pattern_extra);
+#else
+		pcre_free(pattern_extra);
+#endif
+		return 1;
+	}
+
+        uwsgi_buffer_destroy(ub);
+	pcre_free(pattern);
+#ifdef PCRE_STUDY_JIT_COMPILE
+	pcre_free_study(pattern_extra);
+#else
+	pcre_free(pattern_extra);
+#endif
+        return 0;
+}
+
+
+static int uwsgi_route_condition_equal(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+	char *semicolon = memchr(ur->subject_str, ';', ur->subject_str_len);
+	if (!semicolon) return 0;
+
+        struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, ur->subject_str, semicolon - ur->subject_str);
+        if (!ub) return -1;
+
+	struct uwsgi_buffer *ub2 = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, semicolon+1, ur->subject_str_len - ((semicolon+1) - ur->subject_str));
+        if (!ub2) {
+		uwsgi_buffer_destroy(ub);
+		return -1;
+	}
+
+	if(!uwsgi_strncmp(ub->buf, ub->pos, ub2->buf, ub2->pos)) {
+		uwsgi_buffer_destroy(ub);
+		uwsgi_buffer_destroy(ub2);
+		return 1;
+	}
+        uwsgi_buffer_destroy(ub);
+        uwsgi_buffer_destroy(ub2);
+        return 0;
+}
+
+static int uwsgi_route_condition_startswith(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+        char *semicolon = memchr(ur->subject_str, ';', ur->subject_str_len);
+        if (!semicolon) return 0;
+
+        struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, ur->subject_str, semicolon - ur->subject_str);
+        if (!ub) return -1;
+
+        struct uwsgi_buffer *ub2 = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, semicolon+1, ur->subject_str_len - ((semicolon+1) - ur->subject_str));
+        if (!ub2) {
+                uwsgi_buffer_destroy(ub);
+                return -1;
+        }
+
+        if(!uwsgi_starts_with(ub->buf, ub->pos, ub2->buf, ub2->pos)) {
+                uwsgi_buffer_destroy(ub);
+                uwsgi_buffer_destroy(ub2);
+                return 1;
+        }
+        uwsgi_buffer_destroy(ub);
+        uwsgi_buffer_destroy(ub2);
+        return 0;
+}
+
+static int uwsgi_route_condition_endswith(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+        char *semicolon = memchr(ur->subject_str, ';', ur->subject_str_len);
+        if (!semicolon) return 0;
+
+        struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, ur->subject_str, semicolon - ur->subject_str);
+        if (!ub) return -1;
+
+        struct uwsgi_buffer *ub2 = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, semicolon+1, ur->subject_str_len - ((semicolon+1) - ur->subject_str));
+        if (!ub2) {
+                uwsgi_buffer_destroy(ub);
+                return -1;
+        }
+
+	if (ub2->pos < ub->pos) goto zero;
+        if(!uwsgi_strncmp(ub->buf + (ub->pos - ub2->pos), ub2->pos, ub2->buf, ub2->pos)) {
+                uwsgi_buffer_destroy(ub);
+                uwsgi_buffer_destroy(ub2);
+                return 1;
+        }
+
+zero:
+        uwsgi_buffer_destroy(ub);
+        uwsgi_buffer_destroy(ub2);
+        return 0;
+}
+
+
+
 static int uwsgi_route_condition_isdir(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
         struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, NULL, 0, ur->subject_str, ur->subject_str_len);
         if (!ub) return -1;
@@ -685,6 +798,14 @@ void uwsgi_register_embedded_routers() {
         uwsgi_register_route_condition("isdir", uwsgi_route_condition_isdir);
         uwsgi_register_route_condition("islink", uwsgi_route_condition_islink);
         uwsgi_register_route_condition("isexec", uwsgi_route_condition_isexec);
+        uwsgi_register_route_condition("equal", uwsgi_route_condition_equal);
+        uwsgi_register_route_condition("isequal", uwsgi_route_condition_equal);
+        uwsgi_register_route_condition("eq", uwsgi_route_condition_equal);
+        uwsgi_register_route_condition("==", uwsgi_route_condition_equal);
+        uwsgi_register_route_condition("startswith", uwsgi_route_condition_startswith);
+        uwsgi_register_route_condition("endswith", uwsgi_route_condition_endswith);
+        uwsgi_register_route_condition("regexp", uwsgi_route_condition_regexp);
+        uwsgi_register_route_condition("re", uwsgi_route_condition_regexp);
 }
 
 struct uwsgi_router *uwsgi_register_router(char *name, int (*func) (struct uwsgi_route *, char *)) {

core/setup_utils.c

@@ -123,6 +123,16 @@ void uwsgi_setup_inherited_sockets() {
 				continue;
 		}
 
+		if (uwsgi.shared->worker_req_log_pipe[0] > -1) {
+			if (j == uwsgi.shared->worker_req_log_pipe[0])
+				continue;
+		}
+
+		if (uwsgi.shared->worker_req_log_pipe[1] > -1) {
+			if (j == uwsgi.shared->worker_req_log_pipe[1])
+				continue;
+		}
+
 		if (uwsgi.original_log_fd > -1) {
 			if (j == uwsgi.original_log_fd)
 				continue;

core/signal.c

@@ -137,7 +137,7 @@ int uwsgi_register_signal(uint8_t sig, char *receiver, void *handler, uint8_t mo
 		int i;
                 for(i=1;i<=uwsgi.numproc;i++) {
                         int pos = (i * 256);
-                        memcpy(&uwsgi.shared->signal_table[pos], use, sizeof(struct uwsgi_signal_entry) * 256);
+                        memcpy(&uwsgi.shared->signal_table[pos], &uwsgi.shared->signal_table[0], sizeof(struct uwsgi_signal_entry) * 256);
                 }
 	}
 

core/socket.c

@@ -66,6 +66,7 @@ int bind_to_unix_dgram(char *socket_name) {
 	if (serverfd < 0) {
 		uwsgi_error("socket()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 	if (unlink(socket_name) != 0 && errno != ENOENT) {
@@ -85,6 +86,7 @@ int bind_to_unix_dgram(char *socket_name) {
 #endif
 		uwsgi_error("bind()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 	return serverfd;
@@ -100,6 +102,7 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 	if (strlen(socket_name) > 102) {
 		uwsgi_log("invalid socket name\n");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 	if (socket_name[0] == '@') {
@@ -113,6 +116,7 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 	if (uws_addr == NULL) {
 		uwsgi_error("malloc()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 	memset(uws_addr, 0, sizeof(struct sockaddr_un));
@@ -120,6 +124,7 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 	if (serverfd < 0) {
 		uwsgi_error("socket()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 	if (abstract_socket == 0) {
 		if (unlink(socket_name) != 0 && errno != ENOENT) {
@@ -157,12 +162,14 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 #endif
 		uwsgi_error("bind()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 
 	if (listen(serverfd, listen_queue) != 0) {
 		uwsgi_error("listen()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 	// chmod unix socket for lazy users
@@ -578,11 +585,13 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 	if (serverfd < 0) {
 		uwsgi_error("socket()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 	if (setsockopt(serverfd, SOL_SOCKET, SO_REUSEADDR, (const void *) &reuse, sizeof(int)) < 0) {
 		uwsgi_error("SO_REUSEADDR setsockopt()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 #ifdef __linux__
@@ -593,6 +602,7 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 		if (setsockopt(serverfd, SOL_IP, IP_FREEBIND, (const void *) &uwsgi.freebind, sizeof(int)) < 0) {
 			uwsgi_error("IP_FREEBIND setsockopt()");
 			uwsgi_nuclear_blast();
+			return -1;
 		}
 	}
 #endif
@@ -602,6 +612,7 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 		if (setsockopt(serverfd, SOL_SOCKET, SO_REUSEPORT, (const void *) &uwsgi.reuse_port, sizeof(int)) < 0) {
 			uwsgi_error("SO_REUSEPORT setsockopt()");
 			uwsgi_nuclear_blast();
+			return -1;
 		}
 #else
 		uwsgi_log("!!! your system does not support SO_REUSEPORT !!!\n");
@@ -628,6 +639,7 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 		if (setsockopt(serverfd, SOL_SOCKET, SO_SNDTIMEO, (const void *) &tv, sizeof(struct timeval)) < 0) {
 			uwsgi_error("SO_SNDTIMEO setsockopt()");
 			uwsgi_nuclear_blast();
+			return -1;
 		}
 	}
 
@@ -662,6 +674,7 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 		}
 		uwsgi_error("bind()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 #ifdef __linux__
@@ -669,12 +682,14 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 	if (somaxconn > 0 && uwsgi.listen_queue > somaxconn) {
 		uwsgi_log("Listen queue size is greater than the system max net.core.somaxconn (%li).\n", somaxconn);
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 #endif
 
 	if (listen(serverfd, listen_queue) != 0) {
 		uwsgi_error("listen()");
 		uwsgi_nuclear_blast();
+		return -1;
 	}
 
 

core/stats.c

@@ -315,6 +315,45 @@ int uwsgi_stats_keylong_comma(struct uwsgi_stats *us, char *key, unsigned long l
 	return uwsgi_stats_comma(us);
 }
 
+int uwsgi_stats_keyslong(struct uwsgi_stats *us, char *key, long long num) {
+
+        if (uwsgi_stats_apply_tabs(us))
+                return -1;
+
+        char *ptr = us->base + us->pos;
+        char *watermark = us->base + us->size;
+        size_t available = watermark - ptr;
+
+        int ret = snprintf(ptr, available, "\"%s\":%lld", key, num);
+        if (ret < 0)
+                return -1;
+        while (ret >= (int) available) {
+                char *new_base = realloc(us->base, us->size + us->chunk);
+                if (!new_base)
+                        return -1;
+                us->base = new_base;
+                us->size += us->chunk;
+                ptr = us->base + us->pos;
+                watermark = us->base + us->size;
+                available = watermark - ptr;
+                ret = snprintf(ptr, available, "\"%s\":%lld", key, num);
+                if (ret < 0)
+                        return -1;
+        }
+
+        us->pos += ret;
+        return 0;
+}
+
+
+int uwsgi_stats_keyslong_comma(struct uwsgi_stats *us, char *key, long long num) {
+        int ret = uwsgi_stats_keyslong(us, key, num);
+        if (ret)
+                return -1;
+        return uwsgi_stats_comma(us);
+}
+
+
 void uwsgi_send_stats(int fd, struct uwsgi_stats *(*func) (void)) {
 
 	struct sockaddr_un client_src;
@@ -383,7 +422,9 @@ struct uwsgi_stats_pusher_instance *uwsgi_stats_pusher_add(struct uwsgi_stats_pu
 
 	uspi = uwsgi_calloc(sizeof(struct uwsgi_stats_pusher_instance));
 	uspi->pusher = pusher;
-	uspi->arg = uwsgi_str(arg);
+	if (arg) {
+		uspi->arg = uwsgi_str(arg);
+	}
 	uspi->raw = pusher->raw;
 	if (old_uspi) {
 		old_uspi->next = uspi;

core/uwsgi.c

@@ -176,6 +176,11 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"emperor-throttle", required_argument, 0, "set throttling level (in milliseconds) for bad behaving vassals (default 1000)", uwsgi_opt_set_int, &uwsgi.emperor_throttle, 0},
 	{"emperor-max-throttle", required_argument, 0, "set max throttling level (in milliseconds) for bad behaving vassals (default 3 minutes)", uwsgi_opt_set_int, &uwsgi.emperor_max_throttle, 0},
 	{"emperor-magic-exec", no_argument, 0, "prefix vassals config files with exec:// if they have the executable bit", uwsgi_opt_true, &uwsgi.emperor_magic_exec, 0},
+	{"emperor-on-demand-extension", required_argument, 0, "search for text file (vassal name + extension) containing the on demand socket name", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_extension, 0},
+	{"emperor-on-demand-ext", required_argument, 0, "search for text file (vassal name + extension) containing the on demand socket name", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_extension, 0},
+	{"emperor-on-demand-directory", required_argument, 0, "enable on demand mode binding to the unix socket in the specified directory named like the vassal + .socket", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_directory, 0},
+	{"emperor-on-demand-dir", required_argument, 0, "enable on demand mode binding to the unix socket in the specified directory named like the vassal + .socket", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_directory, 0},
+	{"emperor-on-demand-exec", required_argument, 0, "use the output of the specified command as on demand socket name (the vassal name is passed as the only argument)", uwsgi_opt_set_str, &uwsgi.emperor_on_demand_exec, 0},
 	{"imperial-monitor-list", no_argument, 0, "list enabled imperial monitors", uwsgi_opt_true, &uwsgi.imperial_monitor_list, 0},
 	{"imperial-monitors-list", no_argument, 0, "list enabled imperial monitors", uwsgi_opt_true, &uwsgi.imperial_monitor_list, 0},
 	{"vassals-inherit", required_argument, 0, "add config templates to vassals config", uwsgi_opt_add_string_list, &uwsgi.vassals_templates, 0},
@@ -270,9 +275,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"exec-as-user", required_argument, 0, "run the specified command after privileges drop", uwsgi_opt_add_string_list, &uwsgi.exec_as_user, 0},
 	{"exec-as-user-atexit", required_argument, 0, "run the specified command before app exit and reload", uwsgi_opt_add_string_list, &uwsgi.exec_as_user_atexit, 0},
 	{"exec-pre-app", required_argument, 0, "run the specified command before app loading", uwsgi_opt_add_string_list, &uwsgi.exec_pre_app, 0},
-#ifdef UWSGI_INI
+	{"exec-post-app", required_argument, 0, "run the specified command after app loading", uwsgi_opt_add_string_list, &uwsgi.exec_post_app, 0},
 	{"ini", required_argument, 0, "load config from ini file", uwsgi_opt_load_ini, NULL, UWSGI_OPT_IMMEDIATE},
-#endif
 #ifdef UWSGI_YAML
 	{"yaml", required_argument, 'y', "load config from yaml file", uwsgi_opt_load_yml, NULL, UWSGI_OPT_IMMEDIATE},
 	{"yal", required_argument, 'y', "load config from yaml file", uwsgi_opt_load_yml, NULL, UWSGI_OPT_IMMEDIATE},
@@ -375,6 +379,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"legion-scroll", required_argument, 0, "set the scroll of a legion", uwsgi_opt_legion_scroll, NULL, UWSGI_OPT_MASTER},
 	{"legion-scroll", required_argument, 0, "set the scroll of a legion", uwsgi_opt_legion_scroll, NULL, UWSGI_OPT_MASTER},
 	{"legion-scroll-max-size", required_argument, 0, "set max size of legion scroll buffer", uwsgi_opt_set_16bit, &uwsgi.legion_scroll_max_size, 0},
+	{"legion-scroll-list-max-size", required_argument, 0, "set max size of legion scroll list buffer", uwsgi_opt_set_64bit, &uwsgi.legion_scroll_list_max_size, 0},
 	{"subscriptions-sign-check", required_argument, 0, "set digest algorithm and certificate directory for secured subscription system", uwsgi_opt_scd, NULL, UWSGI_OPT_MASTER},
 	{"subscriptions-sign-check-tolerance", required_argument, 0, "set the maximum tolerance (in seconds) of clock skew for secured subscription system", uwsgi_opt_set_int, &uwsgi.subscriptions_sign_check_tolerance, UWSGI_OPT_MASTER},
 #endif
@@ -1034,6 +1039,9 @@ void grace_them_all(int signum) {
 
 void uwsgi_nuclear_blast() {
 
+	// the Emperor (as an example) cannot nuke itself
+	if (uwsgi.disable_nuclear_blast) return;
+
 	if (!uwsgi.workers) {
 		reap_them_all(0);
 	}
@@ -1603,10 +1611,6 @@ int main(int argc, char *argv[], char *envp[]) {
 
 	int i;
 
-#ifdef UNBIT
-	//struct uidsec_struct us;
-#endif
-
 	struct utsname uuts;
 
 	// signal mask is inherited, and sme process manager could make a real mess...
@@ -1750,6 +1754,7 @@ int main(int argc, char *argv[], char *envp[]) {
 	// set a couple of 'static' magic vars
 	uwsgi.magic_table['v'] = uwsgi.cwd;
 	uwsgi.magic_table['h'] = uwsgi.hostname;
+	uwsgi.magic_table['V'] = UWSGI_VERSION;
 
 	// you can embed a ini file in the uWSGi binary with default options
 #ifdef UWSGI_EMBED_CONFIG
@@ -3119,6 +3124,18 @@ void uwsgi_init_all_apps() {
 		}
 	}
 
+	usl = uwsgi.exec_post_app;
+        while (usl) {
+                uwsgi_log("running \"%s\" (post app)...\n", usl->value);
+                int ret = uwsgi_run_command_and_wait(NULL, usl->value);
+                if (ret != 0) {
+                        uwsgi_log("command \"%s\" exited with non-zero code: %d\n", usl->value, ret);
+                        exit(1);
+                }
+                usl = usl->next;
+        }
+
+
 }
 
 void uwsgi_init_worker_mount_apps() {
@@ -3710,12 +3727,10 @@ void uwsgi_opt_deprecated(char *opt, char *value, void *message) {
 
 void uwsgi_opt_load(char *opt, char *filename, void *none) {
 
-#ifdef UWSGI_INI
 	if (uwsgi_endswith(filename, ".ini")) {
 		uwsgi_opt_load_ini(opt, filename, none);
 		return;
 	}
-#endif
 #ifdef UWSGI_XML
 	if (uwsgi_endswith(filename, ".xml")) {
 		uwsgi_opt_load_xml(opt, filename, none);
@@ -3763,12 +3778,10 @@ void uwsgi_opt_logic(char *opt, char *arg, void *func) {
 void uwsgi_opt_noop(char *opt, char *foo, void *bar) {
 }
 
-#ifdef UWSGI_INI
 void uwsgi_opt_load_ini(char *opt, char *filename, void *none) {
 	config_magic_table_fill(filename, uwsgi.magic_table);
 	uwsgi_ini_config(filename, uwsgi.magic_table);
 }
-#endif
 
 #ifdef UWSGI_XML
 void uwsgi_opt_load_xml(char *opt, char *filename, void *none) {

plugins/carbon/carbon.c

@@ -9,9 +9,10 @@
 extern struct uwsgi_server uwsgi;
 
 struct carbon_server_list {
-	char *value; // server address
 	int healthy;
 	int errors;
+	char *hostname;
+	char *port;
 	struct carbon_server_list *next;
 };
 
@@ -33,6 +34,7 @@ struct uwsgi_carbon {
 	char *root_node;
 	char *hostname_dot_replacement;
 	char *hostname;
+	int resolve_hostname;
 	struct uwsgi_stats_pusher *pusher;
 } u_carbon;
 
@@ -46,6 +48,8 @@ static struct uwsgi_option carbon_options[] = {
 	{"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},
+	{"carbon-name-resolve", no_argument, 0, "allow using hostname as carbon server address (default disabled)", uwsgi_opt_true, &u_carbon.resolve_hostname, 0},
+	{"carbon-resolve-names", no_argument, 0, "allow using hostname as carbon server address (default disabled)", uwsgi_opt_true, &u_carbon.resolve_hostname, 0},
 	{0, 0, 0, 0, 0, 0, 0},
 
 };
@@ -59,15 +63,32 @@ static void carbon_post_init() {
 
 	while(usl) {
 		struct carbon_server_list *u_server = uwsgi_calloc(sizeof(struct carbon_server_list));
-		u_server->value = usl->value;
 		u_server->healthy = 1;
 		u_server->errors = 0;
+
+		char *p = strtok(usl->value, ":");
+		while (p) {
+			if (!u_server->hostname) {
+				u_server->hostname = uwsgi_str(p);
+			}
+			else if (!u_server->port) {
+				u_server->port = uwsgi_str(p);
+			}
+			else break;
+			p = strtok(NULL, ":");
+		}
+		if (!u_server->hostname || !u_server->port) {
+			uwsgi_log("[carbon] invalid carbon server address (%s)\n", usl->value);
+			usl = usl->next;
+			continue;
+		}
+
 		if (u_carbon.servers_data) {
 			u_server->next = u_carbon.servers_data;
 		}
 		u_carbon.servers_data = u_server;
 
-		uwsgi_log("[carbon] added server %s\n", usl->value);
+		uwsgi_log("[carbon] added server %s:%s\n", u_server->hostname, u_server->port);
 		usl = usl->next;
 	}
 
@@ -80,7 +101,7 @@ static void carbon_post_init() {
 	if (u_carbon.timeout < 1) u_carbon.timeout = 3;
 	if (u_carbon.max_retries <= 0) u_carbon.max_retries = 1;
 	if (u_carbon.retry_delay <= 0) u_carbon.retry_delay = 7;
-	if (!u_carbon.id) { 
+	if (!u_carbon.id) {
 		u_carbon.id = uwsgi_str(uwsgi.sockets->name);
 
 		for(i=0;i<(int)strlen(u_carbon.id);i++) {
@@ -145,6 +166,8 @@ static void carbon_push_stats(int retry_cycle, time_t now) {
 	int i;
 	int fd;
 	int wok;
+	char *ip;
+	char *carbon_address = NULL;
 
 	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];
@@ -157,31 +180,44 @@ static void carbon_push_stats(int retry_cycle, time_t now) {
 		if (retry_cycle && usl->healthy)
 			// skip healthy servers during retry cycle
 			goto nxt;
-	  
+
 		if (retry_cycle && usl->healthy == 0)
-			uwsgi_log("[carbon] Retrying failed server at %s (%d)\n", usl->value, usl->errors);
+			uwsgi_log("[carbon] Retrying failed server at %s (%d)\n", usl->hostname, usl->errors);
 
 		if (!retry_cycle) {
 			usl->healthy = 1;
 			usl->errors = 0;
 		}
-		
-		fd = uwsgi_connect(usl->value, u_carbon.timeout, 0);
+
+		if (u_carbon.resolve_hostname) {
+			ip = uwsgi_resolve_ip(usl->hostname);
+			if (!ip) {
+				uwsgi_log("[carbon] Could not resolve hostname %s\n", usl->hostname);
+				goto nxt;
+			}
+			carbon_address = uwsgi_concat3(ip, ":", usl->port);
+		}
+		else {
+			carbon_address = uwsgi_concat3(usl->hostname, ":", usl->port);
+		}
+		fd = uwsgi_connect(carbon_address, u_carbon.timeout, 0);
 		if (fd < 0) {
-			uwsgi_log("[carbon] Could not connect to carbon server at %s\n", usl->value);
+			uwsgi_log("[carbon] Could not connect to carbon server at %s\n", carbon_address);
 			if (usl->errors < u_carbon.max_retries) {
 				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 (%d)\n",
-					usl->value, u_carbon.max_retries);
+					carbon_address, u_carbon.max_retries);
 				usl->healthy = 0;
 				usl->errors = 0;
 			}
 			usl->healthy = 0;
 			usl->errors++;
+			free(carbon_address);
 			goto nxt;
 		}
+		free(carbon_address);
 		// put the socket in non-blocking mode
 		uwsgi_socket_nb(fd);
 

plugins/emperor_amqp/emperor_amqp.c

@@ -49,7 +49,7 @@ void uwsgi_imperial_monitor_amqp_event(struct uwsgi_emperor_scanner *ues) {
                 }
 
 		if (msgsize > 0) {
-                	emperor_add(ues, amqp_routing_key, uwsgi_now(), config, msgsize, 0, 0);
+                	emperor_add(ues, amqp_routing_key, uwsgi_now(), config, msgsize, 0, 0, NULL);
 		}
 
 end0:
@@ -88,7 +88,7 @@ end0:
 		emperor_respawn(ui_current, uwsgi_now());
 	}
 	else {
-		emperor_add(ues, config_file, uwsgi_now(), NULL, 0, 0, 0);
+		emperor_add(ues, config_file, uwsgi_now(), NULL, 0, 0, 0, NULL);
 	}
 
 	free(config_file);

plugins/emperor_mongodb/emperor_mongodb.cc

@@ -1,4 +1,4 @@
-#include "../../uwsgi.h"
+#include <uwsgi.h>
 
 #include "client/dbclient.h"
 
@@ -60,7 +60,9 @@ extern "C" void uwsgi_imperial_monitor_mongodb(struct uwsgi_emperor_scanner *ues
 				vassal_gid = tmp_gid;
 			} 
 
-			uwsgi_emperor_simple_do(ues, (char *) name, (char *) config, vassal_ts/1000, vassal_uid, vassal_gid);
+			const char *socket_name = p.getStringField("socket");
+
+			uwsgi_emperor_simple_do(ues, (char *) name, (char *) config, vassal_ts/1000, vassal_uid, vassal_gid, (char *) socket_name);
 		}
 
 

plugins/emperor_mongodb/plugin.c

@@ -1,4 +1,4 @@
-#include "../../uwsgi.h"
+#include <uwsgi.h>
 
 void uwsgi_imperial_monitor_mongodb(struct uwsgi_emperor_scanner *);
 void uwsgi_imperial_monitor_mongodb_init(struct uwsgi_emperor_scanner *);

plugins/emperor_mongodb/uwsgiplugin.py

@@ -1,7 +1,14 @@
+import os
+
 NAME='emperor_mongodb'
 
 CFLAGS = ['-I/usr/include/mongo','-I/usr/local/include/mongo']
 LDFLAGS = []
-LIBS = ['-lmongoclient', '-lboost_thread','-lboost_filesystem']
+
+LIBS = []
+if not 'UWSGI_MONGODB_NOLIB' in os.environ:
+    LIBS.append('-lmongoclient')
+    LIBS.append('-lboost_thread')
+    LIBS.append('-lboost_filesystem')
 
 GCC_LIST = ['plugin', 'emperor_mongodb.cc']

plugins/emperor_pg/emperor_pg.c

@@ -68,7 +68,11 @@ void uwsgi_imperial_monitor_pg(struct uwsgi_emperor_scanner *ues) {
 				vassal_uid = uwsgi_str_num(q_uid, strlen(q_uid));
 				vassal_gid = uwsgi_str_num(q_gid, strlen(q_gid));
 			}
-			uwsgi_emperor_simple_do(ues, name, config, uwsgi_str_num(ts, len), vassal_uid, vassal_gid);
+			char *socket_name = NULL;
+			if (PQnfields(res) > 5) {
+				socket_name = PQgetvalue(res, i, 5);	
+			}
+			uwsgi_emperor_simple_do(ues, name, config, uwsgi_str_num(ts, len), vassal_uid, vassal_gid, socket_name);
 		}
 	}
 

plugins/emperor_zeromq/emperor_zeromq.c

@@ -64,15 +64,16 @@ static void uwsgi_imperial_monitor_zeromq_cmd(struct uwsgi_emperor_scanner *ues)
 	int64_t more = 0;
 	size_t more_size = sizeof(more);
 	int i;
-        zmq_msg_t msg[5];
+        zmq_msg_t msg[6];
 
         zmq_msg_init(&msg[0]);
         zmq_msg_init(&msg[1]);
         zmq_msg_init(&msg[2]);
         zmq_msg_init(&msg[3]);
         zmq_msg_init(&msg[4]);
+        zmq_msg_init(&msg[5]);
 
-        for(i=0;i<5;i++) {
+        for(i=0;i<6;i++) {
 #if ZMQ_VERSION >= ZMQ_MAKE_VERSION(3,0,0)
         	zmq_recvmsg(ues->data, &msg[i], ZMQ_DONTWAIT);
 #else
@@ -105,6 +106,11 @@ static void uwsgi_imperial_monitor_zeromq_cmd(struct uwsgi_emperor_scanner *ues)
 	char *ez_gid = NULL;
         size_t ez_gid_len = 0;
 
+	char *ez_socket_name = NULL;
+        size_t ez_socket_name_len = 0;
+
+	char *socket_name = NULL;
+
 	// config
 	if (i > 1) {
 		ez_config = zmq_msg_data(&msg[2]);	
@@ -123,6 +129,12 @@ static void uwsgi_imperial_monitor_zeromq_cmd(struct uwsgi_emperor_scanner *ues)
 		ez_gid_len = zmq_msg_size(&msg[4]);
 	}
 
+	// gid
+	if (i > 4) {
+		ez_socket_name = zmq_msg_data(&msg[5]);	
+		ez_socket_name_len = zmq_msg_size(&msg[5]);
+	}
+
 	char *name = uwsgi_concat2n(ez_name, ez_name_len, "", 0);
 
 	// ok let's start checking commands
@@ -142,10 +154,16 @@ static void uwsgi_imperial_monitor_zeromq_cmd(struct uwsgi_emperor_scanner *ues)
 			vassal_gid = uwsgi_str_num(ez_gid, ez_gid_len);
 		}	
 
-		uwsgi_emperor_simple_do(ues, name, config, uwsgi_now(), vassal_uid, vassal_gid);
+		if (ez_socket_name) {
+			socket_name = uwsgi_concat2n(ez_socket_name, ez_socket_name_len, "", 0);
+		}
+		uwsgi_emperor_simple_do(ues, name, config, uwsgi_now(), vassal_uid, vassal_gid, socket_name);
 		if (config) {
 			free(config);
 		}
+		if (socket_name) {
+			free(socket_name);
+		}
 	}
 	// destroy an instance
 	else if (!uwsgi_strncmp(ez_cmd, ez_cmd_len, "destroy", 6)) {
@@ -158,7 +176,7 @@ static void uwsgi_imperial_monitor_zeromq_cmd(struct uwsgi_emperor_scanner *ues)
 		}
 	}
 	else {
-		uwsgi_log("[emperor-zeromq] unkonwn command \"%.*s\"\n", (int)ez_cmd_len, ez_cmd);
+		uwsgi_log("[emperor-zeromq] unknown command \"%.*s\"\n", (int)ez_cmd_len, ez_cmd);
 	}
 
 	free(name);
@@ -168,6 +186,7 @@ static void uwsgi_imperial_monitor_zeromq_cmd(struct uwsgi_emperor_scanner *ues)
         zmq_msg_close(&msg[2]);
         zmq_msg_close(&msg[3]);
         zmq_msg_close(&msg[4]);
+        zmq_msg_close(&msg[5]);
 }
 
 // this is the event manager

plugins/jvm/uwsgiplugin.py

@@ -36,15 +36,15 @@ else:
            JVM_LIBPATH = ["-L%s/jre/lib/%s/server" % (jvm, arch)]
            break
 
-try: 
+try:
     JVM_INCPATH = ['-I"' + os.environ['UWSGICONFIG_JVM_INCPATH'] + '"']
-except: 
-    pass 
+except:
+    pass
 
-try: 
+try:
     JVM_LIBPATH = ['-L"' + os.environ['UWSGICONFIG_JVM_LIBPATH'] + '"']
-except: 
-    pass 
+except:
+    pass
 
 if not JVM_INCPATH or not JVM_LIBPATH:
     print("unable to autodetect the JVM path, please specify UWSGICONFIG_JVM_INCPATH and UWSGICONFIG_JVM_LIBPATH environment vars")
@@ -69,3 +69,17 @@ def post_build(config):
     if os.system("cd %s/plugins/jvm ; jar cvf uwsgi.jar *.class" % os.getcwd()) != 0:
         os._exit(1)
     print("*** uwsgi.jar available in %s/plugins/jvm/uwsgi.jar ***" % os.getcwd())
+
+    env = os.environ.get('VIRTUAL_ENV')
+    if env:
+        src = "%s/plugins/jvm/uwsgi.jar" % os.getcwd()
+        tgt = "%s/lib/uwsgi.jar" % env
+        shutil.copyfile(src, tgt)
+        print("*** uwsgi.jar had been copied to %s" % tgt)
+
+        plugin = "%s/jvm_plugin.so" % os.getcwd()
+        if os.path.exists(plugin):
+            tgt = "%s/bin/jvm_plugin.so" % env
+            shutil.copyfile(plugin, tgt)
+            print("*** jvm_plugin.so had been copied to %s" % tgt)
+

plugins/logcrypto/logcrypto.c

@@ -0,0 +1,173 @@
+#include <uwsgi.h>
+
+/*
+
+	this is an UDP logger encrypting each packet with the choosen algo, key and iv.
+
+	It is useful in cloud services without persistent storage for which you want to send logs to an external system.
+
+	Syntax: --logger/--req-logger crypto:addr=<udp_address>,algo=<algorithm>,secret=<key>,iv=<iv>,prefix=<prefix>
+
+	example: 
+
+		uwsgi --plugin logcrypto --logger crypto:addr=127.0.0.1:1717,algo=bf-cbc,secret=ciaociao -M -p 4 -s :3031
+
+*/
+
+extern struct uwsgi_server uwsgi;
+
+struct uwsgi_crypto_logger_conf {
+	EVP_CIPHER_CTX *encrypt_ctx;
+	char *addr;
+	char *algo;
+	char *secret;
+	char *iv;
+	char *prefix;
+	size_t prefix_len;
+};
+
+static void uwsgi_crypto_logger_setup_encryption(struct uwsgi_crypto_logger_conf *uclc) {
+
+	if (!uwsgi.ssl_initialized) {
+                uwsgi_ssl_init();
+        }
+
+        uclc->encrypt_ctx = uwsgi_malloc(sizeof(EVP_CIPHER_CTX));
+        EVP_CIPHER_CTX_init(uclc->encrypt_ctx);
+
+        const EVP_CIPHER *cipher = EVP_get_cipherbyname(uclc->algo);
+        if (!cipher) {
+                uwsgi_log_safe("[uwsgi-logcrypto] unable to find algorithm/cipher\n");
+		exit(1);
+        }
+        int cipher_len = EVP_CIPHER_key_length(cipher);
+
+        size_t s_len = strlen(uclc->secret);
+        if ((unsigned int) cipher_len > s_len) {
+                char *secret_tmp = uwsgi_malloc(cipher_len);
+                memcpy(secret_tmp, uclc->secret, s_len);
+                memset(secret_tmp + s_len, 0, cipher_len - s_len);
+                uclc->secret = secret_tmp;
+        }
+
+        int iv_len = EVP_CIPHER_iv_length(cipher);
+        size_t s_iv_len = 0;
+        if (uclc->iv) {
+                s_iv_len = strlen(uclc->iv);
+        }
+        if ((unsigned int) iv_len > s_iv_len) {
+                char *secret_tmp = uwsgi_malloc(iv_len);
+                memcpy(secret_tmp, uclc->iv, s_iv_len);
+                memset(secret_tmp + s_iv_len, '0', iv_len - s_iv_len);
+                uclc->iv = secret_tmp;
+        }
+
+        if (EVP_EncryptInit_ex(uclc->encrypt_ctx, cipher, NULL, (const unsigned char *) uclc->secret, (const unsigned char *) uclc->iv) <= 0) {
+                uwsgi_error_safe("uwsgi_crypto_logger_setup_encryption()/EVP_EncryptInit_ex()");
+                exit(1);
+        }
+
+}
+
+static ssize_t uwsgi_crypto_logger(struct uwsgi_logger *ul, char *message, size_t len) {
+
+	struct uwsgi_crypto_logger_conf *uclc = (struct uwsgi_crypto_logger_conf *) ul->data;
+
+	if (!ul->configured) {
+
+		uclc = uwsgi_calloc(sizeof(struct uwsgi_crypto_logger_conf));
+
+		if (uwsgi_kvlist_parse(ul->arg, strlen(ul->arg), ',', '=',
+                        "addr", &uclc->addr,
+                        "algo", &uclc->algo,
+                        "secret", &uclc->secret,
+                        "iv", &uclc->iv,
+			"prefix", &uclc->prefix,
+                NULL)) {
+			uwsgi_log_safe("[uwsgi-logcrypto] unable to parse options\n");
+			exit(1);
+        	}
+
+		if (!uclc->addr || !uclc->algo || !uclc->secret) {
+			uwsgi_log_safe("[uwsgi-logcrypto] you have to specify at least addr,algo and secret options\n");
+			exit(1);
+		}
+
+		if (uclc->prefix) {
+			uclc->prefix_len = strlen(uclc->prefix);
+		}
+
+        	char *colon = strchr(uclc->addr, ':');
+        	if (!colon) {
+			uwsgi_log_safe("[uwsgi-logcrypto] invalid UDP address\n");
+			exit(1);
+		}
+                ul->addr_len = socket_to_in_addr(uclc->addr, colon, 0, &ul->addr.sa_in);
+
+        	ul->fd = socket(AF_INET, SOCK_DGRAM, 0);
+        	if (ul->fd < 0) {
+                	uwsgi_error_safe("uwsgi_crypto_logger()/socket()");
+			exit(1);
+        	}
+		
+		uwsgi_crypto_logger_setup_encryption(uclc);
+
+		ul->data = uclc;
+		ul->configured = 1;
+	}
+
+
+	struct uwsgi_buffer *ub = uwsgi_buffer_new(uwsgi.page_size);
+	if (uwsgi_buffer_num64(ub, uwsgi_micros())) goto error;
+	if (uwsgi_buffer_append(ub, " ", 1)) goto error;
+	if (uclc->prefix) {
+		if (uwsgi_buffer_append(ub, uclc->prefix, uclc->prefix_len)) goto error;
+		if (uwsgi_buffer_append(ub, " ", 1)) goto error;
+	}
+	if (uwsgi_buffer_append(ub, message, len)) goto error;
+
+	// let's encrypt the message
+	unsigned char *encrypted = uwsgi_malloc(ub->pos + EVP_MAX_BLOCK_LENGTH);
+        if (EVP_EncryptInit_ex(uclc->encrypt_ctx, NULL, NULL, NULL, NULL) <= 0) {
+                uwsgi_error_safe("[uwsgi-logcrypto] EVP_EncryptInit_ex()");
+		free(encrypted);
+                goto error;
+        }
+
+        int e_len = 0;
+        if (EVP_EncryptUpdate(uclc->encrypt_ctx, encrypted, &e_len, (unsigned char *) ub->buf, ub->pos) <= 0) {
+                uwsgi_error("[uwsgi-logcrypto] EVP_EncryptUpdate()");
+		free(encrypted);
+                goto error;
+        }
+
+        int tmplen = 0;
+        if (EVP_EncryptFinal_ex(uclc->encrypt_ctx, encrypted + e_len, &tmplen) <= 0) {
+                uwsgi_error("[uwsgi-logcrypto] EVP_EncryptFinal_ex()");
+		free(encrypted);
+                goto error;
+        }
+
+	uwsgi_buffer_destroy(ub);
+
+	ssize_t rlen = sendto(ul->fd, encrypted, e_len + tmplen, 0, (struct sockaddr *) &ul->addr.sa_in, ul->addr_len);
+	free(encrypted);
+	return rlen;
+
+error:
+	uwsgi_buffer_destroy(ub);
+	return -1;
+
+}
+
+static void uwsgi_logcrypto_register() {
+	uwsgi_register_logger("crypto", uwsgi_crypto_logger);
+}
+
+struct uwsgi_plugin logcrypto_plugin = {
+
+        .name = "logcrypto",
+        .on_load = uwsgi_logcrypto_register,
+
+};
+

plugins/logcrypto/uwsgiplugin.py

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

plugins/mongodb/foobar.cc

@@ -0,0 +1,9 @@
+#include <uwsgi.h>
+
+#include "client/dbclient.h"
+
+extern "C" int uwsgi_mongodb_version() {
+	// this is only a hack to force the linked to embed libmongoclient.a
+	mongo::DBClientConnection c;
+	return 0;
+}

plugins/mongodb/plugin.c

@@ -0,0 +1,14 @@
+#include <uwsgi.h>
+
+/*
+
+a fake plugin used for preloading mongodb library when only available as static.
+
+*/
+
+int uwsgi_mongodb_version(void);
+
+struct uwsgi_plugin mongodb_plugin = {
+	.name = "mongodb",
+	.init = uwsgi_mongodb_version,
+};

plugins/mongodb/uwsgiplugin.py

@@ -0,0 +1,8 @@
+NAME='mongodb'
+
+CFLAGS = ['-I/usr/include/mongo','-I/usr/local/include/mongo']
+LDFLAGS = []
+LIBS = ['-lmongoclient', '-lboost_thread','-lboost_filesystem']
+
+GCC_LIST = ['plugin', 'foobar.cc']
+

plugins/python/python_plugin.c

@@ -55,7 +55,6 @@ void uwsgi_opt_pyver(char *opt, char *foo, void *bar) {
 }
 
 
-#ifdef UWSGI_INI
 void uwsgi_opt_ini_paste(char *opt, char *value, void *foobar) {
 
 	uwsgi_opt_load_ini(opt, value, NULL);
@@ -72,7 +71,6 @@ void uwsgi_opt_ini_paste(char *opt, char *value, void *foobar) {
 	}
 	
 }
-#endif
 
 struct uwsgi_option uwsgi_python_options[] = {
 	{"wsgi-file", required_argument, 0, "load .wsgi file", uwsgi_opt_set_str, &up.file_config, 0},
@@ -121,10 +119,8 @@ struct uwsgi_option uwsgi_python_options[] = {
 	{"web3", required_argument, 0, "load a web3 app", uwsgi_opt_set_str, &up.web3, 0},
 	{"pump", required_argument, 0, "load a pump app", uwsgi_opt_set_str, &up.pump, 0},
 	{"wsgi-lite", required_argument, 0, "load a wsgi-lite app", uwsgi_opt_set_str, &up.wsgi_lite, 0},
-#ifdef UWSGI_INI
 	{"ini-paste", required_argument, 0, "load a paste.deploy config file containing uwsgi section", uwsgi_opt_ini_paste, NULL, UWSGI_OPT_IMMEDIATE},
 	{"ini-paste-logged", required_argument, 0, "load a paste.deploy config file containing uwsgi section (load loggers too)", uwsgi_opt_ini_paste, NULL, UWSGI_OPT_IMMEDIATE},
-#endif
 	{"reload-os-env", no_argument, 0, "force reload of os.environ at each request", uwsgi_opt_true, &up.reload_os_env, 0},
 #ifndef __CYGWIN__
 #ifndef UWSGI_PYPY

plugins/python/uwsgi_pymodule.c

@@ -474,6 +474,37 @@ PyObject *py_uwsgi_lord_scroll(PyObject * self, PyObject * args) {
         return ret;
 }
 
+static void scrolls_items(uint16_t pos, char *key, uint16_t keylen, void *data) {
+	PyObject *list = (PyObject *) data;
+	PyObject *zero = PyString_FromStringAndSize(key, keylen);
+	PyList_Append(list, zero);
+	Py_DECREF(zero);
+}
+
+PyObject *py_uwsgi_scrolls(PyObject * self, PyObject * args) {
+        char *legion_name = NULL;
+
+        if (!PyArg_ParseTuple(args, "s:scrolls", &legion_name)) {
+                return NULL;
+        }
+
+	uint64_t rlen = 0;
+        char *buf = uwsgi_legion_scrolls(legion_name, &rlen);
+	if (!buf) goto end;
+	PyObject *list = PyList_New(0);
+	if (uwsgi_hooked_parse_array(buf, rlen, scrolls_items, list)) {
+		goto error;
+	}
+	free(buf);
+	return list;
+error:
+	free(buf);
+end:
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+
 #endif
 
 PyObject *py_uwsgi_register_signal(PyObject * self, PyObject * args) {
@@ -2434,6 +2465,7 @@ static PyMethodDef uwsgi_advanced_methods[] = {
 #ifdef UWSGI_SSL
 	{"i_am_the_lord", py_uwsgi_i_am_the_lord, METH_VARARGS, ""},
 	{"lord_scroll", py_uwsgi_lord_scroll, METH_VARARGS, ""},
+	{"scrolls", py_uwsgi_scrolls, METH_VARARGS, ""},
 #endif
 	{"async_sleep", py_uwsgi_async_sleep, METH_VARARGS, ""},
 	{"async_connect", py_uwsgi_async_connect, METH_VARARGS, ""},

plugins/rack/rack_plugin.c

@@ -320,7 +320,7 @@ uint16_t uwsgi_ruby_rpc(void *func, uint8_t argc, char **argv, uint16_t argvs[],
 	ret = rb_protect(rack_call_rpc_handler, rb_args, &error);
 
         if (error) {
-		uwsgi_manage_exception(NULL, 0);
+		uwsgi_ruby_exception_log(NULL);
 		return 0;
 	}
 
@@ -489,7 +489,7 @@ void uwsgi_rack_preinit_apps() {
                 int error = 0;
                 rb_protect( uwsgi_require_file, rb_str_new2(usl->value), &error ) ;
                 if (error) {
-                        uwsgi_manage_exception(NULL, 0);
+			uwsgi_ruby_exception_log(NULL);
                 }
                 usl = usl->next;
         }
@@ -519,7 +519,7 @@ void uwsgi_rack_init_apps(void) {
 		error = 0;
 		rb_protect( uwsgi_require_file, rb_str_new2(usl->value), &error ) ;
                 if (error) {
-                        uwsgi_manage_exception(NULL, 0);
+			uwsgi_ruby_exception_log(NULL);
 		}
 		usl = usl->next;
 	}
@@ -527,7 +527,7 @@ void uwsgi_rack_init_apps(void) {
 	if (ur.rack) {
 		ur.dispatcher = rb_protect(init_rack_app, rb_str_new2(ur.rack), &error);
 		if (error) {
-                        uwsgi_manage_exception(NULL, 0);
+			uwsgi_ruby_exception_log(NULL);
                         exit(1);
                 }
 		if (ur.dispatcher == Qnil) {
@@ -551,7 +551,7 @@ void uwsgi_rack_init_apps(void) {
 		uwsgi_log("loading rails app %s\n", ur.rails);
 		rb_protect( require_rails, 0, &error ) ;
 		if (error) {
-                	uwsgi_manage_exception(NULL, 0);
+			uwsgi_ruby_exception_log(NULL);
 			exit(1);
                 }
 		uwsgi_log("rails app %s ready\n", ur.rails);
@@ -573,7 +573,7 @@ void uwsgi_rack_init_apps(void) {
 			if (acim_call == Qtrue) {
                         	ur.dispatcher = rb_protect(uwsgi_rb_call_new, ac_dispatcher, &error);
 				if (error) {
-                        		uwsgi_manage_exception(NULL, 0);
+					uwsgi_ruby_exception_log(NULL);
                         		exit(1);
 				}
 			}
@@ -583,7 +583,7 @@ void uwsgi_rack_init_apps(void) {
                         uwsgi_log("non-rack rails version detected...loading thin adapter...\n");
 			rb_protect( require_thin, 0, &error ) ;
                 	if (error) {
-                        	uwsgi_manage_exception(NULL, 0);
+				uwsgi_ruby_exception_log(NULL);
                         	exit(1);
                 	}
 			VALUE thin_rack = rb_const_get(rb_cObject, rb_intern("Rack"));
@@ -591,7 +591,7 @@ void uwsgi_rack_init_apps(void) {
 			VALUE thin_rack_adapter_rails = rb_const_get(thin_rack_adapter, rb_intern("Rails"));
 			ur.dispatcher = rb_protect( uwsgi_rb_call_new, thin_rack_adapter_rails, &error);
 			if (error) {
-                        	uwsgi_manage_exception(NULL, 0);
+				uwsgi_ruby_exception_log(NULL);
                         	exit(1);
 			}
                 }
@@ -963,7 +963,7 @@ VALUE init_rack_app( VALUE script ) {
 #endif
         rb_protect( require_rack, 0, &error ) ;
         if (error) {
-		uwsgi_manage_exception(NULL, 0);
+		uwsgi_ruby_exception_log(NULL);
 		return Qnil;
         }
 
@@ -1038,7 +1038,7 @@ int uwsgi_rack_mule(char *opt) {
         if (uwsgi_endswith(opt, (char *)".rb")) {
 		rb_protect( uwsgi_require_file, rb_str_new2(opt), &error ) ;
                 if (error) {
-			uwsgi_manage_exception(NULL, 0);
+			uwsgi_ruby_exception_log(NULL);
 			return 0;
                 }
                 return 1;
@@ -1063,7 +1063,7 @@ void uwsgi_rb_post_fork() {
         // call the post_fork_hook
 	rb_protect(uwsgi_rb_pfh, 0, &error);
 	if (error) {
-		uwsgi_manage_exception(NULL, 0);
+		uwsgi_ruby_exception_log(NULL);
 	}
 }
 
@@ -1081,7 +1081,7 @@ int uwsgi_rack_mule_msg(char *message, size_t len) {
 		VALUE arg = rb_str_new(message, len);
 		rb_protect(uwsgi_rb_mmh, arg, &error);
 		if (error) {
-			uwsgi_manage_exception(NULL, 0);
+			uwsgi_ruby_exception_log(NULL);
 		}
         	return 1;
 	}
@@ -1107,7 +1107,7 @@ int uwsgi_rack_signal_handler(uint8_t sig, void *handler) {
         rb_ary_store(args, 1, rbsig);
         rb_protect(rack_call_signal_handler, args, &error);
         if (error) {
-		uwsgi_manage_exception(NULL, 0);
+		uwsgi_ruby_exception_log(NULL);
                 rb_gc();
                 return -1;
         }
@@ -1155,7 +1155,7 @@ int uwsgi_rack_spooler(char *filename, char *buf, uint16_t len, char *body, size
 
         VALUE ret = rb_protect(uwsgi_rb_do_spooler, spool_dict, &error);
 	if (error) {
-		uwsgi_manage_exception(NULL, 0);
+		uwsgi_ruby_exception_log(NULL);
 		rb_gc();
 		return -1;
 	}

plugins/ring/uwsgiplugin.py

@@ -1,3 +1,6 @@
+import os
+import shutil
+
 jvm_path = 'plugins/jvm'
 
 up = {}
@@ -14,3 +17,13 @@ CFLAGS.append('-I%s' % jvm_path)
 LDFLAGS = []
 LIBS = []
 GCC_LIST = ['ring_plugin']
+
+def post_build(config):
+    env = os.environ.get('VIRTUAL_ENV')
+    if env:
+        plugin = "%s/ring_plugin.so" % os.getcwd()
+        if os.path.exists(plugin):
+            tgt = "%s/bin/ring_plugin.so" % env
+            shutil.copyfile(plugin, tgt)
+            print("*** ring_plugin.so had been copied to %s" % tgt)
+

plugins/router_cache/router_cache.c

@@ -10,25 +10,21 @@ extern struct uwsgi_server uwsgi;
 
 	syntax:
 
-	route = /^foobar1(.*)/ cache:key=foo$1poo,type=body
-	route = /^foobar1 cache:var=PATH_INFO,type=body
-	route = /^foobar2 cache:var=REQUEST_URI,type=full
-	route = /^foobar3 cache:var=REQUEST_URI,type=body,content_type=text/html
+	route = /^foobar1(.*)/ cache:key=foo$1poo,type=body,content_type=text/html,name=foobar
 
 */
 
 struct uwsgi_router_cache_conf {
 
+	// the name of the cache
+	char *name;
+
 	char *key;
 	size_t key_len;
-	char *var;
+
 	char *type;
 
-	long var_offset;
-	long var_offset_len;
-
 	char *content_type;
-	char *name;
 	size_t content_type_len;
 
 	// 0 -> full, 1 -> body
@@ -41,29 +37,14 @@ static int uwsgi_routing_func_cache(struct wsgi_request *wsgi_req, struct uwsgi_
 
 	struct uwsgi_router_cache_conf *urcc = (struct uwsgi_router_cache_conf *) ur->data2;
 
-	if (!uwsgi.cache_max_items) return UWSGI_ROUTE_NEXT;
-
-	char *c_k = NULL;
-	uint16_t c_k_len = 0;
-	int k_need_free = 0;
-
-	if (urcc->key) {
-		char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
-        	uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
-
-        	c_k = uwsgi_regexp_apply_ovec(*subject, *subject_len, urcc->key, urcc->key_len, ur->ovector, ur->ovn);
-		c_k_len = strlen(c_k);
-		k_need_free = 1;
-	}
-	else {
-		char **key = (char **) (((char *) wsgi_req) + urcc->var_offset);
-        	uint16_t *keylen = (uint16_t *) (((char *) wsgi_req) + urcc->var_offset_len);
-		c_k = *key;
-		c_k_len = *keylen;
-	}
+	char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
+        uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
+	struct uwsgi_buffer *ub = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urcc->key, urcc->key_len);
+        if (!ub) return UWSGI_ROUTE_BREAK;
 
 	uint64_t valsize = 0;
-	char *value = uwsgi_cache_magic_get(c_k, c_k_len, &valsize, urcc->name);
+	char *value = uwsgi_cache_magic_get(ub->buf, ub->pos, &valsize, urcc->name);
+	uwsgi_buffer_destroy(ub);
 	if (value) {
 		if (urcc->type_num == 1) {
 			if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto error;
@@ -73,17 +54,14 @@ static int uwsgi_routing_func_cache(struct wsgi_request *wsgi_req, struct uwsgi_
 		// body only
 		uwsgi_response_write_body_do(wsgi_req, value, valsize);
 		free(value);
-		if (k_need_free) free(c_k);
 		if (ur->custom)
 			return UWSGI_ROUTE_NEXT;
 		return UWSGI_ROUTE_BREAK;
 	}
-	if (k_need_free) free(c_k);
 	
 	return UWSGI_ROUTE_NEXT;
 error:
 	free(value);
-	if (k_need_free) free(c_k);
 	return UWSGI_ROUTE_BREAK;
 }
 
@@ -94,7 +72,6 @@ static int uwsgi_router_cache(struct uwsgi_route *ur, char *args) {
 	struct uwsgi_router_cache_conf *urcc = uwsgi_calloc(sizeof(struct uwsgi_router_cache_conf));
                 if (uwsgi_kvlist_parse(ur->data, ur->data_len, ',', '=',
                         "key", &urcc->key,
-                        "var", &urcc->var,
                         "content_type", &urcc->content_type,
                         "name", &urcc->name,
                         "type", &urcc->type, NULL)) {
@@ -106,8 +83,8 @@ static int uwsgi_router_cache(struct uwsgi_route *ur, char *args) {
 			urcc->key_len = strlen(urcc->key);
 		}
 
-		if (!urcc->key && !urcc->var) {
-			uwsgi_log("invalid route syntax: you need to specify a cache key or var\n");
+		if (!urcc->key) {
+			uwsgi_log("invalid route syntax: you need to specify a cache key\n");
 			exit(1);
 		}
 
@@ -116,21 +93,6 @@ static int uwsgi_router_cache(struct uwsgi_route *ur, char *args) {
 
                 urcc->content_type_len = strlen(urcc->content_type);
 
-		if (urcc->var) {
-                if (!strcmp(urcc->var, "REQUEST_URI")) {
-                        urcc->var_offset = offsetof(struct wsgi_request, uri);
-                        urcc->var_offset_len = offsetof(struct wsgi_request, uri_len);
-                }
-                else if (!strcmp(urcc->var, "PATH_INFO")) {
-                        urcc->var_offset = offsetof(struct wsgi_request, path_info);
-                        urcc->var_offset_len = offsetof(struct wsgi_request, path_info_len);
-                }
-                else {
-                        urcc->var_offset = offsetof(struct wsgi_request, uri);
-                        urcc->var_offset_len = offsetof(struct wsgi_request, uri_len);
-                }
-		}
-
                 if (!strcmp(urcc->type, "body")) {
                         urcc->type_num = 1;
                 }

plugins/rpc/rpc_plugin.c

@@ -40,10 +40,113 @@ static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 	return UWSGI_OK;
 }
 
+#ifdef UWSGI_ROUTING
+static int uwsgi_routing_func_rpc(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
+	int ret = -1;
+	// this is the list of args
+        char *argv[UMAX8];
+        // this is the size of each argument
+        uint16_t argvs[UMAX8];
+	// this is a placeholder for tmp uwsgi_buffers
+	struct uwsgi_buffer *ubs[UMAX8];
+
+	char **r_argv = (char **) ur->data2;
+	uint16_t *r_argvs = (uint16_t *) ur->data3;
+
+	char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
+        uint16_t *subject_len = (uint16_t *)  (((char *)(wsgi_req))+ur->subject_len);
+
+	uint64_t i;
+	for(i=0;i<ur->custom;i++) {
+		ubs[i] = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, r_argv[i], r_argvs[i]);
+		if (!ubs[i]) goto end;
+		argv[i] = ubs[i]->buf;
+		argvs[i] = ubs[i]->pos;
+	}
+
+	// ok we now need to check it it is a local call or a remote one
+	char *func = uwsgi_str(ur->data);
+	char *remote = NULL;
+	char *at = strchr(func, '@');
+	if (at) {
+		*at = 0;
+		remote = at+1;
+	}
+	uint16_t size;
+	char *response = uwsgi_do_rpc(remote, func, ur->custom, argv, argvs, &size);
+	free(func);
+	if (!response) goto end;
+
+	ret = UWSGI_ROUTE_BREAK;
+
+	if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) {free(response) ; goto end;}
+        if (uwsgi_response_add_content_length(wsgi_req, size)) {free(response) ; goto end;}
+	uwsgi_response_write_body_do(wsgi_req, response, size);
+	free(response);
+
+end:
+	for(i=0;i<ur->custom;i++) {
+		if (ubs[i] != NULL) {
+			uwsgi_buffer_destroy(ubs[i]);
+		}
+	}
+	return ret;
+}
+
+/*
+	ur->data = the func name
+        ur->custom = the number of arguments
+	ur->data2 = the pointer to the args
+	ur->data3 = the pointer to the args sizes
+*/
+static int uwsgi_router_rpc(struct uwsgi_route *ur, char *args) {
+        ur->func = uwsgi_routing_func_rpc;
+	ur->custom = 0;
+	ur->data2 = uwsgi_calloc(sizeof(char *) * UMAX8);
+	ur->data3 = uwsgi_calloc(sizeof(uint16_t) * UMAX8);
+	char *p = strtok(args, " ");
+	while(p) {
+		if (!ur->data) {
+			ur->data = p;
+		}
+		else {
+			if (ur->custom >= UMAX8) {
+				uwsgi_log("unable to register route: maximum number of rpc args reached\n");
+				free(ur->data2);
+				free(ur->data3);
+				return -1;
+			}
+			char **argv = (char **) ur->data2;
+			uint16_t *argvs = (uint16_t *) ur->data3;
+			argv[ur->custom] = p;
+			argvs[ur->custom] = strlen(p);
+			ur->custom++;	
+		}
+		p = strtok(NULL, " ");
+	}
+
+	if (!ur->data) {
+		uwsgi_log("unable to register route: you need to specify an rpc function\n");
+		free(ur->data2);
+		free(ur->data3);
+		return -1;
+	}
+	return 0;
+}
+
+static void router_rpc_register() {
+        uwsgi_register_router("call", uwsgi_router_rpc);
+        uwsgi_register_router("rpc", uwsgi_router_rpc);
+}
+#endif
+
 struct uwsgi_plugin rpc_plugin = {
 
 	.name = "rpc",
 	.modifier1 = 173,
 	
 	.request = uwsgi_rpc_request,
+#ifdef UWSGI_ROUTING
+	.on_load = router_rpc_register,
+#endif
 };

plugins/stats_pusher_mongodb/uwsgiplugin.py

@@ -1,7 +1,14 @@
+import os
+
 NAME='stats_pusher_mongodb'
 
 CFLAGS = ['-I/usr/include/mongo','-I/usr/local/include/mongo']
 LDFLAGS = []
-LIBS = ['-lmongoclient', '-lboost_thread','-lboost_filesystem']
+
+LIBS = []
+if not 'UWSGI_MONGODB_NOLIB' in os.environ:
+    LIBS.append('-lmongoclient')
+    LIBS.append('-lboost_thread')
+    LIBS.append('-lboost_filesystem')
 
 GCC_LIST = ['plugin', 'stats_pusher_mongodb.cc']

plugins/xslt/uwsgiplugin.py

@@ -0,0 +1,8 @@
+import os
+
+NAME='xslt'
+CFLAGS = os.popen('xslt-config --cflags').read().rstrip().split()
+LDFLAGS = os.popen('xslt-config --libs').read().rstrip().split()
+LIBS = []
+
+GCC_LIST = ['xslt']

plugins/xslt/xslt.c

@@ -0,0 +1,406 @@
+#include <uwsgi.h>
+
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
+
+/*
+
+	XSLT request plugin
+
+	it takes an XML file as input (taken from DOCUMENT_ROOT + PATH_INFO by default)
+	it search for an XSLT stylesheet (by default in DOCUMENT_ROOT + PATH_INFO - ext + .xsl|.xslt)
+	it applies params (by default taken from the QUERY_STRING)
+
+	XSLT routing instruction
+
+	xslt:doc=<path1>,stylesheet=<path2>,params=<params>
+
+*/
+
+struct uwsgi_xslt_config {
+	struct uwsgi_string_list *docroot;
+	struct uwsgi_string_list *ext;
+	struct uwsgi_string_list *var;
+	struct uwsgi_string_list *stylesheet;
+	char *content_type;
+	uint16_t content_type_len;
+} uxslt;
+
+struct uwsgi_router_xslt_conf {
+	char *doc;
+	uint16_t doc_len;
+	char *stylesheet;
+	uint16_t stylesheet_len;
+	char *params;
+	uint16_t params_len;
+	char *content_type;
+	uint16_t content_type_len;
+};
+
+struct uwsgi_option uwsgi_xslt_options[] = {
+	{"xslt-docroot", required_argument, 0, "add a document_root for xslt processing", uwsgi_opt_add_string_list, &uxslt.docroot, 0},
+	{"xslt-ext", required_argument, 0, "search for xslt stylesheets with the specified extension", uwsgi_opt_add_string_list, &uxslt.ext, 0},
+	{"xslt-var", required_argument, 0, "get the xslt stylesheet path from the specified request var", uwsgi_opt_add_string_list, &uxslt.var, 0},
+	{"xslt-stylesheet", required_argument, 0, "if no xslt stylesheet file can be found, use the specified one", uwsgi_opt_add_string_list, &uxslt.stylesheet, 0},
+	{"xslt-content-type", required_argument, 0, "set the content-type for the xslt rsult (default: text/html)", uwsgi_opt_set_str, &uxslt.content_type, 0},
+	{NULL, 0, 0, NULL, NULL, NULL, 0},
+};
+
+static char *uwsgi_xslt_apply(char *xmlfile, char *xsltfile, char *params, int *rlen) {
+
+	char **vparams = NULL;
+	char *tmp_params = NULL;
+	uint16_t count = 0;
+	if (params) {
+		// first count the number of items
+		size_t i;
+		size_t params_len = strlen(params);
+		for(i=0;i<params_len;i++) {
+			if (params[i] == '=') {
+				count++;
+			}
+		}
+		vparams = uwsgi_calloc( sizeof(char *) * ((count * 2) + 1));
+		tmp_params = uwsgi_str(params);
+		char *p = strtok(tmp_params, "&");
+		int pos = 0;
+		while(p) {
+			char *equal = strchr(p, '=');
+			if (equal) {
+				*equal = 0;
+				vparams[pos] = p; pos++;
+				vparams[pos] = uwsgi_concat3("\"", equal+1, "\""); pos++;	
+			}
+			p = strtok(NULL, "&");
+		}
+	}
+
+	// we reset them every time to avoid collision with other xml engines
+	xmlSubstituteEntitiesDefault(1);
+	xmlLoadExtDtdDefaultValue = 1;
+
+        xmlDocPtr doc = xmlParseFile(xmlfile);
+        if (!doc) {
+		if (vparams) {
+			int i; for(i=1;i<(count*2);i+=2) free(vparams[i]);
+			free(tmp_params);
+			free(vparams);
+		}
+		return NULL;
+	}
+
+        xsltStylesheetPtr ss = xsltParseStylesheetFile((const xmlChar *) xsltfile);
+        if (!ss) {
+		xmlFreeDoc(doc);
+		if (vparams) {
+			int i; for(i=1;i<(count*2);i+=2) free(vparams[i]);
+			free(tmp_params);
+			free(vparams);
+		}
+                return NULL;
+        }
+
+        xmlDocPtr res = xsltApplyStylesheet(ss, doc, (const char **) vparams);
+	if (!res) {
+		xsltFreeStylesheet(ss);
+		xmlFreeDoc(doc);
+		if (vparams) {
+			int i; for(i=1;i<(count*2);i+=2) free(vparams[i]);
+			free(tmp_params);
+			free(vparams);
+		}
+		return NULL;
+	}
+
+        xmlChar *output;
+        int ret = xsltSaveResultToString(&output, rlen, res, ss);
+	xsltFreeStylesheet(ss);
+	xmlFreeDoc(res);
+	xmlFreeDoc(doc);
+	if (vparams) {
+		int i; for(i=1;i<(count*2);i+=2) free(vparams[i]);
+		free(tmp_params);
+		free(vparams);
+	}
+	if (ret < 0) return NULL;
+	return (char *) output;
+}
+
+static int uwsgi_request_xslt(struct wsgi_request *wsgi_req) {
+
+	char *xmlfile = NULL;
+	char *output = NULL;
+        int output_rlen = 0;
+
+	char filename[PATH_MAX+1];
+	size_t filename_len = 0;
+	char stylesheet[PATH_MAX+1];
+	size_t stylesheet_len = 0;
+	
+	char *params = NULL;
+
+	if (uwsgi_parse_vars(wsgi_req)) {
+		return -1;
+	}
+
+	// set default values
+	if (!uxslt.content_type_len) {
+		if (!uxslt.content_type) {
+			uxslt.content_type = "text/html";
+		}
+		uxslt.content_type_len = strlen(uxslt.content_type);
+	}
+
+	struct uwsgi_string_list *usl = uxslt.docroot;
+
+	// first check for static docroots
+	if (usl) {
+		while(usl) {
+			xmlfile = uwsgi_concat3n(usl->value, usl->len, "/", 1, wsgi_req->path_info, wsgi_req->path_info_len);
+			if (uwsgi_is_file(xmlfile)) {
+				break;
+			}
+			free(xmlfile);
+			xmlfile = NULL;
+			usl = usl->next;
+		}	
+	}
+	// fallback to DOCUMENT_ROOT
+	else {
+		if (wsgi_req->document_root_len == 0) {
+			uwsgi_403(wsgi_req);
+			return UWSGI_OK;
+		}
+
+		xmlfile = uwsgi_concat3n(wsgi_req->document_root, wsgi_req->document_root_len, "/", 1, wsgi_req->path_info, wsgi_req->path_info_len);
+	}
+
+	if (!xmlfile) {
+		uwsgi_404(wsgi_req);
+		return UWSGI_OK;
+	}
+
+	// we have the full path, check if it is valid
+	if (!uwsgi_expand_path(xmlfile, strlen(xmlfile), filename)) {
+		free(xmlfile);
+		uwsgi_404(wsgi_req);
+		return UWSGI_OK;
+	}
+
+	free(xmlfile);
+
+	if (!uwsgi_is_file(filename)) {
+		uwsgi_403(wsgi_req);
+		return UWSGI_OK;
+	}
+	filename_len = strlen(filename);
+
+	// now search for the xslt file
+	
+	int found = 0;
+
+	// first check for specific vars
+	usl = uxslt.var;
+	while(usl) {
+		uint16_t rlen;
+		char *value = uwsgi_get_var(wsgi_req, usl->value, usl->len, &rlen);
+		if (value) {
+			memcpy(stylesheet, value, rlen);
+			stylesheet[rlen] = 0;
+			stylesheet_len = rlen;
+			found = 1;
+			break;
+		}
+		usl = usl->next;
+	}
+
+	if (found) goto apply;
+
+	// then check for custom extensions
+	if (uxslt.ext) {
+		usl = uxslt.ext;
+		while(usl) {
+			char *tmp_path = uwsgi_concat2n(filename, filename_len, usl->value, usl->len);
+			if (uwsgi_is_file(tmp_path)) {
+				stylesheet_len = filename_len + usl->len;
+				memcpy(stylesheet, tmp_path, stylesheet_len);
+				stylesheet[stylesheet_len] = 0;
+				free(tmp_path);
+				found = 1;
+				break;
+			}
+			free(tmp_path);
+			usl = usl->next;
+		}
+	}
+	// use default extensions .xsl/.xslt
+	else {
+		char *tmp_path = uwsgi_concat2n(filename, filename_len, ".xsl", 4);
+                if (uwsgi_is_file(tmp_path)) {
+                	stylesheet_len = filename_len + 4;
+                        memcpy(stylesheet, tmp_path, stylesheet_len);
+			stylesheet[stylesheet_len] = 0;
+                        free(tmp_path);
+			goto apply;	
+		}
+                free(tmp_path);
+		tmp_path = uwsgi_concat2n(filename, filename_len, ".xslt", 5);
+                if (uwsgi_is_file(tmp_path)) {
+                        stylesheet_len = filename_len + 5;
+                        memcpy(stylesheet, tmp_path, stylesheet_len);
+			stylesheet[stylesheet_len] = 0;
+			found = 1;
+                }
+                free(tmp_path);
+	}
+
+	if (found) goto apply;
+
+	// finally check for static stylesheets
+	usl = uxslt.stylesheet;
+	while(usl) {
+		if (uwsgi_is_file(usl->value)) {
+			memcpy(stylesheet, usl->value, usl->len);
+			stylesheet_len = usl->len;
+			stylesheet[stylesheet_len] = 0;
+			found = 1;
+			break;
+		}
+		usl = usl->next;
+	}
+
+	if (found) goto apply;
+	
+	uwsgi_404(wsgi_req);
+	return UWSGI_OK;
+
+apply:
+	if (wsgi_req->query_string_len > 0) {
+		params = uwsgi_concat2n(wsgi_req->query_string, wsgi_req->query_string_len, "", 0);
+	}
+	// we have both the file and the stylesheet, let's run the engine
+	output = uwsgi_xslt_apply(filename, stylesheet, params, &output_rlen);
+	if (params) free(params);
+	if (!output) {
+		uwsgi_500(wsgi_req);
+		return UWSGI_OK;
+	}
+
+	// prepare headers
+	if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) {
+		uwsgi_500(wsgi_req);
+		goto end;
+	}
+	// content_length
+	if (uwsgi_response_add_content_length(wsgi_req, output_rlen)) {
+		uwsgi_500(wsgi_req);
+		goto end;
+	}
+	// content_type
+	if (uwsgi_response_add_content_type(wsgi_req, uxslt.content_type, uxslt.content_type_len)) {
+		uwsgi_500(wsgi_req);
+		goto end;
+	}
+
+	uwsgi_response_write_body_do(wsgi_req, output, output_rlen);
+
+end:
+	xmlFree(output);
+	return UWSGI_OK;
+}
+
+static void uwsgi_xslt_log(struct wsgi_request *wsgi_req) {
+	log_request(wsgi_req);
+}
+
+static int uwsgi_routing_func_xslt(struct wsgi_request *wsgi_req, struct uwsgi_route *ur){
+
+        struct uwsgi_router_xslt_conf *urxc = (struct uwsgi_router_xslt_conf *) ur->data2;
+
+	char **subject = (char **) (((char *)(wsgi_req))+ur->subject);
+        uint16_t *subject_len = (uint16_t *) (((char *)(wsgi_req))+ur->subject_len);
+
+	struct uwsgi_buffer *ub_doc = NULL;
+	struct uwsgi_buffer *ub_stylesheet = NULL;
+	struct uwsgi_buffer *ub_params = NULL;
+	struct uwsgi_buffer *ub_content_type = NULL;
+
+	ub_doc = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->doc, urxc->doc_len);
+	if (!ub_doc) goto end;
+	ub_stylesheet = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->stylesheet, urxc->stylesheet_len);
+	if (!ub_stylesheet) goto end;
+
+	if (urxc->params) {
+		ub_params = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->params, urxc->params_len);
+		if (!ub_params) goto end;
+	}
+
+	if (urxc->content_type) {
+		ub_content_type = uwsgi_routing_translate(wsgi_req, ur, *subject, *subject_len, urxc->content_type, urxc->content_type_len);
+		if (!ub_content_type) goto end;
+	}
+
+	int rlen;
+        char *output = uwsgi_xslt_apply( ub_doc->buf, ub_stylesheet->buf, ub_params ? ub_params->buf : NULL, &rlen);
+	if (!output) goto end;
+
+        if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
+        if (uwsgi_response_add_content_length(wsgi_req, rlen)) goto end;
+        if (uwsgi_response_add_content_type(wsgi_req, urxc->content_type, urxc->content_type_len)) goto end;
+
+        uwsgi_response_write_body_do(wsgi_req, output, rlen);
+	xmlFree(output);
+
+end:
+	if (ub_doc) uwsgi_buffer_destroy(ub_doc);
+	if (ub_stylesheet) uwsgi_buffer_destroy(ub_stylesheet);
+	if (ub_params) uwsgi_buffer_destroy(ub_params);
+	if (ub_content_type) uwsgi_buffer_destroy(ub_content_type);
+        return UWSGI_ROUTE_BREAK;
+}
+
+
+static int uwsgi_router_xslt(struct uwsgi_route *ur, char *args) {
+        ur->func = uwsgi_routing_func_xslt;
+        ur->data = args;
+        ur->data_len = strlen(args);
+        struct uwsgi_router_xslt_conf *urxc = uwsgi_calloc(sizeof(struct uwsgi_router_xslt_conf));
+        if (uwsgi_kvlist_parse(ur->data, ur->data_len, ',', '=',
+                        "doc", &urxc->doc,
+                        "stylesheet", &urxc->stylesheet,
+                        "content_type", &urxc->content_type,
+                        "params", &urxc->params,
+                        NULL)) {
+                        uwsgi_log("invalid route syntax: %s\n", args);
+                        exit(1);
+	}
+
+	if (!urxc->doc && !urxc->stylesheet) {
+                uwsgi_log("invalid route syntax: you need to specify a doc and a stylesheet\n");
+        	exit(1);
+	}
+
+	urxc->doc_len = strlen(urxc->doc);
+	urxc->stylesheet_len = strlen(urxc->stylesheet);
+
+	if (urxc->params) urxc->params_len = strlen(urxc->params);
+	if (!urxc->content_type) urxc->content_type = "text/html";
+	urxc->content_type_len = strlen(urxc->content_type);
+        ur->data2 = urxc;
+        return 0;
+}
+
+
+static void router_xslt_register() {
+        uwsgi_register_router("xslt", uwsgi_router_xslt);
+}
+
+
+struct uwsgi_plugin xslt_plugin = {
+	.name = "xslt",
+	.modifier1 = 23,
+	.options = uwsgi_xslt_options,
+	.request = uwsgi_request_xslt,
+	.after_request = uwsgi_xslt_log,
+        .on_load = router_xslt_register,
+};

t/xslt/cd.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0"?>
+<!-- Edited by XMLSpy® -->
+<catalog>
+	<cd>
+		<title>Quintessence</title>
+		<artist>Borknagar</artist>
+	</cd>
+	<cd>
+		<title>Torn Beyond Reason</title>
+		<artist>Woods Of Desolation</artist>
+	</cd>
+	<cd>
+		<title>Autumn Aurora</title>
+		<artist>Drudkh</artist>
+	</cd>
+	<cd>
+		<title>Om</title>
+		<artist>Negura Bunget</artist>
+	</cd>
+	<cd>
+		<title>Frostnacht</title>
+		<artist>Helrunar</artist>
+	</cd>
+</catalog>

t/xslt/cd.xml.xslt

@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+
+<xsl:template match="/">
+  <html>
+  <body>
+  <h2>Blackmetal albums</h2>
+    <table border="1">
+      <tr bgcolor="black">
+        <th style="color:white">Title</th>
+        <th style="color:white">Artist</th>
+      </tr>
+      <xsl:for-each select="catalog/cd">
+      <tr>
+        <td><xsl:value-of select="title"/></td>
+        <td><xsl:value-of select="artist"/></td>
+        <td>-<xsl:value-of select="$foobar"/>-</td>
+        <td><xsl:value-of select="$agent"/></td>
+      </tr>
+      </xsl:for-each>
+    </table>
+  </body>
+  </html>
+</xsl:template>
+</xsl:stylesheet>

t/xslt/routex.ini

@@ -0,0 +1,5 @@
+[uwsgi]
+http-socket = :9090
+plugin = xslt
+xml_storage = t/xslt
+route = /(.*)$ xslt:doc=%(xml_storage)/$1.xml,stylesheet=%(xml_storage)/$1.xml.xslt,content_type=text/html,params=foobar=test&agent=${HTTP_USER_AGENT}

unbit.h

@@ -1,51 +0,0 @@
-/* taken from http://wiki.unbit.it/UnbitKernel */
-struct uidsec_struct {
-	/* network limits */
-	unsigned short ipv4_tcp_port;
-	unsigned short ipv4_udp_port;
-	unsigned short ipv4_tcp_control_port;
-
-	int ipv4_tcp_socket_protection;
-	unsigned long long ipv4_firewall_mask;
-
-	/* limits */
-	int fs_readonly;
-
-	/* process markers */
-	int domain_id;
-	int fcgi_id;
-	int scgi_id;
-	int apps_id;
-	int wapp_id;
-	int ssh_id;
-	int cron_id;
-
-	/* thread ? */
-	int cloned_vm;
-
-	/* process limit */
-	int max_dom_proc;
-	int max_apps_proc;
-	int max_apps_thread;
-	int max_ssh_proc;
-	int max_cron_proc;
-
-	/* misc */
-	int control_uid;
-	int listen_backlog;
-	int errors;
-
-	/* counters */
-	int accept_cnt;
-	int accept_last;
-
-	int fork_cnt;
-	int fork_last;
-
-	unsigned long long bio_read;
-	unsigned long long bio_write;
-
-	int memory_errors;
-
-};
-

uwsgi_main.c

@@ -0,0 +1,5 @@
+int uwsgi_init(int, char **, char **);
+
+int main(int argc, char *argv[], char **environ) {
+	return uwsgi_init(argc, argv, environ);
+}

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '1.9'
+uwsgi_version = '1.9.1'
 
 import os
 import re
@@ -64,7 +64,6 @@ report['pcre'] = False
 report['matheval'] = False
 report['routing'] = False
 report['capabilities'] = False
-report['ini'] = False
 report['yaml'] = False
 report['json'] = False
 report['ldap'] = False
@@ -422,6 +421,20 @@ def build_uwsgi(uc, print_only=False):
     for pb in post_build:
         pb(uc)
 
+def open_profile(filename):
+    if filename.startswith('http://') or filename.startswith('https://') or filename.startswith('ftp://'):
+        wrapped = False
+        try:
+            import urllib2
+        except:
+            import urllib.request
+            wrapped = True
+
+        if wrapped:
+            import io
+            return io.TextIOWrapper(urllib.request.urlopen(filename), encoding='utf-8')
+        return urllib2.urlopen(filename)
+    return open(filename)
 
 class uConf(object):
 
@@ -429,8 +442,6 @@ class uConf(object):
         self.config = ConfigParser.ConfigParser()
         if not mute:
             print("using profile: %s" % filename)
-        if not os.path.exists(filename):
-            raise Exception("profile not found !!!")
 
         if os.path.exists('uwsgibuild.lastprofile'):
             ulp = open('uwsgibuild.lastprofile','r')
@@ -443,13 +454,13 @@ class uConf(object):
         ulp.write(filename)
         ulp.close()
 
-        self.config.read(filename)
+        self.config.readfp(open_profile(filename))
         self.gcc_list = ['core/utils', 'core/protocol', 'core/socket', 'core/logging', 'core/master', 'core/master_utils', 'core/emperor',
             'core/notify', 'core/mule', 'core/subscription', 'core/stats', 'core/sendfile', 'core/async', 'core/master_checks',
             'core/offload', 'core/io', 'core/static', 'core/websockets', 'core/spooler', 'core/snmp', 'core/exceptions',
             'core/setup_utils', 'core/clock', 'core/init', 'core/buffer', 'core/reader', 'core/writer', 'core/alarm',
             'core/plugins', 'core/lock', 'core/cache', 'core/daemons', 'core/errors', 'core/hash', 'core/master_events',
-            'core/queue', 'core/event', 'core/signal', 'core/strings', 'core/progress', 'core/timebomb',
+            'core/queue', 'core/event', 'core/signal', 'core/strings', 'core/progress', 'core/timebomb', 'core/ini',
             'core/rpc', 'core/gateway', 'core/loop', 'core/rb_timers', 'core/uwsgi']
         # add protocols
         self.gcc_list.append('proto/base')
@@ -532,7 +543,8 @@ class uConf(object):
             for option in self.config.options('uwsgi'):
                 interpolations[option] = self.get(option)
             iconfig = ConfigParser.ConfigParser(interpolations)
-            iconfig.read(inherit)
+            iconfig.readfp(open_profile(inherit))
+
             for opt in iconfig.options('uwsgi'):
                 if not self.config.has_option('uwsgi', opt):
                     self.set(opt, iconfig.get('uwsgi', opt))
@@ -615,7 +627,6 @@ class uConf(object):
             self.libs.append('-lkvm')
 
         if uwsgi_os == 'Haiku':
-            self.set('async', 'false')
             self.libs.remove('-rdynamic')
             self.libs.remove('-lpthread')
             self.libs.append('-lroot')
@@ -923,11 +934,6 @@ class uConf(object):
         self.cflags.append('-DUWSGI_VERSION_REVISION="' + uver_rev + '"')
         self.cflags.append('-DUWSGI_VERSION_CUSTOM="\\"' + uver_custom + '\\""')
 
-        if self.get('ini'):
-            self.cflags.append("-DUWSGI_INI")
-            self.gcc_list.append('core/ini')
-            report['ini'] = True
-
         if self.get('yaml'):
             self.cflags.append("-DUWSGI_YAML")
             self.gcc_list.append('core/yaml')
@@ -1081,38 +1087,41 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
         print("Error: unable to find directory '%s'" % path)
         sys.exit(1)
 
-    sys.path.insert(0, path)
-    import uwsgiplugin as up
-    if sys.argv[1] != '--plugin':
-        reload(up)
+    up = {}
+    try:
+        execfile('%s/uwsgiplugin.py' % path, up)
+    except:
+        f = open('%s/uwsgiplugin.py' % path)
+        exec(f.read(), up)
+        f.close()
 
     requires = []
 
     p_cflags = cflags[:]
     p_ldflags = ldflags[:]
 
-    p_cflags += up.CFLAGS
-    p_ldflags += up.LDFLAGS
-    p_libs = up.LIBS
+    p_cflags += up['CFLAGS']
+    p_ldflags += up['LDFLAGS']
+    p_libs = up['LIBS']
 
     post_build = None
 
     try:
-        requires = up.REQUIRES
+        requires = up['REQUIRES']
     except:
         pass
 
     try:
-        post_build = up.post_build
+        post_build = up['post_build']
     except:
         pass
 
     p_cflags.insert(0, '-I.')
 
     if name is None:
-        name = up.NAME
+        name = up['NAME']
     else:
-        p_cflags.append("-D%s_plugin=%s_plugin" % (up.NAME, name))
+        p_cflags.append("-D%s_plugin=%s_plugin" % (up['NAME'], name))
 
     try:
         for opt in uc.config.options(name):
@@ -1132,7 +1141,7 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
     if uwsgi_os == 'Darwin':
         shared_flag = '-dynamiclib -undefined dynamic_lookup'
 
-    for cfile in up.GCC_LIST:
+    for cfile in up['GCC_LIST']:
         if cfile.endswith('.a'): 
             gcc_list.append(cfile)
         elif not cfile.endswith('.c') and not cfile.endswith('.cc') and not cfile.endswith('.m'):
@@ -1182,9 +1191,6 @@ def build_plugin(path, uc, cflags, ldflags, libs, name = None):
         except:
             pass
 
-    #for ofile in up.OBJ_LIST:
-    #    gcc_list.insert(0,ofile)
-
     need_pic = ' -fPIC'
     # on cygwin we do not need PIC
     if uwsgi_os.startswith('CYGWIN'):