uWSGI 1.4.3

Avoid call storming of pidfile check that leads to multiple daemons
running instead of one. Fix #65.

ChangeLog

@@ -1,5 +1,14 @@
 *** current ***
 
+ * 1.4.1
+
+- fixed typos in corerouter plugins
+- fixed offloading when the number of threads is higher than 1
+- fixed static_maps for non-existent paths
+- fixed uwsgi_connect() on modern Linux systems to reset the socket to blocking mode
+
+*** november 2012 ***
+
  * 1.4
 
 - gevent improvements

core/daemons.c

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

core/emperor.c

@@ -784,6 +784,8 @@ void uwsgi_imperial_monitor_directory_init(struct uwsgi_emperor_scanner *ues) {
 		exit(1);
 	}
 
+	ues->arg = uwsgi.emperor_absolute_dir;
+
 }
 
 struct uwsgi_imperial_monitor *imperial_monitor_get_by_id(char *scheme) {

core/ini.c

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

core/offload.c

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

core/protocol.c

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

core/socket.c

@@ -718,7 +718,7 @@ int timed_connect(struct pollfd *fdpoll, const struct sockaddr *addr, int addr_s
 
 
 #if defined(__linux__) && defined(SOCK_NONBLOCK) && !defined(OBSOLETE_LINUX_KERNEL)
-	// hmm, nothing to do, as we are already non-blocking
+	uwsgi_socket_b(fdpoll->fd);
 #else
 	/* re-set blocking socket */
 	arg &= (~O_NONBLOCK);

core/utils.c

@@ -2691,15 +2691,10 @@ void init_magic_table(char *magic_table[]) {
 }
 
 char *uwsgi_get_last_char(char *what, char c) {
-	int i, j = 0;
+	int i;
 	char *ptr = NULL;
 
-	if (!strncmp("http://", what, 7))
-		j = 7;
-	if (!strncmp("emperor://", what, 10))
-		j = 10;
-
-	for (i = j; i < (int) strlen(what); i++) {
+	for (i = 0; i < (int) strlen(what); i++) {
 		if (what[i] == c) {
 			ptr = what + i;
 		}
@@ -3279,10 +3274,46 @@ pid_t uwsgi_run_command(char *command, int *stdin_fd, int stdout_fd) {
 	}
 
 	uwsgi_close_all_sockets();
+	//uwsgi_close_all_fds();
+	int i;
+	for (i = 3; i < (int) uwsgi.max_fd; i++) {
+		if (stdin_fd) {
+			if (i == stdin_fd[0] || i == stdin_fd[1]) {
+				continue;
+			} 
+		}
+		if (stdout_fd > -1) {
+			if (i == stdout_fd) {
+				continue;
+			}
+		}
+#ifdef __APPLE__
+                fcntl(i, F_SETFD, FD_CLOEXEC);
+#else
+                close(i);
+#endif
+        }
+
+	
 
 	if (stdin_fd) {
 		close(stdin_fd[1]);
 	}
+	else {
+		if (!uwsgi_valid_fd(0)) {
+			int in_fd = open("/dev/null", O_RDONLY);
+			if (in_fd < 0) {
+				uwsgi_error_open("/dev/null");
+			}
+			else {
+				if (in_fd != 0) {
+					if (dup2(in_fd, 0)) {
+						uwsgi_error("dup2()");
+					}
+				}
+			}
+		}
+	}
 
 	if (stdout_fd > -1 && stdout_fd != 1) {
 		if (dup2(stdout_fd, 1) < 0) {
@@ -4806,7 +4837,7 @@ static void *uwsgi_thread_run(void *arg) {
 
 struct uwsgi_thread *uwsgi_thread_new(void (*func) (struct uwsgi_thread *)) {
 
-	struct uwsgi_thread *ut = uwsgi_malloc(sizeof(struct uwsgi_thread));
+	struct uwsgi_thread *ut = uwsgi_calloc(sizeof(struct uwsgi_thread));
 
 #if defined(SOCK_SEQPACKET) && defined(__linux__)
 	if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, ut->pipe)) {
@@ -5044,3 +5075,23 @@ end:
 	free(symbol_name);
 	return ret;
 }
+
+int uwsgi_valid_fd(int fd) {
+	int ret = fcntl(fd, F_GETFL);
+	if (ret == 0) {
+		return 1;
+	}
+	return 0;
+}
+
+void uwsgi_close_all_fds(void) {
+	int i;
+	for (i = 3; i < (int) uwsgi.max_fd; i++) {
+#ifdef __APPLE__
+        	fcntl(i, F_SETFD, FD_CLOEXEC);
+#else
+                close(i);
+#endif
+	}
+}
+

core/uwsgi.c

@@ -471,6 +471,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 #endif
 
 	{"offload-threads", required_argument, 0, "set the number of offload threads to spawn (per-worker, default 0)", uwsgi_opt_set_int, &uwsgi.offload_threads, 0},
+	{"offload-thread", required_argument, 0, "set the number of offload threads to spawn (per-worker, default 0)", uwsgi_opt_set_int, &uwsgi.offload_threads, 0},
 
 	{"file-serve-mode", required_argument, 0, "set static file serving mode", uwsgi_opt_fileserve_mode, NULL, UWSGI_OPT_MIME},
 	{"fileserve-mode", required_argument, 0, "set static file serving mode", uwsgi_opt_fileserve_mode, NULL, UWSGI_OPT_MIME},
@@ -677,6 +678,17 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 	char *tmp = NULL;
 	char *fullname = filename;
 
+	magic_table['o'] = filename;
+
+	if (uwsgi_check_scheme(filename) || !strcmp(filename, "-")) {
+		return;
+	}
+
+        char *section = uwsgi_get_last_char(filename, ':');
+        if (section) {
+                *section = 0;
+	}
+
 	// we have a special case for symlinks
 	if (uwsgi_is_link(filename)) {
 		if (filename[0] != '/') {
@@ -686,19 +698,16 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 	else {
 
 		fullname = uwsgi_expand_path(filename, strlen(filename), NULL);
-		if (fullname) {
-			char *minimal_name = uwsgi_malloc(strlen(fullname) + 1);
-			memcpy(minimal_name, fullname, strlen(fullname));
-			minimal_name[strlen(fullname)] = 0;
-			free(fullname);
-			fullname = minimal_name;
-		}
-		else {
-			fullname = filename;
+		if (!fullname) {
+			exit(1);
 		}
+		char *minimal_name = uwsgi_malloc(strlen(fullname) + 1);
+		memcpy(minimal_name, fullname, strlen(fullname));
+		minimal_name[strlen(fullname)] = 0;
+		free(fullname);
+		fullname = minimal_name;
 	}
 
-	magic_table['o'] = filename;
 	magic_table['p'] = fullname;
 	magic_table['s'] = uwsgi_get_last_char(fullname, '/') + 1;
 	magic_table['d'] = uwsgi_concat2n(magic_table['p'], magic_table['s'] - magic_table['p'], "", 0);
@@ -732,6 +741,11 @@ void config_magic_table_fill(char *filename, char **magic_table) {
 		magic_table['e'] = uwsgi_get_last_char(filename, '.') + 1;
 	if (uwsgi_get_last_char(magic_table['s'], '.'))
 		magic_table['n'] = uwsgi_concat2n(magic_table['s'], uwsgi_get_last_char(magic_table['s'], '.') - magic_table['s'], "", 0);
+
+	if (section) {
+		magic_table['x'] = section+1;
+		*section = ':';
+	}
 }
 
 int find_worker_id(pid_t pid) {

plugins/carbon/carbon.c

@@ -82,7 +82,7 @@ void carbon_post_init() {
 	// set next update to now()+retry_delay, this way we will have first flush just after start
 	u_carbon.last_update = uwsgi_now() - u_carbon.freq + u_carbon.retry_delay;
 
-	uwsgi_log("[carbon] carbon plugin started, %is frequency, %is timeout, max retries %i, retry delay %is",
+	uwsgi_log("[carbon] carbon plugin started, %is frequency, %is timeout, max retries %i, retry delay %is\n",
 		u_carbon.freq, u_carbon.timeout, u_carbon.max_retries, u_carbon.retry_delay);
 }
 

plugins/cgi/cgi_plugin.c

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

plugins/cheaper_busyness/cheaper_busyness.c

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

plugins/corerouter/corerouter.c

@@ -567,7 +567,7 @@ struct corerouter_session *corerouter_alloc_session(struct uwsgi_corerouter *ucr
         ucr->cr_table[new_connection]->fd = new_connection;
         ucr->cr_table[new_connection]->instance_fd = -1;
 
-	// map courerouter and socket
+	// map corerouter and socket
 	ucr->cr_table[new_connection]->corerouter = ucr;
 	ucr->cr_table[new_connection]->ugs = ugs;
 
@@ -859,7 +859,7 @@ void uwsgi_corerouter_loop(int id, void *data) {
 
 }
 
-int uwsgi_courerouter_has_has_backends(struct uwsgi_corerouter *ucr) {
+int uwsgi_corerouter_has_backends(struct uwsgi_corerouter *ucr) {
 
 	if (ucr->has_backends) return 1;
 
@@ -899,7 +899,7 @@ int uwsgi_corerouter_init(struct uwsgi_corerouter *ucr) {
 			ucr->max_retries = 3;
 	
 
-		ucr->has_backends = uwsgi_courerouter_has_has_backends(ucr);
+		ucr->has_backends = uwsgi_corerouter_has_backends(ucr);
 
 
 		uwsgi_corerouter_setup_sockets(ucr);
@@ -923,7 +923,7 @@ int uwsgi_corerouter_init(struct uwsgi_corerouter *ucr) {
 
 struct uwsgi_plugin corerouter_plugin = {
 
-	.name = "courerouter",
+	.name = "corerouter",
 };
 
 void corerouter_send_stats(struct uwsgi_corerouter *ucr) {

plugins/corerouter/cr.h

@@ -185,7 +185,7 @@ int uwsgi_cr_map_use_cs(struct uwsgi_corerouter *, struct corerouter_session *);
 int uwsgi_cr_map_use_to(struct uwsgi_corerouter *, struct corerouter_session *);
 int uwsgi_cr_map_use_static_nodes(struct uwsgi_corerouter *, struct corerouter_session *);
 
-int uwsgi_courerouter_has_has_backends(struct uwsgi_corerouter *);
+int uwsgi_corerouter_has_backends(struct uwsgi_corerouter *);
 
 int uwsgi_cr_hook_read(struct corerouter_session *, ssize_t (*)(struct corerouter_session *));
 int uwsgi_cr_hook_write(struct corerouter_session *, ssize_t (*)(struct corerouter_session *));

plugins/http/http.c

@@ -399,9 +399,9 @@ int http_parse(struct http_session *h_session, size_t http_req_len) {
 	while (ptr < watermark) {
 		if (*ptr == '\r') {
 			if (ptr + 1 >= watermark)
-				return 0;
+				break;
 			if (*(ptr + 1) != '\n')
-				return 0;
+				break;
 			// multiline header ?
 			if (ptr + 2 < watermark) {
 				if (*(ptr + 2) == ' ' || *(ptr + 2) == '\t') {
@@ -518,6 +518,14 @@ ssize_t hr_read_ssl_body(struct corerouter_session * cs) {
                 if (cs->event_hook_write) {
                         uwsgi_cr_hook_write(cs, NULL);
                 }
+		int ret2 = SSL_pending(hs->ssl);
+                if (ret2 > 0) {
+			if (uwsgi_buffer_fix(hs->post_buf, hs->post_buf->len + ret2 )) return -1;
+                        if (SSL_read(hs->ssl, hs->post_buf->buf + ret, ret2) != ret2) {
+                                return -1;
+                        }
+                        ret += ret2;
+                }
 		hs->post_buf_len = ret;
         	hs->post_buf_pos = 0;
                 uwsgi_cr_hook_read(cs, NULL);
@@ -1131,7 +1139,7 @@ int http_init() {
 
 	uhttp.cr.session_size = sizeof(struct http_session);
 	uhttp.cr.alloc_session = http_alloc_session;
-	if (uhttp.cr.has_sockets && !uwsgi.sockets && !uwsgi_courerouter_has_has_backends(&uhttp.cr)) {
+	if (uhttp.cr.has_sockets && !uwsgi.sockets && !uwsgi_corerouter_has_backends(&uhttp.cr)) {
 		uwsgi_new_socket(uwsgi_concat2("127.0.0.1:0", ""));
 		uhttp.cr.use_socket = 1;
 		uhttp.cr.socket_num = 0;

plugins/lua/lua_plugin.c

@@ -308,6 +308,8 @@ static const luaL_reg uwsgi_api[] = {
 static int uwsgi_lua_input(lua_State *L) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
+	int fd = wsgi_req->async_post ?
+	  fileno(wsgi_req->async_post) : wsgi_req->poll.fd;
 	ssize_t sum, len, total;
 	char *buf, *ptr;
 
@@ -330,7 +332,7 @@ static int uwsgi_lua_input(lua_State *L) {
 
 	ptr = buf;
 	while(total) {
-		len = read(wsgi_req->poll.fd, ptr, total);
+		len = read(fd, ptr, total);
 		ptr += len;
 		total -= len;
 	}

plugins/php/php_plugin.c

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

plugins/psgi/psgi.h

@@ -51,3 +51,4 @@ int uwsgi_perl_obj_can(SV *, char *, size_t);
 int uwsgi_perl_obj_isa(SV *, char *);
 int init_psgi_app(struct wsgi_request *, char *, uint16_t, PerlInterpreter **);
 PerlInterpreter *uwsgi_perl_new_interpreter(void);
+int uwsgi_perl_mule(char *);

plugins/psgi/psgi_loader.c

@@ -233,6 +233,8 @@ xs_init(pTHX)
         /* DynaLoader is a special case */
         newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
 
+	if (!uperl.tmp_input_stash) goto nonworker;
+
         newXS("uwsgi::input::new", XS_input, "uwsgi::input");
         newXS("uwsgi::input::read", XS_input_read, "uwsgi::input");
         newXS("uwsgi::input::seek", XS_input_seek, "uwsgi::input");
@@ -253,6 +255,8 @@ xs_init(pTHX)
 
         uperl.tmp_streaming_stash[uperl.tmp_current_i] = gv_stashpv("uwsgi::streaming", 0);
 
+nonworker:
+
 #ifdef UWSGI_EMBEDDED
         init_perl_embedded_module();
 #endif
@@ -496,3 +500,19 @@ void uwsgi_psgi_app() {
 
 }
 
+int uwsgi_perl_mule(char *opt) {
+
+        if (uwsgi_endswith(opt, ".pl")) {
+                PERL_SET_CONTEXT(uperl.main[0]);
+                uperl.embedding[1] = opt;
+                if (perl_parse(uperl.main[0], xs_init, 2, uperl.embedding, NULL)) {
+                        return 0;
+                }
+                perl_run(uperl.main[0]);
+                return 1;
+        }
+
+        return 0;
+
+}
+

plugins/psgi/psgi_plugin.c

@@ -595,6 +595,32 @@ void uwsgi_perl_enable_threads(void) {
 #endif
 }
 
+int uwsgi_perl_signal_handler(uint8_t sig, void *handler) {
+
+	int ret = 0;
+
+	dSP;
+        ENTER;
+        SAVETMPS;
+        PUSHMARK(SP);
+        XPUSHs( sv_2mortal(newSViv(sig)));
+        PUTBACK;
+
+        call_sv( SvRV((SV*)handler), G_DISCARD);
+
+	if(SvTRUE(ERRSV)) {
+                uwsgi_log("[uwsgi-perl error] %s\n", SvPV_nolen(ERRSV));
+		ret = -1;
+        }
+
+        SPAGAIN;
+        PUTBACK;
+        FREETMPS;
+        LEAVE;
+
+	return ret;
+}
+
 struct uwsgi_plugin psgi_plugin = {
 
 	.name = "psgi",
@@ -606,6 +632,9 @@ struct uwsgi_plugin psgi_plugin = {
 	.mount_app = uwsgi_perl_mount_app,
 
 	.init_thread = uwsgi_perl_init_thread,
+	.signal_handler = uwsgi_perl_signal_handler,
+
+	.mule = uwsgi_perl_mule,
 
 	.post_fork = uwsgi_perl_post_fork,
 	.request = uwsgi_perl_request,

plugins/psgi/psgi_response.c

@@ -59,6 +59,11 @@ int psgi_response(struct wsgi_request *wsgi_req, AV *response) {
 	}
 #endif
 
+	if (SvTYPE(response) != SVt_PVAV) {
+		uwsgi_log("invalid PSGI response type\n");
+		return UWSGI_OK;
+	}
+
 	status_code = av_fetch(response, 0, 0);
 	if (!status_code) { uwsgi_log("invalid PSGI status code\n"); return UWSGI_OK;}
 

plugins/psgi/uwsgi_plmodule.c

@@ -1,6 +1,7 @@
 #include "psgi.h"
 
 extern struct uwsgi_server uwsgi;
+extern struct uwsgi_plugin psgi_plugin;
 
 #ifdef UWSGI_ASYNC
 
@@ -149,6 +150,27 @@ clear:
 	
 }
 
+XS(XS_register_signal) {
+	dXSARGS;
+
+	if (!uwsgi.master_process) {
+		XSRETURN_NO;
+	}
+
+	psgi_check_args(3);
+
+	uint8_t signum = SvIV(ST(0));
+	STRLEN kindlen;
+	char *kind = SvPV(ST(1), kindlen);
+
+	if (uwsgi_register_signal(signum, kind, (void *) newRV_inc(ST(2)), psgi_plugin.modifier1)) {
+		XSRETURN_NO;
+        }
+
+	XSRETURN_YES;
+	
+}
+
 XS(XS_log) {
 
 	dXSARGS;
@@ -219,6 +241,33 @@ XS(XS_suspend) {
 	XSRETURN_UNDEF;
 }
 
+XS(XS_signal_wait) {
+
+	dXSARGS;
+
+	psgi_check_args(0);
+
+        struct wsgi_request *wsgi_req = current_wsgi_req();
+        int received_signal = -1;
+
+        wsgi_req->signal_received = -1;
+
+	if (items > 0) {
+                received_signal = uwsgi_signal_wait(SvIV(ST(0)));
+        }
+        else {
+                received_signal = uwsgi_signal_wait(-1);
+        }
+
+        if (received_signal < 0) {
+		XSRETURN_NO;
+        }
+
+        wsgi_req->signal_received = received_signal;
+	XSRETURN_YES;
+}
+
+
 void init_perl_embedded_module() {
 	psgi_xs(reload);
 	psgi_xs(cache_set);
@@ -231,5 +280,7 @@ void init_perl_embedded_module() {
 	psgi_xs(async_connect);
 	psgi_xs(suspend);
 	psgi_xs(signal);
+	psgi_xs(register_signal);
+	psgi_xs(signal_wait);
 }
 

plugins/router_rewrite/router_rewrite.c

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

test.psgi

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

uwsgi.h

@@ -37,7 +37,7 @@ extern "C" {
 #define thunder_lock if (uwsgi.threads > 1 && !uwsgi.is_et) {pthread_mutex_lock(&uwsgi.thunder_mutex);}
 #define thunder_unlock if (uwsgi.threads > 1 && !uwsgi.is_et) {pthread_mutex_unlock(&uwsgi.thunder_mutex);}
 
-#define uwsgi_check_scheme(file) (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) || !uwsgi_startswith(file, "fd://", 5) || !uwsgi_startswith(file, "exec://", 7) || !uwsgi_startswith(file, "section://", 10))
+#define uwsgi_check_scheme(file) (!uwsgi_startswith(file, "emperor://", 10) || !uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) || !uwsgi_startswith(file, "fd://", 5) || !uwsgi_startswith(file, "exec://", 7) || !uwsgi_startswith(file, "section://", 10))
 
 #define ushared uwsgi.shared
 
@@ -1529,10 +1529,6 @@ struct uwsgi_server {
 
 	int check_static_docroot;
 
-	// linked list for offloaded requests
-	struct uwsgi_offload_request *offload_requests_head;
-	struct uwsgi_offload_request *offload_requests_tail;
-
 	char *daemonize;
 	char *daemonize2;
 	int do_not_change_umask;
@@ -3409,6 +3405,9 @@ struct uwsgi_thread {
 	uint64_t custom1;
 	uint64_t custom2;
 	uint64_t custom3;
+	// linked list for offloaded requests
+        struct uwsgi_offload_request *offload_requests_head;
+        struct uwsgi_offload_request *offload_requests_tail;
 	void (*func)(struct uwsgi_thread *);
 };
 struct uwsgi_thread *uwsgi_thread_new(void (*)(struct uwsgi_thread *));
@@ -3480,6 +3479,8 @@ void uwsgi_user_lock(int);
 void uwsgi_user_unlock(int);
 
 void simple_loop_run_int(int);
+int uwsgi_valid_fd(int);
+void uwsgi_close_all_fds(void);
 
 void uwsgi_check_emperor(void);
 #ifdef UWSGI_AS_SHARED_LIBRARY

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '1.4'
+uwsgi_version = '1.4.3'
 
 import os
 import re
@@ -33,15 +33,20 @@ if not GCC:
 
 CPP = os.environ.get('CPP', 'cpp')
 
-CPUCOUNT = 1
 try:
-    import multiprocessing
-    CPUCOUNT = multiprocessing.cpu_count()
+    CPUCOUNT = int(os.environ.get('CPUCOUNT', -1))
 except:
+    CPUCOUNT = -1
+
+if CPUCOUNT < 1:
     try:
-        CPUCOUNT = int(os.sysconf('SC_NPROCESSORS_ONLN'))
+        import multiprocessing
+        CPUCOUNT = multiprocessing.cpu_count()
     except:
-        pass
+        try:
+            CPUCOUNT = int(os.sysconf('SC_NPROCESSORS_ONLN'))
+        except:
+            CPUCOUNT = 1
 
 binary_list = []