prepare for 1.9.17

pty.c: `--pty-exec` should have a `required_argument`

buildconf/all.ini

@@ -1,3 +1,3 @@
 [uwsgi]
-main_plugin = python,gevent,psgi,lua,php,rack,jvm,jwsgi,ring,mono,transformation_toupper,coroae,v8,cgi,xslt,webdav,ssi,ldap
+main_plugin = python,gevent,psgi,lua,php,rack,jvm,jwsgi,ring,mono,transformation_toupper,coroae,v8,cgi,xslt,webdav,ssi,ldap,gccgo,rados
 inherit = base

core/alarm.c

@@ -184,8 +184,8 @@ static int uwsgi_alarm_log_add(char *alarms, char *regexp, int negate) {
 
 	// map instances to the log
 	char *list = uwsgi_str(alarms);
-	char *p = strtok(list, ",");
-	while (p) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(list, ",", p, ctx) {
 		struct uwsgi_alarm_instance *uai = uwsgi_alarm_get_instance(p);
 		if (!uai) {
 			free(list);
@@ -205,7 +205,6 @@ static int uwsgi_alarm_log_add(char *alarms, char *regexp, int negate) {
 		else {
 			ual->alarms = uall;
 		}
-		p = strtok(NULL, ",");
 	}
 	free(list);
 	return 0;

core/cache.c

@@ -1191,26 +1191,23 @@ struct uwsgi_cache *uwsgi_cache_create(char *arg) {
 		uc->store = c_store;
 
 		if (c_nodes) {
-			char *p = strtok(c_nodes, ";");
-			while(p) {
+			char *p, *ctx = NULL;
+			uwsgi_foreach_token(c_nodes, ";", p, ctx) {
 				uwsgi_string_new_list(&uc->nodes, p);
-				p = strtok(NULL, ";");
 			}
 		}
 
 		if (c_sync) {
-			char *p = strtok(c_sync, ";");
-                        while(p) {
+			char *p, *ctx = NULL;
+			uwsgi_foreach_token(c_sync, ";", p, ctx) {
                                 uwsgi_string_new_list(&uc->sync_nodes, p);
-                                p = strtok(NULL, ";");
                         }
 		}
 
 		if (c_udp_servers) {
-                        char *p = strtok(c_udp_servers, ";");
-                        while(p) {
+			char *p, *ctx = NULL;
+                        uwsgi_foreach_token(c_udp_servers, ";", p, ctx) {
                                 uwsgi_string_new_list(&uc->udp_servers, p);
-                                p = strtok(NULL, ";");
                         }
                 }
 		

core/config.c

@@ -55,10 +55,9 @@ int uwsgi_logic_opt_if_not_exists(char *key, char *value) {
 
 int uwsgi_logic_opt_for(char *key, char *value) {
 
-        char *p = strtok(uwsgi.logic_opt_data, " ");
-        while (p) {
+        char *p, *ctx = NULL;
+	uwsgi_foreach_token(uwsgi.logic_opt_data, " ", p, ctx) {
                 add_exported_option(key, uwsgi_substitute(value, "%(_)", p), 0);
-                p = strtok(NULL, " ");
         }
 
         return 1;

core/emperor.c

@@ -1031,6 +1031,12 @@ static void uwsgi_emperor_spawn_vassal(struct uwsgi_instance *n_ui) {
 			uct = uct->next;
 		}
 
+		uct = uwsgi.vassals_includes;
+                while (uct) {
+                        counter += 2;
+                        uct = uct->next;
+                }
+
 		char **vassal_argv = uwsgi_malloc(sizeof(char *) * counter);
 		// set args
 		vassal_argv[0] = uwsgi.binary_path;
@@ -1093,6 +1099,15 @@ static void uwsgi_emperor_spawn_vassal(struct uwsgi_instance *n_ui) {
 			counter += 2;
 			uct = uct->next;
 		}
+
+		uct = uwsgi.vassals_includes;
+                while (uct) {
+                        vassal_argv[counter] = "--include";
+                        vassal_argv[counter + 1] = uct->value;
+                        counter += 2;
+                        uct = uct->next;
+                }
+
 		vassal_argv[counter] = NULL;
 
 		// disable stdin OR map it to the "on demand" socket
@@ -1506,10 +1521,14 @@ void emperor_loop() {
 		while (ui_current) {
 			if (ui_current->last_heartbeat > 0) {
 				if ((ui_current->last_heartbeat + uwsgi.emperor_heartbeat) < uwsgi_now()) {
-					uwsgi_log("[emperor] vassal %s sent no heartbeat in last %d seconds, respawning it...\n", ui_current->name, uwsgi.emperor_heartbeat);
+					uwsgi_log("[emperor] vassal %s sent no heartbeat in last %d seconds, brutally respawning it...\n", ui_current->name, uwsgi.emperor_heartbeat);
 					// set last_heartbeat to 0 avoiding races
 					ui_current->last_heartbeat = 0;
-					emperor_respawn(ui_current, uwsgi_now());
+					if (ui_current->pid > 0) {
+						if (kill(ui_current->pid, SIGKILL)) {
+							uwsgi_error("[emperor] kill()");
+						}
+					}
 				}
 			}
 			ui_current = ui_current->ui_next;

core/fifo.c

@@ -0,0 +1,122 @@
+#include <uwsgi.h>
+
+extern struct uwsgi_server uwsgi;
+
+/*
+
+	the --master-fifo option create a unix named pipe (fifo) you can use to send management
+	commands to the master:
+
+	echo r > myfifo
+
+*/
+
+// this var can be accessed by plugins and hooks
+void (*uwsgi_fifo_table[256])(int);
+
+static char *uwsgi_fifo_by_slot() {
+	int count = 0;
+	struct uwsgi_string_list *usl;
+	uwsgi_foreach(usl, uwsgi.master_fifo) {
+		if (count == uwsgi.master_fifo_slot) return usl->value;
+		count++;
+	}
+	return uwsgi.master_fifo->value;
+}
+
+static void uwsgi_fifo_set_slot_zero() { uwsgi.master_fifo_slot = 0; }
+static void uwsgi_fifo_set_slot_one() { uwsgi.master_fifo_slot = 1; }
+static void uwsgi_fifo_set_slot_two() { uwsgi.master_fifo_slot = 2; }
+static void uwsgi_fifo_set_slot_three() { uwsgi.master_fifo_slot = 3; }
+static void uwsgi_fifo_set_slot_four() { uwsgi.master_fifo_slot = 4; }
+static void uwsgi_fifo_set_slot_five() { uwsgi.master_fifo_slot = 5; }
+static void uwsgi_fifo_set_slot_six() { uwsgi.master_fifo_slot = 6; }
+static void uwsgi_fifo_set_slot_seven() { uwsgi.master_fifo_slot = 7; }
+static void uwsgi_fifo_set_slot_eight() { uwsgi.master_fifo_slot = 8; }
+static void uwsgi_fifo_set_slot_nine() { uwsgi.master_fifo_slot = 9; }
+
+/*
+
+this is called as soon as possibile allowing plugins (or hooks) to override it
+
+*/
+void uwsgi_master_fifo_prepare() {
+	int i;
+	for(i=0;i<256;i++) {
+		uwsgi_fifo_table[i] = NULL;
+	}
+
+	uwsgi_fifo_table['0'] = uwsgi_fifo_set_slot_zero;
+	uwsgi_fifo_table['1'] = uwsgi_fifo_set_slot_one;
+	uwsgi_fifo_table['2'] = uwsgi_fifo_set_slot_two;
+	uwsgi_fifo_table['3'] = uwsgi_fifo_set_slot_three;
+	uwsgi_fifo_table['4'] = uwsgi_fifo_set_slot_four;
+	uwsgi_fifo_table['5'] = uwsgi_fifo_set_slot_five;
+	uwsgi_fifo_table['6'] = uwsgi_fifo_set_slot_six;
+	uwsgi_fifo_table['7'] = uwsgi_fifo_set_slot_seven;
+	uwsgi_fifo_table['8'] = uwsgi_fifo_set_slot_eight;
+	uwsgi_fifo_table['9'] = uwsgi_fifo_set_slot_nine;
+
+	uwsgi_fifo_table['-'] = uwsgi_cheaper_decrease;
+	uwsgi_fifo_table['+'] = uwsgi_cheaper_increase;
+	uwsgi_fifo_table['c'] = uwsgi_chain_reload;
+	uwsgi_fifo_table['C'] = uwsgi_go_cheap;
+	uwsgi_fifo_table['f'] = uwsgi_refork_master;
+	uwsgi_fifo_table['l'] = uwsgi_log_reopen;
+	uwsgi_fifo_table['L'] = uwsgi_log_rotate;
+	uwsgi_fifo_table['p'] = suspend_resume_them_all;
+	uwsgi_fifo_table['P'] = uwsgi_update_pidfiles;
+	uwsgi_fifo_table['q'] = gracefully_kill_them_all;
+	uwsgi_fifo_table['Q'] = kill_them_all;
+	uwsgi_fifo_table['r'] = grace_them_all;
+	uwsgi_fifo_table['R'] = reap_them_all;
+	uwsgi_fifo_table['s'] = stats;
+	uwsgi_fifo_table['w'] = uwsgi_reload_workers;
+	uwsgi_fifo_table['W'] = uwsgi_brutally_reload_workers;
+
+}
+
+int uwsgi_master_fifo() {
+
+	char *path = uwsgi_fifo_by_slot();
+
+	unlink(path);
+
+	if (mkfifo(path, S_IRUSR|S_IWUSR)) {
+		uwsgi_error("uwsgi_master_fifo()/mkfifo()");
+		exit(1);
+	}
+
+	int fd = open(path, O_RDONLY|O_NONBLOCK);
+	if (fd < 0) {
+		uwsgi_error("uwsgi_master_fifo()/open()");
+		exit(1);
+	}
+
+	uwsgi_socket_nb(fd);
+
+	return fd;
+}
+
+int uwsgi_master_fifo_manage(int fd) {
+	char cmd;
+	ssize_t rlen = read(fd, &cmd, 1);
+	if (rlen < 0) {
+		if (uwsgi_is_again()) return 0;
+		uwsgi_error("uwsgi_master_fifo_manage()/read()");
+		exit(1);
+	}
+	// fifo destroyed, recreate it
+	else if (rlen == 0) {
+		close(fd);
+		uwsgi.master_fifo_fd = uwsgi_master_fifo();
+		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.master_fifo_fd);
+		return 0;
+	}
+
+	if (uwsgi_fifo_table[(int) cmd]) {
+		uwsgi_fifo_table[(int) cmd](0);
+	}
+	
+	return 0;
+}

core/init.c

@@ -172,6 +172,11 @@ void uwsgi_init_default() {
 	
 	// 1 MB default limit
 	uwsgi.chunked_input_limit = 1024*1024;
+
+	// clear reforked status
+	uwsgi.master_is_reforked = 0;
+
+	uwsgi_master_fifo_prepare();
 }
 
 void uwsgi_setup_reload() {
@@ -216,21 +221,19 @@ void uwsgi_autoload_plugins_by_name(char *argv_zero) {
 		p = original_proc_name;
 	p = strstr(p, "uwsgi_");
 	if (p != NULL) {
-		plugins_requested = strtok(uwsgi_str(p + 6), "_");
-		while (plugins_requested) {
+		char *ctx = NULL;
+		uwsgi_foreach_token(uwsgi_str(p + 6), "_", plugins_requested, ctx) {
 			uwsgi_log("[uwsgi] implicit plugin requested %s\n", plugins_requested);
 			uwsgi_load_plugin(-1, plugins_requested, NULL);
-			plugins_requested = strtok(NULL, "_");
 		}
 	}
 
 	plugins_requested = getenv("UWSGI_PLUGINS");
 	if (plugins_requested) {
 		plugins_requested = uwsgi_concat2(plugins_requested, "");
-		char *p = strtok(plugins_requested, ",");
-		while (p != NULL) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(plugins_requested, ",", p, ctx) {
 			uwsgi_load_plugin(-1, p, NULL);
-			p = strtok(NULL, ",");
 		}
 	}
 

core/logging.c

@@ -488,7 +488,6 @@ void uwsgi_logvar_add(struct wsgi_request *wsgi_req, char *key, uint8_t keylen,
 
 void uwsgi_check_logrotate(void) {
 
-	char message[1024];
 	int need_rotation = 0;
 	int need_reopen = 0;
 
@@ -512,70 +511,81 @@ void uwsgi_check_logrotate(void) {
 	}
 
 	if (need_rotation) {
-
-		char *rot_name = uwsgi.log_backupname;
-		int need_free = 0;
-		if (rot_name == NULL) {
-			char *ts_str = uwsgi_num2str((int) uwsgi_now());
-			rot_name = uwsgi_concat3(uwsgi.logfile, ".", ts_str);
-			free(ts_str);
-			need_free = 1;
-		}
-		int ret = snprintf(message, 1024, "[%d] logsize: %llu, triggering rotation to %s...\n", (int) uwsgi_now(), (unsigned long long) uwsgi.shared->logsize, rot_name);
-		if (ret > 0) {
-			if (write(uwsgi.original_log_fd, message, ret) != ret) {
-				// very probably this will never be printed
-				uwsgi_error("write()");
-			}
-		}
-		if (rename(uwsgi.logfile, rot_name) == 0) {
-			// reopen logfile dup'it and eventually gracefully reload workers;
-			int fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP);
-			if (fd < 0) {
-				uwsgi_error_open(uwsgi.logfile);
-				grace_them_all(0);
-			}
-			else {
-				if (dup2(fd, uwsgi.original_log_fd) < 0) {
-					uwsgi_error("dup2()");
-					grace_them_all(0);
-				}
-				close(fd);
-			}
-		}
-		else {
-			uwsgi_error("unable to rotate log: rename()");
-		}
-		if (need_free)
-			free(rot_name);
+		uwsgi_log_rotate();
 	}
 	else if (need_reopen) {
-		int ret = snprintf(message, 1024, "[%d] logsize: %llu, triggering log-reopen...\n", (int) uwsgi_now(), (unsigned long long) uwsgi.shared->logsize);
-		if (ret > 0) {
-			if (write(uwsgi.original_log_fd, message, ret) != ret) {
-				// very probably this will never be printed
-				uwsgi_error("write()");
-			}
-		}
-
-		// reopen logfile;
-		close(uwsgi.original_log_fd);
-		uwsgi.original_log_fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP);
-		if (uwsgi.original_log_fd < 0) {
-			uwsgi_error_open(uwsgi.logfile);
-			grace_them_all(0);
-		}
-		ret = snprintf(message, 1024, "[%d] %s reopened.\n", (int) uwsgi_now(), uwsgi.logfile);
-		if (ret > 0) {
-			if (write(uwsgi.original_log_fd, message, ret) != ret) {
-				// very probably this will never be printed
-				uwsgi_error("write()");
-			}
-		}
-		uwsgi.shared->logsize = lseek(uwsgi.original_log_fd, 0, SEEK_CUR);
+		uwsgi_log_reopen();
 	}
 }
 
+void uwsgi_log_rotate() {
+	char message[1024];
+	if (!uwsgi.logfile) return;
+	char *rot_name = uwsgi.log_backupname;
+                int need_free = 0;
+                if (rot_name == NULL) {
+                        char *ts_str = uwsgi_num2str((int) uwsgi_now());
+                        rot_name = uwsgi_concat3(uwsgi.logfile, ".", ts_str);
+                        free(ts_str);
+                        need_free = 1;
+                }
+                int ret = snprintf(message, 1024, "[%d] logsize: %llu, triggering rotation to %s...\n", (int) uwsgi_now(), (unsigned long long) uwsgi.shared->logsize, rot_name);
+                if (ret > 0) {
+                        if (write(uwsgi.original_log_fd, message, ret) != ret) {
+                                // very probably this will never be printed
+                                uwsgi_error("write()");
+                        }
+                }
+                if (rename(uwsgi.logfile, rot_name) == 0) {
+                        // reopen logfile dup'it and eventually gracefully reload workers;
+                        int fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP);
+                        if (fd < 0) {
+                                uwsgi_error_open(uwsgi.logfile);
+                                grace_them_all(0);
+                        }
+                        else {
+                                if (dup2(fd, uwsgi.original_log_fd) < 0) {
+                                        uwsgi_error("dup2()");
+                                        grace_them_all(0);
+                                }
+                                close(fd);
+                        }
+                }
+                else {
+                        uwsgi_error("unable to rotate log: rename()");
+                }
+                if (need_free)
+                        free(rot_name);
+}
+
+void uwsgi_log_reopen() {
+	char message[1024];
+	if (!uwsgi.logfile) return;
+	int ret = snprintf(message, 1024, "[%d] logsize: %llu, triggering log-reopen...\n", (int) uwsgi_now(), (unsigned long long) uwsgi.shared->logsize);
+        if (ret > 0) {
+                        if (write(uwsgi.original_log_fd, message, ret) != ret) {
+                                // very probably this will never be printed
+                                uwsgi_error("write()");
+                        }
+                }
+
+                // reopen logfile;
+                close(uwsgi.original_log_fd);
+                uwsgi.original_log_fd = open(uwsgi.logfile, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR | S_IRGRP);
+                if (uwsgi.original_log_fd < 0) {
+                        uwsgi_error_open(uwsgi.logfile);
+                        grace_them_all(0);
+                }
+                ret = snprintf(message, 1024, "[%d] %s reopened.\n", (int) uwsgi_now(), uwsgi.logfile);
+                if (ret > 0) {
+                        if (write(uwsgi.original_log_fd, message, ret) != ret) {
+                                // very probably this will never be printed
+                                uwsgi_error("write()");
+                        }
+                }
+                uwsgi.shared->logsize = lseek(uwsgi.original_log_fd, 0, SEEK_CUR);
+}
+
 
 void log_request(struct wsgi_request *wsgi_req) {
 
@@ -1401,6 +1411,16 @@ static void uwsgi_log_func_do(struct uwsgi_string_list *encoders, struct uwsgi_l
 	size_t new_msg_len = len;
 	while(usl) {
 		struct uwsgi_log_encoder *ule = (struct uwsgi_log_encoder *) usl->custom_ptr;
+		if (ule->use_for) {
+			if (ul && ul->id) {
+				if (strcmp(ule->use_for, ul->id)) {
+					goto next;
+				}
+			}
+			else {
+				goto next;
+			}
+		}
 		size_t rlen = 0;
 		char *buf = ule->func(ule, new_msg, new_msg_len, &rlen);
 		if (new_msg != msg) {
@@ -1408,6 +1428,7 @@ static void uwsgi_log_func_do(struct uwsgi_string_list *encoders, struct uwsgi_l
         	}
 		new_msg = buf;
 		new_msg_len = rlen;
+next:
 		usl = usl->next;
 	}
 	if (ul) {
@@ -1625,21 +1646,28 @@ void uwsgi_setup_log_encoders() {
 	uwsgi_foreach(usl, uwsgi.requested_log_encoders) {
 		char *space = strchr(usl->value, ' ');
 		if (space) *space = 0;
+		char *use_for = strchr(usl->value, ':');
+		if (use_for) *use_for = 0;
 		struct uwsgi_log_encoder *ule = uwsgi_log_encoder_by_name(usl->value);
 		if (!ule) {
 			uwsgi_log("log encoder \"%s\" not found\n", usl->value);
 			exit(1);
 		}
-		if (space) *space = ' ';
 		struct uwsgi_log_encoder *ule2 = uwsgi_malloc(sizeof(struct uwsgi_log_encoder));
 		memcpy(ule2, ule, sizeof(struct uwsgi_log_encoder)); 
+		if (use_for) {
+			ule2->use_for = uwsgi_str(use_for+1);
+			*use_for = ':';
+		}
 		// we use a copy
 		if (space) {
+			*space = ' ';
 			ule2->args = uwsgi_str(space+1);
 		}
 		else {
 			ule2->args = uwsgi_str("");
 		}
+
 		usl->custom_ptr = ule2;
 		uwsgi_log("[log-encoder] registered %s\n", usl->value);
 	}
@@ -1647,21 +1675,27 @@ void uwsgi_setup_log_encoders() {
 	uwsgi_foreach(usl, uwsgi.requested_log_req_encoders) {
                 char *space = strchr(usl->value, ' ');
                 if (space) *space = 0;
+		char *use_for = strchr(usl->value, ':');
+		if (use_for) *use_for = 0;
                 struct uwsgi_log_encoder *ule = uwsgi_log_encoder_by_name(usl->value);
                 if (!ule) {
                         uwsgi_log("log encoder \"%s\" not found\n", usl->value);
                         exit(1);
                 }
-                if (space) *space = ' ';
-                struct uwsgi_log_encoder *ule2 = uwsgi_malloc(sizeof(struct uwsgi_log_encoder));
+		struct uwsgi_log_encoder *ule2 = uwsgi_malloc(sizeof(struct uwsgi_log_encoder));
                 memcpy(ule2, ule, sizeof(struct uwsgi_log_encoder));
+                if (use_for) {
+			ule2->use_for = uwsgi_str(use_for+1);
+                        *use_for = ':';
+                }
                 // we use a copy
-		if (space) {
-                	ule2->args = uwsgi_str(space+1);
-		}
-		else {
-			ule2->args = uwsgi_str("");
-		}
+                if (space) {
+                        *space = ' ';
+                        ule2->args = uwsgi_str(space+1);
+                }
+                else {
+                        ule2->args = uwsgi_str("");
+                }
                 usl->custom_ptr = ule2;
 		uwsgi_log("[log-req-encoder] registered %s\n", usl->value);
         }

core/master.c

@@ -222,8 +222,8 @@ int uwsgi_get_tcp_info(int fd) {
 #elif defined(__FreeBSD__)
 		if (!uwsgi.shared->ti.__tcpi_sacked) {
 #endif
-                        return 0;
-                }
+			return 0;
+		}
 
 #if defined(__linux__)
 		uwsgi.shared->load = (uint64_t) uwsgi.shared->ti.tcpi_unacked;
@@ -242,12 +242,12 @@ int uwsgi_get_tcp_info(int fd) {
 					uwsgi_error("write()");
 				}
 				else {
-					uwsgi_log("asking emperor for reinforcements (backlog: %llu)...\n", (unsigned long long ) uwsgi.shared->load);
+					uwsgi_log("asking emperor for reinforcements (backlog: %llu)...\n", (unsigned long long) uwsgi.shared->load);
 				}
 			}
 		}
 		if (uwsgi.shared->load >= uwsgi.shared->max_load) {
-			uwsgi_log_verbose("*** uWSGI listen queue of socket %d full !!! (%llu/%llu) ***\n", fd, (unsigned long long ) uwsgi.shared->load, (unsigned long long ) uwsgi.shared->max_load);
+			uwsgi_log_verbose("*** uWSGI listen queue of socket %d full !!! (%llu/%llu) ***\n", fd, (unsigned long long) uwsgi.shared->load, (unsigned long long) uwsgi.shared->max_load);
 			uwsgi.shared->options[UWSGI_OPTION_BACKLOG_ERRORS]++;
 		}
 
@@ -306,7 +306,6 @@ int master_loop(char **argv, char **environ) {
 	struct uwsgi_rb_timer *min_timeout;
 	struct uwsgi_rbtree *rb_timers = uwsgi_init_rb_timer();
 
-
 	if (uwsgi.procname_master) {
 		uwsgi_set_processname(uwsgi.procname_master);
 	}
@@ -346,6 +345,11 @@ int master_loop(char **argv, char **environ) {
 #endif
 	event_queue_add_fd_read(uwsgi.master_queue, uwsgi.shared->worker_signal_pipe[0]);
 
+	if (uwsgi.master_fifo) {
+		uwsgi.master_fifo_fd = uwsgi_master_fifo();
+		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.master_fifo_fd);
+	}
+
 	if (uwsgi.spoolers) {
 		event_queue_add_fd_read(uwsgi.master_queue, uwsgi.shared->spooler_signal_pipe[0]);
 	}
@@ -477,7 +481,7 @@ int master_loop(char **argv, char **environ) {
 	uwsgi_check_touches(uwsgi.touch_gracefully_stop);
 	// update exec touches
 	struct uwsgi_string_list *usl = uwsgi.touch_exec;
-	while(usl) {
+	while (usl) {
 		char *space = strchr(usl->value, ' ');
 		if (space) {
 			*space = 0;
@@ -489,16 +493,16 @@ int master_loop(char **argv, char **environ) {
 	uwsgi_check_touches(uwsgi.touch_exec);
 	// update signal touches
 	usl = uwsgi.touch_signal;
-        while(usl) {
-                char *space = strchr(usl->value, ' ');
-                if (space) {
-                        *space = 0;
-                        usl->len = strlen(usl->value);
-                        usl->custom_ptr = space + 1;
-                }
-                usl = usl->next;
-        }
-        uwsgi_check_touches(uwsgi.touch_signal);
+	while (usl) {
+		char *space = strchr(usl->value, ' ');
+		if (space) {
+			*space = 0;
+			usl->len = strlen(usl->value);
+			usl->custom_ptr = space + 1;
+		}
+		usl = usl->next;
+	}
+	uwsgi_check_touches(uwsgi.touch_signal);
 
 	// fsmon
 	uwsgi_fsmon_setup();
@@ -741,7 +745,7 @@ int master_loop(char **argv, char **environ) {
 #endif
 
 			// resubscribe every 10 cycles by default
-			if (( (uwsgi.subscriptions || uwsgi.subscriptions2) && ((uwsgi.master_cycles % uwsgi.subscribe_freq) == 0 || uwsgi.master_cycles == 1)) && !uwsgi_instance_is_reloading && !uwsgi_instance_is_dying && !uwsgi.workers[0].suspended) {
+			if (((uwsgi.subscriptions || uwsgi.subscriptions2) && ((uwsgi.master_cycles % uwsgi.subscribe_freq) == 0 || uwsgi.master_cycles == 1)) && !uwsgi_instance_is_reloading && !uwsgi_instance_is_dying && !uwsgi.workers[0].suspended) {
 				uwsgi_subscribe_all(0, 0);
 			}
 
@@ -765,40 +769,34 @@ int master_loop(char **argv, char **environ) {
 				}
 				touched = uwsgi_check_touches(uwsgi.touch_workers_reload);
 				if (touched) {
-                                        uwsgi_log_verbose("*** %s has been touched... workers reload !!! ***\n", touched);
-					uwsgi_block_signal(SIGHUP);
-					for(i=1;i<=uwsgi.numproc;i++) {
-						if (uwsgi.workers[i].pid > 0) {
-							uwsgi_curse(i, SIGHUP);
-						}
-					}
-					uwsgi_unblock_signal(SIGHUP);
-                                        continue;
-                                }
+					uwsgi_log_verbose("*** %s has been touched... workers reload !!! ***\n", touched);
+					uwsgi_reload_workers();
+					continue;
+				}
 				touched = uwsgi_check_touches(uwsgi.touch_chain_reload);
 				if (touched) {
 					if (uwsgi.status.chain_reloading == 0) {
-                                        	uwsgi_log_verbose("*** %s has been touched... chain reload !!! ***\n", touched);
+						uwsgi_log_verbose("*** %s has been touched... chain reload !!! ***\n", touched);
 						uwsgi.status.chain_reloading = 1;
 					}
 					else {
-                                        	uwsgi_log_verbose("*** %s has been touched... but chain reload is already running ***\n", touched);
+						uwsgi_log_verbose("*** %s has been touched... but chain reload is already running ***\n", touched);
 					}
 				}
 
 				// be sure to run it as the last touch check
 				touched = uwsgi_check_touches(uwsgi.touch_exec);
 				if (touched) {
-					if (uwsgi_run_command( touched , NULL, -1) >= 0) {
+					if (uwsgi_run_command(touched, NULL, -1) >= 0) {
 						uwsgi_log_verbose("[uwsgi-touch-exec] running %s\n", touched);
 					}
 				}
 				touched = uwsgi_check_touches(uwsgi.touch_signal);
-                                if (touched) {
+				if (touched) {
 					uint8_t signum = atoi(touched);
 					uwsgi_route_signal(signum);
-                                        uwsgi_log_verbose("[uwsgi-touch-signal] raising %u\n", signum);
-                                }
+					uwsgi_log_verbose("[uwsgi-touch-signal] raising %u\n", signum);
+				}
 			}
 
 			continue;
@@ -815,12 +813,18 @@ int master_loop(char **argv, char **environ) {
 		// reload gateways and daemons only on normal workflow (+outworld status)
 		if (!uwsgi_instance_is_reloading && !uwsgi_instance_is_dying) {
 
-			if (uwsgi_master_check_emperor_death(diedpid)) continue;
-			if (uwsgi_master_check_spoolers_death(diedpid)) continue;
-			if (uwsgi_master_check_mules_death(diedpid)) continue;
-			if (uwsgi_master_check_gateways_death(diedpid)) continue;
-			if (uwsgi_master_check_daemons_death(diedpid)) continue;
-			if (uwsgi_master_check_cron_death(diedpid)) continue;
+			if (uwsgi_master_check_emperor_death(diedpid))
+				continue;
+			if (uwsgi_master_check_spoolers_death(diedpid))
+				continue;
+			if (uwsgi_master_check_mules_death(diedpid))
+				continue;
+			if (uwsgi_master_check_gateways_death(diedpid))
+				continue;
+			if (uwsgi_master_check_daemons_death(diedpid))
+				continue;
+			if (uwsgi_master_check_cron_death(diedpid))
+				continue;
 		}
 
 
@@ -885,8 +889,9 @@ next:
 		// ok, if we are reloading or dying, just continue the master loop
 		// as soon as all of the workers have pid == 0, the action (exit, or reload) is triggered
 		if (uwsgi_instance_is_reloading || uwsgi_instance_is_dying) {
-			if (!uwsgi.workers[thewid].cursed_at) uwsgi.workers[thewid].cursed_at = uwsgi_now();
-			uwsgi_log("worker %d buried after %d seconds\n", thewid, (int) (uwsgi_now()-uwsgi.workers[thewid].cursed_at));
+			if (!uwsgi.workers[thewid].cursed_at)
+				uwsgi.workers[thewid].cursed_at = uwsgi_now();
+			uwsgi_log("worker %d buried after %d seconds\n", thewid, (int) (uwsgi_now() - uwsgi.workers[thewid].cursed_at));
 			uwsgi.workers[thewid].cursed_at = 0;
 			continue;
 		}
@@ -964,3 +969,34 @@ next:
 
 	// never here
 }
+
+void uwsgi_reload_workers() {
+	int i;
+	uwsgi_block_signal(SIGHUP);
+	for (i = 1; i <= uwsgi.numproc; i++) {
+		if (uwsgi.workers[i].pid > 0) {
+			uwsgi_curse(i, SIGHUP);
+		}
+	}
+	uwsgi_unblock_signal(SIGHUP);
+}
+
+void uwsgi_chain_reload() {
+	if (!uwsgi.status.chain_reloading) {
+		uwsgi_log_verbose("chain reload starting...\n");
+		uwsgi.status.chain_reloading = 1;
+	}
+	else {
+		uwsgi_log_verbose("chain reload already running...\n");
+	}
+}
+
+void uwsgi_brutally_reload_workers() {
+	int i;
+	for (i = 1; i <= uwsgi.numproc; i++) {
+		if (uwsgi.workers[i].pid > 0) {
+			uwsgi_log_verbose("killing worker %d (pid: %d)\n", i, (int) uwsgi.workers[i].pid);
+			uwsgi_curse(i, SIGINT);
+		}
+	}
+}

core/master_checks.c

@@ -35,11 +35,17 @@ int uwsgi_master_check_reload(char **argv) {
 // check for chain reload
 void uwsgi_master_check_chain() {
 	if (!uwsgi.status.chain_reloading) return;
-	if (uwsgi.status.chain_reloading > uwsgi.numproc) {
+	int i;
+	int needed_procs = 0;
+	for(i=1;i<=uwsgi.numproc;i++) {
+                if (uwsgi.workers[i].pid > 0 && uwsgi.workers[i].cheaped == 0) {
+			needed_procs++;
+                }
+        }
+	if (uwsgi.status.chain_reloading > needed_procs) {
 		uwsgi.status.chain_reloading = 0;
                 uwsgi_log_verbose("chain reloading complete\n");
 	}
-	int i;
 	uwsgi_block_signal(SIGHUP);
 	for(i=1;i<=uwsgi.numproc;i++) {
 		if (uwsgi.workers[i].pid > 0 && uwsgi.workers[i].cheaped == 0 && uwsgi.workers[i].cursed_at == 0 && i == uwsgi.status.chain_reloading) {

core/master_events.c

@@ -18,6 +18,10 @@ int uwsgi_master_manage_events(int interesting_fd) {
 		}
 	}
 
+	if (uwsgi.master_fifo_fd > -1 && interesting_fd == uwsgi.master_fifo_fd) {
+		return uwsgi_master_fifo_manage(uwsgi.master_fifo_fd);
+	}
+
 	// stats server ?
 	if (uwsgi.stats && uwsgi.stats_fd > -1) {
 		if (interesting_fd == uwsgi.stats_fd) {

core/master_utils.c

@@ -142,6 +142,15 @@ int uwsgi_calc_cheaper(void) {
 		}
 	}
 
+	// then check for fifo
+	if (uwsgi.cheaper_fifo_delta != 0) {
+		if (!ignore_algo) {
+			needed_workers = uwsgi.cheaper_fifo_delta;
+			ignore_algo = 1;
+		}
+		uwsgi.cheaper_fifo_delta = 0;
+	}
+
 	if (!ignore_algo) needed_workers = uwsgi.cheaper_algo();
 
 	if (needed_workers > 0) {
@@ -179,6 +188,11 @@ int uwsgi_calc_cheaper(void) {
 	return 1;
 }
 
+// fake algo to allow control with the fifo
+int uwsgi_cheaper_algo_manual(void) {
+	return 0;
+}
+
 /*
 
         -- Cheaper, spare algorithm, adapted from old-fashioned spare system --
@@ -353,23 +367,30 @@ void uwsgi_reload(char **argv) {
 	int i;
 	int waitpid_status;
 
-	// call a series of waitpid to ensure all processes (gateways, mules and daemons) are dead
-	for (i = 0; i < (ushared->gateways_cnt + uwsgi.daemons_cnt + uwsgi.mules_cnt); i++) {
-		waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
+	if (!uwsgi.master_is_reforked) {
+
+		// call a series of waitpid to ensure all processes (gateways, mules and daemons) are dead
+		for (i = 0; i < (ushared->gateways_cnt + uwsgi.daemons_cnt + uwsgi.mules_cnt); i++) {
+			waitpid(WAIT_ANY, &waitpid_status, WNOHANG);
+		}
+
+		// call master cleanup hooks
+		uwsgi_master_cleanup_hooks();
+
+		// call atexit user exec
+		uwsgi_exec_atexit();
+
+		if (uwsgi.exit_on_reload) {
+			uwsgi_log("uWSGI: GAME OVER (insert coin)\n");
+			exit(0);
+		}
+
+		uwsgi_log("binary reloading uWSGI...\n");
+	}
+	else {
+		uwsgi_log("fork()'ing uWSGI...\n");
 	}
 
-	// call master cleanup hooks
-	uwsgi_master_cleanup_hooks();
-
-	// call atexit user exec
-	uwsgi_exec_atexit();
-
-	if (uwsgi.exit_on_reload) {
-		uwsgi_log("uWSGI: GAME OVER (insert coin)\n");
-		exit(0);
-	}
-
-	uwsgi_log("binary reloading uWSGI...\n");
 	uwsgi_log("chdir() to %s\n", uwsgi.cwd);
 	if (chdir(uwsgi.cwd)) {
 		uwsgi_error("chdir()");
@@ -556,6 +577,7 @@ void uwsgi_fixup_fds(int wid, int muleid, struct uwsgi_gateway *ug) {
 			}
 		}
 
+		if (uwsgi.master_fifo_fd > -1) close(uwsgi.master_fifo_fd);
 	}
 
 
@@ -1512,3 +1534,53 @@ void uwsgi_add_reload_fds() {
 	add_reload_fds(uwsgi.reload_on_fd, "graceful");
 	add_reload_fds(uwsgi.brutal_reload_on_fd, "brutal");
 }
+
+void uwsgi_refork_master() {
+	pid_t pid = fork();
+	if (pid < 0) {
+		uwsgi_error("uwsgi_refork_master()/fork()");
+		return;
+	}
+
+	if (pid > 0) {
+		uwsgi_log_verbose("new master copy spawned with pid %d\n", (int) pid);
+		return;
+	}
+
+	// detach from the old master
+	setsid();
+
+	uwsgi.master_is_reforked = 1;
+	uwsgi_reload(uwsgi.argv);
+	// never here
+	exit(1);
+}
+
+void uwsgi_cheaper_increase() {
+	uwsgi.cheaper_fifo_delta++;
+}
+
+void uwsgi_cheaper_decrease() {
+        uwsgi.cheaper_fifo_delta--;
+}
+
+void uwsgi_go_cheap() {
+	int i;
+	int waitpid_status;
+	if (uwsgi.status.is_cheap) return;
+	uwsgi_log_verbose("going cheap...\n");
+	uwsgi.status.is_cheap = 1;
+                for (i = 1; i <= uwsgi.numproc; i++) {
+                        uwsgi.workers[i].cheaped = 1;
+                        if (uwsgi.workers[i].pid == 0)
+                                continue;
+			uwsgi_log("killing worker %d (pid: %d)\n", i, (int) uwsgi.workers[i].pid);
+                        kill(uwsgi.workers[i].pid, SIGKILL);
+                        if (waitpid(uwsgi.workers[i].pid, &waitpid_status, 0) < 0) {
+                                if (errno != ECHILD)
+                                        uwsgi_error("uwsgi_go_cheap()/waitpid()");
+                        }
+                }
+                uwsgi_add_sockets_to_queue(uwsgi.master_queue, -1);
+                uwsgi_log("cheap mode enabled: waiting for socket connection...\n");
+}

core/mount.c

@@ -108,15 +108,14 @@ int uwsgi_mount(char *fs, char *what, char *where, char *flags) {
 	unsigned long mountflags = 0;
 	if (!flags) goto parsed;
 	char *mflags = uwsgi_str(flags);
-	char *p = strtok(mflags, ",");
-	while(p) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(mflags, ",", p, ctx) {
 		unsigned long flag = (unsigned long) uwsgi_mount_flag(p);
 		if (!flag) {
 			uwsgi_log("unknown mount flag \"%s\"\n", p);
 			exit(1);
 		}
 		mountflags |= flag;
-		p = strtok(NULL, ",");
 	}
 	free(mflags);
 parsed:
@@ -147,15 +146,14 @@ int uwsgi_umount(char *where, char *flags) {
 	unsigned long mountflags = 0;
         if (!flags) goto parsed;
         char *mflags = uwsgi_str(flags);
-        char *p = strtok(mflags, ",");
-        while(p) {
+        char *p, *ctx = NULL;
+	uwsgi_foreach_token(mflags, ",", p, ctx) {
                 unsigned long flag = (unsigned long) uwsgi_mount_flag(p);
                 if (!flag) {
                         uwsgi_log("unknown umount flag \"%s\"\n", p);
                         exit(1);
                 }
                 mountflags |= flag;
-                p = strtok(NULL, ",");
         }
         free(mflags);
 parsed:

core/mule.c

@@ -453,8 +453,8 @@ void uwsgi_setup_mules_and_farms() {
 			create_signal_pipe(uwsgi.farms[i].signal_pipe);
 			create_msg_pipe(uwsgi.farms[i].queue_pipe, uwsgi.mule_msg_size);
 
-			char *p = strtok(mules_list, ",");
-			while (p != NULL) {
+			char *p, *ctx = NULL;
+			uwsgi_foreach_token(mules_list, ",", p, ctx) {
 				struct uwsgi_mule *um = get_mule_by_id(atoi(p));
 				if (!um) {
 					uwsgi_log("invalid mule id: %s\n", p);
@@ -462,8 +462,6 @@ void uwsgi_setup_mules_and_farms() {
 				}
 
 				uwsgi_mule_farm_new(&uwsgi.farms[i].mules, um);
-
-				p = strtok(NULL, ",");
 			}
 			uwsgi_log("created farm %d name: %s mules:%s\n", i + 1, uwsgi.farms[i].name, strchr(farm_name->value, ':') + 1);
 

core/plugins.c

@@ -14,7 +14,9 @@ static void uwsgi_plugin_parse_section(char *filename) {
 			if (equal) {
 				*equal = 0;
 				if (!strcmp(p, "requires")) {
-					uwsgi_load_plugin(-1, equal + 1, NULL);
+					if (!plugin_already_loaded(equal+1)) {	
+						uwsgi_load_plugin(-1, equal + 1, NULL);
+					}
 				}
 			}
 			p = strtok_r(NULL, "\n", &ctx);

core/socket.c

@@ -187,6 +187,14 @@ int bind_to_unix(char *socket_name, int listen_queue, int chmod_socket, int abst
 		return -1;
 	}
 
+#ifdef __linux__
+        long somaxconn = uwsgi_num_from_file("/proc/sys/net/core/somaxconn", 1);
+        if (somaxconn > 0 && uwsgi.listen_queue > somaxconn) {
+                uwsgi_log("Listen queue size is greater than the system max net.core.somaxconn (%li).\n", somaxconn);
+                uwsgi_nuclear_blast();
+                return -1;
+        }
+#endif
 
 	if (listen(serverfd, listen_queue) != 0) {
 		uwsgi_error("listen()");
@@ -1645,8 +1653,8 @@ void uwsgi_map_sockets() {
 			}
 			if ((int) uwsgi_str_num(usl->value, colon - usl->value) == uwsgi_get_socket_num(uwsgi_sock)) {
 				enabled = 0;
-				char *p = strtok(colon + 1, ",");
-				while (p != NULL) {
+				char *p, *ctx = NULL;
+				uwsgi_foreach_token(colon + 1, ",", p, ctx) {
 					int w = atoi(p);
 					if (w < 1 || w > uwsgi.numproc) {
 						uwsgi_log("invalid worker num: %d\n", w);
@@ -1657,7 +1665,6 @@ void uwsgi_map_sockets() {
 						uwsgi_log("mapped socket %d (%s) to worker %d\n", uwsgi_get_socket_num(uwsgi_sock), uwsgi_sock->name, uwsgi.mywid);
 						break;
 					}
-					p = strtok(NULL, ",");
 				}
 			}
 
@@ -1976,3 +1983,4 @@ int uwsgi_accept(int server_fd) {
 
 
 }
+

core/utils.c

@@ -1879,14 +1879,12 @@ char *uwsgi_get_optname_by_index(int index) {
 int uwsgi_list_has_num(char *list, int num) {
 
 	char *list2 = uwsgi_concat2(list, "");
-
-	char *p = strtok(list2, ",");
-	while (p != NULL) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(list2, ",", p, ctx) {
 		if (atoi(p) == num) {
 			free(list2);
 			return 1;
 		}
-		p = strtok(NULL, ",");
 	}
 
 	free(list2);
@@ -1896,14 +1894,12 @@ int uwsgi_list_has_num(char *list, int num) {
 int uwsgi_list_has_str(char *list, char *str) {
 
 	char *list2 = uwsgi_str(list);
-
-	char *p = strtok(list2, " ");
-	while (p != NULL) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(list2, " ", p, ctx) {
 		if (!strcasecmp(p, str)) {
 			free(list2);
 			return 1;
 		}
-		p = strtok(NULL, " ");
 	}
 
 	free(list2);
@@ -2766,14 +2762,12 @@ static int uwsgi_get_unshare_id(char *name) {
 void uwsgi_build_unshare(char *what, int *mask) {
 
 	char *list = uwsgi_str(what);
-
-	char *p = strtok(list, ",");
-	while (p != NULL) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(list, ",", p, ctx) {
 		int u_id = uwsgi_get_unshare_id(p);
 		if (u_id != -1) {
 			*mask |= u_id;
 		}
-		p = strtok(NULL, ",");
 	}
 	free(list);
 }
@@ -2862,8 +2856,8 @@ void uwsgi_build_cap(char *what) {
 	int pos = 0;
 	uwsgi.cap_count = 0;
 
-	char *p = strtok(caps, ",");
-	while (p != NULL) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(caps, ",", p, ctx) {
 		if (is_a_number(p)) {
 			uwsgi.cap_count++;
 		}
@@ -2873,15 +2867,14 @@ void uwsgi_build_cap(char *what) {
 				uwsgi.cap_count++;
 			}
 		}
-		p = strtok(NULL, ",");
 	}
 	free(caps);
 
 	uwsgi.cap = uwsgi_malloc(sizeof(cap_value_t) * uwsgi.cap_count);
 
 	caps = uwsgi_str(what);
-	p = strtok(caps, ",");
-	while (p != NULL) {
+	ctx = NULL;
+	uwsgi_foreach_token(caps, ",", p, ctx) {
 		if (is_a_number(p)) {
 			cap_id = atoi(p);
 		}
@@ -2893,7 +2886,6 @@ void uwsgi_build_cap(char *what) {
 			uwsgi_log("setting capability %s [%d]\n", p, cap_id);
 			pos++;
 		}
-		p = strtok(NULL, ",");
 	}
 	free(caps);
 

core/uwsgi.c

@@ -199,7 +199,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 #endif
 	{"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},
+	{"vassals-inherit", required_argument, 0, "add config templates to vassals config (uses --inherit)", uwsgi_opt_add_string_list, &uwsgi.vassals_templates, 0},
+	{"vassals-include", required_argument, 0, "include config templates to vassals config (uses --include instead of --inherit)", uwsgi_opt_add_string_list, &uwsgi.vassals_includes, 0},
 	{"vassals-start-hook", required_argument, 0, "run the specified command before each vassal starts", uwsgi_opt_set_str, &uwsgi.vassals_start_hook, 0},
 	{"vassals-stop-hook", required_argument, 0, "run the specified command after vassal's death", uwsgi_opt_set_str, &uwsgi.vassals_stop_hook, 0},
 	{"vassal-sos-backlog", required_argument, 0, "ask emperor for sos if backlog queue has more items than the value specified", uwsgi_opt_set_int, &uwsgi.vassal_sos_backlog, 0},
@@ -325,6 +326,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"refork-post-jail", no_argument, 0, "fork() again after jailing. Useful for jailing systems", uwsgi_opt_true, &uwsgi.refork_post_jail, 0},
 	{"re-fork-post-jail", no_argument, 0, "fork() again after jailing. Useful for jailing systems", uwsgi_opt_true, &uwsgi.refork_post_jail, 0},
 
+	{"hook-asap", required_argument, 0, "run the specified hook as soon as possible", uwsgi_opt_add_string_list, &uwsgi.hook_asap, 0},
 	{"hook-pre-jail", required_argument, 0, "run the specified hook before jailing", uwsgi_opt_add_string_list, &uwsgi.hook_pre_jail, 0},
         {"hook-post-jail", required_argument, 0, "run the specified hook after jailing", uwsgi_opt_add_string_list, &uwsgi.hook_post_jail, 0},
         {"hook-in-jail", required_argument, 0, "run the specified hook in jail after initialization", uwsgi_opt_add_string_list, &uwsgi.hook_in_jail, 0},
@@ -337,6 +339,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
         {"hook-as-vassal", required_argument, 0, "run the specified command before exec()ing the vassal", uwsgi_opt_add_string_list, &uwsgi.hook_as_vassal, 0},
         {"hook-as-emperor", required_argument, 0, "run the specified command in the emperor after the vassal has been started", uwsgi_opt_add_string_list, &uwsgi.hook_as_emperor, 0},
 
+	{"exec-asap", required_argument, 0, "run the specified command as soon as possible", uwsgi_opt_add_string_list, &uwsgi.exec_asap, 0},
 	{"exec-pre-jail", required_argument, 0, "run the specified command before jailing", uwsgi_opt_add_string_list, &uwsgi.exec_pre_jail, 0},
 	{"exec-post-jail", required_argument, 0, "run the specified command after jailing", uwsgi_opt_add_string_list, &uwsgi.exec_post_jail, 0},
 	{"exec-in-jail", required_argument, 0, "run the specified command in jail after initialization", uwsgi_opt_add_string_list, &uwsgi.exec_in_jail, 0},
@@ -349,6 +352,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"exec-as-vassal", required_argument, 0, "run the specified command before exec()ing the vassal", uwsgi_opt_add_string_list, &uwsgi.exec_as_vassal, 0},
 	{"exec-as-emperor", required_argument, 0, "run the specified command in the emperor after the vassal has been started", uwsgi_opt_add_string_list, &uwsgi.exec_as_emperor, 0},
 
+	{"mount-asap", required_argument, 0, "mount filesystem as soon as possible", uwsgi_opt_add_string_list, &uwsgi.mount_asap, 0},
 	{"mount-pre-jail", required_argument, 0, "mount filesystem before jailing", uwsgi_opt_add_string_list, &uwsgi.mount_pre_jail, 0},
         {"mount-post-jail", required_argument, 0, "mount filesystem after jailing", uwsgi_opt_add_string_list, &uwsgi.mount_post_jail, 0},
         {"mount-in-jail", required_argument, 0, "mount filesystem in jail after initialization", uwsgi_opt_add_string_list, &uwsgi.mount_in_jail, 0},
@@ -357,6 +361,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
         {"mount-as-vassal", required_argument, 0, "mount filesystem before exec()ing the vassal", uwsgi_opt_add_string_list, &uwsgi.mount_as_vassal, 0},
         {"mount-as-emperor", required_argument, 0, "mount filesystem in the emperor after the vassal has been started", uwsgi_opt_add_string_list, &uwsgi.mount_as_emperor, 0},
 
+	{"umount-asap", required_argument, 0, "unmount filesystem as soon as possible", uwsgi_opt_add_string_list, &uwsgi.umount_asap, 0},
 	{"umount-pre-jail", required_argument, 0, "unmount filesystem before jailing", uwsgi_opt_add_string_list, &uwsgi.umount_pre_jail, 0},
         {"umount-post-jail", required_argument, 0, "unmount filesystem after jailing", uwsgi_opt_add_string_list, &uwsgi.umount_post_jail, 0},
         {"umount-in-jail", required_argument, 0, "unmount filesystem in jail after initialization", uwsgi_opt_add_string_list, &uwsgi.umount_in_jail, 0},
@@ -377,6 +382,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"wait-iface", required_argument, 0, "wait for the specified network interface to come up before running root hooks", uwsgi_opt_add_string_list, &uwsgi.wait_for_interface, 0},
 	{"wait-iface-timeout", required_argument, 0, "set the timeout for wait-for-interface", uwsgi_opt_set_int, &uwsgi.wait_for_interface_timeout, 0},
 
+	{"call-asap", required_argument, 0, "call the specified function as soon as possible", uwsgi_opt_add_string_list, &uwsgi.call_asap, 0},
 	{"call-pre-jail", required_argument, 0, "call the specified function before jailing", uwsgi_opt_add_string_list, &uwsgi.call_pre_jail, 0},
 	{"call-post-jail", required_argument, 0, "call the specified function after jailing", uwsgi_opt_add_string_list, &uwsgi.call_post_jail, 0},
 	{"call-in-jail", required_argument, 0, "call the specified function in jail after initialization", uwsgi_opt_add_string_list, &uwsgi.call_in_jail, 0},
@@ -456,7 +462,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"fs-brutal-reload", required_argument, 0, "brutal reload when the specified filesystem object is modified", uwsgi_opt_add_string_list, &uwsgi.fs_brutal_reload, UWSGI_OPT_MASTER},
 	{"fs-signal", required_argument, 0, "raise a uwsgi signal when the specified filesystem object is modified (syntax: file signal)", uwsgi_opt_add_string_list, &uwsgi.fs_signal, UWSGI_OPT_MASTER},
 
-	{"propagate-touch", no_argument, 0, "over-engineering option for system with flaky signal mamagement", uwsgi_opt_true, &uwsgi.propagate_touch, 0},
+	{"propagate-touch", no_argument, 0, "over-engineering option for system with flaky signal management", uwsgi_opt_true, &uwsgi.propagate_touch, 0},
 	{"limit-post", required_argument, 0, "limit request body", uwsgi_opt_set_64bit, &uwsgi.limit_post, 0},
 	{"no-orphans", no_argument, 0, "automatically kill workers if master dies (can be dangerous for availability)", uwsgi_opt_true, &uwsgi.no_orphans, 0},
 	{"prio", required_argument, 0, "set processes/threads priority", uwsgi_opt_set_rawint, &uwsgi.prio, 0},
@@ -489,6 +495,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"multicast-ttl", required_argument, 0, "set multicast ttl", uwsgi_opt_set_int, &uwsgi.multicast_ttl, 0},
 	{"multicast-loop", required_argument, 0, "set multicast loop (default 1)", uwsgi_opt_set_int, &uwsgi.multicast_loop, 0},
 
+	{"master-fifo", required_argument, 0, "enable the master fifo", uwsgi_opt_add_string_list, &uwsgi.master_fifo, UWSGI_OPT_MASTER},
+
 #ifdef UWSGI_SSL
 	{"legion", required_argument, 0, "became a member of a legion", uwsgi_opt_legion, NULL, UWSGI_OPT_MASTER},
 	{"legion-mcast", required_argument, 0, "became a member of a legion (shortcut for multicast)", uwsgi_opt_legion_mcast, NULL, UWSGI_OPT_MASTER},
@@ -871,6 +879,7 @@ void show_config(void) {
 }
 
 int uwsgi_manage_custom_option(struct uwsgi_custom_option *uco, char *key, char *value) {
+	int configured;
 	size_t i, count = 1;
 	size_t value_len = 0;
 	if (value)
@@ -896,11 +905,10 @@ int uwsgi_manage_custom_option(struct uwsgi_custom_option *uco, char *key, char
 	if (value_len > 0) {
 		tmp_val = uwsgi_str(value);
 		// fill the array of options
-		p = strtok(tmp_val, " ");
-		while (p) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(tmp_val, " ", p, ctx) {
 			opt_argv[pos] = p;
 			pos++;
-			p = strtok(NULL, " ");
 		}
 	}
 	else {
@@ -915,8 +923,8 @@ int uwsgi_manage_custom_option(struct uwsgi_custom_option *uco, char *key, char
 	// now make a copy of the option template
 	char *tmp_opt = uwsgi_str(uco->value);
 	// split it
-	p = strtok(tmp_opt, ";");
-	while (p) {
+	char *ctx = NULL;
+	uwsgi_foreach_token(tmp_opt, ";", p, ctx) {
 		char *equal = strchr(p, '=');
 		if (!equal)
 			goto clear;
@@ -947,9 +955,11 @@ int uwsgi_manage_custom_option(struct uwsgi_custom_option *uco, char *key, char
 				free(old_value);
 			free(placeholder);
 		}
-		// we can ignore its return value
-		(void) uwsgi_manage_opt(new_key, new_value);
-		p = strtok(NULL, ";");
+retry:
+		configured = uwsgi_manage_opt(new_key, new_value);
+		if (!configured && uwsgi.autoload) {
+			if (uwsgi_try_autoload(new_key)) goto retry;
+		}
 	}
 
 clear:
@@ -1060,11 +1070,15 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 
 	int base = '0';
 	char *to_split = uwsgi_str(magic_table['d']);
-	char *p = strtok(to_split, "/");
-	while (p && base <= '9') {
-		magic_table[base] = p;
-		base++;
-		p = strtok(NULL, "/");
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(to_split, "/", p, ctx) {
+		if (base <= '9') {
+			magic_table[base] = p;
+			base++;
+		}
+		else {
+			break;
+		}
 	}
 
 	if (tmp)
@@ -1217,6 +1231,28 @@ void kill_them_all(int signum) {
 	uwsgi_destroy_processes();
 }
 
+// gracefully destroy
+void gracefully_kill_them_all(int signum) {
+
+        if (uwsgi_instance_is_dying) return;
+        uwsgi.status.gracefully_destroying = 1;
+
+        // unsubscribe if needed
+        uwsgi_unsubscribe_all();
+
+        uwsgi_log_verbose("graceful shutdown triggered...\n");
+
+        int i;
+        for (i = 1; i <= uwsgi.numproc; i++) {
+                if (uwsgi.workers[i].pid > 0) {
+                        uwsgi_curse(i, SIGHUP);
+                }
+        }
+
+        uwsgi_destroy_processes();
+}
+
+
 // graceful reload
 void grace_them_all(int signum) {
 	if (uwsgi_instance_is_reloading || uwsgi_instance_is_dying)
@@ -2046,6 +2082,7 @@ int main(int argc, char *argv[], char *envp[]) {
 	uwsgi.magic_table['v'] = uwsgi.cwd;
 	uwsgi.magic_table['h'] = uwsgi.hostname;
 	uwsgi.magic_table['V'] = UWSGI_VERSION;
+	uwsgi.magic_table['['] = "\033";
 
 	// you can embed a ini file in the uWSGi binary with default options
 #ifdef UWSGI_EMBED_CONFIG
@@ -2076,6 +2113,32 @@ int main(int argc, char *argv[], char *envp[]) {
 	// ok, the options dictionary is available, lets manage it
 	uwsgi_configure();
 
+	// run "asap" hooks
+	uwsgi_hooks_run(uwsgi.hook_asap, "asap", 1);
+        struct uwsgi_string_list *usl = NULL;
+        uwsgi_foreach(usl, uwsgi.mount_asap) {
+        	uwsgi_log("mounting \"%s\" (asap)...\n", usl->value);
+                if (uwsgi_mount_hook(usl->value)) exit(1);
+	}
+        uwsgi_foreach(usl, uwsgi.umount_asap) {
+        	uwsgi_log("un-mounting \"%s\" (asap)...\n", usl->value);
+                if (uwsgi_umount_hook(usl->value)) exit(1);
+	}
+        uwsgi_foreach(usl, uwsgi.exec_asap) {
+        	uwsgi_log("running \"%s\" (asap)...\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);
+                }
+	}
+        uwsgi_foreach(usl, uwsgi.call_asap) {
+        	if (uwsgi_call_symbol(usl->value)) {
+                	uwsgi_log("unable to call function \"%s\"\n", usl->value);
+                        exit(1);
+                }
+	}
+
 	// manage envdirs ASAP
 	uwsgi_envdirs(uwsgi.envdirs);
 
@@ -2126,6 +2189,7 @@ int main(int argc, char *argv[], char *envp[]) {
 	// setup cheaper algos
 	uwsgi_register_cheaper_algo("spare", uwsgi_cheaper_algo_spare);
 	uwsgi_register_cheaper_algo("backlog", uwsgi_cheaper_algo_backlog);
+	uwsgi_register_cheaper_algo("manual", uwsgi_cheaper_algo_manual);
 
 	// setup imperial monitors
 	uwsgi_register_imperial_monitor("dir", uwsgi_imperial_monitor_directory_init, uwsgi_imperial_monitor_directory);
@@ -2293,7 +2357,7 @@ int main(int argc, char *argv[], char *envp[]) {
 
 		uwsgi_foreach(usl, uwsgi.call_pre_jail) {
 			if (uwsgi_call_symbol(usl->value)) {
-				uwsgi_log("unaable to call function \"%s\"\n", usl->value);
+				uwsgi_log("unable to call function \"%s\"\n", usl->value);
 				exit(1);
 			}
 		}
@@ -3216,8 +3280,8 @@ void uwsgi_worker_run() {
 
 	// eventually remap plugins
 	if (uwsgi.remap_modifier) {
-		char *map = strtok(uwsgi.remap_modifier, ",");
-		while (map != NULL) {
+		char *map, *ctx = NULL;
+		uwsgi_foreach_token(uwsgi.remap_modifier, ",", map, ctx) {
 			char *colon = strchr(map, ':');
 			if (colon) {
 				colon[0] = 0;
@@ -3226,7 +3290,6 @@ void uwsgi_worker_run() {
 				uwsgi.p[rm_dst]->request = uwsgi.p[rm_src]->request;
 				uwsgi.p[rm_dst]->after_request = uwsgi.p[rm_src]->after_request;
 			}
-			map = strtok(NULL, ",");
 		}
 	}
 
@@ -4000,8 +4063,8 @@ void uwsgi_opt_load_dl(char *opt, char *value, void *none) {
 void uwsgi_opt_load_plugin(char *opt, char *value, void *none) {
 
 	char *plugins_list = uwsgi_concat2(value, "");
-	char *p = strtok(plugins_list, ",");
-	while (p != NULL) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(plugins_list, ",", p, ctx) {
 #ifdef UWSGI_DEBUG
 		uwsgi_debug("loading plugin %s\n", p);
 #endif
@@ -4012,7 +4075,6 @@ void uwsgi_opt_load_plugin(char *opt, char *value, void *none) {
 			uwsgi_log("unable to load plugin \"%s\"\n", p);
 			exit(1);
 		}
-		p = strtok(NULL, ",");
 	}
 	free(p);
 	free(plugins_list);
@@ -4501,3 +4563,12 @@ void uwsgi_print_sym(char *opt, char *symbol, void *foobar) {
 
 	exit(0);
 }
+
+void uwsgi_update_pidfiles() {
+	if (uwsgi.pidfile) {
+		uwsgi_write_pidfile(uwsgi.pidfile);
+	}
+	if (uwsgi.pidfile2) {
+		uwsgi_write_pidfile(uwsgi.pidfile2);
+	}
+}

plugins/carbon/carbon.c

@@ -71,8 +71,8 @@ static void carbon_post_init() {
 		u_server->healthy = 1;
 		u_server->errors = 0;
 
-		char *p = strtok(usl->value, ":");
-		while (p) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(usl->value, ":", p, ctx) {
 			if (!u_server->hostname) {
 				u_server->hostname = uwsgi_str(p);
 			}
@@ -81,7 +81,6 @@ static void carbon_post_init() {
 			}
 			else
 				break;
-			p = strtok(NULL, ":");
 		}
 		if (!u_server->hostname || !u_server->port) {
 			uwsgi_log("[carbon] invalid carbon server address (%s)\n", usl->value);

plugins/cgi/cgi_plugin.c

@@ -828,8 +828,8 @@ clear2:
 			// set the start position of args in argv
 			i = 1;
 			if (helper) i = 2;
-			char *p = strtok(qs, "+");
-			while(p) {
+			char *p, *ctx = NULL;
+			uwsgi_foreach_token(qs, "+", p, ctx) {
 				// create a copy for the url_decoded string
 				char *arg_copy = uwsgi_str(p);
 				uint16_t arg_copy_len = strlen(p);
@@ -838,7 +838,6 @@ clear2:
 				argv[i] = uwsgi_malloc( (arg_copy_len * 2) +1);
 				escape_shell_arg(arg_copy, arg_copy_len, argv[i]);	
 				i++;
-				p = strtok(NULL, "+");
 			}
 			free(qs);
 		}

plugins/forkptyrouter/forkptyrouter.c

@@ -0,0 +1,204 @@
+/*
+
+   uWSGI forkpty-router
+
+*/
+
+#include <uwsgi.h>
+#include "../corerouter/cr.h"
+
+extern struct uwsgi_server uwsgi;
+
+#ifdef __linux__
+#include <pty.h>
+#elif defined(__APPLE__) || defined(__OpenBSD__)
+#include <util.h>
+#elif defined(__FreeBSD__)
+#include <libutil.h>
+#endif
+#ifndef __FreeBSD__
+#include <utmp.h>
+#endif
+
+
+static struct uwsgi_forkptyrouter {
+	struct uwsgi_corerouter cr;
+	char *cmd;
+} ufpty;
+
+extern struct uwsgi_server uwsgi;
+
+struct forkptyrouter_session {
+	struct corerouter_session session;
+	pid_t pid;
+};
+
+static struct uwsgi_option forkptyrouter_options[] = {
+	{"forkptyrouter", required_argument, 0, "run the forkptyrouter on the specified address", uwsgi_opt_undeferred_corerouter, &ufpty, 0},
+	{"forkpty-router", required_argument, 0, "run the forkptyrouter on the specified address", uwsgi_opt_undeferred_corerouter, &ufpty, 0},
+	{"forkptyrouter-command", required_argument, 0, "run the specified command on every connection (default: /bin/sh)", uwsgi_opt_set_str, &ufpty.cmd, 0},
+	{"forkpty-router-command", required_argument, 0, "run the specified command on every connection (default: /bin/sh)", uwsgi_opt_set_str, &ufpty.cmd, 0},
+	{"forkptyrouter-cmd", required_argument, 0, "run the specified command on every connection (default: /bin/sh)", uwsgi_opt_set_str, &ufpty.cmd, 0},
+	{"forkpty-router-cmd", required_argument, 0, "run the specified command on every connection (default: /bin/sh)", uwsgi_opt_set_str, &ufpty.cmd, 0},
+	{"forkptyrouter-processes", required_argument, 0, "prefork the specified number of forkptyrouter processes", uwsgi_opt_set_int, &ufpty.cr.processes, 0},
+	{"forkptyrouter-workers", required_argument, 0, "prefork the specified number of forkptyrouter processes", uwsgi_opt_set_int, &ufpty.cr.processes, 0},
+	{"forkptyrouter-zerg", required_argument, 0, "attach the forkptyrouter to a zerg server", uwsgi_opt_corerouter_zerg, &ufpty, 0},
+
+	{"forkptyrouter-fallback", required_argument, 0, "fallback to the specified node in case of error", uwsgi_opt_add_string_list, &ufpty.cr.fallback, 0},
+
+	{"forkptyrouter-events", required_argument, 0, "set the maximum number of concufptyent events", uwsgi_opt_set_int, &ufpty.cr.nevents, 0},
+	{"forkptyrouter-cheap", no_argument, 0, "run the forkptyrouter in cheap mode", uwsgi_opt_true, &ufpty.cr.cheap, 0},
+
+	{"forkptyrouter-timeout", required_argument, 0, "set forkptyrouter timeout", uwsgi_opt_set_int, &ufpty.cr.socket_timeout, 0},
+
+	{"forkptyrouter-stats", required_argument, 0, "run the forkptyrouter stats server", uwsgi_opt_set_str, &ufpty.cr.stats_server, 0},
+	{"forkptyrouter-stats-server", required_argument, 0, "run the forkptyrouter stats server", uwsgi_opt_set_str, &ufpty.cr.stats_server, 0},
+	{"forkptyrouter-ss", required_argument, 0, "run the forkptyrouter stats server", uwsgi_opt_set_str, &ufpty.cr.stats_server, 0},
+	{"forkptyrouter-harakiri", required_argument, 0, "enable forkptyrouter harakiri", uwsgi_opt_set_int, &ufpty.cr.harakiri, 0},
+
+	{0, 0, 0, 0, 0, 0, 0},
+};
+
+// write to backend
+static ssize_t fpty_instance_write(struct corerouter_peer *peer) {
+	ssize_t len = cr_write(peer, "fpty_instance_write()");
+	// end on empty write
+	if (!len) return 0;
+
+	// the chunk has been sent, start (again) reading from client and instances
+	if (cr_write_complete(peer)) {
+		// reset the buffer
+		peer->out->pos = 0;
+		cr_reset_hooks(peer);
+	}
+
+	return len;
+}
+
+// write to client
+static ssize_t fpty_write(struct corerouter_peer *main_peer) {
+	ssize_t len = cr_write(main_peer, "fpty_write()");
+	// end on empty write
+	if (!len) return 0;
+
+	// ok this response chunk is sent, let's start reading again
+	if (cr_write_complete(main_peer)) {
+		// reset the buffer
+		main_peer->out->pos = 0;
+                cr_reset_hooks(main_peer);
+        } 
+
+	return len;
+}
+
+// read from backend
+static ssize_t fpty_instance_read(struct corerouter_peer *peer) {
+	ssize_t len = cr_read(peer, "fpty_instance_read()");
+	if (!len) return 0;
+
+	// set the input buffer as the main output one
+	peer->session->main_peer->out = peer->in;
+	peer->session->main_peer->out_pos = 0;
+
+	cr_write_to_main(peer, fpty_write);
+	return len;
+}
+
+// read from client
+static ssize_t fpty_read(struct corerouter_peer *main_peer) {
+	ssize_t len = cr_read(main_peer, "fpty_read()");
+	if (!len) return 0;
+
+	main_peer->session->peers->out = main_peer->in;
+	main_peer->session->peers->out_pos = 0;
+
+	cr_write_to_backend(main_peer->session->peers, fpty_instance_write);
+	return len;
+}
+
+static void fpty_session_close(struct corerouter_session *cs) {
+        struct forkptyrouter_session *fpty_session = (struct forkptyrouter_session *) cs;
+	if (fpty_session->pid > 0) {
+		int waitpid_status = 0;
+		if (waitpid(fpty_session->pid, &waitpid_status, WNOHANG) < 0) {
+			uwsgi_error("fpty_session_close()/waitpid()");
+		}
+	}
+}
+
+
+// allocate a new session
+static int forkptyrouter_alloc_session(struct uwsgi_corerouter *ucr, struct uwsgi_gateway_socket *ugs, struct corerouter_session *cs, struct sockaddr *sa, socklen_t s_len) {
+
+	// set default read hook
+	cs->main_peer->last_hook_read = fpty_read;
+
+	// wait4() on close
+	cs->close = fpty_session_close;
+
+	struct forkptyrouter_session *fpty_session = (struct forkptyrouter_session *) cs;
+
+	// add a new peer
+	struct corerouter_peer *peer = uwsgi_cr_peer_add(cs);
+
+	// on new connection generate a new pty
+	fpty_session->pid = forkpty(&peer->fd, NULL, NULL, NULL);
+	if (fpty_session->pid < 0) {
+		uwsgi_error("forkpty()");
+		return -1;
+	}
+	else if (fpty_session->pid == 0) {
+		if (ufpty.cmd) {
+			char *space = strchr(ufpty.cmd, ' ');
+			if (space) {
+				char *argv[4];
+				argv[0] = uwsgi_binsh();
+				argv[1] = "-c";	
+				argv[2] = ufpty.cmd;	
+				argv[3] = NULL;	
+				execve(argv[0], argv, uwsgi.environ);
+			}
+			else {
+				char *argv[2];
+				argv[0] = ufpty.cmd;
+				argv[1] = NULL;	
+				execve(argv[0], argv, uwsgi.environ);
+			}
+		}
+		else {
+			char *argv[2];
+			argv[0] = "/bin/sh";
+			argv[1] = NULL;	
+			execve(argv[0], argv, uwsgi.environ);
+		}
+		// never here;
+		uwsgi_error("forkptyrouter_alloc_session()/execve()");
+		exit(1);
+	}
+
+	ucr->cr_table[peer->fd] = peer;
+	cr_reset_hooks_and_read(peer, fpty_instance_read);
+	return 0;
+}
+
+static int forkptyrouter_init() {
+
+	ufpty.cr.session_size = sizeof(struct forkptyrouter_session);
+	ufpty.cr.alloc_session = forkptyrouter_alloc_session;
+	uwsgi_corerouter_init((struct uwsgi_corerouter *) &ufpty);
+
+	return 0;
+}
+
+static void forkptyrouter_setup() {
+	ufpty.cr.name = uwsgi_str("uWSGI forkptyrouter");
+	ufpty.cr.short_name = uwsgi_str("forkptyrouter");
+}
+
+struct uwsgi_plugin forkptyrouter_plugin = {
+
+	.name = "forkptyrouter",
+	.options = forkptyrouter_options,
+	.init = forkptyrouter_init,
+	.on_load = forkptyrouter_setup
+};

plugins/forkptyrouter/uwsgiplugin.py

@@ -0,0 +1,8 @@
+NAME='forkptyrouter'
+CFLAGS = []
+LDFLAGS = []
+LIBS = []
+
+REQUIRES = ['corerouter']
+
+GCC_LIST = ['forkptyrouter']

plugins/gccgo/gccgo_plugin.c

@@ -123,10 +123,9 @@ static void uwsgi_gccgo_initialize() {
 	int argc = 0;
 	if (ugccgo.args) {
         	char *argv_list = uwsgi_str(ugccgo.args);
-                char *p = strtok(argv_list, " ");
-                while(p) {
+                char *p, *ctx = NULL;
+		uwsgi_foreach_token(argv_list, " ", p, ctx) {
 			argc++;
-                        p = strtok(NULL, " ");
                 }
 		free(argv_list);
         }
@@ -134,12 +133,11 @@ static void uwsgi_gccgo_initialize() {
 	if (argc > 0) {
 		char **argv = uwsgi_calloc(sizeof(char *) * (argc + 1));
 		char *argv_list = uwsgi_str(ugccgo.args);
-		char *p = strtok(argv_list, " ");
+		char *p, *ctx = NULL;
 		int n = 0;
-                while(p) {
+		uwsgi_foreach_token(argv_list, " ", p, ctx) {
 			argv[n] = p;
 			n++;
-                        p = strtok(NULL, " ");
                 }
         	runtime_args(argc, argv);
 	}

plugins/glusterfs/glusterfs.c

@@ -117,13 +117,12 @@ connect:
 
 static void uwsgi_glusterfs_connect_do(struct uwsgi_app *ua) {
 	char *servers = uwsgi_str(ua->callable);
-	char *p = strtok(servers, ";");
-	while(p) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(servers, ";", p, ctx) {
 		uwsgi_log("[glusterfs] try connect to %s for mountpoint %.*s on worker %d ...\n", p, ua->mountpoint_len, ua->mountpoint, uwsgi.mywid);
 		if (uwsgi_glusterfs_try(ua, p)) {
 			goto end;
 		}
-		p = strtok(NULL, ";");
 	}
 end:
 	free(servers);

plugins/ldap/ldap.c

@@ -181,10 +181,9 @@ static void uwsgi_opt_ldap_dump_ldif(char *opt, char *foo, void *bar) {
 		entry = &ule[i];
 
 		char *list2 = uwsgi_concat2(entry->names + 1, "");
-		char *p = strtok(list2, " ");
-		while (p != NULL) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(list2, " ", p, ctx) {
 			uwsgi_log("%.*s $ ", strlen(p) - 2, p + 1);
-			p = strtok(NULL, " ");
 		}
 
 		free(list2);
@@ -228,10 +227,9 @@ static void uwsgi_opt_ldap_dump(char *opt, char *foo, void *bar) {
 		entry = &ule[i];
 
 		char *list2 = uwsgi_concat2(entry->names + 1, "");
-		char *p = strtok(list2, " ");
-		while (p != NULL) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(list2, " ", p, ctx) {
 			uwsgi_log("%.*s $ ", strlen(p) - 2, p + 1);
-			p = strtok(NULL, " ");
 		}
 
 		free(list2);

plugins/libtcc/libtcc.c

@@ -0,0 +1,53 @@
+#include <uwsgi.h>
+#include <libtcc.h>
+
+uint64_t uwsgi_libtcc_counter = 0;
+
+static int uwsgi_libtcc_hook(char *arg) {
+	char *func_base = "uwsgi_libtcc_func";
+	size_t func_len = strlen(func_base) + sizeof(UMAX64_STR);
+	char *func_name = uwsgi_malloc(func_len);
+	if (snprintf(func_name, func_len, "%s%llu", func_base, uwsgi_libtcc_counter) < (int) strlen(func_base)) {
+		free(func_name);
+		return -1;
+	}
+	uwsgi_libtcc_counter++;
+	size_t source_len = 64 + func_len + strlen(arg);
+	char *source = uwsgi_malloc(source_len); 
+	if (snprintf(source, source_len, "void %s() { %s ;}", func_name, arg) < (int) ( strlen(func_base) + strlen(arg))) {
+		free(func_name);
+		free(source);
+		return -1;
+	}
+
+	TCCState *s = tcc_new();
+
+	if (tcc_compile_string(s, source)) goto error;
+	if (tcc_relocate(s, TCC_RELOCATE_AUTO)) goto error;
+
+	void (*func)() = tcc_get_symbol(s, func_name);
+	if (!func) goto error;
+	free(func_name);
+	free(source);
+
+	// call the function
+	func();
+
+	tcc_delete(s);
+	return 0;
+
+error:
+	free(func_name);
+	free(source);
+	tcc_delete(s);
+	return -1;
+}
+
+static void uwsgi_libtcc_setup() {
+	uwsgi_register_hook("tcc", uwsgi_libtcc_hook);
+}
+
+struct uwsgi_plugin libtcc_plugin = {
+	.name = "libtcc",
+	.on_load = uwsgi_libtcc_setup,
+};

plugins/libtcc/uwsgiplugin.py

@@ -0,0 +1,5 @@
+NAME='libtcc'
+CFLAGS=[]
+LDFLAGS=[]
+LIBS=['-ltcc']
+GCC_LIST=['libtcc']

plugins/logfile/logfile.c

@@ -1,6 +1,6 @@
-#include "../../uwsgi.h"
+#include <uwsgi.h>
 
-ssize_t uwsgi_file_logger(struct uwsgi_logger *ul, char *message, size_t len) {
+static ssize_t uwsgi_file_logger(struct uwsgi_logger *ul, char *message, size_t len) {
 
 	if (!ul->configured) {
 		if (ul->arg) {
@@ -18,8 +18,24 @@ ssize_t uwsgi_file_logger(struct uwsgi_logger *ul, char *message, size_t len) {
 
 }
 
+static ssize_t uwsgi_fd_logger(struct uwsgi_logger *ul, char *message, size_t len) {
+
+        if (!ul->configured) {
+		ul->fd = -1;
+                if (ul->arg) ul->fd = atoi(ul->arg);
+                ul->configured = 1;
+        }
+
+        if (ul->fd >= 0) {
+                return write(ul->fd, message, len);
+        }
+        return 0;
+
+}
+
 void uwsgi_file_logger_register() {
 	uwsgi_register_logger("file", uwsgi_file_logger);
+	uwsgi_register_logger("fd", uwsgi_fd_logger);
 }
 
 struct uwsgi_plugin logfile_plugin = {

plugins/logpipe/logpipe.c

@@ -0,0 +1,60 @@
+#include <uwsgi.h>
+
+/*
+
+	The pipe logger
+
+	Author: INADA Naoki
+
+	every log line is sent to the stdin of an external process	
+
+	Example:
+
+		req-logger = pipe:/usr/local/bin/mylogger
+
+*/
+
+static ssize_t uwsgi_pipe_logger(struct uwsgi_logger *ul, char *message, size_t len) {
+	if (!ul->configured) {
+		if (ul->arg) {
+			int pipefd[2];
+			// retry later...
+			if (pipe(pipefd) < 0) return -1;
+			pid_t pid = fork();
+			if (pid < 0) return -1;
+			if (pid > 0) {
+				close(pipefd[0]);
+				ul->fd = pipefd[1];
+			}
+			else {
+				// child
+				setsid();
+				close(pipefd[1]);
+				dup2(pipefd[0], STDIN_FILENO);
+				close(pipefd[0]);
+				uwsgi_exec_command_with_args(ul->arg);
+				exit(1);	// if here something seriously failed
+			}
+		}
+
+		ul->configured = 1;
+	}
+
+	int err = write(ul->fd, message, len);
+	// on failed writes, re-configure the logger
+	if (err <= 0) {
+		close(ul->fd);
+		ul->configured = 0;
+		return err;
+	}
+	return 0;
+}
+
+static void uwsgi_pipe_logger_register() {
+	uwsgi_register_logger("pipe", uwsgi_pipe_logger);
+}
+
+struct uwsgi_plugin logpipe_plugin = {
+	.name = "logpipe",
+	.on_load = uwsgi_pipe_logger_register,
+};

plugins/logpipe/uwsgiplugin.py

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

plugins/msgpack/msgpack.c

@@ -164,8 +164,8 @@ int uwsgi_buffer_msgpack_false(struct uwsgi_buffer *ub) {
 static char *uwsgi_msgpack_log_encoder(struct uwsgi_log_encoder *ule, char *msg, size_t len, size_t *rlen) {
 	char *buf = NULL;
 	if (!ule->configured) {
-		char *p = strtok(ule->args, "|");
-		while(p) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(ule->args, "|", p, ctx) {
 			char *colon = strchr(p, ':');
 			if (colon) *colon = 0;	
 			// find the type of item
@@ -259,7 +259,6 @@ static char *uwsgi_msgpack_log_encoder(struct uwsgi_log_encoder *ule, char *msg,
                         }
 		
 			if (colon) *colon = ':';
-			p = strtok(NULL, "|");
 		}
 		ule->configured = 1;
 	}

plugins/php/uwsgiplugin.py

@@ -5,25 +5,24 @@ NAME='php'
 ld_run_path = None
 PHPPATH = 'php-config'
 
-try:
-    phpdir = os.environ['UWSGICONFIG_PHPDIR']
+phpdir = os.environ.get('UWSGICONFIG_PHPDIR')
+if phpdir:
     ld_run_path = "%s/lib" % phpdir
     PHPPATH = "%s/bin/php-config" % phpdir
-except:
-    pass
 
-try:
-    PHPPATH = os.environ['UWSGICONFIG_PHPPATH']
-except:
-    pass
+PHPPATH = os.environ.get('UWSGICONFIG_PHPPATH', PHPPATH)
 
 CFLAGS = [os.popen(PHPPATH + ' --includes').read().rstrip(), '-Wno-sign-compare']
-
 LDFLAGS = os.popen(PHPPATH + ' --ldflags').read().rstrip().split()
+
 if ld_run_path:
     LDFLAGS.append('-L%s' % ld_run_path)
     os.environ['LD_RUN_PATH'] = ld_run_path
 
 LIBS = [os.popen(PHPPATH + ' --libs').read().rstrip(), '-lphp5']
 
+phplibdir = os.environ.get('UWSGICONFIG_PHPLIBDIR')
+if phplibdir:
+    LIBS.append('-Wl,-rpath=%s' % phplibdir)
+
 GCC_LIST = ['php_plugin']

plugins/psgi/psgi_loader.c

@@ -383,10 +383,9 @@ int init_psgi_app(struct wsgi_request *wsgi_req, char *app, uint16_t app_len, Pe
 			AV *uperl_argv = GvAV(PL_argvgv);
 			if (uperl.argv_items) {
 				char *argv_list = uwsgi_str(uperl.argv_items);
-				char *p = strtok(argv_list, " ");
-				while(p) {
+				char *p, *ctx = NULL;
+				uwsgi_foreach_token(argv_list, " ", p, ctx) {
 					av_push(uperl_argv, newSVpv(p, 0));
-					p = strtok(NULL, " ");
 				}
 			}
 			struct uwsgi_string_list *usl = uperl.argv_item;

plugins/pty/pty.c

@@ -78,7 +78,7 @@ static struct uwsgi_option uwsgi_pty_options[] = {
 	{"pty-input", no_argument, 0, "read from original stdin in addition to pty", uwsgi_opt_true, &upty.input, 0},
 	{"pty-connect", required_argument, 0, "connect the current terminal to a pty server", uwsgi_opt_set_str, &upty.remote, 0},
 	{"pty-no-isig", no_argument, 0, "disable ISIG terminal attribute in client mode", uwsgi_opt_true, &upty.no_isig, 0},
-	{"pty-exec", no_argument, 0, "run the specified command soon after the pty thread is spawned", uwsgi_opt_set_str, &upty.command, 0},
+	{"pty-exec", required_argument, 0, "run the specified command soon after the pty thread is spawned", uwsgi_opt_set_str, &upty.command, 0},
 	{0, 0, 0, 0, 0, 0, 0},
 };
 
@@ -272,8 +272,8 @@ static int uwsgi_pty_client() {
 		exit(1);
 	}
 
-	uwsgi_socket_nb(upty.server_fd);
-	uwsgi_socket_nb(0);
+	//uwsgi_socket_nb(upty.server_fd);
+	//uwsgi_socket_nb(0);
 
 	uwsgi_log("[pty] connected.\n");
 

plugins/python/pyutils.c

@@ -320,8 +320,9 @@ void init_pyargv() {
 		char *tmp_ptr = uwsgi_str(up.argv);
 #ifdef __sun__
                 // FIX THIS !!!
-                ap = strtok(tmp_ptr, " ");
-                while ((ap = strtok(NULL, " ")) != NULL) {
+		char *ctx = NULL;
+                ap = strtok_r(tmp_ptr, " ", &ctx);
+                while ((ap = strtok_r(NULL, " ", &ctx)) != NULL) {
 #else
                 while ((ap = strsep(&tmp_ptr, " \t")) != NULL) {
 #endif
@@ -352,8 +353,9 @@ void init_pyargv() {
 
 #ifdef __sun__
 		// FIX THIS !!!
-		ap = strtok(py_argv_copy, " ");
-		while ((ap = strtok(NULL, " ")) != NULL) {
+		char *ctx = NULL;
+		ap = strtok_r(py_argv_copy, " ", &ctx);
+		while ((ap = strtok_r(NULL, " ", &ctx)) != NULL) {
 #else
 		while ((ap = strsep(&py_argv_copy, " \t")) != NULL) {
 #endif

plugins/rpc/rpc_plugin.c

@@ -158,18 +158,19 @@ static int uwsgi_rpc_request(struct wsgi_request *wsgi_req) {
 		}
 
 		argc = 0;
-		argv[0] = strtok(args, "/");
+		char *ctx = NULL;
+		argv[0] = strtok_r(args, "/", &ctx);
 		if (!argv[0]) {
 			free(args);
 			uwsgi_500(wsgi_req);
 			return UWSGI_OK;
 		}
-		char *p = strtok(NULL, "/");
+		char *p = strtok_r(NULL, "/", &ctx);
 		while(p) {
 			argc++;
 			argv[argc] = p;
 			argvs[argc] = strlen(p);
-			p = strtok(NULL, "/");
+			p = strtok_r(NULL, "/", &ctx);
 		}
 		
 		wsgi_req->uh->pktsize = uwsgi_rpc(argv[0], argc, argv+1, argvs+1, response_buf);
@@ -558,8 +559,8 @@ static int uwsgi_router_rpc_base(struct uwsgi_route *ur, char *args) {
 	ur->custom = 0;
 	ur->data2 = uwsgi_calloc(sizeof(char *) * UMAX8);
 	ur->data3 = uwsgi_calloc(sizeof(uint16_t) * UMAX8);
-	char *p = strtok(args, " ");
-	while(p) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(args, " ", p, ctx) {
 		if (!ur->data) {
 			ur->data = p;
 		}
@@ -576,7 +577,6 @@ static int uwsgi_router_rpc_base(struct uwsgi_route *ur, char *args) {
 			argvs[ur->custom] = strlen(p);
 			ur->custom++;	
 		}
-		p = strtok(NULL, " ");
 	}
 
 	if (!ur->data) {

plugins/webdav/webdav.c

@@ -158,11 +158,10 @@ static void uwsgi_webdav_add_a_prop(xmlNode *node, char *opt, xmlNode *req_prop,
 		else if (type == 2) {
 			new_node = xmlNewChild(node, NULL, BAD_CAST first_space + 1, NULL);
 			char *comps = uwsgi_str(second_space + 1);
-			char *p = strtok(comps, ",");
-			while(p) {
+			char *p, *ctx = NULL;
+			uwsgi_foreach_token(comps, ",", p, ctx) {
 				xmlNode *comp = xmlNewChild(new_node, NULL, BAD_CAST "comp", NULL);
 				xmlNewProp(comp, BAD_CAST "name", BAD_CAST p);
-				p = strtok(NULL, ",");
 			}
 			free(comps);
 		}

plugins/xslt/xslt.c

@@ -72,16 +72,15 @@ static char *uwsgi_xslt_apply(xmlDoc *doc, char *xsltfile, char *params, int *rl
 		}
 		vparams = uwsgi_calloc( sizeof(char *) * ((count * 2) + 1));
 		tmp_params = uwsgi_str(params);
-		char *p = strtok(tmp_params, "&");
 		int pos = 0;
-		while(p) {
+		char *p, *ctx = NULL;
+		uwsgi_foreach_token(tmp_params, "&", p, ctx) {
 			char *equal = strchr(p, '=');
 			if (equal) {
 				*equal = 0;
 				vparams[pos] = p; pos++;
 				vparams[pos] = uwsgi_concat3("\"", equal+1, "\""); pos++;	
 			}
-			p = strtok(NULL, "&");
 		}
 	}
 

plugins/zergpool/zergpool.c

@@ -91,18 +91,17 @@ struct zergpool_socket *add_zergpool_socket(char *name, char *sockets) {
 	}
 
 	char *sock_list = uwsgi_str(sockets);
-	char *p = strtok(sock_list, ",");
-	while(p) {
+	char *p, *ctx = NULL;
+	uwsgi_foreach_token(sock_list, ",", p, ctx) {
 		z_sock->num_sockets++;
-		p = strtok(NULL, ",");
 	}
 	free(sock_list);
 	z_sock->sockets = uwsgi_calloc(sizeof(int) * (z_sock->num_sockets + 1));
 
 	sock_list = uwsgi_str(sockets);
 	int pos = 0;
-	p = strtok(sock_list, ",");
-	while(p) {
+	ctx = NULL;
+	uwsgi_foreach_token(sock_list, ",", p, ctx) {
 		char *port = strchr(p, ':');
 		char *sockname;
 		if (!port) {
@@ -117,7 +116,6 @@ struct zergpool_socket *add_zergpool_socket(char *name, char *sockets) {
 			uwsgi_log("zergpool %s bound to TCP socket %s (fd: %d)\n", name, sockname, z_sock->sockets[pos]);
 		}
 		pos++;
-		p = strtok(NULL, ",");
 		free(sockname);
 	}
 	free(sock_list);

pyuwsgi_run.py

@@ -1,22 +0,0 @@
-import sys
-import os
-import pyuwsgi
-
-orig_args = sys.argv
-orig_executable = sys.executable
-orig_args.insert(0, orig_executable)
-
-uwsgi_args = []
-
-uwsgi_args.append('--socket')
-uwsgi_args.append(':3031')
-#uwsgi_args.append('--master')
-uwsgi_args.append('--module')
-#uwsgi_args.append('welcome')
-uwsgi_args.append('hello')
-
-#pyuwsgi.run('welcome.ini')
-pyuwsgi.run(uwsgi_args)
-
-# if you are here uWSGI has been reloaded
-os.execv(orig_executable, orig_args)

uwsgi.gemspec

@@ -2,7 +2,7 @@ Gem::Specification.new do |s|
   s.name        = 'uwsgi'
   s.license     = 'GPL-2'
   s.version     = `python -c "import uwsgiconfig as uc; print uc.uwsgi_version"`.sub(/-dev-.*/,'')
-  s.date        = '2013-09-14'
+  s.date        = '2013-09-22'
   s.summary     = "uWSGI"
   s.description = "The uWSGI server for Ruby/Rack"
   s.authors     = ["Unbit"]

uwsgi.h

@@ -132,6 +132,8 @@ extern "C" {
 
 #define uwsgi_foreach(x, y) for(x=y;x;x = x->next) 
 
+#define uwsgi_foreach_token(x, y, z, w) for(z=strtok_r(x, y, &w);z;z = strtok_r(NULL, y, &w))
+
 
 #ifndef __need_IOV_MAX
 #define __need_IOV_MAX
@@ -1256,6 +1258,7 @@ struct uwsgi_log_encoder {
 	char *name;
 	char *(*func)(struct uwsgi_log_encoder *, char *, size_t, size_t *);
 	int configured;
+	char *use_for;
 	char *args;
 	void *data;
 	struct uwsgi_log_encoder *next;
@@ -1684,6 +1687,13 @@ struct uwsgi_server {
 	int drop_after_init;
 	int drop_after_apps;
 
+	int master_is_reforked;
+
+	struct uwsgi_string_list *master_fifo;
+	int master_fifo_fd;
+	int master_fifo_slot;
+
+
 	// kill the stack on SIGTERM (instead of brutal reloading)
 	int die_on_term;
 
@@ -1730,6 +1740,8 @@ struct uwsgi_server {
 	uint64_t cheaper_rss_limit_soft;
 	uint64_t cheaper_rss_limit_hard;
 
+	int cheaper_fifo_delta;
+
 	// destroy the stack when idle
 	int die_on_idle;
 
@@ -1774,6 +1786,7 @@ struct uwsgi_server {
 	char *emperor_stats;
 	int emperor_stats_fd;
 	struct uwsgi_string_list *vassals_templates;
+	struct uwsgi_string_list *vassals_includes;
 	// true if loyal to the emperor
 	int loyal;
 
@@ -1952,6 +1965,7 @@ struct uwsgi_server {
 
 	struct uwsgi_hook *hooks;
 
+	struct uwsgi_string_list *hook_asap;
 	struct uwsgi_string_list *hook_pre_jail;
         struct uwsgi_string_list *hook_post_jail;
         struct uwsgi_string_list *hook_in_jail;
@@ -1965,6 +1979,7 @@ struct uwsgi_server {
         struct uwsgi_string_list *hook_as_emperor;
 	
 
+	struct uwsgi_string_list *exec_asap;
 	struct uwsgi_string_list *exec_pre_jail;
 	struct uwsgi_string_list *exec_post_jail;
 	struct uwsgi_string_list *exec_in_jail;
@@ -1977,6 +1992,7 @@ struct uwsgi_server {
         struct uwsgi_string_list *exec_as_vassal;
         struct uwsgi_string_list *exec_as_emperor;
 
+	struct uwsgi_string_list *call_asap;
 	struct uwsgi_string_list *call_pre_jail;
         struct uwsgi_string_list *call_post_jail;
         struct uwsgi_string_list *call_in_jail;
@@ -1995,6 +2011,7 @@ struct uwsgi_server {
         struct uwsgi_string_list *call_as_emperor2;
         struct uwsgi_string_list *call_as_emperor4;
 
+	struct uwsgi_string_list *mount_asap;
 	struct uwsgi_string_list *mount_pre_jail;
         struct uwsgi_string_list *mount_post_jail;
         struct uwsgi_string_list *mount_in_jail;
@@ -2003,6 +2020,7 @@ struct uwsgi_server {
         struct uwsgi_string_list *mount_as_vassal;
         struct uwsgi_string_list *mount_as_emperor;
 
+	struct uwsgi_string_list *umount_asap;
 	struct uwsgi_string_list *umount_pre_jail;
         struct uwsgi_string_list *umount_post_jail;
         struct uwsgi_string_list *umount_in_jail;
@@ -3585,6 +3603,7 @@ int uwsgi_calc_cheaper(void);
 int uwsgi_cheaper_algo_spare(void);
 int uwsgi_cheaper_algo_backlog(void);
 int uwsgi_cheaper_algo_backlog2(void);
+int uwsgi_cheaper_algo_manual(void);
 
 int uwsgi_master_log(void);
 int uwsgi_master_req_log(void);
@@ -4301,6 +4320,24 @@ void uwsgi_log_encoders_register_embedded(void);
 void uwsgi_register_log_encoder(char *, char *(*)(struct uwsgi_log_encoder *, char *, size_t, size_t *));
 
 int uwsgi_accept(int);
+void suspend_resume_them_all(int);
+
+void uwsgi_master_fifo_prepare();
+int uwsgi_master_fifo();
+int uwsgi_master_fifo_manage(int);
+
+void uwsgi_log_rotate();
+void uwsgi_log_reopen();
+void uwsgi_reload_workers();
+void uwsgi_chain_reload();
+void uwsgi_refork_master();
+void uwsgi_update_pidfiles();
+void gracefully_kill_them_all(int);
+void uwsgi_brutally_reload_workers();
+
+void uwsgi_cheaper_increase();
+void uwsgi_cheaper_decrease();
+void uwsgi_go_cheap();
 
 #ifdef __cplusplus
 }

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '1.9.16'
+uwsgi_version = '1.9.17'
 
 import os
 import re
@@ -507,7 +507,7 @@ class uConf(object):
 
         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/notify', 'core/mule', 'core/subscription', 'core/stats', 'core/sendfile', 'core/async', 'core/master_checks', 'core/fifo',
             'core/offload', 'core/io', 'core/static', 'core/websockets', 'core/spooler', 'core/snmp', 'core/exceptions', 'core/config',
             'core/setup_utils', 'core/clock', 'core/init', 'core/buffer', 'core/reader', 'core/writer', 'core/alarm', 'core/cron', 'core/hooks',
             'core/plugins', 'core/lock', 'core/cache', 'core/daemons', 'core/errors', 'core/hash', 'core/master_events', 'core/chunked',