uWSGI 2.0.10

For some reason since e4d65c07ce
we started compiling -Wno-format, possibly because of plugins
dependencies not compiling.
Fedora (and Debian to some degrees) are starting to default to
-Wformat -Werror=format-security which is something sensible for
uwsgi. So let the distro handle the situation when a very recent
gcc version is encountered since they probably know better.

core/emperor.c

@@ -1464,12 +1464,32 @@ static void uwsgi_emperor_spawn_vassal(struct uwsgi_instance *n_ui) {
                 }
         }
 
+	
+	if (uwsgi.emperor_wrapper_override) {
+		char *orig_wrapper = vassal_argv[0];	
+		uwsgi_foreach(usl, uwsgi.emperor_wrapper_override) {
+			vassal_argv[0] = usl->value;
+			uwsgi_log("[emperor] trying to use %s as binary wrapper ...\n", usl->value);
+			execvp(vassal_argv[0], vassal_argv);
+			// not here if the binary is found
+		}
+		vassal_argv[0] = orig_wrapper;
+	}
+
 	// start !!!
 	if (execvp(vassal_argv[0], vassal_argv)) {
 		uwsgi_error("execvp()");
 	}
 	uwsgi_log("[emperor] binary path: %s\n", vassal_argv[0]);
 	uwsgi_log("[emperor] is the uwsgi binary in your system PATH ?\n");
+
+	// trying fallback
+	uwsgi_foreach(usl, uwsgi.emperor_wrapper_fallback) {
+		uwsgi_log("[emperor] trying to use %s as binary fallback ...\n", usl->value);
+                vassal_argv[0] = usl->value;
+                execvp(vassal_argv[0], vassal_argv);
+                // not here if the binary is found
+        }
 	// never here
 	exit(UWSGI_EXILE_CODE);
 }

core/exceptions.c

@@ -464,6 +464,7 @@ void uwsgi_exception_setup_handlers() {
 
 	struct uwsgi_string_list *usl = uwsgi.exception_handlers_instance;
 	while(usl) {
+		// do not free handler !!!
 		char *handler = uwsgi_str(usl->value);
 		char *colon = strchr(handler, ':');
 		if (colon) {
@@ -472,10 +473,8 @@ void uwsgi_exception_setup_handlers() {
 		struct uwsgi_exception_handler *ueh = uwsgi_exception_handler_by_name(handler);
 		if (!ueh) {
 			uwsgi_log("unable to find exception handler: %s\n", handler);
-			free(handler);
 			exit(1);
 		}
-		free(handler);
 
 		struct uwsgi_exception_handler_instance *uehi = uwsgi_calloc(sizeof(struct uwsgi_exception_handler_instance));
 		uehi->handler = ueh;

core/hooks.c

@@ -91,6 +91,14 @@ static int uwsgi_hook_exec(char *arg) {
 	return ret;
 }
 
+static int uwsgi_hook_safeexec(char *arg) {
+        int ret = uwsgi_run_command_and_wait(NULL, arg);
+        if (ret != 0) {
+                uwsgi_log("command \"%s\" exited with non-zero code: %d\n", arg, ret);
+        }
+        return 0;
+}
+
 static int uwsgi_hook_exit(char *arg) {
 	int exit_code = 0;
 	if (strlen(arg) > 1) {
@@ -562,6 +570,7 @@ void uwsgi_register_base_hooks() {
 	uwsgi_register_hook("sticky", uwsgi_hook_sticky);
 
 	uwsgi_register_hook("exec", uwsgi_hook_exec);
+	uwsgi_register_hook("safeexec", uwsgi_hook_safeexec);
 
 	uwsgi_register_hook("create", uwsgi_hook_creat);
 	uwsgi_register_hook("creat", uwsgi_hook_creat);

core/routing.c

@@ -756,6 +756,27 @@ static int uwsgi_router_fixcl(struct uwsgi_route *ur, char *arg) {
         return 0;
 }
 
+// force content length
+static int transform_forcecl(struct wsgi_request *wsgi_req, struct uwsgi_transformation *ut) {
+        char buf[sizeof(UMAX64_STR)+1];
+        int ret = snprintf(buf, sizeof(UMAX64_STR)+1, "%llu", (unsigned long long) ut->chunk->pos);
+        if (ret <= 0 || ret >= (int) (sizeof(UMAX64_STR)+1)) {
+                wsgi_req->write_errors++;
+                return -1;
+        }
+        // do not check for errors !!!
+        uwsgi_response_add_header_force(wsgi_req, "Content-Length", 14, buf, ret);
+        return 0;
+}
+static int uwsgi_router_forcecl_func(struct wsgi_request *wsgi_req, struct uwsgi_route *route) {
+        uwsgi_add_transformation(wsgi_req, transform_forcecl, NULL);
+        return UWSGI_ROUTE_NEXT;
+}
+static int uwsgi_router_forcecl(struct uwsgi_route *ur, char *arg) {
+        ur->func = uwsgi_router_forcecl_func;
+        return 0;
+}
+
 // log route
 static int uwsgi_router_log_func(struct wsgi_request *wsgi_req, struct uwsgi_route *ur) {
 
@@ -1865,6 +1886,7 @@ void uwsgi_register_embedded_routers() {
 
         uwsgi_register_router("flush", uwsgi_router_flush);
         uwsgi_register_router("fixcl", uwsgi_router_fixcl);
+        uwsgi_register_router("forcecl", uwsgi_router_forcecl);
 
         uwsgi_register_router("harakiri", uwsgi_router_harakiri);
 

core/spooler.c

@@ -480,7 +480,7 @@ static void spooler_scandir(struct uwsgi_spooler *uspool, char *dir) {
 	if (!dir)
 		dir = uspool->dir;
 
-	n = scandir(dir, &tasklist, 0, versionsort);
+	n = scandir(dir, &tasklist, NULL, versionsort);
 	if (n < 0) {
 		uwsgi_error("scandir()");
 		return;

core/static.c

@@ -463,23 +463,22 @@ int uwsgi_real_file_serve(struct wsgi_request *wsgi_req, char *real_filename, si
 	wsgi_req->do_not_account_avg_rt = 1;
 
 	size_t fsize = st->st_size;
-        if (wsgi_req->range_to) {
-        	fsize = wsgi_req->range_to - wsgi_req->range_from;
-                if (fsize > (size_t)st->st_size) {
-                	fsize = st->st_size;
-                }
+	// security check
+        if (wsgi_req->range_from > fsize) {
+                wsgi_req->range_from = 0;
+                wsgi_req->range_to = 0;
         }
 	else {
-        	// reset in case of inconsistent size
-        	if (wsgi_req->range_from > fsize) {
-        		wsgi_req->range_from = 0;
-        		fsize = 0;
-        	}
-		else {
-			fsize -= wsgi_req->range_from;
-		}
+		fsize -= wsgi_req->range_from;
 	}
 
+        if (wsgi_req->range_to) {
+        	fsize = (wsgi_req->range_to - wsgi_req->range_from)+1;
+                if (fsize + wsgi_req->range_from > (size_t) (st->st_size)) {
+                	fsize = st->st_size - wsgi_req->range_from;
+                }
+        }
+
 	// HTTP status
 	if (fsize > 0 && (wsgi_req->range_from || wsgi_req->range_to)) {
 		if (uwsgi_response_prepare_headers(wsgi_req, "206 Partial Content", 19)) return -1;

core/uwsgi.c

@@ -2,7 +2,7 @@
 
  *** uWSGI ***
 
- Copyright (C) 2009-2014 Unbit S.a.s. <info@unbit.it>
+ Copyright (C) 2009-2015 Unbit S.a.s. <info@unbit.it>
 
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
@@ -202,6 +202,8 @@ static struct uwsgi_option uwsgi_base_options[] = {
 	{"emperor", required_argument, 0, "run the Emperor", uwsgi_opt_add_string_list, &uwsgi.emperor, 0},
 	{"emperor-proxy-socket", required_argument, 0, "force the vassal to became an Emperor proxy", uwsgi_opt_set_str, &uwsgi.emperor_proxy, 0},
 	{"emperor-wrapper", required_argument, 0, "set a binary wrapper for vassals", uwsgi_opt_set_str, &uwsgi.emperor_wrapper, 0},
+	{"emperor-wrapper-override", required_argument, 0, "set a binary wrapper for vassals to try before the default one", uwsgi_opt_add_string_list, &uwsgi.emperor_wrapper_override, 0},
+	{"emperor-wrapper-fallback", required_argument, 0, "set a binary wrapper for vassals to try as a last resort", uwsgi_opt_add_string_list, &uwsgi.emperor_wrapper_fallback, 0},
 	{"emperor-nofollow", no_argument, 0, "do not follow symlinks when checking for mtime", uwsgi_opt_true, &uwsgi.emperor_nofollow, 0},
 	{"emperor-procname", required_argument, 0, "set the Emperor process name", uwsgi_opt_set_str, &uwsgi.emperor_procname, 0},
 	{"emperor-freq", required_argument, 0, "set the Emperor scan frequency (default 3 seconds)", uwsgi_opt_set_int, &uwsgi.emperor_freq, 0},
@@ -696,7 +698,7 @@ static struct uwsgi_option uwsgi_base_options[] = {
 
 	{"alarm", required_argument, 0, "create a new alarm, syntax: <alarm> <plugin:args>", uwsgi_opt_add_string_list, &uwsgi.alarm_list, UWSGI_OPT_MASTER},
 	{"alarm-cheap", required_argument, 0, "use main alarm thread rather than create dedicated threads for curl-based alarms", uwsgi_opt_true, &uwsgi.alarm_cheap, 0},
-	{"alarm-freq", required_argument, 0, "tune the anti-loop alam system (default 3 seconds)", uwsgi_opt_set_int, &uwsgi.alarm_freq, 0},
+	{"alarm-freq", required_argument, 0, "tune the anti-loop alarm system (default 3 seconds)", uwsgi_opt_set_int, &uwsgi.alarm_freq, 0},
 	{"alarm-fd", required_argument, 0, "raise the specified alarm when an fd is read for read (by default it reads 1 byte, set 8 for eventfd)", uwsgi_opt_add_string_list, &uwsgi.alarm_fd_list, UWSGI_OPT_MASTER},
 	{"alarm-segfault", required_argument, 0, "raise the specified alarm when the segmentation fault handler is executed", uwsgi_opt_add_string_list, &uwsgi.alarm_segfault, UWSGI_OPT_MASTER},
 	{"segfault-alarm", required_argument, 0, "raise the specified alarm when the segmentation fault handler is executed", uwsgi_opt_add_string_list, &uwsgi.alarm_segfault, UWSGI_OPT_MASTER},
@@ -2262,7 +2264,7 @@ void uwsgi_setup(int argc, char *argv[], char *envp[]) {
 		uwsgi_opt_flock(NULL, uwsgi.flock_wait2, NULL);
 
 	// setup master logging
-	if (uwsgi.log_master)
+	if (uwsgi.log_master && !uwsgi.daemonize2)
 		uwsgi_setup_log_master();
 
 	// setup offload engines

plugins/psgi/psgi_loader.c

@@ -11,8 +11,8 @@ XS(XS_input_seek) {
         dXSARGS;
 	struct wsgi_request *wsgi_req = current_wsgi_req();
 
-        psgi_check_args(1);
-	uwsgi_request_body_seek(wsgi_req, SvIV(ST(0)));
+        psgi_check_args(2);
+	uwsgi_request_body_seek(wsgi_req, SvIV(ST(1)));
 
         XSRETURN(0);
 }
@@ -302,15 +302,15 @@ nonworker:
 				else {
 					av_push(_opt_a, newSVpv(uwsgi.exported_opts[i]->value, 0));
 				}
-				hv_store(_opts, uwsgi.exported_opts[i]->key, strlen(uwsgi.exported_opts[i]->key), newRV_inc((SV *) _opt_a), 0);
+				(void ) hv_store(_opts, uwsgi.exported_opts[i]->key, strlen(uwsgi.exported_opts[i]->key), newRV_inc((SV *) _opt_a), 0);
 			}
 		}
 		else {
 			if (uwsgi.exported_opts[i]->value == NULL) {
-				hv_store(_opts, uwsgi.exported_opts[i]->key, strlen(uwsgi.exported_opts[i]->key), newSViv(1), 0);
+				(void )hv_store(_opts, uwsgi.exported_opts[i]->key, strlen(uwsgi.exported_opts[i]->key), newSViv(1), 0);
 			}
 			else {
-				hv_store(_opts, uwsgi.exported_opts[i]->key, strlen(uwsgi.exported_opts[i]->key), newSVpv(uwsgi.exported_opts[i]->value, 0), 0);
+				(void)hv_store(_opts, uwsgi.exported_opts[i]->key, strlen(uwsgi.exported_opts[i]->key), newSVpv(uwsgi.exported_opts[i]->value, 0), 0);
 			}
 		}
 	}

plugins/psgi/psgi_plugin.c

@@ -637,6 +637,19 @@ void uwsgi_perl_after_request(struct wsgi_request *wsgi_req) {
 	// before the environ is set up.
 	if (!wsgi_req->async_environ) return;
 
+	// we need to restore the context in case of multiple interpreters
+	struct uwsgi_app *wi = &uwsgi_apps[wsgi_req->app_id];
+	if (uwsgi.threads < 2) {
+                if (((PerlInterpreter **)wi->interpreter)[0] != uperl.main[0]) {
+                        PERL_SET_CONTEXT(((PerlInterpreter **)wi->interpreter)[0]);
+                }
+        }
+        else {
+                if (((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id] != uperl.main[wsgi_req->async_id]) {
+                        PERL_SET_CONTEXT(((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id]);
+                }
+        }
+
 	// dereference %env
 	SV *env = SvRV((SV *) wsgi_req->async_environ);
 
@@ -684,6 +697,19 @@ void uwsgi_perl_after_request(struct wsgi_request *wsgi_req) {
                 }
         }
 
+	// restore main interpreter if needed
+        if (uwsgi.threads > 1) {
+                if (((PerlInterpreter **)wi->interpreter)[wsgi_req->async_id] != uperl.main[wsgi_req->async_id]) {
+                        PERL_SET_CONTEXT(uperl.main[wsgi_req->async_id]);
+                }
+        }
+        else {
+                if (((PerlInterpreter **)wi->interpreter)[0] != uperl.main[0]) {
+                        PERL_SET_CONTEXT(uperl.main[0]);
+                }
+        }
+
+
 }
 
 int uwsgi_perl_magic(char *mountpoint, char *lazy) {

plugins/rsyslog/rsyslog_plugin.c

@@ -31,7 +31,12 @@ ssize_t uwsgi_rsyslog_logger(struct uwsgi_logger *ul, char *message, size_t len)
 			exit(1);
 		}
 
-                ul->fd = socket(AF_INET, SOCK_DGRAM, 0);
+		if (ul->arg[0] == '/') {
+                	ul->fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+		}
+		else {
+                	ul->fd = socket(AF_INET, SOCK_DGRAM, 0);
+		}
                 if (ul->fd < 0) {
 			uwsgi_error_safe("socket()");
 			exit(1);
@@ -62,7 +67,12 @@ ssize_t uwsgi_rsyslog_logger(struct uwsgi_logger *ul, char *message, size_t len)
 			*port = 0;
 		}
 
-		ul->addr_len = socket_to_in_addr(ul->arg, NULL, portn, &ul->addr.sa_in);
+		if (ul->arg[0] == '/') {
+			ul->addr_len = socket_to_un_addr(ul->arg, &ul->addr.sa_un);
+		}
+		else {
+			ul->addr_len = socket_to_in_addr(ul->arg, NULL, portn, &ul->addr.sa_in);
+		}
 
 		if (port) *port = ':';
 		if (comma) *comma = ',';

t/python/forcecl.py

@@ -0,0 +1,4 @@
+# uwsgi --route-run remheader:Content-Length --route-run forcecl: --wsgi-file t/python/forcecl.py --http-socket :9090
+def application(e, sr):
+    sr('200 OK', [('Content-Length', '1'), ('Content-Length', '2')])
+    return ['xxx']

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        = '2014-12-30'
+  s.date        = '2015-03-17'
   s.summary     = "uWSGI"
   s.description = "The uWSGI server for Ruby/Rack"
   s.authors     = ["Unbit"]

uwsgi.h

@@ -2757,6 +2757,9 @@ struct uwsgi_server {
 	char *subscribe_with_modifier1;
 	struct uwsgi_string_list *pull_headers;
 
+	// uWSGI 2.0.10
+	struct uwsgi_string_list *emperor_wrapper_override;
+	struct uwsgi_string_list *emperor_wrapper_fallback;
 };
 
 struct uwsgi_rpc {

uwsgiconfig.py

@@ -1,6 +1,6 @@
 # uWSGI build system
 
-uwsgi_version = '2.0.9'
+uwsgi_version = '2.0.10'
 
 import os
 import re
@@ -698,7 +698,7 @@ class uConf(object):
         # add -fno-strict-aliasing only on python2 and gcc < 4.3
         if gcc_major >= 4:
             self.cflags = self.cflags + [ '-Wextra', '-Wno-unused-parameter', '-Wno-missing-field-initializers' ]
-        if (gcc_major == 4 and gcc_minor >= 8) or gcc_major > 4:
+        if gcc_major == 4 and gcc_minor < 9:
             self.cflags.append('-Wno-format -Wno-format-security')
 
         self.ldflags = os.environ.get("LDFLAGS", "").split()