fixed python snmp api

.hgtags

@@ -26,3 +26,7 @@ e91bc724325e14c13b8f548c0b6a315c48a1c32a 0.9.8-rc2
 0f1f3924ee5309a9990d9af1ffc68846e3dfb31b 0.9.8-rc4
 42efe1f329005618c8b44f901979ebcecd5216fb 0.9.8
 fd8477b6348faf16588106055ca59df1c488f76a 0.9.8.1
+7169ef1d68d3dab4737bcc3f9e082839e5a06cc1 0.9.8.2
+f4d3c4dcd7a63e21fcc9d8d567374c69935178bd 0.9.8.3
+6945ee03c7ea95eb19217ef1e1fb17d9ae26adbc 0.9.9-beta1
+fb168b0b86169219aa9b8e40f0caa6297cf34dbc 0.9.9-rc1

ChangeLog

@@ -1,5 +1,13 @@
 *** july 2011 ***
 
+ * 0.9.8.3 [20110723]
+
+- implemented uwsgi.SymZipImporter to load embedded zip files
+- OSX Lion is officially supported
+- fixed xinetd support (example file added in contrib)
+- suppot for systemd socket activation
+- added --freebind option (Linux only)
+
  * 0.9.8.2 [20110719]
 
 - fixed an ini and yaml parsing bug spotted by Raffaele Colace

apache2/mod_uwsgi.c

@@ -51,7 +51,6 @@ LoadModule uwsgi_module <path_of_apache_modules>/mod_uwsgi.so
 #include <fcntl.h>
 
 
-#define MAX_VARS 64
 #define DEFAULT_SOCK "/tmp/uwsgi.sock"
 
 typedef struct {
@@ -73,6 +72,7 @@ typedef struct {
 	char script_name[256];
 	char scheme[9];
 	int cgi_mode ;
+	int max_vars;
 } uwsgi_cfg;
 
 module AP_MODULE_DECLARE_DATA uwsgi_module;
@@ -83,8 +83,18 @@ static uint16_t uwsgi_swap16(uint16_t x) {
 }
 #endif
 
-static int uwsgi_add_var(struct iovec *vec, int i, char *key, char *value, uint16_t *pkt_size) {
+static int uwsgi_add_var(struct iovec *vec, int i, request_rec *r, char *key, char *value, uint16_t *pkt_size) {
 
+	uwsgi_cfg *c = ap_get_module_config(r->per_dir_config, &uwsgi_module);
+
+#if APR_IS_BIGENDIAN
+	if (i+6 > c->max_vars) {
+#else
+	if (i+4 > c->max_vars) {
+#endif
+		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: max number of uwsgi variables reached. consider increasing it with uWSGImaxVars directive");
+		return i;
+	}
 
 #if APR_IS_BIGENDIAN
 	char *ptr;
@@ -150,6 +160,8 @@ static void *uwsgi_server_config(apr_pool_t *p, server_rec *s) {
 	c->modifier1 = 0 ;
 	c->modifier2 = 0 ;
 	c->cgi_mode = 0 ;
+	c->max_vars = 128;
+	c->script_name[0] = 0;
 
 	return c;
 }
@@ -164,6 +176,13 @@ static void *uwsgi_dir_config(apr_pool_t *p, char *dir) {
 	c->modifier1 = 0 ;
 	c->modifier2 = 0 ;
 	c->cgi_mode = 0 ;
+	c->max_vars = 128;
+	c->script_name[0] = 0;
+	if (dir) {
+		if (strcmp(dir, "/")) {
+			strncpy(c->script_name, dir, 255);
+		}
+	}
 
 	return c;
 }
@@ -243,11 +262,8 @@ static int uwsgi_handler(request_rec *r) {
 
 	uwsgi_cfg *c = ap_get_module_config(r->per_dir_config, &uwsgi_module);
 
-#if APR_IS_BIGENDIAN
-	struct iovec uwsgi_vars[(MAX_VARS*6)+1] ;
-#else
-	struct iovec uwsgi_vars[(MAX_VARS*4)+1] ;
-#endif
+	struct iovec *uwsgi_vars;
+
 	int vecptr = 1 ;
 	char pkt_header[4];
 	uint16_t pkt_size = 0;
@@ -315,68 +331,49 @@ static int uwsgi_handler(request_rec *r) {
 	}
 
 
+#if APR_IS_BIGENDIAN
+        uwsgi_vars = malloc(sizeof(struct iovec) * (c->max_vars*6)+1);
+#else
+        uwsgi_vars = malloc(sizeof(struct iovec) * (c->max_vars*4)+1);
+#endif
 		
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REQUEST_METHOD", (char *) r->method, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "QUERY_STRING", r->args ? r->args : "", &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SERVER_NAME", (char *) ap_get_server_name(r), &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SERVER_PORT", apr_psprintf(r->pool, "%u",ap_get_server_port(r)), &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SERVER_PROTOCOL", r->protocol, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REQUEST_URI", r->unparsed_uri, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REMOTE_ADDR", r->connection->remote_ip, &pkt_size) ;
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "REMOTE_USER", r->user ? r->user : "", &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REQUEST_METHOD", (char *) r->method, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "QUERY_STRING", r->args ? r->args : "", &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SERVER_NAME", (char *) ap_get_server_name(r), &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SERVER_PORT", apr_psprintf(r->pool, "%u",ap_get_server_port(r)), &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SERVER_PROTOCOL", r->protocol, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REQUEST_URI", r->unparsed_uri, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REMOTE_ADDR", r->connection->remote_ip, &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "REMOTE_USER", r->user ? r->user : "", &pkt_size) ;
 	if (r->user) {
-		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "AUTH_TYPE", (char *) ap_auth_type(r), &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "AUTH_TYPE", (char *) ap_auth_type(r), &pkt_size) ;
 	}
-	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "DOCUMENT_ROOT", (char *) ap_document_root(r), &pkt_size) ;
+	vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "DOCUMENT_ROOT", (char *) ap_document_root(r), &pkt_size) ;
 
 	if (c->scheme[0] != 0) {
-		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "UWSGI_SCHEME", c->scheme, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "UWSGI_SCHEME", c->scheme, &pkt_size) ;
 	}
 
-	if (c->script_name[0] == '/') {
-		if (c->script_name[1] == 0) {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", "", &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri, &pkt_size) ;
-		}
-		else {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", c->script_name, &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri+strlen(c->script_name), &pkt_size) ;
-		}
+	if (c->script_name[0] != 0) {
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", c->script_name, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri+strlen(c->script_name), &pkt_size) ;
 	}
 	else {
-		if (r->path_info) {
-			if (strlen(r->path_info) <= 0) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", "", &pkt_size) ;
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri, &pkt_size) ;
-			}
-			else {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", apr_pstrndup(r->pool, r->uri, (strlen(r->uri) - strlen(r->path_info) )) , &pkt_size) ;
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->path_info, &pkt_size) ;
-			}
-		}
-		else {
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "SCRIPT_NAME", "", &pkt_size) ;
-			vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "PATH_INFO", r->uri, &pkt_size) ;
-		}
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "SCRIPT_NAME", "", &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "PATH_INFO", r->uri, &pkt_size) ;
 	}
 
 
 	headers = apr_table_elts(r->headers_in);
 	h = (apr_table_entry_t *) headers->elts;
 
-	// check for max vars (a bit ugly)
-	cnt = headers->nelts ;
-	if (cnt + 11 > MAX_VARS) {
-		cnt = MAX_VARS -11;
-	}
-
-	for(i=0;i< cnt;i++) {
+	for(i=0;i< headers->nelts;i++) {
 		if (h[i].key){
 			if (!strcasecmp(h[i].key, "Content-Type")) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "CONTENT_TYPE", h[i].val, &pkt_size) ;
+				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "CONTENT_TYPE", h[i].val, &pkt_size) ;
 			}
 			else if (!strcasecmp(h[i].key, "Content-Length")) {
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, "CONTENT_LENGTH", h[i].val, &pkt_size) ;
+				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, "CONTENT_LENGTH", h[i].val, &pkt_size) ;
 			}
 			else {
 				penv = apr_pstrcat(r->pool, "HTTP_", h[i].key, NULL);
@@ -388,7 +385,7 @@ static int uwsgi_handler(request_rec *r) {
 						*cp = toupper(*cp);
 					}
 				}
-				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, penv, h[i].val, &pkt_size) ;
+				vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, penv, h[i].val, &pkt_size) ;
 			}
 		}
 	}
@@ -397,7 +394,7 @@ static int uwsgi_handler(request_rec *r) {
 	headers = apr_table_elts(r->subprocess_env);
 	h = (apr_table_entry_t*) headers->elts;
 	for (i = 0; i < headers->nelts; ++i) {
-		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, h[i].key, h[i].val, &pkt_size) ;
+		vecptr = uwsgi_add_var(uwsgi_vars, vecptr, r, h[i].key, h[i].val, &pkt_size) ;
 	}	
 	
 
@@ -418,11 +415,13 @@ static int uwsgi_handler(request_rec *r) {
 	if (cnt < 0) {
 		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: writev() %s", strerror(errno));
 		close(uwsgi_poll.fd);
+		free(uwsgi_vars);
 		return HTTP_INTERNAL_SERVER_ERROR;
 	}
 	else if (cnt != pkt_size+4) {
 		ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: writev() returned wrong size");
 		close(uwsgi_poll.fd);
+		free(uwsgi_vars);
 		return HTTP_INTERNAL_SERVER_ERROR;
 	}
 
@@ -434,6 +433,7 @@ static int uwsgi_handler(request_rec *r) {
 			if (cnt < 0) {
 				ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: read() client block failed !");
 				close(uwsgi_poll.fd);
+				free(uwsgi_vars);
 				return HTTP_INTERNAL_SERVER_ERROR;
 			}
 		}
@@ -458,6 +458,7 @@ static int uwsgi_handler(request_rec *r) {
 		if (cnt == 0) {
 			ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: recv() timeout");
 			apr_brigade_destroy(bb);
+			free(uwsgi_vars);
 			return HTTP_INTERNAL_SERVER_ERROR;
 		}
 		else if (cnt > 0) {
@@ -467,6 +468,7 @@ static int uwsgi_handler(request_rec *r) {
 					if (errno != ECONNRESET) {
 						ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: recv() %s", strerror(errno));
 						apr_brigade_destroy(bb);
+						free(uwsgi_vars);
 						return HTTP_INTERNAL_SERVER_ERROR;
 					}
 					else {
@@ -489,6 +491,7 @@ static int uwsgi_handler(request_rec *r) {
 					if (r->connection->aborted) { 
 						close(uwsgi_poll.fd);
 						apr_brigade_destroy(bb);
+						free(uwsgi_vars);
 						return HTTP_INTERNAL_SERVER_ERROR;
 					}
 					apr_brigade_write(bb, NULL, NULL, buf, cnt);
@@ -508,6 +511,7 @@ static int uwsgi_handler(request_rec *r) {
 			ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "uwsgi: poll() %s", strerror(errno));
 			close(uwsgi_poll.fd);
 			apr_brigade_destroy(bb);
+			free(uwsgi_vars);
 			return HTTP_INTERNAL_SERVER_ERROR;
 		}
 	}
@@ -521,6 +525,7 @@ static int uwsgi_handler(request_rec *r) {
 
 	if (!c->cgi_mode) {
 		if (uwsgi_http_status_read == 0) {
+			free(uwsgi_vars);
 			return HTTP_INTERNAL_SERVER_ERROR;
 		}
 	}
@@ -528,11 +533,13 @@ static int uwsgi_handler(request_rec *r) {
 
 		if (hret = ap_scan_script_header_err_brigade(r, bb, NULL)) {
 			apr_brigade_destroy(bb);
+			free(uwsgi_vars);
 			return hret;
 		}
 	}
 
 
+	free(uwsgi_vars);
 	return ap_pass_brigade(r->output_filters, bb) ;
 }
 
@@ -564,6 +571,22 @@ static const char * cmd_uwsgi_force_wsgi_scheme(cmd_parms *cmd, void *cfg, const
 
 }
 
+static const char *cmd_uwsgi_max_vars(cmd_parms *cmd, void *cfg, const char *value) {
+	uwsgi_cfg *c ;
+        int val ;
+
+        if (cfg) {
+                c = cfg ;
+        }
+        else {
+                c = ap_get_module_config(cmd->server->module_config, &uwsgi_module);
+        }
+
+        c->max_vars = atoi(value);
+
+        return NULL;
+}
+
 static const char * cmd_uwsgi_modifier1(cmd_parms *cmd, void *cfg, const char *value) {
 
         uwsgi_cfg *c ;
@@ -707,6 +730,7 @@ static const command_rec uwsgi_cmds[] = {
 	AP_INIT_TAKE1("uWSGIforceScriptName", cmd_uwsgi_force_script_name, NULL, ACCESS_CONF, "Fix for PATH_INFO/SCRIPT_NAME when the location has filesystem correspondence"),	
 	AP_INIT_TAKE1("uWSGIforceCGImode", cmd_uwsgi_force_cgi_mode, NULL, ACCESS_CONF, "Force uWSGI CGI mode for perfect integration with apache filter"),	
 	AP_INIT_TAKE1("uWSGIforceWSGIscheme", cmd_uwsgi_force_wsgi_scheme, NULL, ACCESS_CONF, "Force the WSGI scheme var (set by default to \"http\")"),	
+	AP_INIT_TAKE1("uWSGImaxVars", cmd_uwsgi_max_vars, NULL, ACCESS_CONF, "Set the maximum allowed number of uwsgi variables (default 128)"),	
 	{NULL}
 };
 

async.c

@@ -212,6 +212,10 @@ void *async_loop(void *arg1) {
 	uwsgi.async_runqueue = NULL;
 	uwsgi.async_runqueue_cnt = 0;
 
+	if (uwsgi.signal_socket > -1) {
+		event_queue_add_fd_read(uwsgi.async_queue, uwsgi.signal_socket);
+	}
+
 	// set a default request manager
         if (!uwsgi.schedule_to_req) uwsgi.schedule_to_req = async_schedule_to_req;
 

attach.py

@@ -0,0 +1,13 @@
+import struct
+import sys
+import os
+
+filename = sys.argv[1]
+
+size = os.path.getsize(filename)
+
+f = open(filename, 'r')
+print(f.read())
+f.close()
+
+print(struct.pack("<Q", size))

bootstrap2.py

@@ -0,0 +1,4 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.SymbolsZipImporter("pygments_zip"))

bootstrap3.py

@@ -0,0 +1,5 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.SymbolsZipImporter("django_zip:djenv/lib/python2.6/site-packages"))
+sys.meta_path.insert(0, uwsgi.SymbolsZipImporter("djapp_zip"))

bootstrap4.py

@@ -0,0 +1,4 @@
+import sys
+import uwsgi
+
+sys.meta_path.insert(0, uwsgi.ZipImporter("data://0"))

buildconf/default.ini

@@ -28,6 +28,7 @@ bin_name = uwsgi
 append_version =
 plugin_dir = .
 embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, ugreen
+as_shared_library = false
 
 locking = auto
 event = auto

buildconf/django.ini

@@ -0,0 +1,3 @@
+[uwsgi]
+inherit = default
+embed_files = bootstrap3.py,django.zip,djapp.zip

buildconf/gevent.ini

@@ -0,0 +1,3 @@
+[uwsgi]
+inherit = default
+embedded_plugins = python, ping, cache, nagios, rpc, fastrouter, http, gevent

buildconf/lib.ini

@@ -0,0 +1,5 @@
+[uwsgi]
+inherit = default
+bin_name = libuwsgi.so
+embedded_plugins = null
+as_shared_library = true

buildconf/pylua.ini

@@ -1,7 +1,3 @@
 [uwsgi]
 inherit = default
 embedded_plugins = +,lua
-
-[python]
-paste = true
-web3 = true

buildconf/pypy.ini

@@ -0,0 +1,5 @@
+[uwsgi]
+inherit = default
+bin_name = libuwsgi.so
+embedded_plugins = symcall
+as_shared_library = true

buildconf/rack.ini

@@ -1,3 +1,3 @@
 [uwsgi]
 inherit = default
-embedded_plugins = rack, ping, nagios, rpc
+embedded_plugins = rack, ping, cache, nagios, rpc, fastrouter, http, ugreen

cache.c

@@ -8,7 +8,7 @@ void uwsgi_init_cache() {
 	if (!uwsgi.cache_blocksize)
                         uwsgi.cache_blocksize = UMAX16;
 
-                if (uwsgi.cache_blocksize % uwsgi.page_size != 0) {
+                if ((uwsgi.cache_blocksize * uwsgi.cache_max_items) % uwsgi.page_size != 0) {
                         uwsgi_log("invalid cache blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.cache_blocksize, uwsgi.page_size);
                         exit(1);
                 }
@@ -512,6 +512,16 @@ int uwsgi_cache_set(char *key, uint16_t keylen, char *val, uint64_t vallen, uint
 			uci->prev = last_index;
 		}
 	}
+	else if (flags && UWSGI_CACHE_FLAG_UPDATE) {
+		uci = &uwsgi.cache_items[index] ;
+		if (expires) {
+			expires += time(NULL);
+			uci->expires = expires;
+		}
+		memcpy(uwsgi.cache+(index*uwsgi.cache_blocksize), val, vallen);
+		uci->valsize = vallen;
+		ret = 0;
+	}
 
 end:
 	return ret;
@@ -674,6 +684,7 @@ clear:
 		close(ctl_poll.fd);
 	}
 
+	return NULL;
 }
 
 int uwsgi_cache_server(char *socket, int threads) {

config17.ru

@@ -0,0 +1,25 @@
+require 'stringio'
+
+hello = proc do |signum|
+  puts "Hello i am signal #{signum}"
+end
+
+file_changed = proc do |signum| 
+  puts "/tmp has been modified"
+end
+
+UWSGI.register_signal(17, '', hello)
+UWSGI.register_signal(30, '', file_changed)
+
+UWSGI.add_rb_timer(17 , 2)
+UWSGI.add_timer(17 , 1)
+UWSGI.add_file_monitor(30 , '/tmp')
+
+puts UWSGI.signal_registered(1)
+puts UWSGI.signal_registered(17)
+
+run lambda { |env| 
+        puts env.inspect
+	UWSGI.signal(17)
+	[200, {'Content-Type'=>'text/plain'}, StringIO.new("Hello World!\n")] 
+}

contrib/spoolqueue/producer.py

@@ -0,0 +1,11 @@
+from tasksconsumer import enqueue
+
+def application(env, sr):
+
+    sr('200 OK', [('Content-Type','text/html')])
+
+    enqueue(queue='fast', pippo='pluto')
+
+    return "Task enqueued"
+
+

contrib/spoolqueue/tasks.py

@@ -0,0 +1,9 @@
+from tasksconsumer import *
+
+@queueconsumer('fast', 4)
+def fast_queue(arguments):
+    print "fast", arguments
+
+@queueconsumer('slow')
+def slow_queue(arguments):
+    print "foobar", arguments

contrib/spoolqueue/tasksconsumer.py

@@ -0,0 +1,44 @@
+from uwsgidecorators import *
+import Queue
+from threading import Thread
+
+queues = {}
+
+class queueconsumer(object):
+
+    def __init__(self, name, num=1, **kwargs):
+        self.name = name
+	self.num = num
+        self.queue = Queue.Queue()
+	self.threads = []
+	self.func = None
+	queues[self.name] = self
+
+
+    @staticmethod
+    def consumer(self):
+        while True:
+	    req = self.queue.get()
+            print req
+	    self.func(req)
+	    self.queue.task_done()
+
+    def __call__(self, f):
+        self.func = f
+	for i in range(self.num):
+	    t = Thread(target=self.consumer,args=(self,))	
+	    self.threads.append(t)
+	    t.daemon = True
+	    t.start()
+
+@spool
+def spooler_enqueuer(arguments):
+    if 'queue' in arguments:
+        queue = arguments['queue']
+        queues[queue].queue.put(arguments)
+    else:
+        raise Exception("You have to specify a queue name")
+
+
+def enqueue(*args, **kwargs):
+    return spooler_enqueuer.spool(*args, **kwargs)

contrib/xinetd_uwsgi

@@ -0,0 +1,14 @@
+service uwsgi
+{
+        disable         = no
+        id              = uwsgi-000
+        type            = UNLISTED
+        socket_type     = stream
+        server          = /root/uwsgi/uwsgi
+        server_args     = --chdir /root/uwsgi/ --module welcome --logto /tmp/uwsgi.log
+        port            = 3031
+        bind            = 127.0.0.1
+        user            = root
+        wait            = yes
+}
+

emperor.c

@@ -181,7 +181,7 @@ void emperor_add(char *name, time_t born, char *config, uint32_t config_size) {
 	char *colon = NULL;
 	int i;
 
-	sleep(1);
+	usleep(uwsgi.emperor_throttle*1000);
 
 	while (c_ui->ui_next) {
 		c_ui = c_ui->ui_next;

gateway.c

@@ -60,6 +60,11 @@ struct uwsgi_gateway *register_gateway(char *name, void (*loop)(void)) {
                         uwsgi_error("prctl()");
                 }
 #endif
+
+		if (!uwsgi.sockets) {
+			// wait for child end
+			//waitpid(-1, &i, 0);
+		}
 			loop();
 			// never here !!! (i hope)
 			exit(1);	
@@ -117,6 +122,12 @@ void gateway_respawn(int id) {
 	}
 
 	ug->pid = gw_pid;
-	uwsgi_log( "respawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+	ug->respawns++;
+	if (ug->respawns == 1) {
+		uwsgi_log( "spawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+	}
+	else {
+		uwsgi_log( "respawned uWSGI %s %d (pid: %d)\n", ug->name, ug->num, (int) gw_pid);
+	}
 	
 }

hello_world.py

@@ -1,5 +1,6 @@
 import uwsgi
-uwsgi.cache_set('/', "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nHello World from cache")
+#uwsgi.cache_set('/', "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nHello World from cache")
 def application(env, start_response):
     start_response('200 OK', [('Content-Type', 'text/html')])
-    return "<h1>Hello World</h1>"
+    yield str(env['wsgi.input'].fileno())
+    yield "<h1>Hello World</h1>"

ini.c

@@ -92,7 +92,7 @@ void uwsgi_ini_config(char *file, char *magic_table[]) {
 	char *section_asked = "uwsgi";
 	char *colon;
 
-	if (!uwsgi_startswith(file, "http://", 7)) {
+	if (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6) ) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }

json.c

@@ -30,7 +30,7 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
 	char *colon;
 	int i;
 
-	if (!uwsgi_startswith(file, "http://", 7)) {
+	if (!uwsgi_startswith(file, "http://", 7) || !uwsgi_startswith(file, "data://", 7) || !uwsgi_startswith(file, "sym://", 6)) {
                 colon = uwsgi_get_last_char(file, '/');
                 colon = uwsgi_get_last_char(colon, ':');
         }
@@ -49,7 +49,11 @@ void uwsgi_json_config(char *file, char *magic_table[]) {
 
 	json_data = uwsgi_open_and_read(file, &len, 1, magic_table);
 
+#ifdef JANSSON_MAJOR_VERSION 
 	root = json_loads(json_data, 0, &error);
+#else
+	root = json_loads(json_data, &error);
+#endif
 
 	if (!root) {
 		uwsgi_log("error parsing JSON data: line %d %s\n", error.line, error.text);

logging.c

@@ -50,7 +50,7 @@ void log_request(struct wsgi_request *wsgi_req) {
 	if (wsgi_req->do_not_log) return ;
 
 	if (wsgi_req->app_id >= 0) {
-		wi = &uwsgi.apps[wsgi_req->app_id];
+		wi = &uwsgi_apps[wsgi_req->app_id];
 		if (wi->requests > 0) {
 			app_req = wi->requests;
 		}

master.c

@@ -117,7 +117,7 @@ void uwsgi_subscribe(char *subscription) {
 				if (lines[i] == 0) {
 					if (keysize > 0) {
 						if (key[0] != '#' && key[0] != '\n') {
-							modifier1 = strchr(key, ':');
+							modifier1 = strchr(key, ',');
                 					if (modifier1) {
                         					modifier1[0] = 0;
                         					modifier1++;
@@ -135,7 +135,7 @@ void uwsgi_subscribe(char *subscription) {
 					if (keysize > 0) {
 						if (key[0] != '#' && key[0] != '\n') {
 							lines[i] = 0;
-							modifier1 = strchr(key, ':');
+							modifier1 = strchr(key, ',');
                 					if (modifier1) {
                         					modifier1[0] = 0;
                         					modifier1++;
@@ -159,7 +159,7 @@ void uwsgi_subscribe(char *subscription) {
 		}
 	}
 	else {
-		modifier1 = strchr(subscription_key+1, ':');
+		modifier1 = strchr(subscription_key+1, ',');
 		if (modifier1) {
 			modifier1[0] = 0;
 			modifier1++;
@@ -168,7 +168,7 @@ void uwsgi_subscribe(char *subscription) {
 
 		uwsgi_send_subscription(udp_address, subscription_key+1, strlen(subscription_key+1), modifier1, modifier1_len);
 		if (modifier1)
-			modifier1[-1] = ':';
+			modifier1[-1] = ',';
 	}
 
 clear:
@@ -476,7 +476,7 @@ void master_loop(char **argv, char **environ) {
 	}
 
 	if (uwsgi.queue_store && uwsgi.queue_filesize) {
-		if (msync(uwsgi.queue, uwsgi.queue_filesize, MS_ASYNC)) {
+		if (msync(uwsgi.queue_header, uwsgi.queue_filesize, MS_ASYNC)) {
 			uwsgi_error("msync()");
 		}
 	}
@@ -496,10 +496,19 @@ void master_loop(char **argv, char **environ) {
 	for (;;) {
 		//uwsgi_log("ready_to_reload %d %d\n", ready_to_reload, uwsgi.numproc);
 
+		if (uwsgi.to_outworld) {
+			//uwsgi_log("%d/%d\n", uwsgi.lazy_respawned, uwsgi.numproc);
+			if (uwsgi.lazy_respawned >= uwsgi.numproc) {
+				uwsgi.to_outworld = 0;
+				uwsgi.master_mercy = 0;
+				uwsgi.lazy_respawned = 0;
+			}
+		}
 		if (uwsgi.master_mercy) {
 			if (uwsgi.master_mercy < time(NULL)) {
 				for(i=1;i<=uwsgi.numproc;i++) {
 					if (uwsgi.workers[i].pid > 0) {
+						if (uwsgi.lazy && uwsgi.workers[i].destroy == 0) continue;
 						uwsgi_log("worker %d (pid: %d) is taking too much time to die...NO MERCY !!!\n", i, uwsgi.workers[i].pid);
 						if (!kill(uwsgi.workers[i].pid, SIGKILL)) {
 							if (waitpid(uwsgi.workers[i].pid, &waitpid_status, 0) < 0) {
@@ -508,12 +517,17 @@ void master_loop(char **argv, char **environ) {
 							uwsgi.workers[i].pid = 0;
 							if (uwsgi.to_hell) { ready_to_die++;}
 							else if (uwsgi.to_heaven) { ready_to_reload++;}
+							else if (uwsgi.to_outworld) {
+								uwsgi.lazy_respawned++;
+								if (uwsgi_respawn_worker(i)) return;	
+							}
 						}
 						else {
 							uwsgi_error("kill()");
 						}
 					}
 				}
+				uwsgi.master_mercy = 0;
 			}
 		}
 		if (uwsgi.respawn_workers) {
@@ -738,6 +752,9 @@ void master_loop(char **argv, char **environ) {
 								else if (uwsgi.log_socket) {
 									sendto(uwsgi.log_socket_fd, log_buf, rlen, 0, &uwsgi.log_socket_addr->sa, uwsgi.log_socket_size);
 								}
+								else {
+									rlen = write(uwsgi.original_log_fd, log_buf, rlen);
+								}
 								// TODO allow uwsgi.logger = func
 							}	
 						}
@@ -1177,7 +1194,7 @@ void master_loop(char **argv, char **environ) {
 			}
 
 			if (uwsgi.queue_store && uwsgi.queue_filesize && uwsgi.queue_store_sync && ((uwsgi.master_cycles % uwsgi.queue_store_sync) == 0)) {
-				if (msync(uwsgi.queue, uwsgi.queue_filesize, MS_ASYNC)) {
+				if (msync(uwsgi.queue_header, uwsgi.queue_filesize, MS_ASYNC)) {
                         		uwsgi_error("msync()");
                 		}
 			}
@@ -1286,6 +1303,13 @@ void master_loop(char **argv, char **environ) {
 				uwsgi.workers[uwsgi.mywid].harakiri = 0;	
                                 continue;
                         }
+			else if (uwsgi.to_outworld) {
+				uwsgi.lazy_respawned++;
+				uwsgi.workers[uwsgi.mywid].destroy = 0;
+				uwsgi.workers[uwsgi.mywid].pid = 0;
+				// only to be safe :P
+                                uwsgi.workers[uwsgi.mywid].harakiri = 0;
+			}
 
 
 		if (uwsgi.workers[uwsgi.mywid].manage_next_request) {

plugins/fastrouter/fastrouter.c

@@ -19,6 +19,7 @@
 #define LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER	150005
 #define LONG_ARGS_FASTROUTER_TIMEOUT			150006
 #define LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT		150007
+#define LONG_ARGS_FASTROUTER_USE_CODE_STRING		150008
 
 #define FASTROUTER_STATUS_FREE 0
 #define FASTROUTER_STATUS_CONNECTING 1
@@ -55,6 +56,10 @@ struct uwsgi_fastrouter {
 
         int socket_timeout;
 
+	uint8_t code_string_modifier1;
+	char *code_string_code;
+	char *code_string_function;
+
         struct rb_root *timeouts;
 } ufr;
 
@@ -90,6 +95,7 @@ struct option fastrouter_options[] = {
 	{"fastrouter-use-cache", no_argument, &ufr.use_cache, 1},
 	{"fastrouter-use-pattern", required_argument, 0, LONG_ARGS_FASTROUTER_USE_PATTERN},
 	{"fastrouter-use-base", required_argument, 0, LONG_ARGS_FASTROUTER_USE_BASE},
+	{"fastrouter-use-code-string", required_argument, 0, LONG_ARGS_FASTROUTER_USE_CODE_STRING},
 	{"fastrouter-events", required_argument, 0, LONG_ARGS_FASTROUTER_EVENTS},
 	{"fastrouter-subscription-server", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SERVER},
 	{"fastrouter-subscription-slot", required_argument, 0, LONG_ARGS_FASTROUTER_SUBSCRIPTION_SLOT},
@@ -287,6 +293,8 @@ void fastrouter_loop() {
 			}
 		}
 
+		uwsgi_log("uwsgi fastrouter/proxy bound on %s\n", ufr_sock->name);
+
 		event_queue_add_fd_read(fr_queue, ufr_sock->fd);
 		ufr_sock = ufr_sock->next;
 	}
@@ -350,6 +358,7 @@ void fastrouter_loop() {
 					fr_table[new_connection]->status = FASTROUTER_STATUS_RECV_HDR;
 					fr_table[new_connection]->h_pos = 0;
 					fr_table[new_connection]->pos = 0;
+					fr_table[new_connection]->un = NULL;
 					fr_table[new_connection]->instance_failed = 0;
 					fr_table[new_connection]->instance_address_len = 0;
 		
@@ -434,6 +443,11 @@ void fastrouter_loop() {
 #endif
 							if (ufr.use_cache) {
 								fr_session->instance_address = uwsgi_cache_get(fr_session->hostname, fr_session->hostname_len, &fr_session->instance_address_len);
+								char *cs_mod = uwsgi_str_contains(fr_session->instance_address, fr_session->instance_address_len, ',');
+                                                                if (cs_mod) {
+                                                                	fr_session->modifier1 = uwsgi_str_num(cs_mod+1, (fr_session->instance_address_len - (cs_mod - fr_session->instance_address))-1);
+                                                                        fr_session->instance_address_len = (cs_mod - fr_session->instance_address);
+                                                                }
 							}
 							else if (ufr.pattern) {
 								magic_table['s'] = uwsgi_concat2n(fr_session->hostname, fr_session->hostname_len, "", 0);	
@@ -455,6 +469,19 @@ void fastrouter_loop() {
 								fr_session->instance_address_len = tmp_socket_name_len;
 								fr_session->instance_address = tmp_socket_name;
 							}
+							else if (ufr.code_string_code && ufr.code_string_function) {
+								if (uwsgi.p[ufr.code_string_modifier1]->code_string) {
+									fr_session->instance_address = uwsgi.p[ufr.code_string_modifier1]->code_string("uwsgi_fastrouter", ufr.code_string_code, ufr.code_string_function, fr_session->hostname, fr_session->hostname_len);
+									if (fr_session->instance_address) {
+										fr_session->instance_address_len = strlen(fr_session->instance_address);
+										char *cs_mod = uwsgi_str_contains(fr_session->instance_address, fr_session->instance_address_len, ',');
+										if (cs_mod) {
+											fr_session->modifier1 = uwsgi_str_num(cs_mod+1, (fr_session->instance_address_len - (cs_mod - fr_session->instance_address))-1);
+											fr_session->instance_address_len = (cs_mod - fr_session->instance_address);
+										}
+									}
+								}
+							}
 
 							// no address found
 							if (!fr_session->instance_address_len) {
@@ -625,9 +652,17 @@ int fastrouter_init() {
 
 		if (!ufr.nevents) ufr.nevents = 64;
 
-		if (register_gateway("fastrouter", fastrouter_loop) == NULL) {
-			uwsgi_log("unable to register the fastrouter gateway\n");
-			exit(1);
+		if (ufr.code_string_code && ufr.code_string_function) {
+			if (register_fat_gateway("fastrouter", fastrouter_loop) == NULL) {
+				uwsgi_log("unable to register the fastrouter gateway\n");
+				exit(1);
+			}
+		}
+		else {
+			if (register_gateway("fastrouter", fastrouter_loop) == NULL) {
+				uwsgi_log("unable to register the fastrouter gateway\n");
+				exit(1);
+			}
 		}
 	}
 
@@ -636,6 +671,10 @@ int fastrouter_init() {
 	
 int fastrouter_opt(int i, char *optarg) {
 
+	char *cs;
+	char *cs_code;
+	char *cs_func;
+
 	switch(i) {
 		case LONG_ARGS_FASTROUTER:
 			uwsgi_fastrouter_new_socket(generate_socket_name(optarg));
@@ -656,6 +695,24 @@ int fastrouter_opt(int i, char *optarg) {
 			// optimization
 			ufr.base_len = strlen(ufr.base);
 			return 1;
+		case LONG_ARGS_FASTROUTER_USE_CODE_STRING:
+			cs = uwsgi_str(optarg);
+			cs_code = strchr(cs, ':');
+			if (!cs_code) {
+				uwsgi_log("invalid code_string option\n");
+				exit(1);	
+			}
+			cs_code[0] = 0;
+			cs_func = strchr(cs_code+1, ':');
+			if (!cs_func) {
+				uwsgi_log("invalid code_string option\n");
+				exit(1);	
+			}
+			cs_func[0] = 0;
+			ufr.code_string_modifier1 = atoi(cs);
+			ufr.code_string_code = cs_code+1;
+			ufr.code_string_function = cs_func+1;
+			return 1;
 		case LONG_ARGS_FASTROUTER_TIMEOUT:
 			ufr.socket_timeout = atoi(optarg);
 			return -1;

plugins/gevent/gevent.c

@@ -0,0 +1,240 @@
+#include "../python/uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+
+struct option gevent_options[] = {
+	{ 0, 0, 0, 0 }
+};
+
+#define GEVENT_SWITCH PyObject *gswitch = python_call(ugevent.greenlet_switch, ugevent.greenlet_switch_args, 0, NULL); Py_DECREF(gswitch)
+#define GET_CURRENT_GREENLET python_call(ugevent.get_current, ugevent.get_current_args, 0, NULL)
+#define free_req_queue uwsgi.async_queue_unused_ptr++; uwsgi.async_queue_unused[uwsgi.async_queue_unused_ptr] = uwsgi.wsgi_req
+
+struct uwsgi_gevent {
+	PyObject *greenlet_switch;
+	PyObject *greenlet_switch_args;
+	PyObject *get_current;
+	PyObject *get_current_args;
+	PyObject *hub_loop;
+	PyObject *spawn;
+	PyObject *greenlet_args;
+} ugevent;
+
+
+PyObject* gevent_wait_io_and_switch(int fd, PyObject *greenlet_switch) {
+
+	PyObject *watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", fd, 1);
+        if (!watcher) {
+                PyErr_Print();
+		return NULL; 
+        }
+
+	PyObject *ret = PyObject_CallMethod(watcher, "start", "O", greenlet_switch);
+	Py_DECREF(ret);
+
+	return watcher;
+
+}
+
+PyObject *py_uwsgi_gevent_callback(PyObject * self, PyObject * args) {
+
+
+	struct wsgi_request *wsgi_req = find_first_available_wsgi_req();
+
+	if (wsgi_req == NULL) {
+		uwsgi_log("async queue is full !!!\n");
+		goto clear;
+	}
+	uwsgi.wsgi_req = wsgi_req;
+
+	wsgi_req_setup(wsgi_req, wsgi_req->async_id, uwsgi.sockets );
+
+	uwsgi.core[wsgi_req->async_id]->in_request = 1;
+
+	gettimeofday(&wsgi_req->start_of_request, NULL);
+
+	if (wsgi_req_simple_accept(wsgi_req, uwsgi.sockets->fd)) {
+		uwsgi_close_request(wsgi_req);
+		free_req_queue;
+		goto clear;
+	}
+
+	
+	PyTuple_SetItem(ugevent.greenlet_args, 1, PyLong_FromLong((long)wsgi_req));
+
+	PyObject *new_gl = python_call(ugevent.spawn, ugevent.greenlet_args, 0, NULL);
+	Py_DECREF(new_gl);
+
+clear:
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyObject *py_uwsgi_gevent_greenlet(PyObject * self, PyObject * args) {
+
+	PyObject *py_wsgi_req = PyTuple_GetItem(args, 0);
+	struct wsgi_request *wsgi_req = (struct wsgi_request *) PyLong_AsLong(py_wsgi_req);
+	int status ;
+
+	PyObject *current_greenlet = GET_CURRENT_GREENLET;
+	PyObject *greenlet_switch = PyObject_GetAttrString(current_greenlet, "switch");
+
+	for(;;) {
+		uwsgi.wsgi_req = wsgi_req;
+		PyObject *watcher = gevent_wait_io_and_switch(wsgi_req->poll.fd, greenlet_switch);
+		if (!watcher) {
+			goto clear;
+		}
+		uwsgi.wsgi_req = wsgi_req;
+		status = wsgi_req->socket->proto(wsgi_req);
+		PyObject *ret = PyObject_CallMethod(watcher, "stop", NULL);
+		Py_DECREF(ret);
+		Py_DECREF(watcher);
+		if (status < 0) {
+			goto clear;
+		}
+		else if (status == 0) {
+			break;
+		}
+		
+	}
+
+	for(;;) {
+		uwsgi.wsgi_req = wsgi_req;
+		wsgi_req->async_status = uwsgi.p[wsgi_req->uh.modifier1]->request(wsgi_req);
+		if (wsgi_req->async_status <= UWSGI_OK) {
+			goto clear;
+		}
+		GEVENT_SWITCH;
+	}
+
+clear:
+	Py_DECREF(greenlet_switch);
+	Py_DECREF(current_greenlet);
+	uwsgi_close_request(wsgi_req);
+
+	uwsgi.wsgi_req = wsgi_req;
+
+	free_req_queue;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+
+
+}
+
+PyMethodDef uwsgi_gevent_callback_method[] = { {"uwsgi_gevent_callback", py_uwsgi_gevent_callback, METH_VARARGS, ""} };
+PyMethodDef uwsgi_gevent_greenlet_method[] = { {"uwsgi_gevent_greenlet", py_uwsgi_gevent_greenlet, METH_VARARGS, ""} };
+
+
+void gevent_loop() {
+
+	struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
+
+	if (uwsgi.async < 2) {
+		uwsgi_log("the gevent loop engine requires async mode (--async <n>)\n");
+		exit(1);
+	}
+
+
+	PyObject *gevent_dict = get_uwsgi_pydict("gevent");
+	if (!gevent_dict) {
+		PyErr_Print();
+		exit(1);
+	}
+
+	PyObject *gevent_version = PyDict_GetItemString(gevent_dict, "version_info");
+	if (!gevent_version) {
+		PyErr_Print();
+		exit(1);
+	}
+
+	if (PyInt_AsLong(PyTuple_GetItem(gevent_version, 0)) < 1) {
+		uwsgi_log("uWSGI requires at least gevent 1.x version\n");
+		exit(1);
+	}
+
+	ugevent.spawn = PyDict_GetItemString(gevent_dict, "spawn");
+	if (!ugevent.spawn) {
+		PyErr_Print();
+		exit(1);
+	}
+
+	ugevent.greenlet_switch = PyDict_GetItemString(gevent_dict, "sleep");
+	if (!ugevent.greenlet_switch) {
+		PyErr_Print();
+		exit(1);
+	}
+
+	ugevent.greenlet_switch_args = PyTuple_New(0);
+	Py_INCREF(ugevent.greenlet_switch_args);
+	
+
+	PyObject *gevent_get_hub = PyDict_GetItemString(gevent_dict, "get_hub");
+
+	PyObject *gevent_hub = python_call(gevent_get_hub, PyTuple_New(0), 0, NULL);
+	if (!gevent_hub) {
+		PyErr_Print();
+		exit(1);
+	}
+
+	ugevent.get_current = PyDict_GetItemString(gevent_dict, "getcurrent");
+	if (!ugevent.get_current) {
+		PyErr_Print();
+		exit(1);
+	}
+	ugevent.get_current_args = PyTuple_New(0);
+	Py_INCREF(ugevent.get_current_args);
+	
+
+	ugevent.hub_loop = PyObject_GetAttrString(gevent_hub, "loop");
+	if (!ugevent.hub_loop) {
+
+		PyErr_Print();
+		exit(1);
+	}
+
+
+	PyObject *watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi_sock->fd, 1);
+	if (!watcher) {
+		PyErr_Print();
+		exit(1);
+	}
+
+
+	PyObject *uwsgi_gevent_callback = PyCFunction_New(uwsgi_gevent_callback_method, NULL);
+	Py_INCREF(uwsgi_gevent_callback);
+
+	PyObject *uwsgi_gevent_greenlet = PyCFunction_New(uwsgi_gevent_greenlet_method, NULL);
+	Py_INCREF(uwsgi_gevent_greenlet);
+
+	ugevent.greenlet_args = PyTuple_New(2);
+	PyTuple_SetItem(ugevent.greenlet_args, 0, uwsgi_gevent_greenlet);
+
+
+
+	PyObject_CallMethod(watcher, "start", "O", uwsgi_gevent_callback);
+
+	if (PyObject_CallMethod(gevent_hub, "switch", NULL)) {
+		PyErr_Print();
+		exit(1);
+	}
+
+	uwsgi_log("the gevent Hub is no more :(\n");
+
+}
+
+int gevent_init() {
+
+	uwsgi_register_loop( (char *) "gevent", gevent_loop);
+	return 0;
+}
+
+
+struct uwsgi_plugin gevent_plugin = {
+
+	.name = "gevent",
+	.init = gevent_init,
+	.options = gevent_options,
+};

plugins/gevent/uwsgiplugin.py

@@ -0,0 +1,8 @@
+from distutils import sysconfig
+
+NAME='gevent'
+CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True)]
+LDFLAGS = []
+LIBS = []
+
+GCC_LIST = ['gevent']

plugins/http/http.c

@@ -403,6 +403,14 @@ int http_parse(struct http_session *h_session) {
 		ptr++;
 	}
 
+	int i;
+	for(i=0;i<uhttp.http_vars_cnt;i++) {
+		char *equal = strchr(uhttp.http_vars[i],'=');
+		if (equal) {
+			h_session->uh.pktsize += http_add_uwsgi_var(h_session->iov, h_session->uss+c, h_session->uss+c+2, uhttp.http_vars[i], equal-uhttp.http_vars[i], equal+1, strlen(equal+1), &c);
+		}
+	}
+
 #ifdef UWSGI_DEBUG
 	uwsgi_log("vec size: %d pkt size: %d load %d\n", c, h_session->uh.pktsize, uhttp.load);
 #endif

plugins/lua/lua_plugin.c

@@ -374,7 +374,7 @@ void uwsgi_lua_app() {
 			luaL_openlibs(ulua.L[i]);
 			luaL_register(ulua.L[i], "uwsgi", uwsgi_api);
 			if (luaL_loadfile(ulua.L[i], ulua.filename)) {
-				uwsgi_log("unable to load file %s\n", ulua.filename);
+				uwsgi_log("unable to load file %s: %s\n", ulua.filename, lua_tostring(ulua.L[i], -1));
 				exit(1);
 			}
 			// use a pcall
@@ -403,8 +403,7 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 		if ((i = lua_pcall(L, 0, 1, 0)) == 0) {
 			if (lua_type(L, -1) == LUA_TSTRING) {
 				http = lua_tolstring(L, -1, &slen);
-				if ( (rlen = write(wsgi_req->poll.fd, http, slen)) != (ssize_t) slen) {
-					perror("write()");
+				if ( (rlen = wsgi_req->socket->proto_write(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
 					return UWSGI_OK;
 				}
 				wsgi_req->response_size += rlen;
@@ -420,12 +419,12 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	/* Standard WSAPI request */
 	if (!wsgi_req->uh.pktsize) {
 		uwsgi_log( "Invalid WSAPI request. skip.\n");
-		goto clear;
+		goto clear2;
 	}
 
 	if (uwsgi_parse_vars(wsgi_req)) {
 		uwsgi_log("Invalid WSAPI request. skip.\n");
-		goto clear;
+		goto clear2;
 	}
 
 	// put function in the stack
@@ -453,12 +452,16 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	lua_setfield(L, -2, "read");
 	lua_setfield(L, -2, "input");
 
+#ifdef UWSGI_DEBUG
+	uwsgi_log("stack pos %d\n", lua_gettop(L));
+#endif
 
 	// call function
 	i = lua_pcall(L, 1, 3, 0);
 	if (i != 0) {
 		uwsgi_log("%s\n", lua_tostring(L, -1));
 		lua_pop(L, 1);
+                lua_pushvalue(L, -1);
 		goto clear;
 	}
 
@@ -468,26 +471,30 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	// send status
 	if (lua_type(L, -3) == LUA_TSTRING || lua_type(L, -3) == LUA_TNUMBER) {
 		http = lua_tolstring(L, -3, &slen);
-		if (write(wsgi_req->poll.fd, wsgi_req->protocol, wsgi_req->protocol_len) != wsgi_req->protocol_len) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, wsgi_req->protocol, wsgi_req->protocol_len)) != wsgi_req->protocol_len) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, " ", 1) != 1) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, " ", 1)) != 1) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, http, slen) != (ssize_t) slen) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 		// a performance hack
 		ptrbuf = (char *) http;
 		ptrbuf[3] = 0;
 		wsgi_req->status = atoi(ptrbuf);
-		if (write(wsgi_req->poll.fd, "\r\n", 2) != 2) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2)) != 2) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 	}
 	else {
 		raw = 1;
@@ -499,31 +506,41 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	lua_pushnil(L);
 	while(lua_next(L, -3) != 0) {
 		http = lua_tolstring(L, -2, &slen);
-		if (write(wsgi_req->poll.fd, http, slen) != (ssize_t) slen) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, ": ", 2) != 2) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, ": ", 2)) != 2) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 		http = lua_tolstring(L, -1, &slen);
-		if (write(wsgi_req->poll.fd, http, slen) != (ssize_t) slen) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
-		if (write(wsgi_req->poll.fd, "\r\n", 2) != 2) {
-			perror("write()");
+		wsgi_req->headers_size += rlen;
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2)) != 2) {
+			lua_pop(L, 2);
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 		lua_pop(L, 1);
+		wsgi_req->header_cnt++;
 	}
 
 	if (!raw) {
-		if (write(wsgi_req->poll.fd, "\r\n", 2) != 2) {
-			perror("write()");
+		if ( (rlen = wsgi_req->socket->proto_write_header(wsgi_req, "\r\n", 2)) != 2) {
+			lua_pushvalue(L, -1);
 			goto clear;
 		}
+		wsgi_req->headers_size += rlen;
 	}
 
 	// send body with coroutine
@@ -532,8 +549,9 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 	while ( (i = lua_pcall(L, 0, 1, 0)) == 0) {
 		if (lua_type(L, -1) == LUA_TSTRING) {
 			http = lua_tolstring(L, -1, &slen);
-			if ( (rlen = write(wsgi_req->poll.fd, http, slen)) != (ssize_t) slen) {
-				perror("write()");
+			if ( (rlen = wsgi_req->socket->proto_write(wsgi_req, (char *)http, slen)) != (ssize_t) slen) {
+				lua_pop(L, 1);
+                		lua_pushvalue(L, -1);
 				goto clear;
 			}
 			wsgi_req->response_size += rlen;
@@ -550,6 +568,7 @@ int uwsgi_lua_request(struct wsgi_request *wsgi_req) {
 clear:
 
 	lua_pop(L, 4);
+clear2:
 
 	// set frequency
 	lua_gc(L, LUA_GCCOLLECT, 0);
@@ -590,6 +609,55 @@ int uwsgi_lua_magic(char *mountpoint, char *lazy) {
 	return 0;
 }
 
+char *uwsgi_lua_code_string(char *id, char *code, char *func, char *key, uint16_t keylen) {
+
+	static struct lua_State *L = NULL;
+
+	if (!L) {
+		L = luaL_newstate();
+                luaL_openlibs(L);
+                if (luaL_loadfile(L, code) || lua_pcall(L, 0, 0, 0)) {
+                	uwsgi_log("unable to load file %s: %s\n", code, lua_tostring(L, -1));
+			lua_close(L);
+			L = NULL;
+			return NULL;
+                }
+		lua_getglobal(L, func);
+		if (!lua_isfunction(L,-1)) {
+			uwsgi_log("unable to find %s function in lua file %s\n", func, code);
+			lua_close(L);
+			L = NULL;
+			return NULL;
+		}
+		lua_pushnil(L);
+	}
+
+	
+	lua_pop(L, 1);
+
+	lua_pushvalue(L, -1);
+	lua_pushlstring(L, key, keylen);
+
+#ifdef UWSGI_DEBUG
+	uwsgi_log("stack pos %d %.*s\n", lua_gettop(L), keylen, key);
+#endif
+
+        if (lua_pcall(L, 1, 1, 0) != 0) {
+		uwsgi_log("CAZZO\n");
+                uwsgi_log("error running function `f': %s",
+                 lua_tostring(L, -1));
+                return NULL;
+
+        }
+
+	if (lua_isstring(L, -1)) {
+                const char *ret = lua_tolstring(L, -1, NULL);
+		return (char *)ret;
+        }
+
+        return NULL;
+}
+
 int uwsgi_lua_signal_handler(uint8_t sig, void *handler) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
@@ -664,6 +732,8 @@ struct uwsgi_plugin lua_plugin = {
 	.init_apps = uwsgi_lua_app,
 	.magic = uwsgi_lua_magic,
 	.signal_handler = uwsgi_lua_signal_handler,
+
+	.code_string = uwsgi_lua_code_string,
 	.rpc = uwsgi_lua_rpc,
 
 };

plugins/psgi/psgi_response.c

@@ -2,52 +2,7 @@
 
 extern struct uwsgi_server uwsgi;
 
-/* statistically ordered */
-struct http_status_codes hsc[] = {
-        {"200", "OK"},
-        {"302", "Found"},
-        {"404", "Not Found"},
-        {"500", "Internal Server Error"},
-        {"301", "Moved Permanently"},
-        {"304", "Not Modified"},
-        {"303", "See Other"},
-        {"403", "Forbidden"},
-        {"307", "Temporary Redirect"},
-        {"401", "Unauthorized"},
-        {"400", "Bad Request"},
-        {"405", "Method Not Allowed"},
-        {"408", "Request Timeout"},
-
-        {"100", "Continue"},
-        {"101", "Switching Protocols"},
-        {"201", "Created"},
-        {"202", "Accepted"},
-        {"203", "Non-Authoritative Information"},
-        {"204", "No Content"},
-        {"205", "Reset Content"},
-        {"206", "Partial Content"},
-        {"300", "Multiple Choices"},
-        {"305", "Use Proxy"},
-        {"402", "Payment Required"},
-        {"406", "Not Acceptable"},
-        {"407", "Proxy Authentication Required"},
-        {"409", "Conflict"},
-        {"410", "Gone"},
-        {"411", "Length Required"},
-        {"412", "Precondition Failed"},
-        {"413", "Request Entity Too Large"},
-        {"414", "Request-URI Too Long"},
-        {"415", "Unsupported Media Type"},
-        {"416", "Requested Range Not Satisfiable"},
-        {"417", "Expectation Failed"},
-        {"501", "Not Implemented"},
-        {"502", "Bad Gateway"},
-        {"503", "Service Unavailable"},
-        {"504", "Gateway Timeout"},
-        {"505", "HTTP Version Not Supported"},
-        { "", NULL },
-};
-
+extern struct http_status_codes hsc[];
 
 int psgi_response(struct wsgi_request *wsgi_req, PerlInterpreter *my_perl, AV *response) {
 

plugins/python/pump_subhandler.c

@@ -0,0 +1,388 @@
+#include "uwsgi_python.h"
+
+extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+extern PyTypeObject uwsgi_InputType;
+
+
+extern struct http_status_codes hsc[];
+
+
+void *uwsgi_request_subhandler_pump(struct wsgi_request *wsgi_req, struct uwsgi_app *wi) {
+
+	PyObject *zero;
+
+	int i;
+        PyObject *pydictkey, *pydictvalue;
+
+	char *port = memchr(wsgi_req->host, ':', wsgi_req->host_len);
+	if (port) {
+
+		zero = PyString_FromStringAndSize(wsgi_req->host, (port-wsgi_req->host));
+		PyDict_SetItemString(wsgi_req->async_environ, "server_name", zero);
+		Py_DECREF(zero);
+
+		zero = PyString_FromStringAndSize(port, wsgi_req->host_len-((port+1)-wsgi_req->host));
+		PyDict_SetItemString(wsgi_req->async_environ, "server_port", zero);
+		Py_DECREF(zero);
+	}
+	else {
+
+		zero = PyString_FromStringAndSize(wsgi_req->host, wsgi_req->host_len);
+		PyDict_SetItemString(wsgi_req->async_environ, "server_name", zero);
+		Py_DECREF(zero);
+
+		zero = PyString_FromStringAndSize("80", 2);
+		PyDict_SetItemString(wsgi_req->async_environ, "server_port", zero);
+		Py_DECREF(zero);
+	}
+
+	zero = PyString_FromStringAndSize(wsgi_req->remote_addr, wsgi_req->remote_addr_len);
+	PyDict_SetItemString(wsgi_req->async_environ, "remote_addr", zero);
+	Py_DECREF(zero);
+
+	zero = PyString_FromStringAndSize(wsgi_req->path_info, wsgi_req->path_info_len);
+	PyDict_SetItemString(wsgi_req->async_environ, "uri", zero);
+	Py_DECREF(zero);
+
+	if (wsgi_req->query_string_len > 0) {
+		zero = PyString_FromStringAndSize(wsgi_req->query_string, wsgi_req->query_string_len);
+		PyDict_SetItemString(wsgi_req->async_environ, "query_string", zero);
+		Py_DECREF(zero);
+	}
+
+	zero = PyString_FromStringAndSize(uwsgi_lower(wsgi_req->method, wsgi_req->method_len), wsgi_req->method_len);
+	PyDict_SetItemString(wsgi_req->async_environ, "method", zero);
+	Py_DECREF(zero);
+
+	if (wsgi_req->post_cl > 0) {
+		PyDict_SetItemString(wsgi_req->async_environ, "content_length", PyInt_FromLong(wsgi_req->post_cl));
+		if (wsgi_req->content_type_len > 0) {
+			zero = PyString_FromStringAndSize(wsgi_req->content_type, wsgi_req->content_type_len);
+                	PyDict_SetItemString(wsgi_req->async_environ, "content_type", zero);
+                	Py_DECREF(zero);
+		}
+	}
+
+
+
+	PyObject *headers = PyDict_New();
+
+        for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+#ifdef UWSGI_DEBUG
+                uwsgi_debug("%.*s: %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
+#endif
+		if (wsgi_req->hvec[i].iov_len < 6) continue;
+		if (!uwsgi_startswith(wsgi_req->hvec[i].iov_base, "HTTP_", 5)) {
+			(void) uwsgi_lower(wsgi_req->hvec[i].iov_base+5, wsgi_req->hvec[i].iov_len-5);
+#ifdef PYTHREE
+                	pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base+5, wsgi_req->hvec[i].iov_len-5, NULL);
+                	pydictvalue = PyUnicode_DecodeLatin1(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len, NULL);
+#else
+                	pydictkey = PyString_FromStringAndSize(wsgi_req->hvec[i].iov_base+5, wsgi_req->hvec[i].iov_len-5);
+                	pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
+#endif
+			PyObject *old_value = PyDict_GetItem(headers, pydictkey);
+			if (old_value) {
+				if (PyString_Check(old_value)) {
+					PyObject *new_value = PyList_New(0);
+					PyList_Append(new_value, old_value);
+					old_value = new_value;
+                			PyDict_SetItem(headers, pydictkey, old_value);
+					Py_DECREF(old_value);
+				}
+				PyList_Append(old_value, pydictvalue);
+			}
+			else {
+                		PyDict_SetItem(headers, pydictkey, pydictvalue);
+			}
+                	Py_DECREF(pydictkey);
+                	Py_DECREF(pydictvalue);
+		}
+        }
+
+	PyDict_SetItemString(wsgi_req->async_environ, "headers", headers);
+	Py_DECREF(headers);
+
+        // if async_post is mapped as a file, directly use it as wsgi.input
+        if (wsgi_req->async_post) {
+#ifdef PYTHREE
+                wsgi_req->async_input = PyFile_FromFd(fileno(wsgi_req->async_post), "pump_body", "rb", 0, NULL, NULL, NULL, 0);
+#else
+                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "pump_body", "r", NULL);
+#endif
+        }
+        else {
+                // create wsgi.input custom object
+                wsgi_req->async_input = (PyObject *) PyObject_New(uwsgi_Input, &uwsgi_InputType);
+                ((uwsgi_Input*)wsgi_req->async_input)->wsgi_req = wsgi_req;
+                ((uwsgi_Input*)wsgi_req->async_input)->pos = 0;
+                ((uwsgi_Input*)wsgi_req->async_input)->readline_pos = 0;
+                ((uwsgi_Input*)wsgi_req->async_input)->readline_max_size = 0;
+
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "body", wsgi_req->async_input);
+
+
+	if (wsgi_req->scheme_len > 0) {
+		zero = PyString_FromStringAndSize(wsgi_req->scheme, wsgi_req->scheme_len);
+	}
+	else if (wsgi_req->https_len > 0) {
+		if (!strncasecmp(wsgi_req->https, "on", 2) || wsgi_req->https[0] == '1') {
+			zero = PyString_FromString("https");
+		}
+		else {
+			zero = PyString_FromString("http");
+		}
+	}
+	else {
+		zero = PyString_FromString("http");
+	}
+	PyDict_SetItemString(wsgi_req->async_environ, "scheme", zero);
+	Py_DECREF(zero);
+
+
+	wsgi_req->async_app = wi->callable;
+
+	// export .env only in non-threaded mode
+        if (uwsgi.threads < 2) {
+        	PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
+
+        if (uwsgi.cores > 1) {
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+        }
+
+        // cache this ?
+        if (uwsgi.cluster_fd >= 0) {
+                zero = PyString_FromString(uwsgi.cluster);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster", zero);
+                Py_DECREF(zero);
+                zero = PyString_FromString(uwsgi.hostname);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster_node", zero);
+                Py_DECREF(zero);
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", wi->uwsgi_node);
+
+
+	// call
+
+	PyTuple_SetItem(wsgi_req->async_args, 0, wsgi_req->async_environ);
+	return python_call(wsgi_req->async_app, wsgi_req->async_args, uwsgi.catch_exceptions, wsgi_req);
+}
+
+
+int uwsgi_response_subhandler_pump(struct wsgi_request *wsgi_req) {
+
+	PyObject *pychunk;
+	ssize_t wsize;
+	int i;
+
+	struct http_status_codes *http_sc;
+	char sc[4];
+
+	UWSGI_GET_GIL
+
+	// ok its a yield
+	if (!wsgi_req->async_placeholder) {
+		if (PyDict_Check((PyObject *)wsgi_req->async_result)) {
+
+
+			PyObject *status = PyDict_GetItemString((PyObject *)wsgi_req->async_result, "status");
+			if (!status) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			PyObject *headers = PyDict_GetItemString((PyObject *)wsgi_req->async_result, "headers");
+			if (!headers) {
+				uwsgi_log("invalid Pump response (headers).\n"); 
+				goto clear; 
+			}
+
+
+			wsgi_req->async_placeholder =  PyDict_GetItemString((PyObject *)wsgi_req->async_result, "body");
+			if (!wsgi_req->async_placeholder) {
+				uwsgi_log("invalid Pump response (body).\n"); 
+				goto clear; 
+			}
+
+			// get the status code
+			if (!PyInt_Check(status)) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			if (uwsgi_num2str2n(PyInt_AsLong(status), sc, 4) != 3) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			int found = 0;
+			for (http_sc = hsc; http_sc->message != NULL; http_sc++) {
+                		if (http_sc->key[0] == sc[0] && http_sc->key[1] == sc[1] && http_sc->key[2] == sc[2]) {
+                        		wsgi_req->hvec[4].iov_base = (char *) http_sc->message;
+                        		wsgi_req->hvec[4].iov_len = http_sc->message_size;
+					found = 1;
+                        		break;
+                		}
+        		}
+		
+			if (!found) {
+				uwsgi_log("invalid Pump response (status code).\n"); 
+				goto clear; 
+			}
+
+			wsgi_req->hvec[0].iov_base = wsgi_req->protocol;
+			wsgi_req->hvec[0].iov_len = wsgi_req->protocol_len;
+			wsgi_req->hvec[1].iov_base = " ";
+			wsgi_req->hvec[1].iov_len = 1;
+			wsgi_req->hvec[2].iov_base = sc;
+			wsgi_req->hvec[2].iov_len = 3;
+			wsgi_req->hvec[3].iov_base = " ";
+			wsgi_req->hvec[3].iov_len = 1;
+			wsgi_req->hvec[5].iov_base = "\r\n";
+			wsgi_req->hvec[5].iov_len = 2;
+
+			UWSGI_RELEASE_GIL
+                	wsize = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, 6);
+                	UWSGI_GET_GIL
+                	if (wsize < 0) {
+                        	uwsgi_error("writev()");
+                	}
+                	wsgi_req->headers_size += wsize;
+
+			PyObject *hhkey, *hhvalue;
+			Py_ssize_t hhpos = 0;
+			while (PyDict_Next(headers, &hhpos, &hhkey, &hhvalue)) {
+				if (!PyString_Check(hhkey)) continue;
+
+				wsgi_req->hvec[0].iov_base = PyString_AsString(hhkey);
+				wsgi_req->hvec[0].iov_len = PyString_Size(hhkey);	
+				((char*)wsgi_req->hvec[0].iov_base)[0] = toupper((int) ((char*)wsgi_req->hvec[0].iov_base)[0]);
+
+				wsgi_req->hvec[1].iov_base = ": ";
+                        	wsgi_req->hvec[1].iov_len = 2;
+
+				wsgi_req->hvec[3].iov_base = "\r\n";
+                        	wsgi_req->hvec[3].iov_len = 2;
+				if (PyList_Check(hhvalue)) {
+					for(i=0;i<PyList_Size(hhvalue);i++) {
+						PyObject *item = PyList_GetItem(hhvalue, i);
+						if (PyString_Check(item)) {
+							wsgi_req->hvec[2].iov_base = PyString_AsString(item);
+                                        		wsgi_req->hvec[2].iov_len = PyString_Size(item);
+                                        		UWSGI_RELEASE_GIL
+                                        		wsize = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, 4);
+                                        		UWSGI_GET_GIL
+                                        		if (wsize < 0) {
+                                                		uwsgi_error("writev()");
+                                        		}
+                                        		wsgi_req->headers_size += wsize;
+						}
+					}	
+				}
+				else if (PyString_Check(hhvalue)) {
+					wsgi_req->hvec[2].iov_base = PyString_AsString(hhvalue);
+                                	wsgi_req->hvec[2].iov_len = PyString_Size(hhvalue);
+					UWSGI_RELEASE_GIL
+                        		wsize = wsgi_req->socket->proto_writev_header(wsgi_req, wsgi_req->hvec, 4);
+                        		UWSGI_GET_GIL
+                        		if (wsize < 0) {
+                                		uwsgi_error("writev()");
+                        		}
+                        		wsgi_req->headers_size += wsize;
+				}
+			}
+
+			wsgi_req->socket->proto_write(wsgi_req, "\r\n", 2);
+			Py_INCREF((PyObject *)wsgi_req->async_placeholder);
+
+			if (PyString_Check((PyObject *)wsgi_req->async_placeholder)) {
+                		if ((wsize = wsgi_req->socket->proto_write(wsgi_req, PyString_AsString(wsgi_req->async_placeholder), PyString_Size(wsgi_req->async_placeholder))) < 0) {
+                        		uwsgi_error("write()");
+                        		goto clear;
+                		}
+                		wsgi_req->response_size += wsize;
+                		goto clear;
+        		}
+#ifdef PYTHREE
+			else if ((wsgi_req->sendfile_fd = PyObject_AsFileDescriptor((PyObject *)wsgi_req->async_placeholder)) > -1) {
+#else
+			else if (PyFile_Check((PyObject *)wsgi_req->async_placeholder)) {
+				wsgi_req->sendfile_fd = fileno(PyFile_AsFile((PyObject *)wsgi_req->async_placeholder));
+#endif
+                		wsize = uwsgi_sendfile(wsgi_req);
+				if (wsize < 0) {
+					goto clear;
+				}
+                		wsgi_req->response_size += wsize;
+				goto clear;
+			}
+
+			PyObject *tmp = (PyObject *)wsgi_req->async_placeholder;
+
+			wsgi_req->async_placeholder = PyObject_GetIter( (PyObject *)wsgi_req->async_placeholder );
+
+			Py_DECREF(tmp);
+
+			if (!wsgi_req->async_placeholder) {
+				goto clear;
+			}
+#ifdef UWSGI_ASYNC
+			if (uwsgi.async > 1) {
+				UWSGI_RELEASE_GIL
+				return UWSGI_AGAIN;
+			}
+		}
+		else {
+			uwsgi_log("invalid Pump response.\n"); 
+			goto clear; 
+		}
+#endif
+	}
+
+
+
+	pychunk = PyIter_Next(wsgi_req->async_placeholder);
+
+	if (!pychunk) {
+		if (PyErr_Occurred()) PyErr_Print();
+		goto clear;
+	}
+
+
+	if (PyString_Check(pychunk)) {
+		if ((wsize = wsgi_req->socket->proto_write(wsgi_req,  PyString_AsString(pychunk), PyString_Size(pychunk))) < 0) {
+			uwsgi_error("write()");
+			Py_DECREF(pychunk);
+			goto clear;
+		}
+		wsgi_req->response_size += wsize;
+	}
+
+
+	Py_DECREF(pychunk);
+	UWSGI_RELEASE_GIL
+	return UWSGI_AGAIN;
+
+clear:
+	if (wsgi_req->async_input) {
+                Py_DECREF((PyObject *)wsgi_req->async_input);
+        }
+	if (wsgi_req->async_environ) {
+		PyDict_Clear(wsgi_req->async_environ);
+	}
+	Py_XDECREF((PyObject *)wsgi_req->async_placeholder);
+
+	Py_DECREF((PyObject *)wsgi_req->async_result);
+	PyErr_Clear();
+
+	UWSGI_RELEASE_GIL
+	return UWSGI_OK;
+}
+

plugins/python/pyloader.c

@@ -22,12 +22,11 @@ PyMethodDef uwsgi_eventfd_read_method[] = { {"uwsgi_eventfd_read", py_eventfd_re
 PyMethodDef uwsgi_eventfd_write_method[] = { {"uwsgi_eventfd_write", py_eventfd_write, METH_VARARGS, ""}};
 #endif
 
-int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThreadState *interpreter) {
+int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThreadState *interpreter, int app_type) {
 
-	PyObject *zero;
 	PyObject *app_list = NULL, *applications = NULL;
 
-	int id = uwsgi.apps_cnt;
+	int id = uwsgi_apps_cnt;
 	int multiapp = 0;
 
 #ifdef UWSGI_ASYNC
@@ -38,23 +37,8 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 
 	struct uwsgi_app *wi;
 
-	if (wsgi_req->script_name_len == 0) {
-		wsgi_req->script_name = "";
-	}
-	else if (wsgi_req->script_name_len == 1) {
-		if (wsgi_req->script_name[0] == '/') {
-			wsgi_req->script_name = "";
-			wsgi_req->script_name_len = 0;
-		}
-	}
 
-
-	if (uwsgi.vhost) {
-		mountpoint = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|", 1, wsgi_req->script_name, wsgi_req->script_name_len);
-	}
-	else {
-		mountpoint = uwsgi_strncopy(wsgi_req->script_name, wsgi_req->script_name_len);
-	}
+	mountpoint = uwsgi_strncopy(wsgi_req->appid, wsgi_req->appid_len);
 
 	if (uwsgi_get_app_id(mountpoint, strlen(mountpoint), -1) != -1) {
 		uwsgi_log( "mountpoint %.*s already configured. skip.\n", strlen(mountpoint), mountpoint);
@@ -63,7 +47,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 
 
-	wi = &uwsgi.apps[id];
+	wi = &uwsgi_apps[id];
 
 	memset(wi, 0, sizeof(struct uwsgi_app));
 	wi->mountpoint = mountpoint;
@@ -160,7 +144,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	wi->callable = up.loaders[loader](arg1);
 
 	if (!wi->callable) {
-		uwsgi_log("unable to load app SCRIPT_NAME=%s\n", mountpoint);
+		uwsgi_log("unable to load app mountpoint=%s\n", mountpoint);
 		goto doh;
 	}
 
@@ -184,12 +168,22 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		}
 		wi->mountpoint = PyString_AsString(app_mnt);
 		wi->mountpoint_len = strlen(wi->mountpoint);
-		wsgi_req->script_name = wi->mountpoint;
-		wsgi_req->script_name_len = wi->mountpoint_len;
+		wsgi_req->appid = wi->mountpoint;
+		wsgi_req->appid_len = wi->mountpoint_len;
+#ifdef UWSGI_DEBUG
 		uwsgi_log("main mountpoint = %s\n", wi->mountpoint);
+#endif
 		wi->callable = PyDict_GetItem(applications, app_mnt);
+		if (PyString_Check((PyObject *) wi->callable)) {
+			PyObject *callables_dict = get_uwsgi_pydict((char *)arg1);
+			if (callables_dict) {
+				wi->callable = PyDict_GetItem(callables_dict, (PyObject *)wi->callable);	
+			}
+		}
 	}
 
+	Py_INCREF((PyObject *)wi->callable);
+
 #ifdef UWSGI_ASYNC
 	wi->environ = malloc(sizeof(PyObject*)*uwsgi.cores);
 	if (!wi->environ) {
@@ -212,47 +206,29 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #endif
 
-	// check function args
-	// by defaut it is a WSGI app
-	wi->argc = 2;
-	zero = PyObject_GetAttrString(wi->callable, "__code__");
-	if (!zero) {
-		zero = PyObject_GetAttrString(wi->callable, "__call__");
-		if (zero) {
-			zero = PyObject_GetAttrString(wi->callable, "__code__");
-		}
-		else {
-			uwsgi_log("WARNING: unable to get the number of callable args. Fallback to WSGI\n");
-		}
-	}
+	wi->argc = 1;
 
-	// avoid __code__ attr error propagation
-	PyErr_Clear();
-
-	if (zero) {
-		zero = PyObject_GetAttrString(zero, "co_argcount");
-		wi->argc = (int) PyInt_AsLong(zero);
-	}
-
-	if (wi->argc == 2) {
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("-- WSGI callable detected --\n");
+		uwsgi_log("-- WSGI callable selected --\n");
 #endif
 		wi->request_subhandler = uwsgi_request_subhandler_wsgi;
 		wi->response_subhandler = uwsgi_response_subhandler_wsgi;
+		wi->argc = 2;
 	}
-#ifdef UWSGI_WEB3
-	else if (wi->argc == 1) {
+	else if (app_type == PYTHON_APP_TYPE_WEB3) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("-- Web3 callable detected --\n");
+		uwsgi_log("-- Web3 callable selected --\n");
 #endif
 		wi->request_subhandler = uwsgi_request_subhandler_web3;
 		wi->response_subhandler = uwsgi_response_subhandler_web3;
 	}
+	else if (app_type == PYTHON_APP_TYPE_PUMP) {
+#ifdef UWSGI_DEBUG
+		uwsgi_log("-- Pump callable selected --\n");
 #endif
-	else {
-		uwsgi_log("-- INVALID callable detected --\n");
-		goto doh;
+		wi->request_subhandler = uwsgi_request_subhandler_pump;
+		wi->response_subhandler = uwsgi_response_subhandler_pump;
 	}
 
 #ifdef UWSGI_ASYNC
@@ -270,7 +246,8 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		}
 
 		// add start_response on WSGI app
-		if (wi->argc == 2) {
+		Py_INCREF((PyObject *)up.wsgi_spitout);
+		if (app_type == PYTHON_APP_TYPE_WSGI) {
 			if (PyTuple_SetItem(wi->args[i], 1, up.wsgi_spitout)) {
 				uwsgi_log("unable to set start_response in args tuple\n");
 				exit(1);
@@ -279,8 +256,10 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #else
 
+	// add start_response on WSGI app
+	Py_INCREF((PyObject *)up.wsgi_spitout);
 	wi->wsgi_args = PyTuple_New(wi->argc);
-	if (wi->argc == 2) {
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
 		if (PyTuple_SetItem(wi->wsgi_args, 1, up.wsgi_spitout)) {
 			uwsgi_log("unable to set start_response in args tuple\n");
 			exit(1);
@@ -288,7 +267,7 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 	}
 #endif
 
-	if (wi->argc == 2) {
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
 #ifdef UWSGI_SENDFILE
 		// prepare sendfile() for WSGI app
 		wi->sendfile = PyCFunction_New(uwsgi_sendfile_method, NULL);
@@ -300,6 +279,19 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 #endif
 	}
 
+	// cache most used values
+
+	wi->gateway_version = PyTuple_New(2);
+        PyTuple_SetItem(wi->gateway_version, 0, PyInt_FromLong(1));
+        PyTuple_SetItem(wi->gateway_version, 1, PyInt_FromLong(0));
+	Py_INCREF((PyObject *)wi->gateway_version);
+
+	wi->uwsgi_version = PyString_FromString(UWSGI_VERSION);
+	Py_INCREF((PyObject *)wi->uwsgi_version);
+
+	wi->uwsgi_node = PyString_FromString(uwsgi.hostname);
+	Py_INCREF((PyObject *)wi->uwsgi_node);
+
 	if (uwsgi.threads > 1 && id) {
 		// if we have multiple threads we need to initialize a PyThreadState for each one
 		for(i=0;i<uwsgi.threads;i++) {
@@ -316,19 +308,22 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 		PyThreadState_Swap(up.main_thread);
 	}
 
-	if (wi->argc == 1) {
-		uwsgi_log( "Web3 application %d (SCRIPT_NAME=%.*s) ready on interpreter %p", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter);
+	if (app_type == PYTHON_APP_TYPE_WSGI) {
+		uwsgi_log( "WSGI application %d (mountpoint=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
-	else {
-		uwsgi_log( "WSGI application %d (SCRIPT_NAME=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+	else if (app_type == PYTHON_APP_TYPE_WEB3) {
+		uwsgi_log( "Web3 application %d (mountpoint=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
+	}
+	else if (app_type == PYTHON_APP_TYPE_PUMP) {
+		uwsgi_log( "Pump application %d (mountpoint=%.*s) ready on interpreter %p pid: %d", id, wi->mountpoint_len, wi->mountpoint, wi->interpreter, (int) getpid());
 	}
 
-	if (!wsgi_req->script_name_len) {
+	if ((wsgi_req->appid_len == 0 || (wsgi_req->appid_len = 1 && wsgi_req->appid[0] == '/')) && uwsgi.default_app == -1) {
 		uwsgi_rawlog(" (default app)");
 		uwsgi.default_app = id;
 	}
 
-	uwsgi.apps_cnt++;
+	uwsgi_apps_cnt++;
 
 	uwsgi_rawlog("\n");
 
@@ -340,9 +335,29 @@ int init_uwsgi_app(int loader, void *arg1, struct wsgi_request *wsgi_req, PyThre
 				continue;
 			}
 
-			wsgi_req->script_name = PyString_AsString(app_mnt);
-			wsgi_req->script_name_len = strlen(wsgi_req->script_name);
-			init_uwsgi_app(LOADER_CALLABLE, PyDict_GetItem(applications, app_mnt), wsgi_req, wi->interpreter);
+			wsgi_req->appid = PyString_AsString(app_mnt);
+			wsgi_req->appid_len = strlen(wsgi_req->appid);
+			PyObject *a_callable = PyDict_GetItem(applications, app_mnt);
+			if (PyString_Check(a_callable)) {
+
+				PyObject *callables_dict = get_uwsgi_pydict((char *)arg1);
+				if (callables_dict) {
+					a_callable = PyDict_GetItem(callables_dict, a_callable);
+				}
+			}
+			if (!a_callable) {
+				uwsgi_log("skipping broken app %s\n", wsgi_req->appid);
+				continue;
+			}
+			init_uwsgi_app(LOADER_CALLABLE, a_callable, wsgi_req, wi->interpreter, app_type);
+		}
+	}
+
+	// check if we need to emulate fork() COW
+	if (uwsgi.mywid == 0) {
+		for(i=1;i<=uwsgi.numproc;i++) {
+			memcpy(&uwsgi.workers[i].apps[id], &uwsgi.workers[0].apps[id], sizeof(struct uwsgi_app));
+			uwsgi.workers[i].apps_cnt = uwsgi_apps_cnt;
 		}
 	}
 
@@ -441,7 +456,7 @@ PyObject *uwsgi_uwsgi_loader(void *arg1) {
 		tmp_callable = PyDict_GetItemString(wsgi_dict, quick_callable);
 		quick_callable[strlen(quick_callable)] = '(';
 		if (tmp_callable) {
-			return python_call(tmp_callable, PyTuple_New(0), 0);
+			return python_call(tmp_callable, PyTuple_New(0), 0, NULL);
 		}
 	}
 
@@ -523,7 +538,7 @@ PyObject *uwsgi_file_loader(void *arg1) {
 	char *callable = up.callable;
 	if (!callable) callable = "application";
 
-	wsgi_file_module = uwsgi_pyimport_by_filename("uwsgi_wsgi_file", filename);
+	wsgi_file_module = uwsgi_pyimport_by_filename(uwsgi_concat2("uwsgi_file_", uwsgi_pythonize(filename)), filename);
 	if (!wsgi_file_module) {
 		PyErr_Print();
 		exit(1);

plugins/python/python_plugin.c

@@ -3,6 +3,8 @@
 extern struct uwsgi_server uwsgi;
 struct uwsgi_python up;
 
+extern struct http_status_codes hsc[];
+
 #include <glob.h>
 
 extern PyTypeObject uwsgi_InputType;
@@ -12,6 +14,7 @@ struct option uwsgi_python_options[] = {
 	{"file", required_argument, 0, LONG_ARGS_FILE_CONFIG},
 	{"eval", required_argument, 0, LONG_ARGS_EVAL_CONFIG},
 	{"module", required_argument, 0, 'w'},
+	{"wsgi", required_argument, 0, 'w'},
 	{"callable", required_argument, 0, LONG_ARGS_CALLABLE},
 	{"test", required_argument, 0, 'j'},
 	{"home", required_argument, 0, 'H'},
@@ -26,10 +29,17 @@ struct option uwsgi_python_options[] = {
 	{"pyimport", required_argument, 0, LONG_ARGS_PYIMPORT},
 	{"py-import", required_argument, 0, LONG_ARGS_PYIMPORT},
 	{"python-import", required_argument, 0, LONG_ARGS_PYIMPORT},
+	{"spooler-import", required_argument, 0, LONG_ARGS_SPOOLER_PYIMPORT},
+	{"spooler-pyimport", required_argument, 0, LONG_ARGS_SPOOLER_PYIMPORT},
+	{"spooler-py-import", required_argument, 0, LONG_ARGS_SPOOLER_PYIMPORT},
+	{"spooler-python-import", required_argument, 0, LONG_ARGS_SPOOLER_PYIMPORT},
 	{"pp", required_argument, 0, LONG_ARGS_PYTHONPATH},
 	{"pyargv", required_argument, 0, LONG_ARGS_PYARGV},
 	{"optimize", required_argument, 0, 'O'},
 	{"paste", required_argument, 0, LONG_ARGS_PASTE},
+	{"web3", required_argument, 0, LONG_ARGS_WEB3},
+	{"pump", required_argument, 0, LONG_ARGS_PUMP},
+	{"wsgi-lite", required_argument, 0, LONG_ARGS_WSGI_LITE},
 #ifdef UWSGI_INI
 	{"ini-paste", required_argument, 0, LONG_ARGS_INI_PASTE},
 #endif
@@ -38,6 +48,7 @@ struct option uwsgi_python_options[] = {
 	{"pep3333-input", no_argument, &up.pep3333_input, 1},
 	{"reload-os-env", no_argument, &up.reload_os_env, 1},
 	{"no-site", no_argument, &Py_NoSiteFlag, 1},
+	{"pyshell", no_argument, 0, LONG_ARGS_PYSHELL},
 
 	{0, 0, 0, 0},
 };
@@ -167,6 +178,14 @@ void uwsgi_python_reset_random_seed() {
 
 void uwsgi_python_post_fork() {
 
+#ifdef UWSGI_SPOOLER
+	if (uwsgi.shared->spooler_pid > 0) {
+		if (uwsgi.shared->spooler_pid == getpid()) {
+			UWSGI_GET_GIL
+		}
+	}	
+#endif
+
 	uwsgi_python_reset_random_seed();
 
 #ifdef UWSGI_EMBEDDED
@@ -175,7 +194,7 @@ void uwsgi_python_post_fork() {
 	if (uwsgi_dict) {
 		PyObject *pfh = PyDict_GetItemString(uwsgi_dict, "post_fork_hook");
 		if (pfh) {
-			python_call(pfh, PyTuple_New(0), 0);
+			python_call(pfh, PyTuple_New(0), 0, NULL);
 		}
 	}
 	PyErr_Clear();
@@ -195,7 +214,7 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 	char *real_filename = filename;
 
 
-	if (strncmp(filename, "http://", 7) && strncmp(filename, "sym://", 6)) {
+	if (strncmp(filename, "http://", 7) && strncmp(filename, "sym://", 6) && strncmp(filename, "data://", 7)) {
 
 		pyfile = fopen(filename, "r");
 		if (!pyfile) {
@@ -225,7 +244,8 @@ PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) {
 		if (!py_file_node) {
 			PyErr_Print();
 			uwsgi_log("failed to parse file %s\n", real_filename);
-			free(real_filename);
+			if (is_a_package)
+				free(real_filename);
 			fclose(pyfile);
 			return NULL;
 		}
@@ -436,12 +456,17 @@ void init_uwsgi_embedded_module() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *) &uwsgi_InputType);
+
 	up.embedded_dict = PyModule_GetDict(new_uwsgi_module);
 	if (!up.embedded_dict) {
 		uwsgi_log("could not get uwsgi module __dict__\n");
 		exit(1);
 	}
 
+	// just for safety
+	Py_INCREF(up.embedded_dict);
+
 	if (PyDict_SetItemString(up.embedded_dict, "version", PyString_FromString(UWSGI_VERSION))) {
 		PyErr_Print();
 		exit(1);
@@ -553,6 +578,23 @@ void init_uwsgi_embedded_module() {
 		exit(1);
 	}
 
+	PyObject *py_magic_table = PyDict_New();
+	uint8_t mtk;
+	for (i = 0; i <= 0xff; i++) {
+		// a bit of magic :P
+		mtk = i;
+                if (uwsgi.magic_table[i]) {
+			if (uwsgi.magic_table[i][0] != 0) {
+				PyDict_SetItem(py_magic_table, PyString_FromStringAndSize((char *) &mtk, 1), PyString_FromString(uwsgi.magic_table[i]));
+			}
+		}
+        }
+
+	if (PyDict_SetItemString(up.embedded_dict, "magic_table", py_magic_table)) {
+		PyErr_Print();
+		exit(1);
+	}
+
 #ifdef UNBIT
 	if (PyDict_SetItemString(up.embedded_dict, "unbit", Py_True)) {
 #else
@@ -631,9 +673,17 @@ void init_uwsgi_embedded_module() {
 		init_uwsgi_module_sharedarea(new_uwsgi_module);
 	}
 
-	init_uwsgi_module_cache(new_uwsgi_module);
+	if (uwsgi.cache_max_items > 0) {
+		init_uwsgi_module_cache(new_uwsgi_module);
+	}
 
-	init_uwsgi_module_queue(new_uwsgi_module);
+	if (uwsgi.queue_size > 0) {
+		init_uwsgi_module_queue(new_uwsgi_module);
+	}
+
+	if (uwsgi.snmp) {
+		init_uwsgi_module_snmp(new_uwsgi_module);
+	}
 
 	if (up.extension) {
 		up.extension();
@@ -697,9 +747,17 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 			uwsgi_log("you can specify at most %d --pymodule-alias options\n", MAX_PYMODULE_ALIAS);
 		}
 		return 1;
+	case LONG_ARGS_PYSHELL:
+		uwsgi.honour_stdin = 1;
+		up.pyshell = 1;
+		uwsgi.to_hell = 1;
+		return 1;
 	case LONG_ARGS_PYIMPORT:
 		uwsgi_string_new_list(&up.import_list, optarg);
 		return 1;
+	case LONG_ARGS_SPOOLER_PYIMPORT:
+		uwsgi_string_new_list(&up.spooler_import_list, optarg);
+		return 1;
 	case LONG_ARGS_POST_PYMODULE_ALIAS:
 		uwsgi_string_new_list(&up.post_pymodule_alias, optarg);
 		return 1;
@@ -741,6 +799,15 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 		}
 		return 1;
 #endif
+	case LONG_ARGS_WEB3:
+		up.web3 = optarg;
+		return 1;
+	case LONG_ARGS_PUMP:
+		up.pump = optarg;
+		return 1;
+	case LONG_ARGS_WSGI_LITE:
+		up.wsgi_lite = optarg;
+		return 1;
 	case LONG_ARGS_PASTE:
 		up.paste = optarg;
 		return 1;
@@ -754,12 +821,12 @@ int uwsgi_python_manage_options(int i, char *optarg) {
 
 int uwsgi_python_mount_app(char *mountpoint, char *app) {
 
-	uwsgi.wsgi_req->script_name = mountpoint;
-	uwsgi.wsgi_req->script_name_len = strlen(mountpoint);
+	uwsgi.wsgi_req->appid = mountpoint;
+	uwsgi.wsgi_req->appid_len = strlen(mountpoint);
 	if (uwsgi.single_interpreter) {
-		return init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, up.main_thread);
+		return init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
 	}
-	return init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, NULL);
+	return init_uwsgi_app(LOADER_MOUNT, app, uwsgi.wsgi_req, NULL, PYTHON_APP_TYPE_WSGI);
 
 }
 
@@ -775,10 +842,16 @@ char *uwsgi_pythonize(char *orig) {
 	else if (!strncmp(name, "http://", 7)) {
 		name+=7;
 	}
+	else if (!strncmp(name, "data://", 7)) {
+		name+=7;
+	}
 
 	len = strlen(name);
 	for(i=0;i<len;i++) {
-		if (name[i] == '/') {
+		if (name[i] == '.') {
+			name[i] = '_';
+		}
+		else if (name[i] == '/') {
 			name[i] = '.';
 		}
 	}
@@ -792,8 +865,34 @@ char *uwsgi_pythonize(char *orig) {
 
 }
 
+void uwsgi_python_spooler_init(void) {
+
+	struct uwsgi_string_list *upli = up.spooler_import_list;
+
+	
+	UWSGI_GET_GIL
+
+        while(upli) {
+                if (strchr(upli->value, '/') || uwsgi_endswith(upli->value, ".py")) {
+                        uwsgi_pyimport_by_filename(uwsgi_pythonize(upli->value), upli->value);
+                }
+                else {
+                        if (PyImport_ImportModule(upli->value) == NULL) {
+                                PyErr_Print();
+                        }
+                }
+                upli = upli->next;
+        }
+
+	UWSGI_RELEASE_GIL
+	
+
+}
+
 void uwsgi_python_init_apps() {
 
+	struct http_status_codes *http_sc;
+
 
 	if (uwsgi.async > 1) {
 		up.current_recursion_depth = uwsgi_malloc(sizeof(int)*uwsgi.async);
@@ -885,17 +984,30 @@ void uwsgi_python_init_apps() {
 
 
 	if (up.wsgi_config != NULL) {
-		init_uwsgi_app(LOADER_UWSGI, up.wsgi_config, uwsgi.wsgi_req, up.main_thread);
+		init_uwsgi_app(LOADER_UWSGI, up.wsgi_config, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
 	}
 
 	if (up.file_config != NULL) {
-		init_uwsgi_app(LOADER_FILE, up.file_config, uwsgi.wsgi_req, up.main_thread);
+		init_uwsgi_app(LOADER_FILE, up.file_config, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
 	}
 	if (up.paste != NULL) {
-		init_uwsgi_app(LOADER_PASTE, up.paste, uwsgi.wsgi_req, up.main_thread);
+		init_uwsgi_app(LOADER_PASTE, up.paste, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
 	}
 	if (up.eval != NULL) {
-		init_uwsgi_app(LOADER_EVAL, up.eval, uwsgi.wsgi_req, up.main_thread);
+		init_uwsgi_app(LOADER_EVAL, up.eval, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
+	}
+	if (up.web3 != NULL) {
+		init_uwsgi_app(LOADER_UWSGI, up.web3, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WEB3);
+	}
+	if (up.pump != NULL) {
+		init_uwsgi_app(LOADER_UWSGI, up.pump, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_PUMP);
+		// filling http status codes
+        	for (http_sc = hsc; http_sc->message != NULL; http_sc++) {
+                	http_sc->message_size = (int) strlen(http_sc->message);
+        	}
+	}
+	if (up.wsgi_lite != NULL) {
+		init_uwsgi_app(LOADER_UWSGI, up.wsgi_lite, uwsgi.wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI_LITE);
 	}
 
 	if (uwsgi.profiler) {
@@ -975,16 +1087,16 @@ int uwsgi_python_xml(char *node, char *content) {
 	}
 
 	if (!strcmp("script", node)) {
-		return init_uwsgi_app(LOADER_UWSGI, content, uwsgi.wsgi_req, interpreter);
+		return init_uwsgi_app(LOADER_UWSGI, content, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 	}
 	else if (!strcmp("file", node)) {
-		return init_uwsgi_app(LOADER_FILE, content, uwsgi.wsgi_req, interpreter);
+		return init_uwsgi_app(LOADER_FILE, content, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 	}
 	else if (!strcmp("eval", node)) {
-		return init_uwsgi_app(LOADER_EVAL, content, uwsgi.wsgi_req, interpreter);
+		return init_uwsgi_app(LOADER_EVAL, content, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 	}
 	else if (!strcmp("wsgi", node)) {
-		return init_uwsgi_app(LOADER_EVAL, content, uwsgi.wsgi_req, interpreter);
+		return init_uwsgi_app(LOADER_EVAL, content, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 	}
 	else if (!strcmp("module", node)) {
 		uwsgi.wsgi_req->module = content;
@@ -995,10 +1107,10 @@ int uwsgi_python_xml(char *node, char *content) {
 			uwsgi.wsgi_req->callable++;
 			uwsgi.wsgi_req->callable_len = strlen(uwsgi.wsgi_req->callable);
 			uwsgi.wsgi_req->module_len = strlen(uwsgi.wsgi_req->module);
-			return init_uwsgi_app(LOADER_DYN, uwsgi.wsgi_req, uwsgi.wsgi_req, interpreter);
+			return init_uwsgi_app(LOADER_DYN, uwsgi.wsgi_req, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 		}
 		else {
-			return init_uwsgi_app(LOADER_UWSGI, content, uwsgi.wsgi_req, interpreter);
+			return init_uwsgi_app(LOADER_UWSGI, content, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 		}
 		return 1;
 	}
@@ -1010,7 +1122,7 @@ int uwsgi_python_xml(char *node, char *content) {
 	else if (!strcmp("callable", node)) {
 		uwsgi.wsgi_req->callable = content;
 		uwsgi.wsgi_req->callable_len = strlen(content);
-		return init_uwsgi_app(LOADER_DYN, uwsgi.wsgi_req, uwsgi.wsgi_req, interpreter);
+		return init_uwsgi_app(LOADER_DYN, uwsgi.wsgi_req, uwsgi.wsgi_req, interpreter, PYTHON_APP_TYPE_WSGI);
 	}
 
 	return 0;
@@ -1031,6 +1143,56 @@ void uwsgi_python_suspend(struct wsgi_request *wsgi_req) {
 
 }
 
+char *uwsgi_python_code_string(char *id, char *code, char *function, char *key, uint16_t keylen) {
+
+	PyObject *cs_module = NULL;
+	PyObject *cs_dict = NULL;
+
+	UWSGI_GET_GIL;
+
+	cs_module = PyImport_ImportModule(id);
+	if (!cs_module) {
+		PyErr_Clear();
+		cs_module = uwsgi_pyimport_by_filename(id, code);
+	}
+
+	if (!cs_module) {
+		UWSGI_RELEASE_GIL;
+		return NULL;
+	}
+
+	cs_dict = PyModule_GetDict(cs_module);
+	if (!cs_dict) {
+		PyErr_Print();
+		UWSGI_RELEASE_GIL;
+		return NULL;
+	}
+	
+	PyObject *func = PyDict_GetItemString(cs_dict, function);
+	if (!func) {
+		uwsgi_log("function %s not available in %s\n", function, code);
+		PyErr_Print();
+		UWSGI_RELEASE_GIL;
+		return NULL;
+	}
+
+	PyObject *args = PyTuple_New(1);
+
+	PyTuple_SetItem(args, 0, PyString_FromStringAndSize(key, keylen));
+
+	PyObject *ret = python_call(func, args, 0, NULL);
+	Py_DECREF(args);
+	if (ret && PyString_Check(ret)) {
+		char *val = PyString_AsString(ret);
+		UWSGI_RELEASE_GIL;
+		return val;
+	}
+
+	UWSGI_RELEASE_GIL;
+	return NULL;
+	
+}
+
 int uwsgi_python_signal_handler(uint8_t sig, void *handler) {
 
 	UWSGI_GET_GIL;
@@ -1046,8 +1208,8 @@ int uwsgi_python_signal_handler(uint8_t sig, void *handler) {
 
 	PyTuple_SetItem(args, 0, PyInt_FromLong(sig));
 
-	ret = python_call(handler, args, 0);
-
+	ret = python_call(handler, args, 0, NULL);
+	Py_DECREF(args);
 	if (ret) {
 		UWSGI_RELEASE_GIL;
 		return 0;
@@ -1073,7 +1235,7 @@ uint16_t uwsgi_python_rpc(void *func, uint8_t argc, char **argv, char *buffer) {
 		PyTuple_SetItem(pyargs, i, PyString_FromString(argv[i]));
 	}
 
-	ret = python_call((PyObject *) func, pyargs, 0);
+	ret = python_call((PyObject *) func, pyargs, 0, NULL);
 
 	if (ret) {
 		if (PyString_Check(ret)) {
@@ -1143,8 +1305,9 @@ int uwsgi_python_spooler(char *filename, char *buf, uint16_t len, char *body, si
 		PyDict_SetItemString(spool_dict, "body", PyString_FromStringAndSize(body, body_len));
 	}
 	PyTuple_SetItem(pyargs, 0, spool_dict);
-	
-	ret = python_call(spool_func, pyargs, 0);
+
+	ret = python_call(spool_func, pyargs, 0, NULL);
+
 	if (ret) {
 		if (!PyInt_Check(ret)) {
 			// error, retry
@@ -1186,6 +1349,17 @@ void uwsgi_python_fixup() {
 	uwsgi.p[30] = uwsgi.p[0];
 }
 
+void uwsgi_python_hijack(void) {
+	// the pyshell will be execute only in the first worker
+
+	if (up.pyshell && uwsgi.mywid == 1) {
+		UWSGI_GET_GIL;
+		PyImport_ImportModule("readline");
+		PyRun_InteractiveLoop(stdin, "uwsgi");
+		exit(0);
+	}
+}
+
 struct uwsgi_plugin python_plugin = {
 
 	.name = "python",
@@ -1214,11 +1388,16 @@ struct uwsgi_plugin python_plugin = {
 	.suspend = uwsgi_python_suspend,
 	.resume = uwsgi_python_resume,
 
+	.hijack_worker = uwsgi_python_hijack,
+	.spooler_init = uwsgi_python_spooler_init,
+
 	.signal_handler = uwsgi_python_signal_handler,
 	.rpc = uwsgi_python_rpc,
 
 	.spooler = uwsgi_python_spooler,
 
+	.code_string = uwsgi_python_code_string,
+
 	.help = uwsgi_python_help,
 
 };

plugins/python/pyutils.c

@@ -8,7 +8,7 @@ int manage_python_response(struct wsgi_request *wsgi_req) {
 	return uwsgi_response_subhandler_wsgi(wsgi_req);
 }
 
-PyObject *python_call(PyObject *callable, PyObject *args, int catch) {
+PyObject *python_call(PyObject *callable, PyObject *args, int catch, struct wsgi_request *wsgi_req) {
 
 	PyObject *pyret;
 
@@ -22,7 +22,13 @@ PyObject *python_call(PyObject *callable, PyObject *args, int catch) {
 		if (PyErr_ExceptionMatches(PyExc_MemoryError)) {
 			uwsgi_log("Memory Error detected !!!\n");
 		}
-		uwsgi.workers[uwsgi.mywid].exceptions++;
+		// this can be in a spooler or in the master
+		if (uwsgi.mywid > 0) {
+			uwsgi.workers[uwsgi.mywid].exceptions++;
+			if (wsgi_req) {
+				uwsgi_apps[wsgi_req->app_id].exceptions++;
+			}
+		}
 		if (!catch) {
 			PyErr_Print();
 		}
@@ -39,7 +45,7 @@ PyObject *python_call(PyObject *callable, PyObject *args, int catch) {
 
 int uwsgi_python_call(struct wsgi_request *wsgi_req, PyObject *callable, PyObject *args) {
 
-	wsgi_req->async_result = python_call(callable, args, 0);
+	wsgi_req->async_result = python_call(callable, args, 0, wsgi_req);
 
 	if (wsgi_req->async_result) {
 		while ( manage_python_response(wsgi_req) != UWSGI_OK) {

plugins/python/symimporter.c

@@ -1,5 +1,7 @@
 #include "uwsgi_python.h"
 
+#ifndef PYTHREE
+
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
@@ -8,6 +10,14 @@ struct _symimporter {
 	PyObject_HEAD;
 } uwsgi_symbol_importer_object;
 
+struct _symzipimporter {
+	PyObject_HEAD;
+	char *prefix;
+	PyObject *zip;
+        PyObject *items;
+} uwsgi_symbol_zip_importer_object;
+
+
 static char *symbolize(char *name) {
 
 	char *base = uwsgi_concat2(name, "");
@@ -22,6 +32,84 @@ static char *symbolize(char *name) {
 	return base;
 }
 
+static char *name_to_py(char *prefix, char *name) {
+
+	char *base;
+	char *ptr;
+
+	if (prefix) {
+		if (prefix[strlen(prefix)-1] == '/') { 
+        		base = uwsgi_concat3(prefix, name, ".py");
+			ptr = base + strlen(prefix);
+		}
+		else {
+        		base = uwsgi_concat4(prefix, "/", name, ".py");
+			ptr = base + strlen(prefix) + 1;
+		}
+	}
+	else {
+        	base = uwsgi_concat2(name, ".py");
+		ptr = base;
+	}
+        while(*ptr != 0) {
+                if (*ptr == '.') {
+                        *ptr = '/';
+                }
+                ptr++;
+        }
+
+	// fix .py
+	ptr-=3;
+	*ptr = '.';
+        return base;
+}
+
+static char *name_to_init_py(char *prefix, char *name) {
+
+	char *base;
+	char *ptr;
+
+	if (prefix) {
+		if (prefix[strlen(prefix)-1] == '/') { 
+        		base = uwsgi_concat3(prefix, name, "/__init__.py");
+			ptr = base + strlen(prefix);
+		}
+		else {
+        		base = uwsgi_concat4(prefix, "/", name, "/__init__.py");
+			ptr = base + strlen(prefix) + 1;
+		}
+	}
+	else {
+        	base = uwsgi_concat2(name, "/__init__.py");
+		ptr = base;
+	}
+
+        while(*ptr != 0) {
+                if (*ptr == '.') {
+                        *ptr = '/';
+                }
+                ptr++;
+        }
+
+        // fix .py
+        ptr-=3;
+        *ptr = '.';
+
+        return base;
+}
+
+
+
+
+static char *name_to_symbol(char *name, char *what) {
+
+        char *symbol = uwsgi_concat4("_binary_", name, "_", what);
+        char *sym_ptr_start = dlsym(RTLD_DEFAULT, symbol);
+        free(symbol);
+        return sym_ptr_start;
+}
+
+
 static char *name_to_symbol_module(char *name, char *what) {
 
 	char *symbol = uwsgi_concat4("_binary_", name, "_py_", what);
@@ -38,6 +126,127 @@ static char *name_to_symbol_pkg(char *name, char *what) {
 	return sym_ptr_start;
 }
 
+int py_list_has_string(PyObject *obj, char *name) {
+
+	Py_ssize_t i, len = PyList_Size(obj);
+	int found = 0;
+	for(i=0;i<len;i++) {
+		PyObject *current = PyList_GetItem(obj, i);
+		char *filename = PyString_AsString(current);
+		if (!strcmp(filename, name)) {
+			found = 1;
+			break;
+		}
+	}
+
+	return found;
+}
+
+static PyObject* symzipimporter_find_module(PyObject *self, PyObject *args) {
+
+	char *fullname;
+	PyObject *path = NULL;
+	struct _symzipimporter *this = (struct _symzipimporter *) self;
+
+	if (!PyArg_ParseTuple(args, "s|O:find_module", &fullname, &path)) {
+		return NULL;
+	}
+
+	char *filename = name_to_py(this->prefix, fullname);
+
+	if (py_list_has_string(this->items, filename)) {
+		free(filename);
+		return self;
+	}
+
+	PyErr_Clear();
+	free(filename);
+
+	filename = name_to_init_py(this->prefix, fullname);
+
+	if (py_list_has_string(this->items, filename)) {
+		free(filename);
+		return self;
+	}
+
+	PyErr_Clear();
+	free(filename);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject* symzipimporter_load_module(PyObject *self, PyObject *args) {
+
+	char *fullname;
+	char *modname;
+        struct _symzipimporter *this = (struct _symzipimporter *) self;
+
+        if (!PyArg_ParseTuple(args, "s:load_module", &fullname)) {
+                return NULL;
+        }
+
+        char *filename = name_to_py(this->prefix, fullname);
+
+        if (py_list_has_string(this->items, filename)) {
+		PyObject *mod = PyImport_AddModule(fullname);
+                if (!mod) goto clear;
+                PyObject *dict = PyModule_GetDict(mod);
+                if (!dict) goto clear;
+
+                PyDict_SetItemString(dict, "__loader__", self);
+
+                modname = uwsgi_concat2("symzip://", fullname);
+
+		PyObject *source = PyObject_CallMethod(this->zip, "read", "(s)", filename);
+                free(filename);
+                PyObject *code = Py_CompileString(PyString_AsString(source), modname, Py_file_input);
+                mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
+
+                Py_DECREF(code);
+                Py_DECREF(source);
+                free(modname);
+                return mod;
+        }
+
+        PyErr_Clear();
+        free(filename);
+
+        filename = name_to_init_py(this->prefix, fullname);
+
+        if (py_list_has_string(this->items, filename)) {
+		PyObject *mod = PyImport_AddModule(fullname);
+                if (!mod) goto clear;
+                PyObject *dict = PyModule_GetDict(mod);
+                if (!dict) goto clear;
+
+                modname = uwsgi_concat2("symzip://", fullname);
+
+		PyObject *pkgpath = Py_BuildValue("[O]", PyString_FromString(modname));
+
+                PyDict_SetItemString(dict, "__path__", pkgpath);
+                PyDict_SetItemString(dict, "__loader__", self);
+
+
+                PyObject *source = PyObject_CallMethod(this->zip, "read", "(s)", filename);
+                free(filename);
+                PyObject *code = Py_CompileString(PyString_AsString(source), modname, Py_file_input);
+                mod = PyImport_ExecCodeModuleEx(fullname, code, modname);
+
+                Py_DECREF(code);
+                Py_DECREF(source);
+                free(modname);
+                return mod;
+        }
+
+clear:
+        PyErr_Clear();
+        free(filename);
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
 static PyObject* symimporter_find_module(PyObject *self, PyObject *args) {
 
 	char *fullname;
@@ -142,8 +351,15 @@ clear:
 }
 
 static PyMethodDef symimporter_methods[] = {
-    {"find_module", symimporter_find_module, METH_VARARGS},
-    {"load_module", symimporter_load_module, METH_VARARGS},
+	{"find_module", symimporter_find_module, METH_VARARGS},
+ 	{"load_module", symimporter_load_module, METH_VARARGS},
+	{ NULL, NULL },
+};
+
+static PyMethodDef symzipimporter_methods[] = {
+	{"find_module", symzipimporter_find_module, METH_VARARGS},
+	{"load_module", symzipimporter_load_module, METH_VARARGS},
+	{ NULL, NULL },
 };
 
 static void uwsgi_symimporter_free(struct _symimporter *self) {
@@ -193,6 +409,288 @@ static PyTypeObject SymImporter_Type = {
     PyObject_GC_Del,                            /* tp_free */
 };
 
+static int
+zipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
+{
+
+
+        char *name;
+        char *prefix = NULL;
+	int len = 0;
+
+        if (!PyArg_ParseTuple(args, "s", &name))
+                return -1;
+
+        // avoid GC !!!
+        name = uwsgi_concat2(name, "");
+
+	if (!uwsgi_startswith(name, "http://", 7) || !uwsgi_startswith(name, "data://", 7) || !uwsgi_startswith(name, "sym://", 6) ) {
+                prefix = uwsgi_get_last_char(name, '/');
+                prefix = uwsgi_get_last_char(prefix, ':');
+        }
+        else {
+                prefix = uwsgi_get_last_char(name, ':');
+        }
+
+	if (prefix) {
+		prefix[0] = 0;
+	}
+
+
+	char *body = uwsgi_open_and_read(name, &len, 0, NULL);
+	if (!body) {
+		return -1;
+	}
+
+	PyObject *stringio = PyImport_ImportModule("StringIO");
+        if (!stringio) {
+                return -1;
+        }
+
+        PyObject *stringio_dict = PyModule_GetDict(stringio);
+        if (!stringio_dict) {
+                return -1;
+        }
+
+        PyObject *stringio_stringio = PyDict_GetItemString(stringio_dict, "StringIO");
+        if (!stringio_stringio) {
+                return -1;
+        }
+
+        PyObject *stringio_args = PyTuple_New(1);
+        PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(body, len));
+
+        PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+        if (!source_code) {
+                return -1;
+        }
+
+        PyObject *zipfile = PyImport_ImportModule("zipfile");
+        if (!zipfile) {
+                return -1;
+        }
+
+        PyObject *zipfile_dict = PyModule_GetDict(zipfile);
+        if (!zipfile_dict) {
+                return -1;
+        }
+
+        PyObject *zipfile_zipfile = PyDict_GetItemString(zipfile_dict, "ZipFile");
+        if (!zipfile_zipfile) {
+                return -1;
+        }
+
+        PyObject *zipfile_args = PyTuple_New(1);
+        PyTuple_SetItem(zipfile_args, 0, source_code);
+
+        self->zip = PyInstance_New(zipfile_zipfile, zipfile_args, NULL);
+        if (!self->zip) {
+                return -1;
+        }
+
+        Py_INCREF(self->zip);
+
+        self->items = PyObject_CallMethod(self->zip, "namelist", NULL);
+        if (!self->items) {
+                return -1;
+        }
+
+        Py_INCREF(self->items);
+
+        self->prefix = NULL;
+        if (prefix) {
+                self->prefix = prefix+1;
+                prefix[0] = ':';
+        }
+
+
+        return 0;
+}
+
+
+
+static int
+symzipimporter_init(struct _symzipimporter *self, PyObject *args, PyObject *kwds)
+{
+
+
+	char *name;
+	char *prefix = NULL;
+
+	if (!PyArg_ParseTuple(args, "s", &name))
+        	return -1; 
+
+	// avoid GC !!!
+	name = uwsgi_concat2(name, "");
+
+	prefix = strchr(name, ':');
+	if (prefix) {
+		prefix[0] = 0;
+	}
+
+	char *code_start = name_to_symbol(name, "start");
+	if (!code_start) {
+		PyErr_Format(PyExc_ValueError, "unable to find symbol");
+		return -1;
+	}
+
+	char *code_end = name_to_symbol(name, "end");
+	if (!code_end) {
+		PyErr_Format(PyExc_ValueError, "unable to find symbol");
+		return -1;
+	}
+
+	PyObject *stringio = PyImport_ImportModule("StringIO");
+	if (!stringio) {
+		return -1;
+	}
+
+	PyObject *stringio_dict = PyModule_GetDict(stringio);
+	if (!stringio_dict) {
+		return -1;
+	}
+
+	PyObject *stringio_stringio = PyDict_GetItemString(stringio_dict, "StringIO");
+	if (!stringio_stringio) {
+		return -1;
+	}
+
+	PyObject *stringio_args = PyTuple_New(1);
+	PyTuple_SetItem(stringio_args, 0, PyString_FromStringAndSize(code_start, code_end-code_start));
+
+	PyObject *source_code = PyInstance_New(stringio_stringio, stringio_args, NULL);
+	if (!source_code) {
+		return -1;
+	}
+
+	PyObject *zipfile = PyImport_ImportModule("zipfile");
+	if (!zipfile) {
+		return -1;
+	}
+	
+	PyObject *zipfile_dict = PyModule_GetDict(zipfile);
+        if (!zipfile_dict) {
+                return -1;
+        }
+
+        PyObject *zipfile_zipfile = PyDict_GetItemString(zipfile_dict, "ZipFile");
+        if (!zipfile_zipfile) {
+                return -1;
+        }
+
+        PyObject *zipfile_args = PyTuple_New(1);
+        PyTuple_SetItem(zipfile_args, 0, source_code);
+
+	self->zip = PyInstance_New(zipfile_zipfile, zipfile_args, NULL);
+        if (!self->zip) {
+                return -1;
+        }
+
+	Py_INCREF(self->zip);
+
+	self->items = PyObject_CallMethod(self->zip, "namelist", NULL);
+        if (!self->items) {
+                return -1;
+        }
+
+	Py_INCREF(self->items);
+
+	self->prefix = NULL;
+	if (prefix) {
+		self->prefix = prefix+1;
+		prefix[0] = ':';
+	}
+
+
+	return 0;
+}
+
+static PyTypeObject SymZipImporter_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "uwsgi.SymbolsZipImporter",
+    sizeof(struct _symzipimporter),
+    0,                                          /* tp_itemsize */
+    (destructor) uwsgi_symimporter_free,            /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_compare */
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,
+    "uwsgi symbols zip importer",                                          /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    symzipimporter_methods,                        /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    (initproc) symzipimporter_init,                 /* tp_init */
+    PyType_GenericAlloc,                        /* tp_alloc */
+    PyType_GenericNew,                          /* tp_new */
+    PyObject_GC_Del,                            /* tp_free */
+};
+
+static PyTypeObject ZipImporter_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "uwsgi.ZipImporter",
+    sizeof(struct _symzipimporter),
+    0,                                          /* tp_itemsize */
+    (destructor) uwsgi_symimporter_free,            /* tp_dealloc */
+    0,                                          /* tp_print */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_compare */
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                    /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT,
+    "uwsgi zip importer",                                          /* tp_doc */
+    0,                                          /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    symzipimporter_methods,                        /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    (initproc) zipimporter_init,                 /* tp_init */
+    PyType_GenericAlloc,                        /* tp_alloc */
+    PyType_GenericNew,                          /* tp_new */
+    PyObject_GC_Del,                            /* tp_free */
+};
+
+
+
 int uwsgi_init_symbol_import() {
 
 
@@ -202,6 +700,18 @@ int uwsgi_init_symbol_import() {
 		exit(1);
 	}
 
+	if (PyType_Ready(&ZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize zip importer module\n");
+		exit(1);
+	}
+
+	if (PyType_Ready(&SymZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols zip importer module\n");
+		exit(1);
+	}
+
 	PyObject *uwsgi_em = PyImport_ImportModule("uwsgi");
 	if (!uwsgi_em) {
 		PyErr_Print();
@@ -209,6 +719,7 @@ int uwsgi_init_symbol_import() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *)&SymImporter_Type);
 	if (PyModule_AddObject(uwsgi_em, "SymbolsImporter",
                            (PyObject *)&SymImporter_Type) < 0) {
 		PyErr_Print();
@@ -216,7 +727,25 @@ int uwsgi_init_symbol_import() {
 		exit(1);
 	}
 
+	Py_INCREF((PyObject *)&ZipImporter_Type);
+	if (PyModule_AddObject(uwsgi_em, "ZipImporter",
+                           (PyObject *)&ZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize zip importer object\n");
+		exit(1);
+	}
+
+	Py_INCREF((PyObject *)&SymZipImporter_Type);
+	if (PyModule_AddObject(uwsgi_em, "SymbolsZipImporter",
+                           (PyObject *)&SymZipImporter_Type) < 0) {
+		PyErr_Print();
+		uwsgi_log("unable to initialize symbols zip importer object\n");
+		exit(1);
+	}
+
+
         return 0;
 	
 }
 
+#endif

plugins/python/uwsgi_pymodule.c

@@ -830,7 +830,6 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 	size_t chunk;
 	off_t pos = 0;
 	size_t filesize = 0;
-	struct stat stat_buf;
 	struct wsgi_request *wsgi_req = current_wsgi_req();
 
 	int fd = -1;
@@ -839,17 +838,29 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 		return NULL;
 	}
 
+
 	if (PyString_Check(what)) {
 
 		filename = PyString_AsString(what);
 
 		fd = open(filename, O_RDONLY);
 		if (fd < 0) {
-			uwsgi_error("open");
+			uwsgi_error_open(filename);
 			goto clear;
 		}
 
 	}
+#ifdef PYTHREE
+	else if (PyUnicode_Check(what)) {
+		filename = PyBytes_AsString(PyUnicode_AsASCIIString(what));
+
+		fd = open(filename, O_RDONLY);
+		if (fd < 0) {
+			uwsgi_error_open(filename);
+			goto clear;
+		}
+	}
+#endif
 	else {
 		fd = PyObject_AsFileDescriptor(what);
 		if (fd < 0)
@@ -861,31 +872,30 @@ PyObject *py_uwsgi_advanced_sendfile(PyObject * self, PyObject * args) {
 		}
 	}
 
-	if (!filesize) {
-		if (fstat(fd, &stat_buf)) {
-			uwsgi_error("fstat()");
-			goto clear2;
-		}
-		else {
-			filesize = stat_buf.st_size;
-		}
+	int tmp_fd = wsgi_req->sendfile_fd;
+	size_t tmp_filesize = wsgi_req->sendfile_fd_size;
+	size_t tmp_chunk = wsgi_req->sendfile_fd_chunk;
+	off_t tmp_pos = wsgi_req->sendfile_fd_pos;
 
-	}
+	wsgi_req->sendfile_fd = fd;
+	wsgi_req->sendfile_fd_size = filesize;
+	wsgi_req->sendfile_fd_chunk = chunk;
+	wsgi_req->sendfile_fd_pos = pos;
 
-	if (!filesize)
-		goto clear2;
+	// do sendfile
+	wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
 
-	if (!chunk)
-		chunk = 4096;
-
-	uwsgi.wsgi_req->response_size += uwsgi_do_sendfile(wsgi_req->poll.fd, fd, filesize, chunk, &pos, 0);
+	// revert to old values
+	wsgi_req->sendfile_fd = tmp_fd;
+	wsgi_req->sendfile_fd_size = tmp_filesize;
+	wsgi_req->sendfile_fd_chunk = tmp_chunk;
+	wsgi_req->sendfile_fd_pos = tmp_pos;
+	
 
 	close(fd);
 	Py_INCREF(Py_True);
 	return Py_True;
 
-      clear2:
-	close(fd);
       clear:
 	Py_INCREF(Py_None);
 	return Py_None;
@@ -1009,81 +1019,102 @@ PyObject *py_uwsgi_embedded_data(PyObject * self, PyObject * args) {
 }
 
 PyObject *py_uwsgi_sharedarea_inclong(PyObject * self, PyObject * args) {
-	int pos = 0;
-	long value = 0;
+	uint64_t pos = 0;
+	uint64_t value = 1;
+	uint64_t current_value = 0;
 
 	if (uwsgi.sharedareasize <= 0) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	if (!PyArg_ParseTuple(args, "ii:sharedarea_inclong", &pos, &value)) {
+	if (!PyArg_ParseTuple(args, "l|l:sharedarea_inclong", &pos, &value)) {
 		return NULL;
 	}
 
-	if (pos + 4 >= uwsgi.page_size * uwsgi.sharedareasize) {
+	if (pos + 8 >= uwsgi.page_size * uwsgi.sharedareasize) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	memcpy(&value, uwsgi.sharedarea + pos, 4);
-	value++;
-	memcpy(uwsgi.sharedarea + pos, &value, 4);
+	uwsgi_wlock(uwsgi.sa_lock);
 
-	return PyInt_FromLong(value);
+	memcpy(&current_value, uwsgi.sharedarea + pos, 8);
+	value = current_value + value;
+	memcpy(uwsgi.sharedarea + pos, &value, 8);
+
+	PyObject *ret = PyInt_FromLong(value);
+
+        uwsgi_rwunlock(uwsgi.sa_lock);
+
+	return ret;
 
 }
 
 PyObject *py_uwsgi_sharedarea_writelong(PyObject * self, PyObject * args) {
-	int pos = 0;
-	long value;
+	uint64_t pos = 0;
+	uint64_t value = 0;
 
 	if (uwsgi.sharedareasize <= 0) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	if (!PyArg_ParseTuple(args, "ii:sharedarea_writelong", &pos, &value)) {
+	if (!PyArg_ParseTuple(args, "ll:sharedarea_writelong", &pos, &value)) {
 		return NULL;
 	}
 
-	if (pos + 4 >= uwsgi.page_size * uwsgi.sharedareasize) {
+	if (pos + 8 >= uwsgi.page_size * uwsgi.sharedareasize) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	memcpy(uwsgi.sharedarea + pos, &value, 4);
+	uwsgi_wlock(uwsgi.sa_lock);
 
-	return PyInt_FromLong(value);
+	memcpy(uwsgi.sharedarea + pos, &value, 8);
+
+
+	PyObject *ret = PyInt_FromLong(value);
+
+        uwsgi_rwunlock(uwsgi.sa_lock);
+
+	return ret;
 
 }
 
 PyObject *py_uwsgi_sharedarea_write(PyObject * self, PyObject * args) {
-	int pos = 0;
+	uint64_t pos = 0;
 	char *value;
+	Py_ssize_t value_len = 0;
 
 	if (uwsgi.sharedareasize <= 0) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	if (!PyArg_ParseTuple(args, "is:sharedarea_write", &pos, &value)) {
+	if (!PyArg_ParseTuple(args, "ls#:sharedarea_write", &pos, &value, &value_len)) {
 		return NULL;
 	}
 
-	if (pos + (int) strlen(value) >= uwsgi.page_size * uwsgi.sharedareasize) {
+	if (pos + value_len >= uwsgi.page_size * uwsgi.sharedareasize) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	memcpy(uwsgi.sharedarea + pos, value, strlen(value));
+	uwsgi_wlock(uwsgi.sa_lock);
 
-	return PyInt_FromLong(strlen(value));
+	memcpy(uwsgi.sharedarea + pos, value, value_len);
+
+	PyObject *ret = PyInt_FromLong(value_len);
+
+	uwsgi_rwunlock(uwsgi.sa_lock);
+	
+	return ret;
 
 }
 
 PyObject *py_uwsgi_sharedarea_writebyte(PyObject * self, PyObject * args) {
-	int pos = 0;
+	uint64_t pos = 0;
 	char value;
 
 	if (uwsgi.sharedareasize <= 0) {
@@ -1092,7 +1123,7 @@ PyObject *py_uwsgi_sharedarea_writebyte(PyObject * self, PyObject * args) {
 	}
 
 
-	if (!PyArg_ParseTuple(args, "ib:sharedarea_writebyte", &pos, &value)) {
+	if (!PyArg_ParseTuple(args, "lb:sharedarea_writebyte", &pos, &value)) {
 		return NULL;
 	}
 
@@ -1101,46 +1132,58 @@ PyObject *py_uwsgi_sharedarea_writebyte(PyObject * self, PyObject * args) {
 		return Py_None;
 	}
 
+	uwsgi_wlock(uwsgi.sa_lock);
+
 	uwsgi.sharedarea[pos] = value;
 
-	return PyInt_FromLong(uwsgi.sharedarea[pos]);
+	PyObject *ret = PyInt_FromLong(uwsgi.sharedarea[pos]);
+
+	uwsgi_rwunlock(uwsgi.sa_lock);
+
+	return ret;
 
 }
 
 PyObject *py_uwsgi_sharedarea_readlong(PyObject * self, PyObject * args) {
-	int pos = 0;
-	long value;
+	uint64_t pos = 0;
+	uint64_t value;
 
 	if (uwsgi.sharedareasize <= 0) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	if (!PyArg_ParseTuple(args, "i:sharedarea_readlong", &pos)) {
+	if (!PyArg_ParseTuple(args, "l:sharedarea_readlong", &pos)) {
 		return NULL;
 	}
 
-	if (pos + 4 >= uwsgi.page_size * uwsgi.sharedareasize) {
+	if (pos + 8 >= uwsgi.page_size * uwsgi.sharedareasize) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	memcpy(&value, uwsgi.sharedarea + pos, 4);
+	uwsgi_wlock(uwsgi.sa_lock);
 
-	return PyInt_FromLong(value);
+	memcpy(&value, uwsgi.sharedarea + pos, 8);
+
+	PyObject *ret = PyLong_FromLong(value);
+
+	uwsgi_rwunlock(uwsgi.sa_lock);
+
+	return ret;
 
 }
 
 
 PyObject *py_uwsgi_sharedarea_readbyte(PyObject * self, PyObject * args) {
-	int pos = 0;
+	uint64_t pos = 0;
 
 	if (uwsgi.sharedareasize <= 0) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	if (!PyArg_ParseTuple(args, "i:sharedarea_readbyte", &pos)) {
+	if (!PyArg_ParseTuple(args, "l:sharedarea_readbyte", &pos)) {
 		return NULL;
 	}
 
@@ -1149,20 +1192,26 @@ PyObject *py_uwsgi_sharedarea_readbyte(PyObject * self, PyObject * args) {
 		return Py_None;
 	}
 
-	return PyInt_FromLong(uwsgi.sharedarea[pos]);
+	uwsgi_wlock(uwsgi.sa_lock);
+
+	PyObject *ret = PyInt_FromLong(uwsgi.sharedarea[pos]);
+
+	uwsgi_rwunlock(uwsgi.sa_lock);
+
+	return ret;
 
 }
 
 PyObject *py_uwsgi_sharedarea_read(PyObject * self, PyObject * args) {
-	int pos = 0;
-	int len = 1;
+	uint64_t pos = 0;
+	uint64_t len = 1;
 
 	if (uwsgi.sharedareasize <= 0) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
-	if (!PyArg_ParseTuple(args, "i|i:sharedarea_read", &pos, &len)) {
+	if (!PyArg_ParseTuple(args, "l|l:sharedarea_read", &pos, &len)) {
 		return NULL;
 	}
 
@@ -1171,7 +1220,13 @@ PyObject *py_uwsgi_sharedarea_read(PyObject * self, PyObject * args) {
 		return Py_None;
 	}
 
-	return PyString_FromStringAndSize(uwsgi.sharedarea + pos, len);
+	uwsgi_wlock(uwsgi.sa_lock);
+
+	PyObject *ret = PyString_FromStringAndSize(uwsgi.sharedarea + pos, len);
+
+	uwsgi_rwunlock(uwsgi.sa_lock);
+
+	return ret;
 }
 
 #ifdef UWSGI_SPOOLER
@@ -2083,8 +2138,9 @@ PyObject *py_uwsgi_total_requests(PyObject * self, PyObject * args) {
 	/* uWSGI workers */
 PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 
-	PyObject *worker_dict, *zero;
-	int i;
+	PyObject *worker_dict, *apps_dict, *apps_tuple, *zero;
+	int i, j;
+	struct uwsgi_app *ua;
 
 	for (i = 0; i < uwsgi.numproc; i++) {
 		worker_dict = PyTuple_GetItem(up.workers_tuple, i);
@@ -2157,6 +2213,43 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 		   Py_DECREF(zero);
 		 */
 
+		apps_tuple = PyTuple_New(uwsgi.workers[i+1].apps_cnt);
+
+		for(j=0;j<uwsgi.workers[i+1].apps_cnt;j++) {
+			apps_dict = PyDict_New();
+			ua = &uwsgi.workers[i+1].apps[j];
+
+			PyDict_SetItemString(apps_dict, "id", PyInt_FromLong(j));
+
+			PyDict_SetItemString(apps_dict, "modifier1", PyInt_FromLong(ua->modifier1));
+
+			zero = PyString_FromStringAndSize(ua->mountpoint, ua->mountpoint_len);
+			PyDict_SetItemString(apps_dict, "mountpoint", zero);
+			Py_DECREF(zero);
+
+			PyDict_SetItemString(apps_dict, "interpreter", PyInt_FromLong((long)ua->interpreter));
+			PyDict_SetItemString(apps_dict, "callable", PyInt_FromLong((long)ua->interpreter));
+
+			PyDict_SetItemString(apps_dict, "requests", PyInt_FromLong(ua->requests));
+			PyDict_SetItemString(apps_dict, "exceptions", PyInt_FromLong(ua->exceptions));
+
+			if (ua->chdir) {
+				zero = PyString_FromString(ua->chdir);
+			}
+			else {
+				zero = PyString_FromString("");
+			}
+			PyDict_SetItemString(apps_dict, "chdir", zero);
+			Py_DECREF(zero);
+
+			PyTuple_SetItem(apps_tuple, j, apps_dict);
+
+		}
+	
+
+		PyDict_SetItemString(worker_dict, "apps", apps_tuple);
+		Py_DECREF(apps_tuple);
+
 	}
 
 
@@ -2171,6 +2264,7 @@ PyObject *py_uwsgi_workers(PyObject * self, PyObject * args) {
 
 }
 
+
 	/* uWSGI reload */
 PyObject *py_uwsgi_reload(PyObject * self, PyObject * args) {
 
@@ -2239,7 +2333,9 @@ PyObject *py_uwsgi_disconnect(PyObject * self, PyObject * args) {
 	uwsgi_log("disconnecting worker %d (pid :%d) from session...\n", uwsgi.mywid, uwsgi.mypid);
 #endif
 
-	fclose(wsgi_req->async_post);
+	if (wsgi_req->socket) {
+		wsgi_req->socket->proto_close(wsgi_req);
+	}
 	wsgi_req->fd_closed = 1;
 
 	Py_INCREF(Py_True);
@@ -2396,7 +2492,9 @@ PyObject *py_uwsgi_grunt(PyObject * self, PyObject * args) {
 
 	// close connection on the worker
 	if (PyTuple_Size(args) == 0) {
-		fclose(wsgi_req->async_post);
+		if (wsgi_req->socket) {
+			wsgi_req->socket->proto_close(wsgi_req);
+		}
 		wsgi_req->fd_closed = 1;
 	}
 
@@ -2673,6 +2771,43 @@ PyObject *py_uwsgi_cache_set(PyObject * self, PyObject * args) {
 
 }
 
+PyObject *py_uwsgi_cache_update(PyObject * self, PyObject * args) {
+
+        char *key;
+        char *value;
+        Py_ssize_t vallen = 0;
+        Py_ssize_t keylen = 0;
+        char *remote = NULL;
+
+        uint64_t expires = 0;
+
+        if (!PyArg_ParseTuple(args, "s#s#|is:cache_update", &key, &keylen, &value, &vallen, &expires, &remote)) {
+                return NULL;
+        }
+
+        if ((uint64_t)vallen > uwsgi.cache_blocksize) {
+                return PyErr_Format(PyExc_ValueError, "uWSGI cache items size must be < %llu, requested %d bytes", (unsigned long long)uwsgi.cache_blocksize, (int) vallen);
+        }
+
+        if (remote && strlen(remote) > 0) {
+                uwsgi_simple_send_string2(remote, 111, 1, key, keylen, value, vallen, uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
+        }
+        else if (uwsgi.cache_max_items) {
+                uwsgi_wlock(uwsgi.cache_lock);
+                if (uwsgi_cache_set(key, keylen, value, vallen, expires, UWSGI_CACHE_FLAG_UPDATE)) {
+                        uwsgi_rwunlock(uwsgi.cache_lock);
+                        Py_INCREF(Py_None);
+                        return Py_None;
+                }
+                uwsgi_rwunlock(uwsgi.cache_lock);
+        }
+
+        Py_INCREF(Py_True);
+        return Py_True;
+
+}
+
+
 
 PyObject *py_uwsgi_cache_exists(PyObject * self, PyObject * args) {
 
@@ -2734,25 +2869,58 @@ PyObject *py_uwsgi_queue_push(PyObject * self, PyObject * args) {
 	
 }
 
+PyObject *py_uwsgi_queue_set(PyObject * self, PyObject * args) {
+
+        Py_ssize_t msglen = 0;
+	uint64_t pos = 0;
+        char *message ;
+        PyObject *res;
+
+        if (!PyArg_ParseTuple(args, "ls#:queue_set", &pos, &message, &msglen)) {
+                return NULL;
+        }
+
+        if (uwsgi.queue_size) {
+                uwsgi_wlock(uwsgi.queue_lock);
+                if (uwsgi_queue_set(pos, message, msglen)) {
+                        Py_INCREF(Py_True);
+                        res = Py_True;
+                }
+                else {
+                        Py_INCREF(Py_None);
+                        res = Py_None;
+                }
+                uwsgi_rwunlock(uwsgi.queue_lock);
+                return res;
+        }
+
+        Py_INCREF(Py_None);
+        return Py_None;
+
+}
+
+
 PyObject *py_uwsgi_queue_slot(PyObject * self, PyObject * args) {
 
-	return PyInt_FromLong(uwsgi.shared->queue_pos);
+	return PyInt_FromLong(uwsgi.queue_header->pos);
 }
 
+PyObject *py_uwsgi_queue_pull_slot(PyObject * self, PyObject * args) {
+
+	return PyInt_FromLong(uwsgi.queue_header->pull_pos);
+}
+
+
 PyObject *py_uwsgi_queue_pull(PyObject * self, PyObject * args) {
 
 	char *message;
 	uint64_t size;
 	PyObject *res;
 
-	if (!PyArg_ParseTuple(args, ":queue_pull")) {
-                return NULL;
-        }
-
 	if (uwsgi.queue_size) {
 		uwsgi_wlock(uwsgi.queue_lock);
 		message = uwsgi_queue_pull(&size);
-		if (message) {
+		if (message && size > 0) {
                         res = PyString_FromStringAndSize(message, size);
                 }
                 else {
@@ -2768,6 +2936,32 @@ PyObject *py_uwsgi_queue_pull(PyObject * self, PyObject * args) {
 
 }
 
+PyObject *py_uwsgi_queue_pop(PyObject * self, PyObject * args) {
+
+        char *message;
+        uint64_t size;
+        PyObject *res;
+
+        if (uwsgi.queue_size) {
+                uwsgi_wlock(uwsgi.queue_lock);
+                message = uwsgi_queue_pop(&size);
+                if (message && size > 0) {
+                        res = PyString_FromStringAndSize(message, size);
+                }
+                else {
+                        Py_INCREF(Py_None);
+                        res = Py_None;
+                }
+                uwsgi_rwunlock(uwsgi.queue_lock);
+                return res;
+        }
+
+        Py_INCREF(Py_None);
+        return Py_None;
+
+}
+
+
 PyObject *py_uwsgi_queue_get(PyObject * self, PyObject * args) {
 
 	long index = 0;
@@ -2782,7 +2976,7 @@ PyObject *py_uwsgi_queue_get(PyObject * self, PyObject * args) {
 	if (uwsgi.queue_size) {
 		uwsgi_rlock(uwsgi.queue_lock);
 		message = uwsgi_queue_get(index, &size);
-		if (message) {
+		if (message && size > 0) {
 			res = PyString_FromStringAndSize(message, size);
 		}
 		else {
@@ -2812,8 +3006,8 @@ PyObject *py_uwsgi_queue_last(PyObject * self, PyObject * args) {
         if (uwsgi.queue_size) {
 		res = PyList_New(0);
                 uwsgi_rlock(uwsgi.queue_lock);
-		if (uwsgi.shared->queue_pos > 0) {
-			base = uwsgi.shared->queue_pos-1;
+		if (uwsgi.queue_header->pos > 0) {
+			base = uwsgi.queue_header->pos-1;
 		}
 		else {
 			base = uwsgi.queue_size-1;
@@ -2906,6 +3100,7 @@ PyObject *py_uwsgi_cache_get(PyObject * self, PyObject * args) {
 static PyMethodDef uwsgi_cache_methods[] = {
 	{"cache_get", py_uwsgi_cache_get, METH_VARARGS, ""},
 	{"cache_set", py_uwsgi_cache_set, METH_VARARGS, ""},
+	{"cache_update", py_uwsgi_cache_update, METH_VARARGS, ""},
 	{"cache_del", py_uwsgi_cache_del, METH_VARARGS, ""},
 	{"cache_exists", py_uwsgi_cache_exists, METH_VARARGS, ""},
 	{NULL, NULL},
@@ -2913,10 +3108,13 @@ static PyMethodDef uwsgi_cache_methods[] = {
 
 static PyMethodDef uwsgi_queue_methods[] = {
 	{"queue_get", py_uwsgi_queue_get, METH_VARARGS, ""},
+	{"queue_set", py_uwsgi_queue_set, METH_VARARGS, ""},
 	{"queue_last", py_uwsgi_queue_last, METH_VARARGS, ""},
 	{"queue_push", py_uwsgi_queue_push, METH_VARARGS, ""},
 	{"queue_pull", py_uwsgi_queue_pull, METH_VARARGS, ""},
+	{"queue_pop", py_uwsgi_queue_pop, METH_VARARGS, ""},
 	{"queue_slot", py_uwsgi_queue_slot, METH_VARARGS, ""},
+	{"queue_pull_slot", py_uwsgi_queue_pull_slot, METH_VARARGS, ""},
 	{NULL, NULL},
 };
 
@@ -2997,6 +3195,8 @@ void init_uwsgi_module_queue(PyObject * current_uwsgi_module) {
                 PyDict_SetItemString(uwsgi_module_dict, uwsgi_function->ml_name, func);
                 Py_DECREF(func);
         }
+
+	PyDict_SetItemString(uwsgi_module_dict, "queue_size", PyInt_FromLong(uwsgi.queue_size));
 }
 
 
@@ -3017,4 +3217,126 @@ void init_uwsgi_module_sharedarea(PyObject * current_uwsgi_module) {
 	}
 }
 
+PyObject *py_snmp_counter32(PyObject * self, PyObject * args) {
+
+                   uint8_t oid_num;
+                   uint32_t oid_val = 0;
+
+                   if (!PyArg_ParseTuple(args, "bI:snmp_set_counter32", &oid_num, &oid_val)) {
+                   return NULL;
+                   }
+
+                   if (oid_num > 100 || oid_num < 1)
+                   goto clear;
+
+                   uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_COUNTER32;
+                   uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
+
+                   Py_INCREF(Py_True);
+                   return Py_True;
+
+clear:
+
+		Py_INCREF(Py_None);
+		return Py_None;
+}
+
+PyObject *py_snmp_counter64(PyObject * self, PyObject * args) {
+
+	uint8_t oid_num;
+	uint64_t oid_val = 0;
+
+	if (!PyArg_ParseTuple(args, "bK:snmp_set_counter64", &oid_num, &oid_val)) {
+		return NULL;
+	}
+
+	if (oid_num > 100 || oid_num < 1)
+	goto clear;
+
+	uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_COUNTER64;
+	uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
+
+	Py_INCREF(Py_True);
+	return Py_True;
+
+clear:
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyObject *py_snmp_gauge(PyObject * self, PyObject * args) {
+
+	uint8_t oid_num;
+	uint32_t oid_val = 0;
+
+	if (!PyArg_ParseTuple(args, "bI:snmp_set_gauge", &oid_num, &oid_val)) {
+		return NULL;
+	}
+
+	if (oid_num > 100 || oid_num < 1)
+		goto clear;
+
+	uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_GAUGE;
+	uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
+
+	Py_INCREF(Py_True);
+	return Py_True;
+
+clear:
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+PyObject *py_snmp_community(PyObject * self, PyObject * args) {
+
+        char *snmp_community;
+
+        if (!PyArg_ParseTuple(args, "s:snmp_set_community", &snmp_community)) {
+                return NULL;
+        }
+
+        if (strlen(snmp_community) > 72) {
+                uwsgi_log( "*** warning the supplied SNMP community string will be truncated to 72 chars ***\n");
+                memcpy(uwsgi.shared->snmp_community, snmp_community, 72);
+        }
+        else {
+                memcpy(uwsgi.shared->snmp_community, snmp_community, strlen(snmp_community) + 1);
+        }
+
+        Py_INCREF(Py_True);
+        return Py_True;
+
+}
+
+
+static PyMethodDef uwsgi_snmp_methods[] = {
+        {"snmp_set_counter32", py_snmp_counter32, METH_VARARGS, ""},
+        {"snmp_set_counter64", py_snmp_counter64, METH_VARARGS, ""},
+        {"snmp_set_gauge", py_snmp_gauge, METH_VARARGS, ""},
+        {"snmp_set_community", py_snmp_community, METH_VARARGS, ""},
+        {NULL, NULL},
+};
+
+void init_uwsgi_module_snmp(PyObject * current_uwsgi_module) {
+
+        PyMethodDef *uwsgi_function;
+
+	PyObject *uwsgi_module_dict = PyModule_GetDict(current_uwsgi_module);
+        if (!uwsgi_module_dict) {
+                uwsgi_log("could not get uwsgi module __dict__\n");
+                exit(1);
+        }
+
+        for (uwsgi_function = uwsgi_snmp_methods; uwsgi_function->ml_name != NULL; uwsgi_function++) {
+                PyObject *func = PyCFunction_New(uwsgi_function, NULL);
+                PyDict_SetItemString(uwsgi_module_dict, uwsgi_function->ml_name, func);
+                Py_DECREF(func);
+        }
+
+        uwsgi_log( "SNMP python functions initialized.\n");
+}
+
+
 #endif

plugins/python/uwsgi_python.h

@@ -15,6 +15,17 @@
 #define LONG_ARGS_RELOAD_OS_ENV		LONG_ARGS_PYTHON_BASE + 5
 #define LONG_ARGS_PYIMPORT		LONG_ARGS_PYTHON_BASE + 6
 #define LONG_ARGS_POST_PYMODULE_ALIAS   LONG_ARGS_PYTHON_BASE + 7
+#define LONG_ARGS_WEB3			LONG_ARGS_PYTHON_BASE + 8
+#define LONG_ARGS_PUMP			LONG_ARGS_PYTHON_BASE + 9
+#define LONG_ARGS_WSGI_LITE		LONG_ARGS_PYTHON_BASE + 10
+#define LONG_ARGS_PYSHELL		LONG_ARGS_PYTHON_BASE + 11
+#define LONG_ARGS_SPOOLER_PYIMPORT	LONG_ARGS_PYTHON_BASE + 12
+
+#define PYTHON_APP_TYPE_WSGI		0
+#define PYTHON_APP_TYPE_WEB3		1
+#define PYTHON_APP_TYPE_WSGI2		2
+#define PYTHON_APP_TYPE_PUMP		3
+#define PYTHON_APP_TYPE_WSGI_LITE	4
 
 #if PY_MINOR_VERSION == 4 && PY_MAJOR_VERSION == 2
 #define Py_ssize_t ssize_t
@@ -83,6 +94,16 @@ PyAPI_FUNC(PyObject *) PyMarshal_ReadObjectFromString(char *, Py_ssize_t);
 
 #define LOADER_MAX              8
 
+typedef struct uwsgi_Input {
+        PyObject_HEAD
+        char readline[1024];
+        size_t readline_size;
+        size_t readline_max_size;
+        size_t readline_pos;
+        size_t pos;
+        struct wsgi_request *wsgi_req;
+} uwsgi_Input;
+
 struct uwsgi_python {
 
 	char *home;
@@ -104,8 +125,11 @@ struct uwsgi_python {
 
 	char *test_module;
 
+	int pyshell;
+
 	struct uwsgi_string_list *python_path;
 	struct uwsgi_string_list *import_list;
+	struct uwsgi_string_list *spooler_import_list;
 	struct uwsgi_string_list *post_pymodule_alias;
 
 	PyObject *loader_dict;
@@ -116,6 +140,9 @@ struct uwsgi_python {
 	char *paste;
 	char *eval;
 
+	char *web3;
+	char *pump;
+	char *wsgi_lite;
 
 	char *callable;
 
@@ -152,6 +179,7 @@ struct uwsgi_python {
 	void (*extension)(void);
 
 	int reload_os_env;
+
 };
 
 
@@ -165,7 +193,7 @@ void uwsgi_paste_config(char *);
 void uwsgi_file_config(char *);
 void uwsgi_eval_config(char *);
 
-int init_uwsgi_app(int, void *, struct wsgi_request *wsgi_req, PyThreadState *);
+int init_uwsgi_app(int, void *, struct wsgi_request *, PyThreadState *, int);
 
 
 PyObject *py_eventfd_read(PyObject *, PyObject *);
@@ -174,7 +202,7 @@ PyObject *py_eventfd_write(PyObject *, PyObject *);
 
 int manage_python_response(struct wsgi_request *);
 int uwsgi_python_call(struct wsgi_request *, PyObject *, PyObject *);
-PyObject *python_call(PyObject *, PyObject *, int);
+PyObject *python_call(PyObject *, PyObject *, int, struct wsgi_request *);
 
 #ifdef UWSGI_SENDFILE
 PyObject *py_uwsgi_sendfile(PyObject *, PyObject *);
@@ -187,10 +215,11 @@ PyObject *py_uwsgi_spit(PyObject *, PyObject *);
 
 void init_pyargv(void);
 
-#ifdef UWSGI_WEB3
 void *uwsgi_request_subhandler_web3(struct wsgi_request *, struct uwsgi_app *);
 int uwsgi_response_subhandler_web3(struct wsgi_request *);
-#endif
+
+void *uwsgi_request_subhandler_pump(struct wsgi_request *, struct uwsgi_app *);
+int uwsgi_response_subhandler_pump(struct wsgi_request *);
 
 PyObject *uwsgi_uwsgi_loader(void *);
 PyObject *uwsgi_dyn_loader(void *);
@@ -220,6 +249,7 @@ void init_uwsgi_module_spooler(PyObject *);
 void init_uwsgi_module_sharedarea(PyObject *);
 void init_uwsgi_module_cache(PyObject *);
 void init_uwsgi_module_queue(PyObject *);
+void init_uwsgi_module_snmp(PyObject *);
 
 PyObject *uwsgi_pyimport_by_filename(char *, char *);
 
@@ -232,6 +262,8 @@ int uwsgi_python_profiler_call(PyObject *, PyFrameObject *, int, PyObject *);
 
 void uwsgi_python_reset_random_seed(void);
 
+char *uwsgi_pythonize(char *);
+
 #ifdef __linux__
 #ifndef PYTHREE
 int uwsgi_init_symbol_import(void);

plugins/python/uwsgiplugin.py

@@ -3,7 +3,7 @@ import os,sys
 from distutils import sysconfig
 
 NAME='python'
-GCC_LIST = ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter']
+GCC_LIST = ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter']
 
 CFLAGS = ['-I' + sysconfig.get_python_inc(), '-I' + sysconfig.get_python_inc(plat_specific=True) ] 
 LDFLAGS = []

plugins/python/web3_subhandler.c

@@ -1,20 +1,70 @@
-#include "uwsgi.h"
+#include "uwsgi_python.h"
 
 extern struct uwsgi_server uwsgi;
+extern struct uwsgi_python up;
+extern PyTypeObject uwsgi_InputType;
 
 void *uwsgi_request_subhandler_web3(struct wsgi_request *wsgi_req, struct uwsgi_app *wi) {
 
-	PyObject *zero, *wsgi_socket;
+	PyObject *zero;
 
-	wsgi_socket = PyFile_FromFile(wsgi_req->async_post, "web3_input", "r", NULL);
-	PyDict_SetItemString(wsgi_req->async_environ, "web3.input", wsgi_socket);
-	Py_DECREF(wsgi_socket);
+	int i;
+        PyObject *pydictkey, *pydictvalue;
+        char *path_info;
 
-	zero = PyTuple_New(2);
-	PyTuple_SetItem(zero, 0, PyInt_FromLong(1));
-	PyTuple_SetItem(zero, 1, PyInt_FromLong(0));
-	PyDict_SetItemString(wsgi_req->async_environ, "web3.version", zero);
-	Py_DECREF(zero);
+        for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+#ifdef UWSGI_DEBUG
+                uwsgi_debug("%.*s: %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
+#endif
+#ifdef PYTHREE
+                pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, NULL);
+                pydictvalue = PyUnicode_DecodeLatin1(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len, NULL);
+#else
+                pydictkey = PyString_FromStringAndSize(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len);
+                pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
+#endif
+                PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
+                Py_DECREF(pydictkey);
+                Py_DECREF(pydictvalue);
+        }
+
+        if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
+                wsgi_req->uh.modifier1 = 0;
+                pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
+                if (pydictkey) {
+                        if (PyString_Check(pydictkey)) {
+                                pydictvalue = PyDict_GetItemString(wsgi_req->async_environ, "PATH_INFO");
+                                if (pydictvalue) {
+                                        if (PyString_Check(pydictvalue)) {
+                                                path_info = PyString_AsString(pydictvalue);
+                                                PyDict_SetItemString(wsgi_req->async_environ, "PATH_INFO", PyString_FromString(path_info + PyString_Size(pydictkey)));
+                                        }
+                                }
+                        }
+                }
+        }
+
+        // if async_post is mapped as a file, directly use it as wsgi.input
+        if (wsgi_req->async_post) {
+#ifdef PYTHREE
+                wsgi_req->async_input = PyFile_FromFd(fileno(wsgi_req->async_post), "web3_input", "rb", 0, NULL, NULL, NULL, 0);
+#else
+                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "web3_input", "r", NULL);
+#endif
+        }
+        else {
+                // create wsgi.input custom object
+                wsgi_req->async_input = (PyObject *) PyObject_New(uwsgi_Input, &uwsgi_InputType);
+                ((uwsgi_Input*)wsgi_req->async_input)->wsgi_req = wsgi_req;
+                ((uwsgi_Input*)wsgi_req->async_input)->pos = 0;
+                ((uwsgi_Input*)wsgi_req->async_input)->readline_pos = 0;
+                ((uwsgi_Input*)wsgi_req->async_input)->readline_max_size = 0;
+
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "web3.input", wsgi_req->async_input);
+
+	PyDict_SetItemString(wsgi_req->async_environ, "web3.version", wi->gateway_version);
 
 	zero = PyFile_FromFile(stderr, "web3_input", "w", NULL);
 	PyDict_SetItemString(wsgi_req->async_environ, "web3.errors", zero);
@@ -31,35 +81,53 @@ void *uwsgi_request_subhandler_web3(struct wsgi_request *wsgi_req, struct uwsgi_
 	}
 
 	if (wsgi_req->scheme_len > 0) {
-		zero = PyString_FromStringAndSize(wsgi_req->scheme, wsgi_req->scheme_len);
+		zero = UWSGI_PYFROMSTRINGSIZE(wsgi_req->scheme, wsgi_req->scheme_len);
 	}
 	else if (wsgi_req->https_len > 0) {
 		if (!strncasecmp(wsgi_req->https, "on", 2) || wsgi_req->https[0] == '1') {
-			zero = PyString_FromString("https");
+			zero = UWSGI_PYFROMSTRING("https");
 		}
 		else {
-			zero = PyString_FromString("http");
+			zero = UWSGI_PYFROMSTRING("http");
 		}
 	}
 	else {
-		zero = PyString_FromString("http");
+		zero = UWSGI_PYFROMSTRING("http");
 	}
 	PyDict_SetItemString(wsgi_req->async_environ, "web3.url_scheme", zero);
 	Py_DECREF(zero);
 
 
-	wsgi_req->async_app = wi->wsgi_callable;
+	wsgi_req->async_app = wi->callable;
 
-	PyDict_SetItemString(uwsgi.embedded_dict, "env", wsgi_req->async_environ);
+	// export .env only in non-threaded mode
+        if (uwsgi.threads < 2) {
+        	PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
+        }
 
-	// TODO: fix this
-	//PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", uwsgi_version);
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
+
+        if (uwsgi.cores > 1) {
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+        }
+
+        // cache this ?
+        if (uwsgi.cluster_fd >= 0) {
+                zero = PyString_FromString(uwsgi.cluster);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster", zero);
+                Py_DECREF(zero);
+                zero = PyString_FromString(uwsgi.hostname);
+                PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster_node", zero);
+                Py_DECREF(zero);
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", wi->uwsgi_node);
 
 
 	// call
 
 	PyTuple_SetItem(wsgi_req->async_args, 0, wsgi_req->async_environ);
-	return python_call(wsgi_req->async_app, wsgi_req->async_args, uwsgi.catch_exceptions);
+	return python_call(wsgi_req->async_app, wsgi_req->async_args, uwsgi.catch_exceptions, wsgi_req);
 }
 
 
@@ -68,16 +136,7 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 	PyObject *pychunk;
 	ssize_t wsize;
 
-	// return or yield ? (PyString on python2 PyBytes on python3)
-	if (PyString_Check((PyObject *)wsgi_req->async_result)) {
-		if ((wsize = write(wsgi_req->poll.fd, PyString_AsString(wsgi_req->async_result), PyString_Size(wsgi_req->async_result))) < 0) {
-			uwsgi_error("write()");
-			goto clear;
-		}
-		wsgi_req->response_size += wsize;
-		goto clear;
-	}
-
+	UWSGI_GET_GIL
 
 	// ok its a yield
 	if (!wsgi_req->async_placeholder) {
@@ -86,19 +145,51 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 				uwsgi_log("invalid Web3 response.\n"); 
 				goto clear; 
 			} 
-			if (py_uwsgi_spit(NULL, (PyObject *)wsgi_req->async_result) == Py_None) { 
+
+
+
+			wsgi_req->async_placeholder = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 0); 
+			Py_INCREF((PyObject *)wsgi_req->async_placeholder);
+
+			PyObject *spit_args = PyTuple_New(2);
+
+			PyObject *status = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 1);
+			Py_INCREF(status);
+			PyTuple_SetItem(spit_args, 0, status);
+
+			PyObject *headers = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 2);
+			Py_INCREF(headers);
+			PyTuple_SetItem(spit_args, 1, headers);
+
+			if (py_uwsgi_spit(NULL, spit_args) == Py_None) { 
+				Py_DECREF(spit_args);
 				goto clear; 
 			} 
 
-			wsgi_req->async_result = PyTuple_GetItem((PyObject *)wsgi_req->async_result, 0); 
 
-			wsgi_req->async_placeholder = PyObject_GetIter( (PyObject *)wsgi_req->async_result );
+			Py_DECREF(spit_args);
+
+			if (PyString_Check((PyObject *)wsgi_req->async_placeholder)) {
+                		if ((wsize = wsgi_req->socket->proto_write(wsgi_req, PyString_AsString(wsgi_req->async_placeholder), PyString_Size(wsgi_req->async_placeholder))) < 0) {
+                        		uwsgi_error("write()");
+                        		goto clear;
+                		}
+                		wsgi_req->response_size += wsize;
+                		goto clear;
+        		}
+
+			PyObject *tmp = (PyObject *)wsgi_req->async_placeholder;
+
+			wsgi_req->async_placeholder = PyObject_GetIter( (PyObject *)wsgi_req->async_placeholder );
+
+			Py_DECREF(tmp);
 
 			if (!wsgi_req->async_placeholder) {
-				goto clear2;
+				goto clear;
 			}
 #ifdef UWSGI_ASYNC
 			if (uwsgi.async > 1) {
+				UWSGI_RELEASE_GIL
 				return UWSGI_AGAIN;
 			}
 		}
@@ -119,9 +210,8 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 	}
 
 
-
 	if (PyString_Check(pychunk)) {
-		if ((wsize = write(wsgi_req->poll.fd, PyString_AsString(pychunk), PyString_Size(pychunk))) < 0) {
+		if ((wsize = wsgi_req->socket->proto_write(wsgi_req,  PyString_AsString(pychunk), PyString_Size(pychunk))) < 0) {
 			uwsgi_error("write()");
 			Py_DECREF(pychunk);
 			goto clear;
@@ -131,34 +221,22 @@ int uwsgi_response_subhandler_web3(struct wsgi_request *wsgi_req) {
 
 
 	Py_DECREF(pychunk);
+	UWSGI_RELEASE_GIL
 	return UWSGI_AGAIN;
 
 clear:
+	if (wsgi_req->async_input) {
+                Py_DECREF((PyObject *)wsgi_req->async_input);
+        }
 	if (wsgi_req->async_environ) {
 		PyDict_Clear(wsgi_req->async_environ);
 	}
-	if (wsgi_req->async_post && !wsgi_req->fd_closed) {
-		fclose(wsgi_req->async_post);
-		if (!uwsgi.post_buffering || wsgi_req->post_cl <= (size_t) uwsgi.post_buffering) {
-			wsgi_req->fd_closed = 1;
-		}
-	}
 	Py_XDECREF((PyObject *)wsgi_req->async_placeholder);
-clear2:
+
 	Py_DECREF((PyObject *)wsgi_req->async_result);
 	PyErr_Clear();
 
-#ifdef UWSGI_DEBUG
-	if (wsgi_req->async_placeholder) {
-		uwsgi_debug("wsgi_req->async_placeholder: %d\n", ((PyObject *)wsgi_req->async_placeholder)->ob_refcnt);
-	}
-	if (wsgi_req->async_result) {
-		uwsgi_debug("wsgi_req->async_result: %d\n", ((PyObject *)wsgi_req->async_result)->ob_refcnt);
-	}
-	if (wsgi_req->async_app) {
-		uwsgi_debug("wsgi_req->async_app: %d\n", ((PyObject *)wsgi_req->async_app)->ob_refcnt);
-	}
-#endif
+	UWSGI_RELEASE_GIL
 	return UWSGI_OK;
 }
 

plugins/python/wsgi_handlers.c

@@ -4,16 +4,6 @@ extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
 
 
-typedef struct uwsgi_Input {
-        PyObject_HEAD
-	char readline[1024];
-	size_t readline_size;
-	size_t readline_max_size;
-	size_t readline_pos;
-	size_t pos;
-	struct wsgi_request *wsgi_req;
-} uwsgi_Input;
-
 PyObject *uwsgi_Input_iter(PyObject *self) {
         Py_INCREF(self);
         return self;
@@ -62,7 +52,7 @@ PyObject *uwsgi_Input_getline(uwsgi_Input *self) {
 	else {
         	rlen = read(wsgi_req->poll.fd, self->readline, 1024);
 	}
-        if (rlen < 0) {
+        if (rlen <= 0) {
                 UWSGI_GET_GIL
                 return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
         }
@@ -166,7 +156,7 @@ static PyObject *uwsgi_Input_read(uwsgi_Input *self, PyObject *args) {
                	}
 
 		rlen = read(self->wsgi_req->poll.fd, tmp_buf+tmp_pos, remains);
-		if (rlen < 0) {
+		if (rlen <= 0) {
                        	free(tmp_buf);
                        	UWSGI_GET_GIL
                        	return PyErr_Format(PyExc_IOError, "error reading wsgi.input data");
@@ -221,12 +211,18 @@ static PyObject *uwsgi_Input_close(uwsgi_Input *self, PyObject *args) {
 	return Py_None;
 }
 
+static PyObject *uwsgi_Input_fileno(uwsgi_Input *self, PyObject *args) {
+
+	return PyInt_FromLong(self->wsgi_req->poll.fd);
+}
+
 static PyMethodDef uwsgi_Input_methods[] = {
 	{ "read",      (PyCFunction)uwsgi_Input_read,      METH_VARARGS, 0 },
 	{ "readline",  (PyCFunction)uwsgi_Input_readline,  METH_VARARGS, 0 },
 	{ "readlines", (PyCFunction)uwsgi_Input_readlines, METH_VARARGS, 0 },
 // add close to allow mod_wsgi compatibility
 	{ "close",     (PyCFunction)uwsgi_Input_close,     METH_VARARGS, 0 },
+	{ "fileno",     (PyCFunction)uwsgi_Input_fileno,     METH_VARARGS, 0 },
 	{ NULL, NULL}
 };
 
@@ -327,16 +323,10 @@ PyObject *py_eventfd_write(PyObject * self, PyObject * args) {
 
 int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
-	int i;
-
-	PyObject *pydictkey, *pydictvalue;
-
-	char *path_info;
 	struct uwsgi_app *wi;
 
 	int tmp_stderr;
-	char *what;
-	int what_len;
+	int free_appid = 0;
 
 #ifdef UWSGI_ASYNC
 	if (wsgi_req->async_status == UWSGI_AGAIN) {
@@ -363,7 +353,7 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 	/* Standard WSGI request */
 	if (!wsgi_req->uh.pktsize) {
-		uwsgi_log( "Invalid WSGI request. skip.\n");
+		uwsgi_log( "Empty python request. skip.\n");
 		return -1;
 	}
 
@@ -372,76 +362,59 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	}
 
 
-	if (!up.ignore_script_name) {
-
-		if (!wsgi_req->script_name)
-			wsgi_req->script_name = "";
+	if (wsgi_req->appid_len == 0) {
+		if (!up.ignore_script_name) {
+			wsgi_req->appid = wsgi_req->script_name;
+			wsgi_req->appid_len = wsgi_req->script_name_len;
+		}
 
 		if (uwsgi.vhost) {
-			what = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|",1, wsgi_req->script_name, wsgi_req->script_name_len);
-			what_len = wsgi_req->host_len + 1 + wsgi_req->script_name_len;
+			wsgi_req->appid = uwsgi_concat3n(wsgi_req->host, wsgi_req->host_len, "|",1, wsgi_req->script_name, wsgi_req->script_name_len);
+			wsgi_req->appid_len = wsgi_req->host_len + 1 + wsgi_req->script_name_len;
 #ifdef UWSGI_DEBUG
-			uwsgi_debug("VirtualHost SCRIPT_NAME=%s\n", what);
+			uwsgi_debug("VirtualHost KEY=%.*s\n", wsgi_req->appid_len, wsgi_req->appid);
 #endif
+			free_appid = 1;
 		}
-		else {
-			what = wsgi_req->script_name;
-			what_len = wsgi_req->script_name_len;
-		}
+	}
 
 
-		if ( (wsgi_req->app_id = uwsgi_get_app_id(what, what_len, 0))  == -1) {
-			if (wsgi_req->script_name_len > 1 || uwsgi.default_app < 0 || uwsgi.vhost) {
-				/* unavailable app for this SCRIPT_NAME */
-				wsgi_req->app_id = -1;
-				if (wsgi_req->script_len > 0
-						|| wsgi_req->module_len > 0
-						|| wsgi_req->file_len > 0
-						|| wsgi_req->paste_len > 0
-				   ) {
-					// this part must be heavy locked in threaded modes
-					if (uwsgi.threads > 1) {
-						pthread_mutex_lock(&up.lock_pyloaders);
-					}
 
-					UWSGI_GET_GIL
-					if (uwsgi.single_interpreter) {
-						wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, up.main_thread);
-					}
-					else {
-						wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, NULL);
-					}
-					UWSGI_RELEASE_GIL
-					if (uwsgi.threads > 1) {
-						pthread_mutex_unlock(&up.lock_pyloaders);
-					}
-				}
+	if ( (wsgi_req->app_id = uwsgi_get_app_id(wsgi_req->appid, wsgi_req->appid_len, 0))  == -1) {
+		wsgi_req->app_id = uwsgi.default_app;
+		if (uwsgi.no_default_app) {
+                	wsgi_req->app_id = -1;
+        	}
+		if (wsgi_req->dynamic) {
+			// this part must be heavy locked in threaded modes
+			if (uwsgi.threads > 1) {
+				pthread_mutex_lock(&up.lock_pyloaders);
+			}
+
+			UWSGI_GET_GIL
+			if (uwsgi.single_interpreter) {
+				wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, up.main_thread, PYTHON_APP_TYPE_WSGI);
+			}
+			else {
+				wsgi_req->app_id = init_uwsgi_app(LOADER_DYN, (void *) wsgi_req, wsgi_req, NULL, PYTHON_APP_TYPE_WSGI);
+			}
+			UWSGI_RELEASE_GIL
+			if (uwsgi.threads > 1) {
+				pthread_mutex_unlock(&up.lock_pyloaders);
 			}
 		}
-
-		if (uwsgi.vhost) {
-			free(what);
-		}
-
-	}
-	else {
-		wsgi_req->app_id = 0;
 	}
 
+	if (free_appid) {
+		free(wsgi_req->appid);
+	}
 
 	if (wsgi_req->app_id == -1) {
-		// use default app ?
-		if (!uwsgi.no_default_app && uwsgi.default_app >= 0) {
-			wsgi_req->app_id = uwsgi.default_app;
-		}
-		else {
-			internal_server_error(wsgi_req, "wsgi application not found");
-			goto clear2;
-		}
-
+		internal_server_error(wsgi_req, "Python application not found");
+		goto clear2;
 	}
 
-	wi = &uwsgi.apps[wsgi_req->app_id];
+	wi = &uwsgi_apps[wsgi_req->app_id];
 
 	up.swap_ts(wsgi_req, wi);
 	
@@ -455,21 +428,6 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 	}
 
 
-	if (wsgi_req->protocol_len < 5) {
-		uwsgi_log( "INVALID PROTOCOL: %.*s\n", wsgi_req->protocol_len, wsgi_req->protocol);
-		internal_server_error(wsgi_req, "invalid HTTP protocol !!!");
-		goto clear;
-
-	}
-
-	if (strncmp(wsgi_req->protocol, "HTTP/", 5)) {
-		uwsgi_log( "INVALID PROTOCOL: %.*s\n", wsgi_req->protocol_len, wsgi_req->protocol);
-		internal_server_error(wsgi_req, "invalid HTTP protocol !!!");
-		goto clear;
-	}
-
-
-
 #ifdef UWSGI_ASYNC
 	wsgi_req->async_environ = wi->environ[wsgi_req->async_id];
 	wsgi_req->async_args = wi->args[wsgi_req->async_id];
@@ -485,60 +443,6 @@ int uwsgi_request_wsgi(struct wsgi_request *wsgi_req) {
 
 	Py_INCREF((PyObject *)wsgi_req->async_environ);
 
-	for (i = 0; i < wsgi_req->var_cnt; i += 2) {
-#ifdef UWSGI_DEBUG
-		uwsgi_debug("%.*s: %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
-#endif
-#ifdef PYTHREE
-		pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, NULL);
-		pydictvalue = PyUnicode_DecodeLatin1(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len, NULL);
-#else
-		pydictkey = PyString_FromStringAndSize(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len);
-		pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
-#endif
-		PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
-		Py_DECREF(pydictkey);
-		Py_DECREF(pydictvalue);
-	}
-
-	if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
-		wsgi_req->uh.modifier1 = 0;
-		pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
-		if (pydictkey) {
-			if (PyString_Check(pydictkey)) {
-				pydictvalue = PyDict_GetItemString(wsgi_req->async_environ, "PATH_INFO");
-				if (pydictvalue) {
-					if (PyString_Check(pydictvalue)) {
-						path_info = PyString_AsString(pydictvalue);
-						PyDict_SetItemString(wsgi_req->async_environ, "PATH_INFO", PyString_FromString(path_info + PyString_Size(pydictkey)));
-					}
-				}
-			}
-		}
-	}
-
-
-
-	// if async_post is mapped as a file, directly use it as wsgi.input
-	if (wsgi_req->async_post) {
-#ifdef PYTHREE
-                wsgi_req->async_input = PyFile_FromFd(fileno(wsgi_req->async_post), "wsgi_input", "rb", 0, NULL, NULL, NULL, 0);
-#else
-                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "wsgi_input", "r", NULL);
-#endif
-	}
-	else {
-		// create wsgi.input custom object
-		wsgi_req->async_input = (PyObject *) PyObject_New(uwsgi_Input, &uwsgi_InputType);
-		((uwsgi_Input*)wsgi_req->async_input)->wsgi_req = wsgi_req; 
-		((uwsgi_Input*)wsgi_req->async_input)->pos = 0;
-		((uwsgi_Input*)wsgi_req->async_input)->readline_pos = 0;
-		((uwsgi_Input*)wsgi_req->async_input)->readline_max_size = 0;
-
-	}
-
-	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_req->async_input);
-
 	wsgi_req->async_result = wi->request_subhandler(wsgi_req, wi);
 
 	UWSGI_RELEASE_GIL

plugins/python/wsgi_headers.c

@@ -38,7 +38,8 @@ PyObject *py_uwsgi_spit(PyObject * self, PyObject * args) {
 			// in this way, error will be reported to the log
 			PyErr_Restore(exc_type, exc_val, exc_tb);
 
-			goto clear;	
+			// the error is reported, let's continue...
+			//goto clear;	
 		}
 	}
 

plugins/python/wsgi_subhandler.c

@@ -2,19 +2,67 @@
 
 extern struct uwsgi_server uwsgi;
 extern struct uwsgi_python up;
+extern PyTypeObject uwsgi_InputType;
 
 void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_app *wi) {
 
 	PyObject *zero;
+	int i;
+	PyObject *pydictkey, *pydictvalue;
+	char *path_info;
 
-	//static PyObject *uwsgi_version = NULL;
+        for (i = 0; i < wsgi_req->var_cnt; i += 2) {
+#ifdef UWSGI_DEBUG
+                uwsgi_debug("%.*s: %.*s\n", wsgi_req->hvec[i].iov_len, wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i+1].iov_len, wsgi_req->hvec[i+1].iov_base);
+#endif
+#ifdef PYTHREE
+                pydictkey = PyUnicode_DecodeLatin1(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len, NULL);
+                pydictvalue = PyUnicode_DecodeLatin1(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len, NULL);
+#else
+                pydictkey = PyString_FromStringAndSize(wsgi_req->hvec[i].iov_base, wsgi_req->hvec[i].iov_len);
+                pydictvalue = PyString_FromStringAndSize(wsgi_req->hvec[i + 1].iov_base, wsgi_req->hvec[i + 1].iov_len);
+#endif
+                PyDict_SetItem(wsgi_req->async_environ, pydictkey, pydictvalue);
+                Py_DECREF(pydictkey);
+                Py_DECREF(pydictvalue);
+        }
 
-	/*
-	   if (uwsgi_version == NULL) {
-	   uwsgi_version = PyString_FromString(UWSGI_VERSION);
-	   }
-	   */
 
+        if (wsgi_req->uh.modifier1 == UWSGI_MODIFIER_MANAGE_PATH_INFO) {
+                wsgi_req->uh.modifier1 = 0;
+                pydictkey = PyDict_GetItemString(wsgi_req->async_environ, "SCRIPT_NAME");
+                if (pydictkey) {
+                        if (PyString_Check(pydictkey)) {
+                                pydictvalue = PyDict_GetItemString(wsgi_req->async_environ, "PATH_INFO");
+                                if (pydictvalue) {
+                                        if (PyString_Check(pydictvalue)) {
+                                                path_info = PyString_AsString(pydictvalue);
+                                                PyDict_SetItemString(wsgi_req->async_environ, "PATH_INFO", PyString_FromString(path_info + PyString_Size(pydictkey)));
+                                        }
+                                }
+                        }
+                }
+        }
+
+        // if async_post is mapped as a file, directly use it as wsgi.input
+        if (wsgi_req->async_post) {
+#ifdef PYTHREE
+                wsgi_req->async_input = PyFile_FromFd(fileno(wsgi_req->async_post), "wsgi_input", "rb", 0, NULL, NULL, NULL, 0);
+#else
+                wsgi_req->async_input = PyFile_FromFile(wsgi_req->async_post, "wsgi_input", "r", NULL);
+#endif
+        }
+        else {
+                // create wsgi.input custom object
+                wsgi_req->async_input = (PyObject *) PyObject_New(uwsgi_Input, &uwsgi_InputType);
+                ((uwsgi_Input*)wsgi_req->async_input)->wsgi_req = wsgi_req;
+                ((uwsgi_Input*)wsgi_req->async_input)->pos = 0;
+                ((uwsgi_Input*)wsgi_req->async_input)->readline_pos = 0;
+                ((uwsgi_Input*)wsgi_req->async_input)->readline_max_size = 0;
+
+        }
+
+        PyDict_SetItemString(wsgi_req->async_environ, "wsgi.input", wsgi_req->async_input);
 
 #ifdef UWSGI_SENDFILE
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.file_wrapper", wi->sendfile);
@@ -28,12 +76,7 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 	}
 #endif
 
-	// cache this
-	zero = PyTuple_New(2);
-	PyTuple_SetItem(zero, 0, PyInt_FromLong(1));
-	PyTuple_SetItem(zero, 1, PyInt_FromLong(0));
-	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.version", zero);
-	Py_DECREF(zero);
+	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.version", wi->gateway_version);
 
 	zero = PyFile_FromFile(stderr, "wsgi_input", "w", NULL);
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.errors", zero);
@@ -55,18 +98,18 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 	}
 
 	if (wsgi_req->scheme_len > 0) {
-		zero = PyString_FromStringAndSize(wsgi_req->scheme, wsgi_req->scheme_len);
+		zero = UWSGI_PYFROMSTRINGSIZE(wsgi_req->scheme, wsgi_req->scheme_len);
 	}
 	else if (wsgi_req->https_len > 0) {
 		if (!strncasecmp(wsgi_req->https, "on", 2) || wsgi_req->https[0] == '1') {
-			zero = PyString_FromString("https");
+			zero = UWSGI_PYFROMSTRING("https");
 		}
 		else {
-			zero = PyString_FromString("http");
+			zero = UWSGI_PYFROMSTRING("http");
 		}
 	}
 	else {
-		zero = PyString_FromString("http");
+		zero = UWSGI_PYFROMSTRING("http");
 	}
 	PyDict_SetItemString(wsgi_req->async_environ, "wsgi.url_scheme", zero);
 	Py_DECREF(zero);
@@ -79,14 +122,15 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 		PyDict_SetItemString(up.embedded_dict, "env", wsgi_req->async_environ);
 	}
 
-	zero = PyString_FromString(UWSGI_VERSION);
-	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", zero);
-	Py_DECREF(zero);
+	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.version", wi->uwsgi_version);
 
 	if (uwsgi.cores > 1) {
-		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", PyInt_FromLong(wsgi_req->async_id));
+		zero = PyInt_FromLong(wsgi_req->async_id);
+		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.core", zero);
+		Py_DECREF(zero);
 	}
 
+	// cache this ?
 	if (uwsgi.cluster_fd >= 0) {
 		zero = PyString_FromString(uwsgi.cluster);
 		PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.cluster", zero);
@@ -96,9 +140,7 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 		Py_DECREF(zero);
 	}
 
-	zero = PyString_FromString(uwsgi.hostname);
-	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", zero);
-	Py_DECREF(zero);
+	PyDict_SetItemString(wsgi_req->async_environ, "uwsgi.node", wi->uwsgi_node);
 
 
 #ifdef UWSGI_ROUTING
@@ -113,7 +155,7 @@ void *uwsgi_request_subhandler_wsgi(struct wsgi_request *wsgi_req, struct uwsgi_
 
 
 	PyTuple_SetItem(wsgi_req->async_args, 0, wsgi_req->async_environ);
-	return python_call(wsgi_req->async_app, wsgi_req->async_args, up.catch_exceptions);
+	return python_call(wsgi_req->async_app, wsgi_req->async_args, up.catch_exceptions, wsgi_req);
 }
 
 int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
@@ -180,6 +222,7 @@ int uwsgi_response_subhandler_wsgi(struct wsgi_request *wsgi_req) {
 				uwsgi_log("Memory Error detected !!!\n");	
 			}		
 			uwsgi.workers[uwsgi.mywid].exceptions++;
+			uwsgi_apps[wsgi_req->app_id].exceptions++;
 			PyErr_Print();
 		}	
 		goto clear;

plugins/python24/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python24'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.4-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python25/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python25'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.5-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python26/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python26'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.6-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python27/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python27'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python2.7-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python30/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python30'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python3.0-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python31/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python31'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python3.1-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/python32/uwsgiplugin.py

@@ -2,7 +2,7 @@ import os,sys
 
 NAME='python32'
 
-GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'gil', 'uwsgi_pymodule', 'profiler'])
+GCC_LIST = map(lambda x: '../python/' + x, ['python_plugin', 'pyutils', 'pyloader', 'wsgi_handlers', 'wsgi_headers', 'wsgi_subhandler', 'web3_subhandler', 'pump_subhandler', 'gil', 'uwsgi_pymodule', 'profiler', 'symimporter'])
 
 CFLAGS = os.popen('python3.2-config --cflags').read().rstrip().split()
 CFLAGS.append('-Wno-unused-parameter')

plugins/rack/rack_plugin.c

@@ -32,53 +32,7 @@ void uwsgi_ruby_exception(void) {
 
 
 
-/* statistically ordered */
-static struct http_status_codes hsc[] = {
-
-	{"200", "OK"},
-	{"302", "Found"},
-	{"404", "Not Found"},
-	{"500", "Internal Server Error"},
-	{"301", "Moved Permanently"},
-	{"304", "Not Modified"},
-	{"303", "See Other"},
-	{"403", "Forbidden"},
-	{"307", "Temporary Redirect"},
-	{"401", "Unauthorized"},
-	{"400", "Bad Request"},
-	{"405", "Method Not Allowed"},
-	{"408", "Request Timeout"},
-
-	{"100", "Continue"},
-	{"101", "Switching Protocols"},
-	{"201", "Created"},
-	{"202", "Accepted"},
-	{"203", "Non-Authoritative Information"},
-	{"204", "No Content"},
-	{"205", "Reset Content"},
-	{"206", "Partial Content"},
-	{"300", "Multiple Choices"},
-	{"305", "Use Proxy"},
-	{"402", "Payment Required"},
-	{"406", "Not Acceptable"},
-	{"407", "Proxy Authentication Required"},
-	{"409", "Conflict"},
-	{"410", "Gone"},
-	{"411", "Length Required"},
-	{"412", "Precondition Failed"},
-	{"413", "Request Entity Too Large"},
-	{"414", "Request-URI Too Long"},
-	{"415", "Unsupported Media Type"},
-	{"416", "Requested Range Not Satisfiable"},
-	{"417", "Expectation Failed"},
-	{"501", "Not Implemented"},
-	{"502", "Bad Gateway"},
-	{"503", "Service Unavailable"},
-	{"504", "Gateway Timeout"},
-	{"505", "HTTP Version Not Supported"},
-	{ "", NULL },
-};
-
+extern struct http_status_codes hsc[];
 
 
 VALUE rb_uwsgi_io_new(VALUE class, VALUE wr) {
@@ -186,6 +140,142 @@ VALUE require_rails(VALUE arg) {
 
 VALUE init_rack_app(VALUE);
 
+VALUE uwsgi_ruby_signal_registered(VALUE *class, VALUE signum) {
+
+	uint8_t uwsgi_signal = NUM2INT(signum);
+
+	if (uwsgi_signal_registered(uwsgi_signal)) {
+		return Qtrue;
+        }
+
+	return Qfalse;
+}
+
+
+VALUE uwsgi_ruby_register_signal(VALUE *class, VALUE signum, VALUE sigkind, VALUE rbhandler) {
+
+        uint8_t uwsgi_signal = NUM2INT(signum);
+        char *signal_kind = RSTRING_PTR(sigkind);
+
+        if (uwsgi_register_signal(uwsgi_signal, signal_kind, (void *) rbhandler, 7)) {
+		rb_raise(rb_eRuntimeError, "unable to register signal %d", uwsgi_signal);
+		return Qnil;
+        }
+
+	rb_gc_register_address(&rbhandler);
+
+	return Qtrue;
+}
+
+
+VALUE uwsgi_ruby_signal(VALUE *class, VALUE signum) {
+
+        uint8_t uwsgi_signal = NUM2INT(signum);
+	ssize_t rlen; 
+
+	rlen = write(uwsgi.signal_socket, &uwsgi_signal, 1);
+        if (rlen != 1) {
+                uwsgi_error("write()");
+        }
+
+	return Qtrue;
+}
+
+VALUE rack_call_signal_handler(VALUE args) {
+
+	return rb_funcall(rb_ary_entry(args, 0), rb_intern("call"), 1, rb_ary_entry(args, 1));
+}
+
+int uwsgi_rack_signal_handler(uint8_t sig, void *handler) {
+
+	int error = 0;
+
+	VALUE rbhandler = (VALUE) handler;
+	VALUE args = rb_ary_new2(2);
+	rb_ary_store(args, 0, rbhandler);
+	VALUE rbsig = INT2NUM(sig);
+	rb_ary_store(args, 1, rbsig);
+	VALUE ret = rb_protect(rack_call_signal_handler, args, &error);
+	if (error) {
+        	uwsgi_ruby_exception();
+		// free resources (useless ?)
+		rb_gc_unregister_address(&args);
+		rb_gc_unregister_address(&ret);
+		rb_gc_unregister_address(&rbsig);
+        	return -1;
+	}
+
+	// free resources (useless ?)
+	rb_gc_unregister_address(&args);
+	rb_gc_unregister_address(&ret);
+	rb_gc_unregister_address(&rbsig);
+
+	return 0;
+}
+
+VALUE rack_uwsgi_add_cron(VALUE *class, VALUE rbsignum, VALUE rbmin, VALUE rbhour, VALUE rbday, VALUE rbmon, VALUE rbweek) {
+
+        uint8_t uwsgi_signal = NUM2INT(rbsignum);
+        int minute = NUM2INT(rbmin);
+	int hour = NUM2INT(rbhour);
+	int day = NUM2INT(rbday);
+	int month = NUM2INT(rbmon);
+	int week = NUM2INT(rbweek);
+
+        if (uwsgi_signal_add_cron(uwsgi_signal, minute, hour, day, month, week)) {
+                rb_raise(rb_eRuntimeError, "unable to add cron");
+		return Qnil;
+        }
+
+        return Qtrue;
+}
+
+
+
+VALUE rack_uwsgi_add_timer(VALUE *class, VALUE rbsignum, VALUE secs) {
+
+        uint8_t uwsgi_signal = NUM2INT(rbsignum);
+	int seconds = NUM2INT(secs);
+
+        if (uwsgi_add_timer(uwsgi_signal, seconds)) {
+                rb_raise(rb_eRuntimeError, "unable to add timer");
+		return Qnil;
+	}
+
+        return Qtrue;
+}
+
+VALUE rack_uwsgi_add_rb_timer(VALUE *class, VALUE rbsignum, VALUE secs) {
+
+
+        uint8_t uwsgi_signal = NUM2INT(rbsignum);
+	int seconds = NUM2INT(secs);
+	
+
+        if (uwsgi_signal_add_rb_timer(uwsgi_signal, seconds, 0)) {
+                rb_raise(rb_eRuntimeError, "unable to add rb_timer");
+		return Qnil;
+	}
+
+        return Qtrue;
+}
+
+
+
+VALUE rack_uwsgi_add_file_monitor(VALUE *class, VALUE rbsignum, VALUE rbfilename) {
+
+        uint8_t uwsgi_signal = NUM2INT(rbsignum);
+        char *filename = RSTRING_PTR(rbfilename);
+
+        if (uwsgi_add_file_monitor(uwsgi_signal, filename)) {
+                rb_raise(rb_eRuntimeError, "unable to add file monitor");
+		return Qnil;
+	}
+
+	return Qtrue;
+}
+
+
 VALUE uwsgi_ruby_wait_fd_read(VALUE *class, VALUE arg1, VALUE arg2) {
 
 	struct wsgi_request *wsgi_req = current_wsgi_req();
@@ -253,13 +343,13 @@ int uwsgi_rack_init(){
 	char **argv = sargv;
 #endif
 
-	int error;
 
 	// filling http status codes
         for (http_sc = hsc; http_sc->message != NULL; http_sc++) {
                 http_sc->message_size = (int) strlen(http_sc->message);
         }
 
+	ur.unprotected = 0;
 
 #ifdef RUBY19
 	ruby_sysinit(&argc, &argv);
@@ -281,6 +371,20 @@ int uwsgi_rack_init(){
 	rb_define_module_function(rb_uwsgi_embedded, "wait_fd_read", uwsgi_ruby_wait_fd_read, 2);
 	rb_define_module_function(rb_uwsgi_embedded, "wait_fd_write", uwsgi_ruby_wait_fd_write, 2);
 	rb_define_module_function(rb_uwsgi_embedded, "async_connect", uwsgi_ruby_async_connect, 1);
+	rb_define_module_function(rb_uwsgi_embedded, "signal", uwsgi_ruby_signal, 1);
+	rb_define_module_function(rb_uwsgi_embedded, "register_signal", uwsgi_ruby_register_signal, 3);
+	rb_define_module_function(rb_uwsgi_embedded, "signal_registered", uwsgi_ruby_signal_registered, 1);
+	rb_define_module_function(rb_uwsgi_embedded, "add_cron", rack_uwsgi_add_cron, 6);
+	rb_define_module_function(rb_uwsgi_embedded, "add_timer", rack_uwsgi_add_timer, 2);
+	rb_define_module_function(rb_uwsgi_embedded, "add_rb_timer", rack_uwsgi_add_rb_timer, 2);
+	rb_define_module_function(rb_uwsgi_embedded, "add_file_monitor", rack_uwsgi_add_file_monitor, 2);
+
+	return 0;
+}
+
+void uwsgi_rack_init_apps(void) {
+
+	int error;
 
 	if (ur.rack) {
 		ur.dispatcher = rb_protect(init_rack_app, rb_str_new2(ur.rack), &error);
@@ -289,9 +393,12 @@ int uwsgi_rack_init(){
                         exit(1);
                 }
 		if (ur.dispatcher == Qnil) {
+			uwsgi_log("unable to find RACK entry point\n");
 			exit(1);
 		}
 		rb_gc_register_address(&ur.dispatcher);
+
+		goto ready;
 	}
 	else if (ur.rails) {
 		if (chdir(ur.rails)) {
@@ -314,10 +421,18 @@ int uwsgi_rack_init(){
 			uwsgi_log("unable to load rails dispatcher\n");
 			exit(1);
 		}
+
+		goto ready;
 	}
 
+	return;
 
+ready:
 	ur.call = rb_intern("call");
+	if (!ur.call) {
+		uwsgi_log("unable to find RACK entry point\n");
+		return;
+	}
 	rb_gc_register_address(&ur.call);
 
 
@@ -332,8 +447,6 @@ int uwsgi_rack_init(){
 	rb_define_method(ur.rb_uwsgi_io_class, "read", rb_uwsgi_io_read, -2);
 	rb_define_method(ur.rb_uwsgi_io_class, "rewind", rb_uwsgi_io_rewind, 0);
 
-	return 0;
-
 }
 
 VALUE call_dispatch(VALUE env) {
@@ -521,7 +634,21 @@ int uwsgi_rack_request(struct wsgi_request *wsgi_req) {
 	rb_ary_store(rbv, 1, INT2NUM(1));
 	rb_hash_aset(env, rb_str_new2("rack.version"), rbv);
 
-	rb_hash_aset(env, rb_str_new2("rack.url_scheme"), rb_str_new2("http"));
+	if (wsgi_req->scheme_len > 0) {
+		rb_hash_aset(env, rb_str_new2("rack.url_scheme"), rb_str_new(wsgi_req->scheme, wsgi_req->scheme_len));
+        }
+        else if (wsgi_req->https_len > 0) {
+                if (!strncasecmp(wsgi_req->https, "on", 2) || wsgi_req->https[0] == '1') {
+			rb_hash_aset(env, rb_str_new2("rack.url_scheme"), rb_str_new2("https"));
+                }
+                else {
+			rb_hash_aset(env, rb_str_new2("rack.url_scheme"), rb_str_new2("http"));
+                }
+        }
+        else {
+		rb_hash_aset(env, rb_str_new2("rack.url_scheme"), rb_str_new2("http"));
+        }
+
 
 	rb_hash_aset(env, rb_str_new2("rack.multithread"), Qfalse);
 	rb_hash_aset(env, rb_str_new2("rack.multiprocess"), Qtrue);
@@ -625,7 +752,7 @@ int uwsgi_rack_request(struct wsgi_request *wsgi_req) {
 			wsgi_req->response_size = uwsgi_sendfile(wsgi_req);
 			if (wsgi_req->response_size > 0) {
 				while(wsgi_req->response_size < wsgi_req->sendfile_fd_size) {
-					uwsgi_log("sendfile_fd_size = %d\n", wsgi_req->sendfile_fd_size);
+					//uwsgi_log("sendfile_fd_size = %d\n", wsgi_req->sendfile_fd_size);
 					wsgi_req->response_size += uwsgi_sendfile(wsgi_req);
 				}
 			}
@@ -692,11 +819,16 @@ void uwsgi_rack_after_request(struct wsgi_request *wsgi_req) {
 
 int uwsgi_rack_manage_options(int i, char *optarg) {
 
+
 	switch(i) {
 		case LONG_ARGS_RAILS:
+			// HACK: can be overridden with --post-buffering
+			if (!uwsgi.post_buffering) uwsgi.post_buffering = 4096;
 			ur.rails = optarg;
 			return 1;
 		case LONG_ARGS_RACK:
+			// HACK: can be overridden with --post-buffering
+			if (!uwsgi.post_buffering) uwsgi.post_buffering = 4096;
 			ur.rack = optarg;
 			return 1;
 		case LONG_ARGS_RUBY_GC_FREQ:
@@ -798,6 +930,9 @@ struct uwsgi_plugin rack_plugin = {
 	.request = uwsgi_rack_request,
 	.after_request = uwsgi_rack_after_request,
 
+	.signal_handler = uwsgi_rack_signal_handler,
+
+	.init_apps = uwsgi_rack_init_apps,
 	//.mount_app = uwsgi_rack_mount_app,
 	.manage_xml = uwsgi_rack_xml,
 

plugins/symcall/symcall_plugin.c

@@ -0,0 +1,33 @@
+#include "../../uwsgi.h"
+
+extern struct uwsgi_server uwsgi;
+int (*symcall_function)(struct wsgi_request *);
+
+int uwsgi_symcall_init(){
+	symcall_function = dlsym(RTLD_DEFAULT, "pypy_uwsgi_request");
+	uwsgi_log("symcall function ptr: %p\n", symcall_function);
+	return 0;
+}
+
+int uwsgi_symcall_request(struct wsgi_request *wsgi_req) {
+
+	return symcall_function(wsgi_req);
+
+}
+
+
+void uwsgi_symcall_after_request(struct wsgi_request *wsgi_req) {
+	// TODO
+}
+
+
+struct uwsgi_plugin symcall_plugin = {
+
+        .name = "symcall",
+        .modifier1 = 18,
+        .init = uwsgi_symcall_init,
+        .request = uwsgi_symcall_request,
+        .after_request = uwsgi_symcall_after_request,
+
+};
+

plugins/symcall/uwsgiplugin.py

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

proto/http.c

@@ -42,6 +42,14 @@ static uint16_t http_add_uwsgi_header(struct wsgi_request *wsgi_req, char *hh, i
 	if (uwsgi_strncmp("CONTENT_TYPE", 12, hh, keylen) && uwsgi_strncmp("CONTENT_LENGTH", 14, hh, keylen)) {
 		keylen += 5;
 		prefix = 1;
+		if (!uwsgi_strncmp("IF_MODIFIED_SINCE", 17, hh, keylen)) {
+        		wsgi_req->if_modified_since = val;
+                	wsgi_req->if_modified_since_len = vallen;
+        	}
+		else if (uwsgi.vhost_host && !uwsgi_strncmp("HOST", 4, hh, keylen)) {
+        		wsgi_req->host = val;
+                	wsgi_req->host_len = vallen;
+        	}
 	}
 	else if (!uwsgi_strncmp("CONTENT_LENGTH", 14, hh, keylen)) {
 		wsgi_req->post_cl = uwsgi_str_num(val, vallen);
@@ -96,6 +104,8 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	while (ptr < watermark) {
 		if (*ptr == ' ') {
 			wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_METHOD", 14, base, ptr - base);
+			wsgi_req->method = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+			wsgi_req->method_len = ptr - base;
 			ptr++;
 			break;
 		}
@@ -107,16 +117,25 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 	while (ptr < watermark) {
 		if (*ptr == '?' && !query_string) {
 			wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, base, ptr - base);
+			wsgi_req->path_info = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+			wsgi_req->path_info_len = ptr - base;
 			query_string = ptr + 1;
 		}
 		else if (*ptr == ' ') {
 			wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "REQUEST_URI", 11, base, ptr - base);
+			wsgi_req->uri = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+			wsgi_req->uri_len = ptr - base;
+			
 			if (!query_string) {
 				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "PATH_INFO", 9, base, ptr - base);
+				wsgi_req->path_info = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+				wsgi_req->path_info_len = ptr - base;
 				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, "", 0);
 			}
 			else {
 				wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "QUERY_STRING", 12, query_string, ptr - query_string);
+				wsgi_req->query_string = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - query_string);
+				wsgi_req->query_string_len = ptr - query_string;
 			}
 			ptr++;
 			break;
@@ -133,6 +152,8 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 			if (*(ptr + 1) != '\n')
 				return 0;
 			wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PROTOCOL", 15, base, ptr - base);
+			wsgi_req->protocol = (wsgi_req->buffer + wsgi_req->uh.pktsize) - (ptr - base);
+			wsgi_req->protocol_len = ptr - base;
 			ptr += 2;
 			break;
 		}
@@ -144,14 +165,24 @@ static int http_parse(struct wsgi_request *wsgi_req, char *watermark) {
 
 	// SERVER_NAME
 	wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_NAME", 11, uwsgi.hostname, uwsgi.hostname_len);
+	wsgi_req->host = uwsgi.hostname;
+	wsgi_req->host_len = uwsgi.hostname_len;
 
 	// SERVER_PORT
-	wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "3031", 4);
+	char *server_port = strchr(wsgi_req->socket->name, ':');
+	if (server_port) {
+		wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, server_port+1, strlen(server_port+1));
+	}
+	else {
+		wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "SERVER_PORT", 11, "80", 2);
+	}
 
 	// REMOTE_ADDR
 	memset(ip, 0, INET_ADDRSTRLEN+1);
 	if (inet_ntop(AF_INET, (void *) &http_sin->sin_addr.s_addr, ip, INET_ADDRSTRLEN)) {
 		wsgi_req->uh.pktsize += proto_base_add_uwsgi_var(wsgi_req, "REMOTE_ADDR", 11, ip, strlen(ip));
+		wsgi_req->remote_addr = (wsgi_req->buffer + wsgi_req->uh.pktsize) - strlen(ip);
+		wsgi_req->remote_addr_len = strlen(ip);
 	}
 	else {
 		uwsgi_error("inet_ntop()");
@@ -253,7 +284,7 @@ int uwsgi_proto_http_parser(struct wsgi_request *wsgi_req) {
 			remains = len - (j + 1);
 			http_parse(wsgi_req, ptr);
 			//is there a Content_Length ?
-			if (wsgi_req->post_cl) {
+			if (wsgi_req->post_cl > 0) {
 				wsgi_req->async_post = tmpfile();
 				if (!wsgi_req->async_post) {
 					free(wsgi_req->proto_parser_buf);

proto/zeromq.c

@@ -454,7 +454,6 @@ ssize_t uwsgi_proto_zeromq_sendfile(struct wsgi_request * wsgi_req) {
 
 	wsgi_req->sendfile_fd_chunk = 65536;
 
-
 	if (uwsgi.async > 1) {
 		len = read(wsgi_req->sendfile_fd, buf, UMIN(remains, wsgi_req->sendfile_fd_chunk));
 		if (len != (int) UMIN(remains, wsgi_req->sendfile_fd_chunk)) {

protocol.c

@@ -405,7 +405,7 @@ int uwsgi_parse_array(char *buffer, uint16_t size, char **argv, uint8_t *argc) {
 				*argc = *argc + 1;
 			}
 			else {
-				uwsgi_log( "invalid uwsgi array. skip this request.\n");
+				uwsgi_log( "invalid uwsgi array. skip this var.\n");
                         	return -1;
 			}
 		}
@@ -419,6 +419,73 @@ int uwsgi_parse_array(char *buffer, uint16_t size, char **argv, uint8_t *argc) {
 	return 0;
 }
 
+int uwsgi_simple_parse_vars(struct wsgi_request *wsgi_req, char *ptrbuf, char *bufferend) {
+	
+	uint16_t strsize;
+
+	while (ptrbuf < bufferend) {
+                if (ptrbuf + 2 < bufferend) {
+                        memcpy(&strsize, ptrbuf, 2);
+#ifdef __BIG_ENDIAN__
+                        strsize = uwsgi_swap16(strsize);
+#endif
+                        /* key cannot be null */
+                        if (!strsize) {
+                                uwsgi_log( "uwsgi key cannot be null. skip this request.\n");
+                                return -1;
+                        }
+
+                        ptrbuf += 2;
+                        if (ptrbuf + strsize < bufferend) {
+                                // var key
+                                wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptrbuf;
+                                wsgi_req->hvec[wsgi_req->var_cnt].iov_len = strsize;
+                                ptrbuf += strsize;
+                                // value can be null (even at the end) so use <=
+                                if (ptrbuf + 2 <= bufferend) {
+                                        memcpy(&strsize, ptrbuf, 2);
+#ifdef __BIG_ENDIAN__
+                                        strsize = uwsgi_swap16(strsize);
+#endif
+                                        ptrbuf += 2;
+                                        if (ptrbuf + strsize <= bufferend) {
+                                                
+                                                if (wsgi_req->var_cnt < uwsgi.vec_size - (4 + 1)) {
+                                                        wsgi_req->var_cnt++;
+                                                }
+                                                else {
+                                                        uwsgi_log( "max vec size reached. skip this header.\n");
+                                                        return -1;
+                                                }
+                                                // var value
+                                                wsgi_req->hvec[wsgi_req->var_cnt].iov_base = ptrbuf;
+                                                wsgi_req->hvec[wsgi_req->var_cnt].iov_len = strsize;
+
+                                                if (wsgi_req->var_cnt < uwsgi.vec_size - (4 + 1)) {
+                                                        wsgi_req->var_cnt++;
+                                                }
+                                                else {
+                                                        uwsgi_log( "max vec size reached. skip this var.\n");
+                                                        return -1;
+                                                }
+                                                ptrbuf += strsize;
+                                        }
+                                        else {
+                                                uwsgi_log("invalid uwsgi request (current strsize: %d). skip.\n", strsize);
+                                                return -1;
+                                        }
+                                }
+                                else {
+                                        uwsgi_log("invalid uwsgi request (current strsize: %d). skip.\n", strsize);
+                                        return -1;
+                                }
+			}
+		}
+	}
+
+	return 0;
+}
+
 int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 
 	char *buffer = wsgi_req->buffer;
@@ -433,6 +500,13 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 
 	/* set an HTTP 500 status as default */
 	wsgi_req->status = 500;
+	
+	// has the protocol already parsed the request ?
+	if (wsgi_req->uri_len > 0) {
+		i = uwsgi_simple_parse_vars(wsgi_req, ptrbuf, bufferend);
+		if (i == 0) goto next;
+		return i;
+	}
 
 	while (ptrbuf < bufferend) {
 		if (ptrbuf + 2 < bufferend) {
@@ -442,7 +516,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 #endif
 			/* key cannot be null */
                         if (!strsize) {
-                                uwsgi_log( "uwsgi key cannot be null. skip this request.\n");
+                                uwsgi_log( "uwsgi key cannot be null. skip this var.\n");
                                 return -1;
                         }
 			
@@ -508,14 +582,17 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 						else if (!uwsgi_strncmp("UWSGI_SCRIPT", 12, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len )) {
 							wsgi_req->script = ptrbuf;
 							wsgi_req->script_len = strsize;
+							wsgi_req->dynamic = 1;
 						}
 						else if (!uwsgi_strncmp("UWSGI_MODULE", 12, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->module = ptrbuf;
 							wsgi_req->module_len = strsize;
+							wsgi_req->dynamic = 1;
 						}
 						else if (!uwsgi_strncmp("UWSGI_CALLABLE", 14, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->callable = ptrbuf;
 							wsgi_req->callable_len = strsize;
+							wsgi_req->dynamic = 1;
 						}
 						else if (!uwsgi_strncmp("UWSGI_PYHOME", 12, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->pyhome = ptrbuf;
@@ -525,9 +602,14 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->chdir = ptrbuf;
 							wsgi_req->chdir_len = strsize;
 						}
+						else if (!uwsgi_strncmp("UWSGI_APPID", 11, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+							wsgi_req->appid = ptrbuf;
+							wsgi_req->appid_len = strsize;
+						}
 						else if (!uwsgi_strncmp("UWSGI_FILE", 10, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->file = ptrbuf;
 							wsgi_req->file_len = strsize;
+							wsgi_req->dynamic = 1;
 						}
 						else if (!uwsgi_strncmp("UWSGI_TOUCH_RELOAD", 18, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->touch_reload = ptrbuf;
@@ -570,6 +652,10 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->if_modified_since = ptrbuf;
 							wsgi_req->if_modified_since_len = strsize;
 						}
+						else if (!uwsgi_strncmp("CONTENT_TYPE", 12, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
+							wsgi_req->content_type = ptrbuf;
+							wsgi_req->content_type_len = strsize;
+						}
 						else if (!uwsgi_strncmp("CONTENT_LENGTH", 14, wsgi_req->hvec[wsgi_req->var_cnt].iov_base, wsgi_req->hvec[wsgi_req->var_cnt].iov_len)) {
 							wsgi_req->post_cl = get_content_length(ptrbuf, strsize);
 							if (uwsgi.limit_post) {
@@ -585,7 +671,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->var_cnt++;
 						}
 						else {
-							uwsgi_log( "max vec size reached. skip this header.\n");
+							uwsgi_log( "max vec size reached. skip this var.\n");
 							return -1;
 						}
 						// var value
@@ -596,7 +682,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 							wsgi_req->var_cnt++;
 						}
 						else {
-							uwsgi_log( "max vec size reached. skip this header.\n");
+							uwsgi_log( "max vec size reached. skip this var.\n");
 							return -1;
 						}
 						ptrbuf += strsize;
@@ -618,6 +704,8 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 		}
 	}
 
+next:
+
 	if (uwsgi.post_buffering > 0 && !wsgi_req->body_as_file && !wsgi_req->async_post) {
         	// read to disk if post_cl > post_buffering (it will eventually do upload progress...)
                 if (wsgi_req->post_cl >= (size_t) uwsgi.post_buffering) {
@@ -661,7 +749,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 	}
 
 	if (uwsgi.manage_script_name) {
-		if (uwsgi.apps_cnt > 0 && wsgi_req->path_info_len > 1) {
+		if (uwsgi_apps_cnt > 0 && wsgi_req->path_info_len > 1) {
 			// starts with 1 as the 0 app is the default (/) one
 			int best_found = 0;
 			char *orig_path_info = wsgi_req->path_info;
@@ -669,7 +757,7 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 			// if SCRIPT_NAME is not allocated, add a slot for it
 			if (script_name == -1) {
 				if (wsgi_req->var_cnt >= uwsgi.vec_size - (4 + 2)) {
-					uwsgi_log( "max vec size reached. skip this header.\n");
+					uwsgi_log( "max vec size reached. skip this var.\n");
                                         return -1;
 				}
 				wsgi_req->var_cnt++;
@@ -678,13 +766,13 @@ int uwsgi_parse_vars(struct wsgi_request *wsgi_req) {
 				wsgi_req->var_cnt++;
 				script_name = wsgi_req->var_cnt;
 			}
-			for(i=0;i<uwsgi.apps_cnt;i++) {
-				//uwsgi_log("app mountpoint = %.*s\n", uwsgi.apps[i].mountpoint_len, uwsgi.apps[i].mountpoint);
-				if (orig_path_info_len >= uwsgi.apps[i].mountpoint_len) {
-					if (!uwsgi_startswith(orig_path_info, uwsgi.apps[i].mountpoint, uwsgi.apps[i].mountpoint_len) && uwsgi.apps[i].mountpoint_len > best_found) {
-						best_found = uwsgi.apps[i].mountpoint_len;
-						wsgi_req->script_name = uwsgi.apps[i].mountpoint;
-						wsgi_req->script_name_len = uwsgi.apps[i].mountpoint_len;
+			for(i=0;i<uwsgi_apps_cnt;i++) {
+				//uwsgi_log("app mountpoint = %.*s\n", uwsgi_apps[i].mountpoint_len, uwsgi_apps[i].mountpoint);
+				if (orig_path_info_len >= uwsgi_apps[i].mountpoint_len) {
+					if (!uwsgi_startswith(orig_path_info, uwsgi_apps[i].mountpoint, uwsgi_apps[i].mountpoint_len) && uwsgi_apps[i].mountpoint_len > best_found) {
+						best_found = uwsgi_apps[i].mountpoint_len;
+						wsgi_req->script_name = uwsgi_apps[i].mountpoint;
+						wsgi_req->script_name_len = uwsgi_apps[i].mountpoint_len;
 						wsgi_req->path_info = orig_path_info+wsgi_req->script_name_len;
 						wsgi_req->path_info_len = orig_path_info_len-wsgi_req->script_name_len;
 

queue.c

@@ -6,17 +6,15 @@ void uwsgi_init_queue() {
 	if (!uwsgi.queue_blocksize)
                         uwsgi.queue_blocksize = 8192;
 
-                if (uwsgi.queue_blocksize % uwsgi.page_size != 0) {
-                        uwsgi_log("invalid queue blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.queue_blocksize, uwsgi.page_size);
+                if ((uwsgi.queue_blocksize * uwsgi.queue_size) % uwsgi.page_size != 0) {
+                        uwsgi_log("invalid queue size/blocksize %llu: must be a multiple of memory page size (%d bytes)\n", (unsigned long long) uwsgi.queue_blocksize, uwsgi.page_size);
                         exit(1);
                 }
 
 
-                uwsgi.shared->queue_pos = 0;
-                uwsgi.shared->queue_pull_pos = 0;
 
                 if (uwsgi.queue_store) {
-                        uwsgi.queue_filesize = uwsgi.queue_blocksize * uwsgi.queue_size;
+                        uwsgi.queue_filesize = uwsgi.queue_blocksize * uwsgi.queue_size + 16;
                         int queue_fd;
                         struct stat qst;
 
@@ -45,16 +43,26 @@ void uwsgi_init_queue() {
                                 exit(1);
                         }
                         uwsgi.queue = mmap(NULL, uwsgi.queue_filesize, PROT_READ | PROT_WRITE, MAP_SHARED, queue_fd, 0);
-                        uwsgi_queue_fix();
+
+			// fix header
+			uwsgi.queue_header = uwsgi.queue;
+			uwsgi.queue+=16;
                 }
                 else {
-                        uwsgi.queue = mmap(NULL, uwsgi.queue_blocksize * uwsgi.queue_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                        uwsgi.queue = mmap(NULL, (uwsgi.queue_blocksize * uwsgi.queue_size)+16, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+			// fix header
+			uwsgi.queue_header = uwsgi.queue;
+			uwsgi.queue+=16;
+                	uwsgi.queue_header->pos = 0;
+                	uwsgi.queue_header->pull_pos = 0;
                 }
                 if (!uwsgi.queue) {
                         uwsgi_error("mmap()");
                         exit(1);
                 }
 
+
+
                 uwsgi.queue_lock = uwsgi_mmap_shared_rwlock();
                 uwsgi_rwlock_init(uwsgi.queue_lock);
 
@@ -78,33 +86,20 @@ char *uwsgi_queue_get(uint64_t index, uint64_t *size) {
 	
 }
 
-void uwsgi_queue_fix() {
-
-        uint64_t i;
-	char *value;
-	uint64_t size;
-
-        for(i=0;i< uwsgi.queue_size;i++) {
-                // valid record ?
-		value = uwsgi_queue_get(i, &size);
-		if (value && size) {
-			uwsgi.shared->queue_pos++;
-		}
-		else {
-			return;
-		}
-        }
-}
-
 
 char *uwsgi_queue_pop(uint64_t *size) {
 
         struct uwsgi_queue_item *uqi;
         char *ptr = (char *) uwsgi.queue;
 
-	if (uwsgi.shared->queue_pos > 0) uwsgi.shared->queue_pos--;
+	if (uwsgi.queue_header->pos == 0) {
+		uwsgi.queue_header->pos = uwsgi.queue_size-1;
+	}
+	else {
+		uwsgi.queue_header->pos--;
+	}
 
-        ptr = ptr + (uwsgi.queue_blocksize*uwsgi.shared->queue_pos);
+        ptr = ptr + (uwsgi.queue_blocksize*uwsgi.queue_header->pos);
         uqi = (struct uwsgi_queue_item *) ptr;
 
         if (!uqi->size) return NULL;
@@ -122,16 +117,16 @@ char *uwsgi_queue_pull(uint64_t *size) {
 	struct uwsgi_queue_item *uqi;
 	char *ptr = (char *) uwsgi.queue;	
 
-	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.shared->queue_pull_pos);
+	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.queue_header->pull_pos);
 	uqi = (struct uwsgi_queue_item *) ptr;
 
 	if (!uqi->size) return NULL;
 
 	*size = uqi->size;
 
-	uwsgi.shared->queue_pull_pos++;
+	uwsgi.queue_header->pull_pos++;
 
-	if (uwsgi.shared->queue_pull_pos >= uwsgi.queue_size) uwsgi.shared->queue_pull_pos = 0;
+	if (uwsgi.queue_header->pull_pos >= uwsgi.queue_size) uwsgi.queue_header->pull_pos = 0;
 
 	// remove item
 	uqi->size = 0;
@@ -150,7 +145,7 @@ int uwsgi_queue_push(char *message, uint64_t size) {
 
 	if (!size) return 0;
 
-	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.shared->queue_pos);
+	ptr = ptr + (uwsgi.queue_blocksize*uwsgi.queue_header->pos);
 	uqi = (struct uwsgi_queue_item *) ptr;
 
 	ptr += sizeof(struct uwsgi_queue_item);
@@ -159,9 +154,34 @@ int uwsgi_queue_push(char *message, uint64_t size) {
 	uqi->ts = time(NULL);
 	memcpy(ptr, message, size);
 
-	uwsgi.shared->queue_pos++;
+	uwsgi.queue_header->pos++;
 	
-	if (uwsgi.shared->queue_pos >= uwsgi.queue_size) uwsgi.shared->queue_pos = 0;
+	if (uwsgi.queue_header->pos >= uwsgi.queue_size) uwsgi.queue_header->pos = 0;
 
 	return 1;
 }
+
+int uwsgi_queue_set(uint64_t pos, char *message, uint64_t size) {
+
+        struct uwsgi_queue_item *uqi;
+        char *ptr = (char *) uwsgi.queue;
+
+        if (size > uwsgi.queue_blocksize + sizeof(struct uwsgi_queue_item))
+                return 0;
+
+        if (!size) return 0;
+
+	if (pos >= uwsgi.queue_size) return 0;
+
+        ptr = ptr + (uwsgi.queue_blocksize*pos);
+        uqi = (struct uwsgi_queue_item *) ptr;
+
+        ptr += sizeof(struct uwsgi_queue_item);
+
+        uqi->size = size;
+        uqi->ts = time(NULL);
+        memcpy(ptr, message, size);
+
+        return 1;
+}
+

setup.py

@@ -8,6 +8,14 @@ from setuptools.dist import Distribution
 from setuptools.command.install import install
 from setuptools.command.build_ext import build_ext
 
+def get_profile():
+    profile = os.environ.get('UWSGI_PROFILE','buildconf/default.ini')
+    if not profile.endswith('.ini'):
+        profile = "%s.ini" % profile
+    if not '/' in profile:
+        profile = "buildconf/%s" % profile
+
+    return profile
 
 def patch_bin_path(cmd, conf):
 
@@ -26,7 +34,7 @@ def patch_bin_path(cmd, conf):
 class uWSGIBuilder(build_ext):
 
     def run(self):
-        conf = uc.uConf('buildconf/default.ini')
+        conf = uc.uConf(get_profile())
         patch_bin_path(self, conf)
         uc.build_uwsgi( conf )
 
@@ -38,7 +46,7 @@ class uWSGIInstall(install):
         if self.record:
             record_file = open(self.record,'w')
 
-        conf = uc.uConf('buildconf/default.ini')
+        conf = uc.uConf(get_profile())
         patch_bin_path(self, conf)
         uc.build_uwsgi( conf )
 

skel.c

@@ -0,0 +1,10 @@
+/* this is a skeleton to use libuwsgi in external projects */
+
+extern char **environ;
+
+int uwsgi_init(int, char **, char **);
+
+int main(int argc, char **argv, char **environ) {
+
+	uwsgi_init(argc, argv, environ);
+}

snmp.c

@@ -350,123 +350,6 @@ static int get_snmp_integer(uint8_t * ptr, uint64_t * val) {
 			return size + oid_sz;
 
 		}
-
-		/*
-		   PyObject *py_snmp_counter32(PyObject * self, PyObject * args) {
-
-		   uint8_t oid_num;
-		   uint32_t oid_val = 0;
-
-		   if (!PyArg_ParseTuple(args, "bI:snmp_set_counter32", &oid_num, &oid_val)) {
-		   return NULL;
-		   }
-
-		   if (oid_num > 100 || oid_num < 1)
-		   goto clear;
-
-		   uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_COUNTER32;
-		   uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
-
-		   Py_INCREF(Py_True);
-		   return Py_True;
-
-clear:
-
-Py_INCREF(Py_None);
-return Py_None;
-}
-
-PyObject *py_snmp_counter64(PyObject * self, PyObject * args) {
-
-uint8_t oid_num;
-uint64_t oid_val = 0;
-
-if (!PyArg_ParseTuple(args, "bK:snmp_set_counter64", &oid_num, &oid_val)) {
-return NULL;
-}
-
-if (oid_num > 100 || oid_num < 1)
-goto clear;
-
-uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_COUNTER64;
-uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
-
-Py_INCREF(Py_True);
-return Py_True;
-
-clear:
-
-Py_INCREF(Py_None);
-return Py_None;
-}
-
-PyObject *py_snmp_gauge(PyObject * self, PyObject * args) {
-
-uint8_t oid_num;
-uint32_t oid_val = 0;
-
-if (!PyArg_ParseTuple(args, "bI:snmp_set_gauge", &oid_num, &oid_val)) {
-return NULL;
-}
-
-if (oid_num > 100 || oid_num < 1)
-goto clear;
-
-uwsgi.shared->snmp_value[oid_num - 1].type = SNMP_GAUGE;
-uwsgi.shared->snmp_value[oid_num - 1].val = oid_val;
-
-Py_INCREF(Py_True);
-return Py_True;
-
-clear:
-
-Py_INCREF(Py_None);
-return Py_None;
-}
-
-PyObject *py_snmp_community(PyObject * self, PyObject * args) {
-
-	char *snmp_community;
-
-	if (!PyArg_ParseTuple(args, "s:snmp_set_community", &snmp_community)) {
-		return NULL;
-	}
-
-	if (strlen(snmp_community) > 72) {
-		uwsgi_log( "*** warning the supplied SNMP community string will be truncated to 72 chars ***\n");
-		memcpy(uwsgi.shared->snmp_community, snmp_community, 72);
-	}
-	else {
-		memcpy(uwsgi.shared->snmp_community, snmp_community, strlen(snmp_community) + 1);
-	}
-
-	Py_INCREF(Py_True);
-	return Py_True;
-
-}
-
-static PyMethodDef uwsgi_snmp_methods[] = {
-	{"snmp_set_counter32", py_snmp_counter32, METH_VARARGS, ""},
-	{"snmp_set_counter64", py_snmp_counter64, METH_VARARGS, ""},
-	{"snmp_set_gauge", py_snmp_gauge, METH_VARARGS, ""},
-	{"snmp_set_community", py_snmp_community, METH_VARARGS, ""},
-	{NULL, NULL},
-};
-
-void snmp_init() {
-
-	PyMethodDef *uwsgi_function;
-
-	for (uwsgi_function = uwsgi_snmp_methods; uwsgi_function->ml_name != NULL; uwsgi_function++) {
-		PyObject *func = PyCFunction_New(uwsgi_function, NULL);
-		PyDict_SetItemString(uwsgi.embedded_dict, uwsgi_function->ml_name, func);
-		Py_DECREF(func);
-	}
-
-	uwsgi_log( "SNMP python functions initialized.\n");
-}
-*/
-
 #else
 #warning "*** SNMP support is disabled ***"
 #endif

socket.c

@@ -500,6 +500,17 @@ int bind_to_tcp(char *socket_name, int listen_queue, char *tcp_port) {
 		uwsgi_nuclear_blast();
 	}
 
+#ifdef __linux__
+#ifdef IP_FREEBIND
+	if (uwsgi.freebind) {
+		if (setsockopt(serverfd, SOL_IP, IP_FREEBIND, (const void *) &uwsgi.freebind, sizeof(int)) < 0) {
+			uwsgi_error("setsockopt()");
+			uwsgi_nuclear_blast();
+		}
+	}
+#endif
+#endif
+
 	if (uwsgi.reuse_port) {
 #ifdef SO_REUSEPORT
 		if (setsockopt(serverfd, SOL_SOCKET, SO_REUSEPORT, (const void *) &uwsgi.reuse_port, sizeof(int)) < 0) {
@@ -758,7 +769,25 @@ struct uwsgi_socket *uwsgi_new_socket(char *name) {
 
 			char *auto_port = uwsgi_num2str(ntohs(sin.sin_port));
 			uwsgi_sock->name = uwsgi_concat3n(name, tcp_port-name, ":", 1, auto_port, strlen(auto_port));
-		}	
+		}
+		// is it fd 0 ?
+		else if (tcp_port[1] == ':') {
+			uwsgi_sock->fd = 0;
+                        uwsgi_sock->family = AF_INET;
+			uwsgi_sock->bound = 1;
+
+			socket_type_len = sizeof(struct sockaddr_in);
+
+			if (getsockname(0, (struct sockaddr *)&sin, &socket_type_len)) {
+				uwsgi_error("getsockname()");
+				exit(1);
+			}
+
+
+			char *auto_port = uwsgi_num2str(ntohs(sin.sin_port));
+			char *auto_ip = inet_ntoa(sin.sin_addr);
+			uwsgi_sock->name = uwsgi_concat3n(auto_ip, strlen(auto_ip), ":", 1, auto_port, strlen(auto_port));
+		}
 	}
 	
 	return uwsgi_sock;
@@ -790,7 +819,12 @@ void uwsgi_add_socket_from_fd(struct uwsgi_socket *uwsgi_sock, int fd) {
 				uwsgi_sock->family = AF_UNIX;
 				uwsgi_sock->bound = 1;
 				uwsgi_sock->name = uwsgi_concat2(usa.sa_un.sun_path+abstract, "");
-				uwsgi_log("uwsgi zerg socket %d attached to UNIX address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), usa.sa_un.sun_path+abstract, uwsgi_sock->fd);
+				if (uwsgi.zerg) {
+					uwsgi_log("uwsgi zerg socket %d attached to UNIX address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), usa.sa_un.sun_path+abstract, uwsgi_sock->fd);
+				}
+				else {
+					uwsgi_log("uwsgi socket %d attached to UNIX address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), usa.sa_un.sun_path+abstract, uwsgi_sock->fd);
+				}
 				return;
 			}
 			if (!strcmp(usa.sa_un.sun_path+abstract, uwsgi_sock->name+abstract)) {
@@ -825,7 +859,12 @@ void uwsgi_add_socket_from_fd(struct uwsgi_socket *uwsgi_sock, int fd) {
 						uwsgi_sock->family = AF_INET;
 						uwsgi_sock->bound = 1;
 						uwsgi_sock->name = uwsgi_concat2(computed_addr, "");
-						uwsgi_log("uwsgi zerg socket %d attached to INET address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), computed_addr, uwsgi_sock->fd);
+						if (uwsgi.zerg) {
+							uwsgi_log("uwsgi zerg socket %d attached to INET address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), computed_addr, uwsgi_sock->fd);
+						}
+						else {
+							uwsgi_log("uwsgi socket %d attached to INET address %s fd %d\n", uwsgi_get_socket_num(uwsgi_sock), computed_addr, uwsgi_sock->fd);
+						}
 						free(computed_addr);
 						return;
 					}

spooler.c

@@ -9,6 +9,9 @@ static void spooler_scandir(char *);
 #endif
 void spooler_manage_task(char *, char *);
 
+// fake function to allow waking the spooler
+void spooler_wakeup() {}
+
 pid_t spooler_start() {
 	
 	int i;
@@ -30,6 +33,10 @@ pid_t spooler_start() {
 		exit(1);
 	}
 	else if (pid == 0) {
+		// USR1 will be used to wake up the spooler
+		signal(SIGUSR1, spooler_wakeup);
+		uwsgi.mywid = -1;
+		uwsgi.mypid = pid;
 		uwsgi_close_all_sockets();
 		if (uwsgi.master_process) {
 			close(uwsgi.shared->spooler_signal_pipe[0]);
@@ -39,7 +46,24 @@ pid_t spooler_start() {
 				}
 			}
 		}
+
+		for (i = 0; i < 0xFF; i++) {
+                	if (uwsgi.p[i]->post_fork) {
+                        	uwsgi.p[i]->post_fork();
+                	}
+        	}
 		uwsgi.signal_socket = uwsgi.shared->spooler_signal_pipe[1];
+		for (i = 0; i < 0xFF; i++) {
+                	if (uwsgi.p[i]->spooler_init) {
+                        	uwsgi.p[i]->spooler_init();
+                	}
+        	}
+
+        	for (i = 0; i < uwsgi.gp_cnt; i++) {
+                	if (uwsgi.gp[i]->spooler_init) {
+                        	uwsgi.gp[i]->spooler_init();
+                	}
+        	}
 		spooler();
 	}
 	else if (pid > 0) {
@@ -160,13 +184,20 @@ int spool_request(char *filename, int rn, int core_id, char *buffer, int size, c
 	
 	uwsgi_unlock(uwsgi.spooler_lock);
 
+/*	wake up the spooler ... (HACKY) */
+	if (uwsgi.shared->spooler_pid > 0 ) {
+		(void) kill(uwsgi.shared->spooler_pid, SIGUSR1);
+	}
+
 	return 1;
 
 
       clear:
 	uwsgi_unlock(uwsgi.spooler_lock);
 	uwsgi_error("write()");
-	unlink(filename);
+	if (unlink(filename)) {
+		uwsgi_error("unlink()");
+	}
 	close(fd);
 	return 0;
 }
@@ -231,10 +262,8 @@ void spooler() {
 				if (interesting_fd == uwsgi.shared->spooler_signal_pipe[1]) {
 					uint8_t uwsgi_signal;
 					if (read(interesting_fd, &uwsgi_signal, 1) <= 0) {
-                                        	if (uwsgi.no_orphans) {
                                                 	uwsgi_log_verbose("uWSGI spooler screams: UAAAAAAH my master died, i will follow him...\n");
                                                		end_me(0); 
-                                        	}
                                 	}
                                 	else {
 #ifdef UWSGI_DEBUG
@@ -416,7 +445,6 @@ int uwsgi_request_spooler(struct wsgi_request *wsgi_req) {
 		return -1;
 	}
 
-	uwsgi_log("managing spool request...\n");
 	i = spool_request(spool_filename, uwsgi.workers[0].requests + 1, wsgi_req->async_id, wsgi_req->buffer, wsgi_req->uh.pktsize, NULL, 0, NULL, 0);
 	wsgi_req->uh.modifier1 = 255;
 	wsgi_req->uh.pktsize = 0;

tests/multiapp.txt

@@ -0,0 +1,23 @@
+- case 1
+
+single static app
+
+- case 2
+
+single static multiapp
+
+- case 3
+
+multi app static mountpoint
+
+- case 4
+
+dynamic apps with UWSGI_APPID
+
+- case 5
+
+dynamic apps with SCRIPT_NAME
+
+- case 6
+
+dynamic apps with vhost mode

tests/picazzo.py

@@ -0,0 +1,22 @@
+from picasso import *
+
+def home(req):
+  if not req["session"].get("user"):
+    return redirect("/login")
+  return "<h1>Welcome back, %s!</h1>" % req["session"]["user"]
+
+def login(req):
+  return "<form method='post'><input type='submit' name='foo' value='login' /></form>"
+
+def login_post(req):
+  print req
+  req["session"]["user"] = "James"
+  return redirect("/")
+
+routes = setup_routes(
+  GET("/", home),
+  GET("/login", login),
+  POST("/login", login_post),
+  routing.not_found("<h1>Not Found</h1>"))
+
+app = setup_app(routes)

tests/pump.py

@@ -0,0 +1,7 @@
+def app(req):
+  print(req)
+  ret = {"status": 200,
+          "headers": {"content_type": "text/html", "foo":['bar0','bar1','bar2']},
+          "body": "<h1>Hello!</h1>"}
+  print(ret)
+  return ret

tests/queue.py

@@ -0,0 +1,48 @@
+# uwsgi --queue 10 --queue-store test.queue --master --module tests.queue --socket :3031
+
+import uwsgi
+import os
+from flask import Flask,render_template,request,redirect,flash
+
+app = Flask(__name__)
+app.debug = True
+app.secret_key = os.urandom(24)
+
+@app.route('/')
+def index():
+
+    return render_template('queue.html', uwsgi=uwsgi)
+
+@app.route('/push', methods=['POST'])
+def push_item():
+    if uwsgi.queue_push(request.form['body']):
+        flash('item enqueued')
+        return redirect('/')
+    else:
+        flash('unable to enqueue item')
+        return render_template('queue.html', uwsgi=uwsgi)
+
+@app.route('/get', methods=['POST'])
+def get_item():
+    flash( "slot %s value = %s" % (request.form['slot'], uwsgi.queue_get( int(request.form['slot']) )))
+    return redirect('/')
+
+@app.route('/pop', methods=['POST'])
+def pop_item():
+    flash( "popped value = %s" %  uwsgi.queue_pop() )
+    return redirect('/')
+
+@app.route('/pull', methods=['POST'])
+def pull_item():
+    flash( "pulled value = %s" %  uwsgi.queue_pull() )
+    return redirect('/')
+
+
+@app.route('/set', methods=['POST'])
+def set_item():
+    if uwsgi.queue_set(int(request.form['pos']), request.form['body']):
+        flash('item set')
+        return redirect('/')
+    else:
+        flash('unable to set item')
+        return render_template('queue.html', uwsgi=uwsgi)

tests/refcount.py

@@ -0,0 +1,6 @@
+import sys
+
+def application(e, sr):
+    sr('200 OK', [('Content-Type','text/html')])
+    print sys.gettotalrefcount()
+    yield '%s' % sys.gettotalrefcount()

tests/sharedarea.py

@@ -0,0 +1,16 @@
+import uwsgi
+
+uwsgi.sharedarea_writelong(173, 30)
+
+def application(e, sr):
+
+    sr('200 Ok', [('Content-Type','text/html')])
+
+    uwsgi.sharedarea_write(17, e['REQUEST_URI'])
+
+    uwsgi.sharedarea_inclong(173)
+    uwsgi.sharedarea_inclong(173, 17)
+
+    yield uwsgi.sharedarea_read(17, len(e['REQUEST_URI']))
+    yield "<br/>"
+    yield str(uwsgi.sharedarea_readlong(173))

tests/templates/queue.html

@@ -0,0 +1,50 @@
+<head>
+<style>
+.flash {
+color: red;
+}
+</style>
+</head>
+<body>
+{% with messages = get_flashed_messages() %}
+        {% if messages %}
+                <div class="flash">
+                        <ul>
+                        {% for message in messages %}
+                                <li>{{ message }}</li>
+                        {% endfor %}
+                        </ul>
+                </div>
+        {% endif %}
+{% endwith %}
+<h1>next available slot: {{uwsgi.queue_slot()}}</h1>
+<h1>next available pull slot: {{uwsgi.queue_pull_slot()}}</h1>
+{% for item in range(0, uwsgi.queue_size) %}
+
+slot {{item}} = {{uwsgi.queue_get(item)}}<br/>
+
+{% endfor %}
+
+<br/>
+
+<form method="POST" action="/push">
+<input type="text" name="body"><input type="submit" value="push value" /><br/>
+</form>
+
+<form method="POST" action="/get">
+<input type="text" name="slot" size="9"><input type="submit" value="get value" /><br/>
+</form>
+
+<form method="POST" action="/pop">
+<input type="submit" value="pop value" /><br/>
+</form>
+
+<form method="POST" action="/pull">
+<input type="submit" value="pull value" /><br/>
+</form>
+
+<form method="POST" action="/set">
+<input type="text" name="pos" size="5" /> <input type="text" name="body"><input type="submit" value="set value" /><br/>
+</form>
+
+</body>

tests/ugevent.py

@@ -0,0 +1,48 @@
+import gevent
+import gevent.socket
+import sys
+
+if 'gettotalrefcount' in sys.__dict__:
+    REFCNT = True
+else:
+    REFCNT = False
+
+
+def bg_task():
+    for i in range(1,10):
+        print "background task", i
+        gevent.sleep(2)
+
+def long_task():
+    for i in range(1,10):
+        print i
+        gevent.sleep()
+
+def application(e, sr):
+
+    sr('200 OK', [('Content-Type','text/html')])
+
+    t = gevent.spawn(long_task)
+
+    t.join()
+
+    yield "sleeping for 3 seconds...<br/>"
+
+    gevent.sleep(3)
+
+    yield "done<br>"
+
+    yield "getting some ips...<br/>"
+
+    urls = ['www.google.com', 'www.example.com', 'www.python.org', 'projects.unbit.it']
+    jobs = [gevent.spawn(gevent.socket.gethostbyname, url) for url in urls]
+    gevent.joinall(jobs, timeout=2)
+
+    for j in jobs:
+        yield "ip = %s<br/>" % j.value
+
+    if REFCNT:
+        print sys.gettotalrefcount()
+
+    # this task will goes on after request end
+    gevent.spawn(bg_task)

tests/web3.py

@@ -0,0 +1,9 @@
+class AppClass(object):
+
+    def __call__(self, environ):
+        status = b'200 OK'
+        headers = [(b'Content-type', b'text/plain')]
+        body = [b'Hello world!\n']
+        return body, status, headers
+
+application = AppClass()

utils.c

@@ -3,6 +3,54 @@
 
 extern struct uwsgi_server uwsgi;
 
+/* statistically ordered */
+struct http_status_codes hsc[] = {
+        {"200", "OK"},
+        {"302", "Found"},
+        {"404", "Not Found"},
+        {"500", "Internal Server Error"},
+        {"301", "Moved Permanently"},
+        {"304", "Not Modified"},
+        {"303", "See Other"},
+        {"403", "Forbidden"},
+        {"307", "Temporary Redirect"},
+        {"401", "Unauthorized"},
+        {"400", "Bad Request"},
+        {"405", "Method Not Allowed"},
+        {"408", "Request Timeout"},
+
+        {"100", "Continue"},
+        {"101", "Switching Protocols"},
+        {"201", "Created"},
+        {"202", "Accepted"},
+        {"203", "Non-Authoritative Information"},
+        {"204", "No Content"},
+        {"205", "Reset Content"},
+        {"206", "Partial Content"},
+        {"300", "Multiple Choices"},
+        {"305", "Use Proxy"},
+        {"402", "Payment Required"},
+        {"406", "Not Acceptable"},
+        {"407", "Proxy Authentication Required"},
+        {"409", "Conflict"},
+        {"410", "Gone"},
+        {"411", "Length Required"},
+        {"412", "Precondition Failed"},
+        {"413", "Request Entity Too Large"},
+        {"414", "Request-URI Too Long"},
+        {"415", "Unsupported Media Type"},
+        {"416", "Requested Range Not Satisfiable"},
+        {"417", "Expectation Failed"},
+        {"501", "Not Implemented"},
+        {"502", "Bad Gateway"},
+        {"503", "Service Unavailable"},
+        {"504", "Gateway Timeout"},
+        {"505", "HTTP Version Not Supported"},
+        { "", NULL },
+};
+
+
+
 #ifdef __BIG_ENDIAN__
 uint16_t uwsgi_swap16(uint16_t x) {
 	return (uint16_t) ((x & 0xff) << 8 | (x & 0xff00) >> 8);
@@ -282,6 +330,12 @@ void log_socket(char *socket_name) {
 
 	// create log connection with the master
 
+	create_logpipe();
+
+}
+
+void create_logpipe(void) {
+
 	if (socketpair(AF_UNIX, SOCK_DGRAM, 0, uwsgi.shared->worker_log_pipe)) {
                 uwsgi_error("socketpair()\n");
                 exit(1);
@@ -290,7 +344,7 @@ void log_socket(char *socket_name) {
         uwsgi_socket_nb(uwsgi.shared->worker_log_pipe[0]);
         uwsgi_socket_nb(uwsgi.shared->worker_log_pipe[1]);
 
-	if (uwsgi.shared->worker_log_pipe[1] != 1) {
+        if (uwsgi.shared->worker_log_pipe[1] != 1) {
                 if (dup2(uwsgi.shared->worker_log_pipe[1], 1) < 0) {
                         uwsgi_error("dup2()");
                         exit(1);
@@ -673,7 +727,9 @@ void uwsgi_close_request(struct wsgi_request *wsgi_req) {
 void wsgi_req_setup(struct wsgi_request *wsgi_req, int async_id, struct uwsgi_socket *uwsgi_sock) {
 
 	wsgi_req->poll.events = POLLIN;
+
 	wsgi_req->app_id = uwsgi.default_app;
+
 	wsgi_req->async_id = async_id;
 #ifdef UWSGI_SENDFILE
 	wsgi_req->sendfile_fd = -1;
@@ -901,6 +957,15 @@ void env_to_arg(char *src, char *dst) {
 	dst[strlen(src)] = 0;
 }
 
+char *uwsgi_lower(char *str, size_t size) {
+	size_t i;
+	for(i=0;i<size;i++) {
+		str[i] = tolower((int) str[i]);
+	}
+
+	return str;
+}
+
 void parse_sys_envs(char **envs) {
 
 	char **uenvs = envs;
@@ -1008,6 +1073,17 @@ void uwsgi_log_verbose(const char *fmt, ...) {
 	rlen = write(2, logpkt, rlen);
 }
 
+char *uwsgi_str_contains(char *str, int slen, char what) {
+
+	int i;
+	for(i=0;i<slen;i++) {
+		if (str[i] == what) {
+			return str+i;
+		}
+	}
+	return NULL;
+}
+
 inline int uwsgi_strncmp(char *src, int slen, char *dst, int dlen) {
 
 	if (slen != dlen)
@@ -1263,22 +1339,22 @@ char *uwsgi_strncopy(char *s, int len) {
 }
 
 
-int uwsgi_get_app_id(char *script_name, int script_name_len, int modifier1) {
+int uwsgi_get_app_id(char *app_name, int app_name_len, int modifier1) {
 
 	int i;
 	struct stat st;
 
-	for (i = 0; i < uwsgi.apps_cnt; i++) {
+	for (i = 0; i < uwsgi_apps_cnt; i++) {
 #ifdef UWSGI_DEBUG
-		uwsgi_log("searching for %.*s in %.*s %p\n", script_name_len, script_name, uwsgi.apps[i].mountpoint_len, uwsgi.apps[i].mountpoint, uwsgi.apps[i].callable);
+		uwsgi_log("searching for %.*s in %.*s %p\n", app_name_len, app_name, uwsgi_apps[i].mountpoint_len, uwsgi_apps[i].mountpoint, uwsgi_apps[i].callable);
 #endif
-		if (!uwsgi.apps[i].callable) {
+		if (!uwsgi_apps[i].callable) {
 			continue;
 		}
-		if (!uwsgi_strncmp(uwsgi.apps[i].mountpoint, uwsgi.apps[i].mountpoint_len, script_name, script_name_len)) {
-			if (uwsgi.apps[i].touch_reload) {
-				if (!stat(uwsgi.apps[i].touch_reload, &st)) {
-					if (st.st_mtime != uwsgi.apps[i].touch_reload_mtime) {
+		if (!uwsgi_strncmp(uwsgi_apps[i].mountpoint, uwsgi_apps[i].mountpoint_len, app_name, app_name_len)) {
+			if (uwsgi_apps[i].touch_reload) {
+				if (!stat(uwsgi_apps[i].touch_reload, &st)) {
+					if (st.st_mtime != uwsgi_apps[i].touch_reload_mtime) {
 						// serve the new request and reload
 						uwsgi.workers[uwsgi.mywid].manage_next_request = 0;
 						if (uwsgi.threads > 1) {
@@ -1286,14 +1362,14 @@ int uwsgi_get_app_id(char *script_name, int script_name_len, int modifier1) {
 						}
 
 #ifdef UWSGI_DEBUG
-						uwsgi_log("mtime %d %d\n", st.st_mtime, uwsgi.apps[i].touch_reload_mtime);
+						uwsgi_log("mtime %d %d\n", st.st_mtime, uwsgi_apps[i].touch_reload_mtime);
 #endif
 					}
 				}
 			}
 			if (modifier1 == -1)
 				return i;
-			if (modifier1 == uwsgi.apps[i].modifier1)
+			if (modifier1 == uwsgi_apps[i].modifier1)
 				return i;
 		}
 	}
@@ -1322,7 +1398,7 @@ int uwsgi_read_whole_body_in_mem(struct wsgi_request *wsgi_req, char *buf) {
 	ssize_t len;
 	char *ptr = buf;
 
-	while (post_remains) {
+	while (post_remains > 0) {
 		if (uwsgi.shared->options[UWSGI_OPTION_HARAKIRI] > 0) {
 			inc_harakiri(uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT]);
 		}
@@ -1338,6 +1414,7 @@ int uwsgi_read_whole_body_in_mem(struct wsgi_request *wsgi_req, char *buf) {
 		}
 
 		len = read(wsgi_req->poll.fd, ptr, post_remains);
+
 		if (len <= 0) {
 			uwsgi_error("read()");
 			return 0;
@@ -1791,6 +1868,66 @@ char *uwsgi_open_and_read(char *url, int *size, int add_zero, char *magic_table[
 		memcpy(buffer, &UWSGI_EMBED_CONFIG, &UWSGI_EMBED_CONFIG_END-&UWSGI_EMBED_CONFIG);
 	}
 #endif
+	else if (!strncmp("data://", url, 7)) {
+		fd = open(uwsgi.binary_path, O_RDONLY);
+		if (fd < 0) {
+			uwsgi_error_open(uwsgi.binary_path);
+			exit(1);
+		}
+		int slot = atoi(url+7);
+		if (slot < 0) {
+			uwsgi_log("invalid binary data slot requested\n");
+			exit(1);
+		}
+		uwsgi_log("requesting binary data slot %d\n", slot);
+		off_t fo = lseek(fd, 0, SEEK_END);
+		if (fo < 0) {
+			uwsgi_error("lseek()");
+			uwsgi_log("invalid binary data slot requested\n");
+			exit(1);
+		}
+		int i = 0;
+		uint64_t datasize = 0;
+		for(i=0;i<=slot;i++) {
+			fo = lseek(fd, -9, SEEK_CUR);
+			if (fo < 0) {
+				uwsgi_error("lseek()");
+				uwsgi_log("invalid binary data slot requested\n");
+				exit(1);
+			}
+			ssize_t len = read(fd, &datasize, 8);
+			if (len != 8) {
+				uwsgi_error("read()");
+				uwsgi_log("invalid binary data slot requested\n");
+				exit(1);
+			}
+			if (datasize == 0) {
+				uwsgi_log("0 size binary data !!!\n");
+				exit(1);
+			}
+			fo = lseek(fd, -(datasize+9), SEEK_CUR);	
+			if (fo < 0) {
+				uwsgi_error("lseek()");
+				uwsgi_log("invalid binary data slot requested\n");
+				exit(1);
+			}
+
+			if (i == slot) {
+				*size = datasize;
+				if (add_zero) {
+                        		*size+=1;
+                		}
+				buffer = uwsgi_malloc(*size);
+                		memset(buffer, 0, *size);
+				len = read(fd, buffer, datasize);
+				if (len != (ssize_t) datasize) {
+					uwsgi_error("read()");
+					uwsgi_log("invalid binary data slot requested\n");
+					exit(1);
+				}
+			}
+		}
+	}
 	else if (!strncmp("sym://", url, 6)) {
 		char *symbol = uwsgi_concat3("_binary_", url+6, "_start") ;
 		void *sym_start_ptr = dlsym(RTLD_DEFAULT, symbol);
@@ -1895,7 +2032,7 @@ char *magic_sub(char *buffer, int len, int *size, char *magic_table[]) {
 void init_magic_table(char *magic_table[]) {
 
 	int i;
-	for (i = 0; i < 0xff; i++) {
+	for (i = 0; i <= 0xff; i++) {
 		magic_table[i] = "";
 	}
 
@@ -2041,6 +2178,10 @@ int uwsgi_num2str2(int num, char *ptr) {
 	return snprintf(ptr, 11, "%d", num);
 }
 
+int uwsgi_num2str2n(int num, char *ptr, int size) {
+	return snprintf(ptr, size, "%d", num);
+}
+
 int is_unix(char *socket_name, int len) {
 	int i;
 	for (i = 0; i < len; i++) {
@@ -2557,3 +2698,56 @@ void uwsgi_chown(char *filename, char *owner) {
 	}
 
 }
+
+char *uwsgi_get_binary_path(char *argvzero) {
+
+#if defined(__linux__)
+	char *buf = uwsgi_malloc(uwsgi.page_size);
+	ssize_t len = readlink("/proc/self/exe", buf, uwsgi.page_size);
+	if (len > 0) {
+		return buf;
+	}
+	free(buf);
+#elif defined(__APPLE__)
+	char *buf = uwsgi_malloc(uwsgi.page_size);
+	uint32_t len = uwsgi.page_size;
+	if (_NSGetExecutablePath(buf, &len) == 0) {
+		// return only absolute path
+		char *newbuf = realpath(buf, NULL);
+		if (newbuf) {
+			free(buf);
+			return newbuf;
+		}
+	}
+	free(buf);
+#elif defined(__sun__)
+	char *buf = (char *)getexecname();
+	if (buf) {
+		// return only absolute path
+		if (buf[0] == '/') {
+			return buf;
+		}
+		char *newbuf = realpath(buf, NULL);
+		free(buf);
+		if (newbuf) {
+			return newbuf;	
+		}
+	}	
+#elif defined(__FreeBSD__)
+	char *buf = uwsgi_malloc(uwsgi.page_size);
+	size_t len = uwsgi.page_size;
+	int mib[4];
+	mib[0] = CTL_KERN;
+	mib[1] = KERN_PROC;
+	mib[2] = KERN_PROC_PATHNAME;
+	mib[3] = -1;
+	if (sysctl(mib, 4, buf, &len, NULL, 0) == 0) {
+		return buf;
+	}
+	free(buf);
+#endif
+
+
+	return argvzero;
+
+}

uwsgi.c

@@ -29,12 +29,15 @@ extern char **environ;
 
 static char *short_options = NULL;
 
-static char *base_short_options = "s:p:t:x:d:l:v:b:mcaCTiMhrR:z:A:Q:Ly:";
+static char *base_short_options = "s:S:p:t:x:d:l:v:b:mcaCTiMhrR:z:A:Q:Ly:";
 
 UWSGI_DECLARE_EMBEDDED_PLUGINS;
 
 static struct option long_base_options[] = {
 	{"socket", required_argument, 0, 's'},
+	{"uwsgi-socket", required_argument, 0, 's'},
+	{"http-socket", required_argument, 0, LONG_ARGS_HTTP_SOCKET},
+	{"fastcgi-socket", required_argument, 0, LONG_ARGS_FASTCGI_SOCKET},
 	{"protocol", required_argument, 0, LONG_ARGS_PROTOCOL},
 	{"socket-protocol", required_argument, 0, LONG_ARGS_SOCKET_PROTOCOL},
 	{"shared-socket", required_argument, 0, LONG_ARGS_SHARED_SOCKET},
@@ -46,6 +49,7 @@ static struct option long_base_options[] = {
 	{"xmlconfig", required_argument, 0, 'x'},
 	{"xml", required_argument, 0, 'x'},
 #endif
+	{"set", required_argument, 0, 'S'},
 	{"inherit", required_argument, 0, LONG_ARGS_INHERIT},
 	{"daemonize", required_argument, 0, 'd'},
 	{"listen", required_argument, 0, 'l'},
@@ -57,6 +61,9 @@ static struct option long_base_options[] = {
 	{"abstract-socket", no_argument, 0, 'a'},
 	{"chmod-socket", optional_argument, 0, 'C'},
 	{"chown-socket", required_argument, 0, LONG_ARGS_CHOWN_SOCKET},
+#ifdef __linux__
+	{"freebind", no_argument, &uwsgi.freebind, 1},
+#endif
 	{"map-socket", required_argument, 0, LONG_ARGS_MAP_SOCKET},
 	{"chmod", optional_argument, 0, 'C'},
 #ifdef UWSGI_THREADING
@@ -70,6 +77,7 @@ static struct option long_base_options[] = {
 	{"emperor-amqp-vhost", required_argument, 0, LONG_ARGS_EMPEROR_AMQP_VHOST},
 	{"emperor-amqp-username", required_argument, 0, LONG_ARGS_EMPEROR_AMQP_USERNAME},
 	{"emperor-amqp-password", required_argument, 0, LONG_ARGS_EMPEROR_AMQP_PASSWORD},
+	{"emperor-throttle", required_argument, 0, LONG_ARGS_EMPEROR_THROTTLE},
 	{"vassals-inherit", required_argument, 0, LONG_ARGS_VASSALS_INHERIT},
 	{"vassals-start-hook", required_argument, 0, LONG_ARGS_VASSALS_START_HOOK},
 	{"vassals-stop-hook", required_argument, 0, LONG_ARGS_VASSALS_STOP_HOOK},
@@ -195,6 +203,8 @@ static struct option long_base_options[] = {
 	{"mount", required_argument, 0, LONG_ARGS_MOUNT},
 	{"grunt", no_argument, &uwsgi.grunt, 1},
 	{"threads", required_argument, 0, LONG_ARGS_THREADS},
+	{"threads-stacksize", required_argument, 0, LONG_ARGS_THREADS_STACKSIZE},
+	{"thread-stacksize", required_argument, 0, LONG_ARGS_THREADS_STACKSIZE},
 	{"vhost", no_argument, &uwsgi.vhost, 1},
 	{"vhost-host", no_argument, 0, LONG_ARGS_VHOSTHOST},
 #ifdef UWSGI_ROUTING
@@ -490,18 +500,26 @@ void kill_them_all(int signum) {
 		if (uwsgi.gateways[i].pid > 0)
 			kill(uwsgi.gateways[i].pid, SIGKILL);
 	}
+
 }
 
 void grace_them_all(int signum) {
 	int i;
 	int waitpid_status;
 
+	if (uwsgi.to_heaven == 1 || uwsgi.to_outworld == 1 || uwsgi.lazy_respawned > 0) return;
+
 	if (!uwsgi.lazy)
 		uwsgi.to_heaven = 1;
+	else uwsgi.to_outworld = 1;
 
 	if (uwsgi.reload_mercy > 0) {
 		uwsgi.master_mercy = time(NULL) + uwsgi.reload_mercy;
 	}
+	else {
+		// wait max 60 seconds for graceful reload
+		uwsgi.master_mercy = time(NULL) + 60;
+	}
 
 #ifdef UWSGI_SPOOLER
 	if (uwsgi.spool_dir && uwsgi.shared->spooler_pid > 0) {
@@ -547,8 +565,10 @@ void grace_them_all(int signum) {
 				}
 			}
 		}
-		else if (uwsgi.workers[i].pid > 0)
+		else if (uwsgi.workers[i].pid > 0) {
+			if (uwsgi.lazy) uwsgi.workers[i].destroy = 1;
 			kill(uwsgi.workers[i].pid, SIGHUP);
+		}
 	}
 
 	if (uwsgi.auto_snapshot) {
@@ -574,8 +594,12 @@ void uwsgi_nuclear_blast() {
 void reap_them_all(int signum) {
 	int i;
 
+	// avoid reace condition in lazy mode
+	if (uwsgi.to_outworld == 1 || uwsgi.lazy_respawned > 0) return;
+
 	if (!uwsgi.lazy)
 		uwsgi.to_heaven = 1;
+	else uwsgi.to_outworld = 1;
 
 	for (i = 0; i < uwsgi.shared->daemons_cnt; i++) {
 		if (uwsgi.shared->daemons[i].pid > 0)
@@ -633,16 +657,31 @@ void snapshot_me(int signum) {
 void stats(int signum) {
 	//fix this for better logging(this cause races)
 	struct uwsgi_app *ua = NULL;
-	int i;
+	int i, j;
 
-	uwsgi_log("*** pid %d stats ***\n", getpid());
-	uwsgi_log("\ttotal requests: %llu\n", uwsgi.workers[0].requests);
-	for (i = 0; i < uwsgi.apps_cnt; i++) {
-		ua = &uwsgi.apps[i];
-		if (ua) {
-			uwsgi_log("\tapp %d requests: %d\n", i, ua->requests);
+	if (uwsgi.mywid == 0) {
+		uwsgi_log("\tworkers total requests: %llu\n", uwsgi.workers[0].requests);
+		uwsgi_log("-----------------\n");
+		for(j=1;j<=uwsgi.numproc;j++) {
+			for (i = 0; i < uwsgi.workers[j].apps_cnt; i++) {
+				ua = &uwsgi.workers[j].apps[i];
+				if (ua) {
+					uwsgi_log("\tworker %d app %d [%.*s] requests: %d exceptions: %d\n", j, i, ua->mountpoint_len, ua->mountpoint, ua->requests, ua->exceptions);
+				}
+			}
+			uwsgi_log("-----------------\n");
 		}
 	}
+	else {
+		uwsgi_log("worker %d total requests: %llu\n", uwsgi.mywid, uwsgi.workers[0].requests);
+		for (i = 0; i < uwsgi.workers[uwsgi.mywid].apps_cnt; i++) {
+			ua = &uwsgi.workers[uwsgi.mywid].apps[i];
+			if (ua) {
+				uwsgi_log("\tapp %d [%.*s] requests: %d exceptions: %d\n", i, ua->mountpoint_len, ua->mountpoint, ua->requests, ua->exceptions);
+			}
+		}
+		uwsgi_log("-----------------\n");
+	}
 	uwsgi_log("\n");
 }
 
@@ -743,7 +782,11 @@ static void vacuum(void) {
 	}
 }
 
+#ifdef UWSGI_AS_SHARED_LIBRARY
+int uwsgi_init(int argc, char *argv[], char *envp[]) {
+#else
 int main(int argc, char *argv[], char *envp[]) {
+#endif
 
 	int i, j;
 	int rlen;
@@ -766,19 +809,19 @@ int main(int argc, char *argv[], char *envp[]) {
 #endif
 
 	char *emperor_env;
-	char *magic_table[0xff];
 	char *optname;
 
 	signal(SIGHUP, SIG_IGN);
 	signal(SIGTERM, SIG_IGN);
 
-	init_magic_table(magic_table);
 	//initialize masterpid with a default value
 	masterpid = getpid();
 
 	memset(&uwsgi, 0, sizeof(struct uwsgi_server));
 	uwsgi.cwd = uwsgi_get_cwd();
 
+	init_magic_table(uwsgi.magic_table);
+
 	atexit(vacuum);
 
 
@@ -819,12 +862,12 @@ int main(int argc, char *argv[], char *envp[]) {
 	uwsgi.cache_server_fd = -1;
 
 	uwsgi.emperor_fd_config = -1;
+	uwsgi.emperor_throttle = 1000;
 	uwsgi.emperor_pid = -1;
 
 	uwsgi.cluster_fd = -1;
 	uwsgi.cores = 1;
 
-	uwsgi.apps_cnt = 0;
 	uwsgi.default_app = -1;
 
 	uwsgi.buffer_size = 4096;
@@ -894,7 +937,8 @@ int main(int argc, char *argv[], char *envp[]) {
 		}
 	}
 
-	uwsgi.binary_path = argv[0];
+	uwsgi.page_size = getpagesize();
+	uwsgi.binary_path = uwsgi_get_binary_path(argv[0]);
 
 	//initialize embedded plugins
 	UWSGI_LOAD_EMBEDDED_PLUGINS
@@ -929,11 +973,11 @@ int main(int argc, char *argv[], char *envp[]) {
 	uwsgi.hostname_len = strlen(uwsgi.hostname);
 
 
-	magic_table['v'] = uwsgi.cwd;
-	magic_table['h'] = uwsgi.hostname;
+	uwsgi.magic_table['v'] = uwsgi.cwd;
+	uwsgi.magic_table['h'] = uwsgi.hostname;
 
 #ifdef UWSGI_EMBED_CONFIG
-	uwsgi_ini_config("", magic_table);	
+	uwsgi_ini_config("", uwsgi.magic_table);	
 #endif
 
 	uwsgi.option_index = -1;
@@ -1022,36 +1066,36 @@ int main(int argc, char *argv[], char *envp[]) {
 			}
 		}
 	}
-
+	
 #ifdef UWSGI_XML
 	if (uwsgi.xml_config != NULL) {
-		config_magic_table_fill(uwsgi.xml_config, magic_table);
-		uwsgi_xml_config(uwsgi.xml_config, uwsgi.wsgi_req, 0, magic_table);
-		uwsgi.xml_config = magic_table['p'];
+		config_magic_table_fill(uwsgi.xml_config, uwsgi.magic_table);
+		uwsgi_xml_config(uwsgi.xml_config, uwsgi.wsgi_req, 0, uwsgi.magic_table);
+		uwsgi.xml_config = uwsgi.magic_table['p'];
 	}
 #endif
 #ifdef UWSGI_INI
 	if (uwsgi.ini != NULL) {
-		config_magic_table_fill(uwsgi.ini, magic_table);
-		uwsgi_ini_config(uwsgi.ini, magic_table);
+		config_magic_table_fill(uwsgi.ini, uwsgi.magic_table);
+		uwsgi_ini_config(uwsgi.ini, uwsgi.magic_table);
 	}
 #endif
 #ifdef UWSGI_YAML
 	if (uwsgi.yaml != NULL) {
-		config_magic_table_fill(uwsgi.yaml, magic_table);
-		uwsgi_yaml_config(uwsgi.yaml, magic_table);
+		config_magic_table_fill(uwsgi.yaml, uwsgi.magic_table);
+		uwsgi_yaml_config(uwsgi.yaml, uwsgi.magic_table);
 	}
 #endif
 #ifdef UWSGI_JSON
 	if (uwsgi.json != NULL) {
-		config_magic_table_fill(uwsgi.json, magic_table);
-		uwsgi_json_config(uwsgi.json, magic_table);
+		config_magic_table_fill(uwsgi.json, uwsgi.magic_table);
+		uwsgi_json_config(uwsgi.json, uwsgi.magic_table);
 	}
 #endif
 #ifdef UWSGI_SQLITE3
 	if (uwsgi.sqlite3 != NULL) {
-		config_magic_table_fill(uwsgi.sqlite3, magic_table);
-		uwsgi_sqlite3_config(uwsgi.sqlite3, magic_table);
+		config_magic_table_fill(uwsgi.sqlite3, uwsgi.magic_table);
+		uwsgi_sqlite3_config(uwsgi.sqlite3, uwsgi.magic_table);
 	}
 #endif
 #ifdef UWSGI_LDAP
@@ -1068,36 +1112,36 @@ int main(int argc, char *argv[], char *envp[]) {
 		uwsgi_log("using %s as config template\n", uct->filename);
 #ifdef UWSGI_XML
 		if (!strcmp(uct->filename + strlen(uct->filename) - 4, ".xml")) {
-			uwsgi_xml_config(uct->filename, uwsgi.wsgi_req, 0, magic_table);
+			uwsgi_xml_config(uct->filename, uwsgi.wsgi_req, 0, uwsgi.magic_table);
 		}
 #endif
 #ifdef UWSGI_INI
 		if (!strcmp(uct->filename + strlen(uct->filename) - 4, ".ini")) {
-			uwsgi_ini_config(uct->filename, magic_table);
+			uwsgi_ini_config(uct->filename, uwsgi.magic_table);
 		}
 #endif
 #ifdef UWSGI_YAML
 		if (!strcmp(uct->filename + strlen(uct->filename) - 4, ".yml")) {
-			uwsgi_yaml_config(uct->filename, magic_table);
+			uwsgi_yaml_config(uct->filename, uwsgi.magic_table);
 		}
 		if (!strcmp(uct->filename + strlen(uct->filename) - 5, ".yaml")) {
-			uwsgi_yaml_config(uct->filename, magic_table);
+			uwsgi_yaml_config(uct->filename, uwsgi.magic_table);
 		}
 #endif
 #ifdef UWSGI_JSON
 		if (!strcmp(uct->filename + strlen(uct->filename) - 3, ".js")) {
-			uwsgi_json_config(uct->filename, magic_table);
+			uwsgi_json_config(uct->filename, uwsgi.magic_table);
 		}
 #endif
 #ifdef UWSGI_SQLITE3
 		if (!strcmp(uct->filename + strlen(uct->filename) - 3, ".db")) {
-			uwsgi_sqlite3_config(uct->filename, magic_table);
+			uwsgi_sqlite3_config(uct->filename, uwsgi.magic_table);
 		}
 		if (!strcmp(uct->filename + strlen(uct->filename) - 7, ".sqlite")) {
-			uwsgi_sqlite3_config(uct->filename, magic_table);
+			uwsgi_sqlite3_config(uct->filename, uwsgi.magic_table);
 		}
 		if (!strcmp(uct->filename + strlen(uct->filename) - 8, ".sqlite3")) {
-			uwsgi_sqlite3_config(uct->filename, magic_table);
+			uwsgi_sqlite3_config(uct->filename, uwsgi.magic_table);
 		}
 #endif
 		uct = uct->next;
@@ -1230,8 +1274,7 @@ int main(int argc, char *argv[], char *envp[]) {
 	//call after_opt hooks
 
 	if (uwsgi.binary_path == argv[0]) {
-		uwsgi.binary_path = uwsgi_malloc(strlen(argv[0]) + 1);
-		memcpy(uwsgi.binary_path, argv[0], strlen(argv[0]) + 1);
+		uwsgi.binary_path = uwsgi_str(argv[0]);
 	}
 
 	if (!uwsgi.no_initial_output) {
@@ -1267,6 +1310,8 @@ int main(int argc, char *argv[], char *envp[]) {
 		fclose(pidfile);
 	}
 
+	uwsgi_log("detected binary path: %s\n", uwsgi.binary_path);
+
 	struct uwsgi_socket *shared_sock = uwsgi.shared_sockets;
 	while (shared_sock) {
 		char *tcp_port = strchr(shared_sock->name, ':');
@@ -1433,7 +1478,6 @@ int uwsgi_start(void *v_argv) {
 	}
 #endif
 
-	uwsgi.page_size = getpagesize();
 
 	if (!uwsgi.no_initial_output) {
 		uwsgi_log("your memory page size is %d bytes\n", uwsgi.page_size);
@@ -1536,8 +1580,11 @@ int uwsgi_start(void *v_argv) {
 
 	if (uwsgi.post_buffering > 0) {
 		uwsgi.async_post_buf = uwsgi_malloc(sizeof(char *) * uwsgi.cores);
-		if (!uwsgi.post_buffering_bufsize) {
+		if (!uwsgi.post_buffering_bufsize)
 			uwsgi.post_buffering_bufsize = 8192;
+		if (uwsgi.post_buffering_bufsize < uwsgi.post_buffering) {
+			uwsgi.post_buffering_bufsize = uwsgi.post_buffering;
+			uwsgi_log("setting request body buffering size to %d bytes\n", uwsgi.post_buffering_bufsize);
 		}
 	}
 	for (i = 0; i < uwsgi.cores; i++) {
@@ -1560,7 +1607,6 @@ int uwsgi_start(void *v_argv) {
 	}
 	if (uwsgi.vhost) {
 		uwsgi_log("VirtualHosting mode enabled.\n");
-		uwsgi.apps_cnt = 0;
 	}
 
 
@@ -1611,18 +1657,18 @@ int uwsgi_start(void *v_argv) {
 	uwsgi_lock_init(uwsgi.rpc_table_lock);
 
 	if (uwsgi.sharedareasize > 0) {
-		uwsgi.sharedareamutex = uwsgi_mmap_shared_lock();
 
 		uwsgi.sharedarea = mmap(NULL, uwsgi.page_size * uwsgi.sharedareasize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
 		if (uwsgi.sharedarea) {
 			uwsgi_log("shared area mapped at %p, you can access it with uwsgi.sharedarea* functions.\n", uwsgi.sharedarea);
-			uwsgi_lock_init(uwsgi.sharedareamutex);
 		}
 		else {
 			uwsgi_error("mmap()");
 			exit(1);
 		}
 
+		uwsgi.sa_lock = uwsgi_mmap_shared_rwlock();
+                uwsgi_rwlock_init(uwsgi.sa_lock);
 	}
 
 	if (uwsgi.queue_size > 0) {
@@ -1656,6 +1702,29 @@ int uwsgi_start(void *v_argv) {
 
 	if (!uwsgi.no_server) {
 
+		// systemd socket activation
+		if (!uwsgi.is_a_reload) {
+			char *listen_pid = getenv("LISTEN_PID");
+			if (listen_pid) {
+				if (atoi(listen_pid) == (int) getpid()) {
+					char *listen_fds = getenv("LISTEN_FDS");
+					if (listen_fds) {
+						int systemd_fds = atoi(listen_fds);
+						if (systemd_fds > 0) {
+							for(i=3;i<3+systemd_fds;i++) {
+								uwsgi_sock = uwsgi_new_socket(NULL);
+								uwsgi_add_socket_from_fd(uwsgi_sock, i);
+							}
+						}
+						unsetenv("LISTEN_PID");
+						unsetenv("LISTEN_FDS");
+						goto skipzero;
+					}
+				}
+			}
+		}
+
+
 		//check for inherited sockets
 		if (uwsgi.is_a_reload || uwsgi.zerg) {
 
@@ -1775,11 +1844,11 @@ int uwsgi_start(void *v_argv) {
 					uwsgi_log("uwsgi socket %d inherited UNIX address %s fd 0\n", uwsgi_get_socket_num(uwsgi_sock), uwsgi_sock->name);
 				}
 				else {
-					uwsgi_sock = uwsgi_new_socket(uwsgi_concat2(":0", ""));
+					uwsgi_sock = uwsgi_new_socket(uwsgi_concat2("::",""));
 					uwsgi_log("uwsgi socket %d inherited INET address %s fd 0\n", uwsgi_get_socket_num(uwsgi_sock), uwsgi_sock->name);
 				}
 			}
-			else {
+			else if (!uwsgi.honour_stdin) {
 				int fd = open("/dev/null", O_RDONLY);
 				if (fd < 0) {
 					uwsgi_error_open("/dev/null");
@@ -1795,6 +1864,8 @@ int uwsgi_start(void *v_argv) {
 			}
 
 		}
+
+skipzero:
 	
 		// check for auto_port socket
 		uwsgi_sock = uwsgi.sockets;
@@ -1820,7 +1891,12 @@ int uwsgi_start(void *v_argv) {
 				exit(1);
 			}
 
-			if (uwsgi.protocol && !strcmp("http", uwsgi.protocol)) {
+			char *requested_protocol = uwsgi_sock->proto_name;
+			if (!requested_protocol) {
+				requested_protocol = uwsgi.protocol;
+			}
+
+			if (requested_protocol && !strcmp("http", requested_protocol)) {
 				uwsgi_sock->proto = uwsgi_proto_http_parser;
 				uwsgi_sock->proto_accept = uwsgi_proto_base_accept;
 				uwsgi_sock->proto_write = uwsgi_proto_http_write;
@@ -1830,8 +1906,10 @@ int uwsgi_start(void *v_argv) {
 				uwsgi_sock->proto_sendfile = NULL;
 				uwsgi_sock->proto_close = uwsgi_proto_base_close;
 			}
-			else if (uwsgi.protocol && (!strcmp("fastcgi", uwsgi.protocol) || !strcmp("fcgi", uwsgi.protocol))) {
-				uwsgi.shared->options[UWSGI_OPTION_CGI_MODE] = 1;
+			else if (requested_protocol && (!strcmp("fastcgi", requested_protocol) || !strcmp("fcgi", requested_protocol))) {
+				if (!strcmp(uwsgi.protocol, "fastcgi") || !strcmp(uwsgi.protocol, "fcgi")) {
+					uwsgi.shared->options[UWSGI_OPTION_CGI_MODE] = 1;
+				}
 				uwsgi_sock->proto = uwsgi_proto_fastcgi_parser;
 				uwsgi_sock->proto_accept = uwsgi_proto_base_accept;
 				uwsgi_sock->proto_write = uwsgi_proto_fastcgi_write;
@@ -1901,10 +1979,19 @@ int uwsgi_start(void *v_argv) {
 
 
 #ifdef UWSGI_THREADING
-	if (uwsgi.sockets) {
+	if (uwsgi.sockets || uwsgi.gateways_cnt) {
 		if (uwsgi.has_threads) {
 			if (uwsgi.threads > 1)
 				uwsgi.current_wsgi_req = threaded_current_wsgi_req;
+			(void) pthread_attr_init(&uwsgi.threads_attr);
+			if (uwsgi.threads_stacksize) {
+				if (pthread_attr_setstacksize(&uwsgi.threads_attr, uwsgi.threads_stacksize*1024) == 0) {
+					uwsgi_log("threads stack size set to %dk\n", uwsgi.threads_stacksize);
+				}
+				else {
+					uwsgi_log("!!! unable to set requested threads stacksize !!!\n");
+				}
+			}
 			for (i = 0; i < 0xFF; i++) {
 				if (uwsgi.p[i]->enable_threads)
 					uwsgi.p[i]->enable_threads();
@@ -1918,6 +2005,8 @@ int uwsgi_start(void *v_argv) {
 		exit(1);
 	}
 	else if (!uwsgi.sockets && uwsgi.gateways_cnt && !uwsgi.no_server && !uwsgi.master_process) {
+		// here we will have a zombie... sorry
+		uwsgi_log("...you should enable the master process... really...\n");
 		exit(0);
 	}
 
@@ -1961,7 +2050,8 @@ int uwsgi_start(void *v_argv) {
 
 
 
-	memset(uwsgi.apps, 0, sizeof(uwsgi.apps));
+	// apps are now per-worker
+	//memset(uwsgi.apps, 0, sizeof(uwsgi.apps));
 
 	uwsgi.workers = (struct uwsgi_worker *) mmap(NULL, sizeof(struct uwsgi_worker) * (uwsgi.numproc + 1 + uwsgi.grunt), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
 	if (!uwsgi.workers) {
@@ -2145,6 +2235,7 @@ int uwsgi_start(void *v_argv) {
 		//from now on the process is a real worker
 	}
 
+
 	uwsgi_sock = uwsgi.sockets;
 	while (uwsgi_sock) {
 		struct uwsgi_string_list *usl = uwsgi.map_socket;
@@ -2365,7 +2456,6 @@ int uwsgi_start(void *v_argv) {
 
 		uwsgi.async_queue_unused_ptr = uwsgi.async - 1;
 
-		event_queue_add_fd_read(uwsgi.async_queue, uwsgi.signal_socket);
 	}
 #endif
 
@@ -2473,8 +2563,25 @@ void uwsgi_ignition() {
 		uwsgi_log("[snapshot] process %d is the new worker %d\n", (int) getpid(), uwsgi.mywid);
 	}
 
+	for (i = 0; i < 0xFF; i++) {
+                if (uwsgi.p[i]->hijack_worker) {
+                        uwsgi.p[i]->hijack_worker();
+                }
+        }
+
+        for (i = 0; i < uwsgi.gp_cnt; i++) {
+                if (uwsgi.gp[i]->hijack_worker) {
+                        uwsgi.gp[i]->hijack_worker();
+                }
+        }
+
+
 	if (uwsgi.loop) {
 		void (*u_loop) (void) = uwsgi_get_loop(uwsgi.loop);
+		if (!u_loop) {
+			uwsgi_log("unavailable loop engine !!!\n");
+			exit(1);
+		}
 		uwsgi_log("running %s loop %p\n", uwsgi.loop, u_loop);
 		u_loop();
 		uwsgi_log("done\n");
@@ -2490,7 +2597,7 @@ void uwsgi_ignition() {
 				}
 				for (i = 1; i < uwsgi.threads; i++) {
 					long j = i;
-					pthread_create(&uwsgi.core[i]->thread_id, NULL, zeromq_loop, (void *) j);
+					pthread_create(&uwsgi.core[i]->thread_id, &uwsgi.threads_attr, zeromq_loop, (void *) j);
 				}
 			}
 
@@ -2508,7 +2615,7 @@ void uwsgi_ignition() {
 			}
 			for (i = 1; i < uwsgi.threads; i++) {
 				long j = i;
-				pthread_create(&uwsgi.core[i]->thread_id, NULL, simple_loop, (void *) j);
+				pthread_create(&uwsgi.core[i]->thread_id, &uwsgi.threads_attr, simple_loop, (void *) j);
 			}
 		}
 
@@ -2535,6 +2642,7 @@ static int manage_base_opt(int i, char *optarg) {
 	struct uwsgi_static_map *usm, *old_usm;
 	struct uwsgi_config_template *uct, *old_uct;
 	struct uwsgi_cron *uc, *old_uc;
+	struct uwsgi_socket *uwsgi_sock = NULL;
 	int zerg_fd;
 
 	switch (i) {
@@ -2619,6 +2727,10 @@ static int manage_base_opt(int i, char *optarg) {
 		uwsgi.has_threads = 1;
 		uwsgi.threads = atoi(optarg);
 		return 1;
+	case LONG_ARGS_THREADS_STACKSIZE:
+		uwsgi.has_threads = 1;
+		uwsgi.threads_stacksize = atoi(optarg);
+		return 1;
 #endif
 	case LONG_ARGS_PROTOCOL:
 		uwsgi.protocol = optarg;
@@ -2637,6 +2749,9 @@ static int manage_base_opt(int i, char *optarg) {
 	case LONG_ARGS_EMPEROR_BROODLORD:
 		uwsgi.emperor_broodlord = atoi(optarg);
 		return 1;
+	case LONG_ARGS_EMPEROR_THROTTLE:
+		uwsgi.emperor_throttle = atoi(optarg);
+		return 1;
 	case LONG_ARGS_EMPEROR:
 		uwsgi.emperor_dir = optarg;
 		return 1;
@@ -2660,6 +2775,8 @@ static int manage_base_opt(int i, char *optarg) {
 		uwsgi.lazy = 1;
 		return 1;
 	case LONG_ARGS_LOG_MASTER:
+		uwsgi.original_log_fd = dup(1);
+		create_logpipe();
 		uwsgi.log_master = 1;
 		return 1;
 	case LONG_ARGS_LOG_SOCKET:
@@ -3080,7 +3197,26 @@ static int manage_base_opt(int i, char *optarg) {
 		}
 		return 1;
 	case 's':
-		uwsgi_new_socket(generate_socket_name(optarg));
+		uwsgi_sock = uwsgi_new_socket(generate_socket_name(optarg));
+		uwsgi_sock->proto_name = "uwsgi";
+		return 1;
+	case 'S':
+		p = strchr(optarg, '=');
+		if (!p) {
+			uwsgi_log("invalid --set value\n");
+			exit(1);
+		}
+		p[0] = 0;
+		add_exported_option(uwsgi_str(optarg), p+1, 1);
+		p[0] = '=';
+		return 1;
+	case LONG_ARGS_HTTP_SOCKET:
+		uwsgi_sock = uwsgi_new_socket(generate_socket_name(optarg));
+		uwsgi_sock->proto_name = "http";
+		return 1;
+	case LONG_ARGS_FASTCGI_SOCKET:
+		uwsgi_sock = uwsgi_new_socket(generate_socket_name(optarg));
+		uwsgi_sock->proto_name = "fastcgi";
 		return 1;
 	case LONG_ARGS_ZERG:
 		zerg_fd = uwsgi_connect(optarg, 30, 0);
@@ -3987,9 +4123,8 @@ void uwsgi_init_all_apps() {
 	}
 
 	// no app initialized and virtualhosting enabled
-	if (uwsgi.apps_cnt == 0) {
+	if (uwsgi_apps_cnt == 0) {
 		uwsgi_log("*** no app loaded. going in full dynamic mode ***\n");
-		uwsgi.apps_cnt = 1;
 	}
 
 }

uwsgi.h

@@ -13,10 +13,14 @@ extern "C" {
 #define uwsgi_error_open(x)  uwsgi_log("open(\"%s\"): %s [%s line %d]\n", x, strerror(errno), __FILE__, __LINE__);
 #define uwsgi_debug(x, ...) uwsgi_log("[uWSGI DEBUG] " x, __VA_ARGS__);
 #define uwsgi_rawlog(x) if (write(2, x, strlen(x)) != strlen(x)) uwsgi_error("write()")
+#define uwsgi_str(x) uwsgi_concat2(x, "")
 
 #define uwsgi_notify(x) if (uwsgi.notify) uwsgi.notify(x)
 #define uwsgi_notify_ready() if (uwsgi.notify_ready) uwsgi.notify_ready()
 
+#define uwsgi_apps uwsgi.workers[uwsgi.mywid].apps
+#define uwsgi_apps_cnt uwsgi.workers[uwsgi.mywid].apps_cnt
+
 #define wsgi_req_time ((wsgi_req->end_of_request.tv_sec * 1000000 + wsgi_req->end_of_request.tv_usec) - (wsgi_req->start_of_request.tv_sec * 1000000 + wsgi_req->start_of_request.tv_usec))/1000
 
 #define thunder_lock if (uwsgi.threads > 1) {pthread_mutex_lock(&uwsgi.thunder_mutex);}
@@ -102,6 +106,10 @@ extern char UWSGI_EMBED_CONFIG_END;
 #include <netinet/tcp.h>
 #include <netdb.h>
 
+#ifdef __FreeBSD__
+#include <sys/sysctl.h>
+#endif
+
 #include <stdarg.h>
 #include <errno.h>
 #include <ctype.h>
@@ -161,6 +169,7 @@ extern int pivot_root(const char *new_root, const char *put_old);
 
 #ifdef __APPLE__
 #define MAC_OS_X_VERSION_MIN_REQUIRED MAC_OS_X_VERSION_10_4
+#include <mach-o/dyld.h>
 #endif
 
 #include <dlfcn.h>
@@ -235,6 +244,7 @@ extern int pivot_root(const char *new_root, const char *put_old);
 
 #define UWSGI_CACHE_MAX_KEY_SIZE 2048
 #define UWSGI_CACHE_FLAG_UNGETTABLE	0x0001
+#define UWSGI_CACHE_FLAG_UPDATE		0x0002
 
 #define uwsgi_cache_update_start(x, y, z) uwsgi_cache_set(x, y, "", 0, CACHE_FLAG_UNGETTABLE)
 
@@ -295,6 +305,7 @@ struct uwsgi_gateway {
 	pid_t pid;
 	int num;
 	int use_signals;
+	uint64_t respawns;
 };
 
 
@@ -312,6 +323,11 @@ struct uwsgi_daemon {
 	//int pipe[2];
 };
 
+struct uwsgi_queue_header {
+	uint64_t pos;
+	uint64_t pull_pos;
+};
+
 struct uwsgi_queue_item {
 	uint64_t size;
 	time_t ts;
@@ -466,6 +482,10 @@ struct uwsgi_opt {
 #define LONG_ARGS_CACHE_SERVER		17129
 #define LONG_ARGS_CACHE_SERVER_THREADS	17130
 #define LONG_ARGS_CHOWN_SOCKET		17131
+#define LONG_ARGS_HTTP_SOCKET		17132
+#define LONG_ARGS_FASTCGI_SOCKET	17133
+#define LONG_ARGS_THREADS_STACKSIZE	17134
+#define LONG_ARGS_EMPEROR_THROTTLE	17135
 
 
 #define UWSGI_OK	0
@@ -591,11 +611,15 @@ struct uwsgi_plugin {
 	void (*suspend) (struct wsgi_request *);
 	void (*resume) (struct wsgi_request *);
 
+	void (*hijack_worker) (void);
+	void (*spooler_init) (void);
+
 	int (*magic) (char *, char *);
 
 	void *(*encode_string) (char *);
 	char *(*decode_string) (void *);
 	int (*signal_handler) (uint8_t, void *);
+	char *(*code_string) (char *, char *, char *, char *, uint16_t);
 
 	int (*spooler) (char *, char *, uint16_t, char *, size_t);
 
@@ -638,12 +662,17 @@ struct uwsgi_app {
 	int (*response_subhandler) (struct wsgi_request *);
 
 	int argc;
-	int requests;
+	uint64_t requests;
+	uint64_t exceptions;
 	char *chdir;
 
 	char *touch_reload;
 	time_t touch_reload_mtime;
 
+	void *gateway_version;
+        void *uwsgi_version;
+        void *uwsgi_node;
+
 };
 
 
@@ -690,6 +719,10 @@ struct wsgi_request {
 	//temporary attr
 
 	int app_id;
+	int dynamic;
+
+	char *appid;
+	uint16_t appid_len;
 
 	struct pollfd poll;
 
@@ -725,6 +758,9 @@ struct wsgi_request {
 	char *host;
 	uint16_t host_len;
 
+	char *content_type;
+	uint16_t content_type_len;
+
 	char *path_info;
 	uint16_t path_info_len;
 
@@ -869,7 +905,6 @@ struct uwsgi_server {
 	int hostname_len;
 	int no_initial_output;
 	int has_threads;
-	int apps_cnt;
 	int default_app;
 
 	char *logto2;
@@ -901,6 +936,7 @@ struct uwsgi_server {
 	int emperor_fd;
 	int emperor_fd_config;
 	int early_emperor;
+        int emperor_throttle;
 	char *emperor_dir;
 	pid_t emperor_pid;
 	int	emperor_broodlord;
@@ -960,8 +996,11 @@ struct uwsgi_server {
 	int log_micros;
 	char *log_strftime;
 
+	int honour_stdin;
+
 	int log_master;
 	int log_syslog;
+	int original_log_fd;
 
 	int log_socket;
 	int log_socket_fd;
@@ -1040,6 +1079,9 @@ struct uwsgi_server {
 
 	int to_heaven;
 	int to_hell;
+	int to_outworld;
+
+	int lazy_respawned;
 
 	int buffer_size;
 
@@ -1061,6 +1103,8 @@ struct uwsgi_server {
 
 	int harakiri_verbose;
 
+	char *magic_table[256];
+
 	int numproc;
 	int async;
 	int async_running;
@@ -1073,8 +1117,7 @@ struct uwsgi_server {
 	int vec_size;
 
 	char *sharedarea;
-	void *sharedareamutex;
-	int sharedareasize;
+	uint64_t sharedareasize;
 
 #ifdef UWSGI_THREADING
 	pthread_mutex_t six_feet_under_lock;
@@ -1095,6 +1138,10 @@ struct uwsgi_server {
 	struct timeval start_tv;
 
 	int abstract_socket;
+#ifdef __linux__
+	int freebind;
+#endif
+
 	int chmod_socket;
 	char *chown_socket;
 	mode_t chmod_socket_value;
@@ -1138,7 +1185,6 @@ struct uwsgi_server {
 
 	struct uwsgi_shared *shared;
 
-	struct uwsgi_app apps[MAX_APPS];
 
 	int no_orphans;
 
@@ -1204,6 +1250,8 @@ struct uwsgi_server {
 	struct uwsgi_core **core;
 
 	int threads;
+	pthread_attr_t threads_attr;
+	size_t threads_stacksize;
 
 	//this key old the u_request structure per core / thread
 	pthread_key_t tur_key;
@@ -1259,6 +1307,7 @@ struct uwsgi_server {
 	uint64_t queue_size;
 	uint64_t queue_blocksize;
 	void *queue;
+	struct uwsgi_queue_header *queue_header;
 	char *queue_store;
 	size_t queue_filesize;
 	int queue_store_sync;
@@ -1274,6 +1323,7 @@ struct uwsgi_server {
 	void *rb_timer_table_lock;
 	void *cron_table_lock;
 	void *rpc_table_lock;
+        void *sa_lock;
 #ifdef UWSGI_SPOOLER
 	void *spooler_lock;
 #endif
@@ -1399,8 +1449,6 @@ struct uwsgi_shared {
 	uint64_t cache_first_available_item;
 	uint64_t cache_unused_stack_ptr;
 
-	uint64_t queue_pos;
-	uint64_t queue_pull_pos;
 
 	int worker_signal_pipe[2];
 #ifdef UWSGI_SPOOLER
@@ -1485,6 +1533,9 @@ struct uwsgi_worker {
 
 	int destroy;
 
+	int apps_cnt;
+	struct uwsgi_app apps[MAX_APPS];
+
 };
 
 
@@ -1823,6 +1874,8 @@ void uwsgi_init_cache(void);
 char *uwsgi_queue_get(uint64_t, uint64_t *);
 char *uwsgi_queue_pull(uint64_t *);
 int uwsgi_queue_push(char *, uint64_t);
+char *uwsgi_queue_pop(uint64_t *);
+int uwsgi_queue_set(uint64_t, char *, uint64_t);
 
 // maintain alignment here !!!
 struct uwsgi_dict_item {
@@ -1949,8 +2002,6 @@ inline int event_queue_write(void);
 
 void uwsgi_help(void);
 
-void uwsgi_queue_fix(void);
-
 int uwsgi_str2_num(char *);
 int uwsgi_str3_num(char *);
 int uwsgi_str4_num(char *);
@@ -2094,7 +2145,22 @@ int uwsgi_cache_server(char *, int);
 
 void uwsgi_chown(char *, char *);
 
+char *uwsgi_get_binary_path(char *);
+
+char *uwsgi_lower(char *, size_t);
+int uwsgi_num2str2n(int, char *, int);
+void create_logpipe(void);
+
+char *uwsgi_str_contains(char *, int, char);
+
+int uwsgi_simple_parse_vars(struct wsgi_request *, char *, char *);
+
+#ifdef UWSGI_AS_SHARED_LIBRARY
+int uwsgi_init(int, char **, char **);
+#endif
+
 #ifdef __cplusplus
 }
 #endif
 
+

uwsgicc/static/css/custom-theme/jquery-ui-1.8.14.custom.css

@@ -1,7 +1,7 @@
 /*
- * jQuery UI CSS Framework 1.8.7
+ * jQuery UI CSS Framework 1.8.14
  *
- * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
  * http://jquery.org/license
  *
@@ -42,45 +42,45 @@
 
 
 /*
- * jQuery UI CSS Framework 1.8.7
+ * jQuery UI CSS Framework 1.8.14
  *
- * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
  * http://jquery.org/license
  *
  * http://docs.jquery.com/UI/Theming/API
  *
- * To view and modify this theme, visit http://jqueryui.com/themeroller/?ffDefault=Trebuchet%20MS,%20Tahoma,%20Verdana,%20Arial,%20sans-serif&fwDefault=bold&fsDefault=1.1em&cornerRadius=4px&bgColorHeader=f6a828&bgTextureHeader=12_gloss_wave.png&bgImgOpacityHeader=35&borderColorHeader=e78f08&fcHeader=ffffff&iconColorHeader=ffffff&bgColorContent=eeeeee&bgTextureContent=03_highlight_soft.png&bgImgOpacityContent=100&borderColorContent=dddddd&fcContent=333333&iconColorContent=222222&bgColorDefault=f6f6f6&bgTextureDefault=02_glass.png&bgImgOpacityDefault=100&borderColorDefault=cccccc&fcDefault=1c94c4&iconColorDefault=ef8c08&bgColorHover=fdf5ce&bgTextureHover=02_glass.png&bgImgOpacityHover=100&borderColorHover=fbcb09&fcHover=c77405&iconColorHover=ef8c08&bgColorActive=ffffff&bgTextureActive=02_glass.png&bgImgOpacityActive=65&borderColorActive=fbd850&fcActive=eb8f00&iconColorActive=ef8c08&bgColorHighlight=ffe45c&bgTextureHighlight=03_highlight_soft.png&bgImgOpacityHighlight=75&borderColorHighlight=fed22f&fcHighlight=363636&iconColorHighlight=228ef1&bgColorError=b81900&bgTextureError=08_diagonals_thick.png&bgImgOpacityError=18&borderColorError=cd0a0a&fcError=ffffff&iconColorError=ffd27a&bgColorOverlay=666666&bgTextureOverlay=08_diagonals_thick.png&bgImgOpacityOverlay=20&opacityOverlay=50&bgColorShadow=000000&bgTextureShadow=01_flat.png&bgImgOpacityShadow=10&opacityShadow=20&thicknessShadow=5px&offsetTopShadow=-5px&offsetLeftShadow=-5px&cornerRadiusShadow=5px
+ * To view and modify this theme, visit http://jqueryui.com/themeroller/?ffDefault=lucida%20grande,%20helvetica,%20arial&fwDefault=normal&fsDefault=1.1em&cornerRadius=5px&bgColorHeader=222222&bgTextureHeader=03_highlight_soft.png&bgImgOpacityHeader=30&borderColorHeader=555555&fcHeader=ffffff&iconColorHeader=b1d630&bgColorContent=ffffff&bgTextureContent=01_flat.png&bgImgOpacityContent=100&borderColorContent=555555&fcContent=222222&iconColorContent=b1d630&bgColorDefault=222222&bgTextureDefault=04_highlight_hard.png&bgImgOpacityDefault=30&borderColorDefault=ffffff&fcDefault=ffffff&iconColorDefault=b1d630&bgColorHover=b1d630&bgTextureHover=05_inset_soft.png&bgImgOpacityHover=75&borderColorHover=ffffff&fcHover=222222&iconColorHover=000000&bgColorActive=ffffff&bgTextureActive=05_inset_soft.png&bgImgOpacityActive=65&borderColorActive=555555&fcActive=222222&iconColorActive=b1d630&bgColorHighlight=d9e99f&bgTextureHighlight=02_glass.png&bgImgOpacityHighlight=55&borderColorHighlight=b1d630&fcHighlight=222222&iconColorHighlight=2e83ff&bgColorError=fef1ec&bgTextureError=05_inset_soft.png&bgImgOpacityError=95&borderColorError=cd0a0a&fcError=cd0a0a&iconColorError=cd0a0a&bgColorOverlay=000000&bgTextureOverlay=01_flat.png&bgImgOpacityOverlay=0&opacityOverlay=80&bgColorShadow=aaaaaa&bgTextureShadow=01_flat.png&bgImgOpacityShadow=0&opacityShadow=30&thicknessShadow=8px&offsetTopShadow=-8px&offsetLeftShadow=-8px&cornerRadiusShadow=8px
  */
 
 
 /* Component containers
 ----------------------------------*/
-.ui-widget { font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif; font-size: 1.1em; }
+.ui-widget { font-family: lucida grande, helvetica, arial; font-size: 1.1em; }
 .ui-widget .ui-widget { font-size: 1em; }
-.ui-widget input, .ui-widget select, .ui-widget textarea, .ui-widget button { font-family: Trebuchet MS, Tahoma, Verdana, Arial, sans-serif; font-size: 1em; }
-.ui-widget-content { border: 1px solid #dddddd; background: #eeeeee url(images/ui-bg_highlight-soft_100_eeeeee_1x100.png) 50% top repeat-x; color: #333333; }
-.ui-widget-content a { color: #333333; }
-.ui-widget-header { border: 1px solid #e78f08; background: #f6a828 url(images/ui-bg_gloss-wave_35_f6a828_500x100.png) 50% 50% repeat-x; color: #ffffff; font-weight: bold; }
+.ui-widget input, .ui-widget select, .ui-widget textarea, .ui-widget button { font-family: lucida grande, helvetica, arial; font-size: 1em; }
+.ui-widget-content { border: 1px solid #555555; background: #ffffff url(images/ui-bg_flat_100_ffffff_40x100.png) 50% 50% repeat-x; color: #222222; }
+.ui-widget-content a { color: #222222; }
+.ui-widget-header { border: 1px solid #555555; background: #222222 url(images/ui-bg_highlight-soft_30_222222_1x100.png) 50% 50% repeat-x; color: #ffffff; font-weight: bold; }
 .ui-widget-header a { color: #ffffff; }
 
 /* Interaction states
 ----------------------------------*/
-.ui-state-default, .ui-widget-content .ui-state-default, .ui-widget-header .ui-state-default { border: 1px solid #cccccc; background: #f6f6f6 url(images/ui-bg_glass_100_f6f6f6_1x400.png) 50% 50% repeat-x; font-weight: bold; color: #1c94c4; }
-.ui-state-default a, .ui-state-default a:link, .ui-state-default a:visited { color: #1c94c4; text-decoration: none; }
-.ui-state-hover, .ui-widget-content .ui-state-hover, .ui-widget-header .ui-state-hover, .ui-state-focus, .ui-widget-content .ui-state-focus, .ui-widget-header .ui-state-focus { border: 1px solid #fbcb09; background: #fdf5ce url(images/ui-bg_glass_100_fdf5ce_1x400.png) 50% 50% repeat-x; font-weight: bold; color: #c77405; }
-.ui-state-hover a, .ui-state-hover a:hover { color: #c77405; text-decoration: none; }
-.ui-state-active, .ui-widget-content .ui-state-active, .ui-widget-header .ui-state-active { border: 1px solid #fbd850; background: #ffffff url(images/ui-bg_glass_65_ffffff_1x400.png) 50% 50% repeat-x; font-weight: bold; color: #eb8f00; }
-.ui-state-active a, .ui-state-active a:link, .ui-state-active a:visited { color: #eb8f00; text-decoration: none; }
+.ui-state-default, .ui-widget-content .ui-state-default, .ui-widget-header .ui-state-default { border: 1px solid #ffffff; background: #222222 url(images/ui-bg_highlight-hard_30_222222_1x100.png) 50% 50% repeat-x; font-weight: normal; color: #ffffff; }
+.ui-state-default a, .ui-state-default a:link, .ui-state-default a:visited { color: #ffffff; text-decoration: none; }
+.ui-state-hover, .ui-widget-content .ui-state-hover, .ui-widget-header .ui-state-hover, .ui-state-focus, .ui-widget-content .ui-state-focus, .ui-widget-header .ui-state-focus { border: 1px solid #ffffff; background: #b1d630 url(images/ui-bg_inset-soft_75_b1d630_1x100.png) 50% 50% repeat-x; font-weight: normal; color: #222222; }
+.ui-state-hover a, .ui-state-hover a:hover { color: #222222; text-decoration: none; }
+.ui-state-active, .ui-widget-content .ui-state-active, .ui-widget-header .ui-state-active { border: 1px solid #555555; background: #ffffff url(images/ui-bg_inset-soft_65_ffffff_1x100.png) 50% 50% repeat-x; font-weight: normal; color: #222222; }
+.ui-state-active a, .ui-state-active a:link, .ui-state-active a:visited { color: #222222; text-decoration: none; }
 .ui-widget :active { outline: none; }
 
 /* Interaction Cues
 ----------------------------------*/
-.ui-state-highlight, .ui-widget-content .ui-state-highlight, .ui-widget-header .ui-state-highlight  {border: 1px solid #fed22f; background: #ffe45c url(images/ui-bg_highlight-soft_75_ffe45c_1x100.png) 50% top repeat-x; color: #363636; }
-.ui-state-highlight a, .ui-widget-content .ui-state-highlight a,.ui-widget-header .ui-state-highlight a { color: #363636; }
-.ui-state-error, .ui-widget-content .ui-state-error, .ui-widget-header .ui-state-error {border: 1px solid #cd0a0a; background: #b81900 url(images/ui-bg_diagonals-thick_18_b81900_40x40.png) 50% 50% repeat; color: #ffffff; }
-.ui-state-error a, .ui-widget-content .ui-state-error a, .ui-widget-header .ui-state-error a { color: #ffffff; }
-.ui-state-error-text, .ui-widget-content .ui-state-error-text, .ui-widget-header .ui-state-error-text { color: #ffffff; }
+.ui-state-highlight, .ui-widget-content .ui-state-highlight, .ui-widget-header .ui-state-highlight  {border: 1px solid #b1d630; background: #d9e99f url(images/ui-bg_glass_55_d9e99f_1x400.png) 50% 50% repeat-x; color: #222222; }
+.ui-state-highlight a, .ui-widget-content .ui-state-highlight a,.ui-widget-header .ui-state-highlight a { color: #222222; }
+.ui-state-error, .ui-widget-content .ui-state-error, .ui-widget-header .ui-state-error {border: 1px solid #cd0a0a; background: #fef1ec url(images/ui-bg_inset-soft_95_fef1ec_1x100.png) 50% bottom repeat-x; color: #cd0a0a; }
+.ui-state-error a, .ui-widget-content .ui-state-error a, .ui-widget-header .ui-state-error a { color: #cd0a0a; }
+.ui-state-error-text, .ui-widget-content .ui-state-error-text, .ui-widget-header .ui-state-error-text { color: #cd0a0a; }
 .ui-priority-primary, .ui-widget-content .ui-priority-primary, .ui-widget-header .ui-priority-primary { font-weight: bold; }
 .ui-priority-secondary, .ui-widget-content .ui-priority-secondary,  .ui-widget-header .ui-priority-secondary { opacity: .7; filter:Alpha(Opacity=70); font-weight: normal; }
 .ui-state-disabled, .ui-widget-content .ui-state-disabled, .ui-widget-header .ui-state-disabled { opacity: .35; filter:Alpha(Opacity=35); background-image: none; }
@@ -89,14 +89,14 @@
 ----------------------------------*/
 
 /* states and images */
-.ui-icon { width: 16px; height: 16px; background-image: url(images/ui-icons_222222_256x240.png); }
-.ui-widget-content .ui-icon {background-image: url(images/ui-icons_222222_256x240.png); }
-.ui-widget-header .ui-icon {background-image: url(images/ui-icons_ffffff_256x240.png); }
-.ui-state-default .ui-icon { background-image: url(images/ui-icons_ef8c08_256x240.png); }
-.ui-state-hover .ui-icon, .ui-state-focus .ui-icon {background-image: url(images/ui-icons_ef8c08_256x240.png); }
-.ui-state-active .ui-icon {background-image: url(images/ui-icons_ef8c08_256x240.png); }
-.ui-state-highlight .ui-icon {background-image: url(images/ui-icons_228ef1_256x240.png); }
-.ui-state-error .ui-icon, .ui-state-error-text .ui-icon {background-image: url(images/ui-icons_ffd27a_256x240.png); }
+.ui-icon { width: 16px; height: 16px; background-image: url(images/ui-icons_b1d630_256x240.png); }
+.ui-widget-content .ui-icon {background-image: url(images/ui-icons_b1d630_256x240.png); }
+.ui-widget-header .ui-icon {background-image: url(images/ui-icons_b1d630_256x240.png); }
+.ui-state-default .ui-icon { background-image: url(images/ui-icons_b1d630_256x240.png); }
+.ui-state-hover .ui-icon, .ui-state-focus .ui-icon {background-image: url(images/ui-icons_000000_256x240.png); }
+.ui-state-active .ui-icon {background-image: url(images/ui-icons_b1d630_256x240.png); }
+.ui-state-highlight .ui-icon {background-image: url(images/ui-icons_2e83ff_256x240.png); }
+.ui-state-error .ui-icon, .ui-state-error-text .ui-icon {background-image: url(images/ui-icons_cd0a0a_256x240.png); }
 
 /* positioning */
 .ui-icon-carat-1-n { background-position: 0 0; }
@@ -280,22 +280,65 @@
 ----------------------------------*/
 
 /* Corner radius */
-.ui-corner-tl { -moz-border-radius-topleft: 4px; -webkit-border-top-left-radius: 4px; border-top-left-radius: 4px; }
-.ui-corner-tr { -moz-border-radius-topright: 4px; -webkit-border-top-right-radius: 4px; border-top-right-radius: 4px; }
-.ui-corner-bl { -moz-border-radius-bottomleft: 4px; -webkit-border-bottom-left-radius: 4px; border-bottom-left-radius: 4px; }
-.ui-corner-br { -moz-border-radius-bottomright: 4px; -webkit-border-bottom-right-radius: 4px; border-bottom-right-radius: 4px; }
-.ui-corner-top { -moz-border-radius-topleft: 4px; -webkit-border-top-left-radius: 4px; border-top-left-radius: 4px; -moz-border-radius-topright: 4px; -webkit-border-top-right-radius: 4px; border-top-right-radius: 4px; }
-.ui-corner-bottom { -moz-border-radius-bottomleft: 4px; -webkit-border-bottom-left-radius: 4px; border-bottom-left-radius: 4px; -moz-border-radius-bottomright: 4px; -webkit-border-bottom-right-radius: 4px; border-bottom-right-radius: 4px; }
-.ui-corner-right {  -moz-border-radius-topright: 4px; -webkit-border-top-right-radius: 4px; border-top-right-radius: 4px; -moz-border-radius-bottomright: 4px; -webkit-border-bottom-right-radius: 4px; border-bottom-right-radius: 4px; }
-.ui-corner-left { -moz-border-radius-topleft: 4px; -webkit-border-top-left-radius: 4px; border-top-left-radius: 4px; -moz-border-radius-bottomleft: 4px; -webkit-border-bottom-left-radius: 4px; border-bottom-left-radius: 4px; }
-.ui-corner-all { -moz-border-radius: 4px; -webkit-border-radius: 4px; border-radius: 4px; }
+.ui-corner-all, .ui-corner-top, .ui-corner-left, .ui-corner-tl { -moz-border-radius-topleft: 5px; -webkit-border-top-left-radius: 5px; -khtml-border-top-left-radius: 5px; border-top-left-radius: 5px; }
+.ui-corner-all, .ui-corner-top, .ui-corner-right, .ui-corner-tr { -moz-border-radius-topright: 5px; -webkit-border-top-right-radius: 5px; -khtml-border-top-right-radius: 5px; border-top-right-radius: 5px; }
+.ui-corner-all, .ui-corner-bottom, .ui-corner-left, .ui-corner-bl { -moz-border-radius-bottomleft: 5px; -webkit-border-bottom-left-radius: 5px; -khtml-border-bottom-left-radius: 5px; border-bottom-left-radius: 5px; }
+.ui-corner-all, .ui-corner-bottom, .ui-corner-right, .ui-corner-br { -moz-border-radius-bottomright: 5px; -webkit-border-bottom-right-radius: 5px; -khtml-border-bottom-right-radius: 5px; border-bottom-right-radius: 5px; }
 
 /* Overlays */
-.ui-widget-overlay { background: #666666 url(images/ui-bg_diagonals-thick_20_666666_40x40.png) 50% 50% repeat; opacity: .50;filter:Alpha(Opacity=50); }
-.ui-widget-shadow { margin: -5px 0 0 -5px; padding: 5px; background: #000000 url(images/ui-bg_flat_10_000000_40x100.png) 50% 50% repeat-x; opacity: .20;filter:Alpha(Opacity=20); -moz-border-radius: 5px; -webkit-border-radius: 5px; border-radius: 5px; }/*
- * jQuery UI Autocomplete 1.8.7
+.ui-widget-overlay { background: #000000 url(images/ui-bg_flat_0_000000_40x100.png) 50% 50% repeat-x; opacity: .80;filter:Alpha(Opacity=80); }
+.ui-widget-shadow { margin: -8px 0 0 -8px; padding: 8px; background: #aaaaaa url(images/ui-bg_flat_0_aaaaaa_40x100.png) 50% 50% repeat-x; opacity: .30;filter:Alpha(Opacity=30); -moz-border-radius: 8px; -khtml-border-radius: 8px; -webkit-border-radius: 8px; border-radius: 8px; }/*
+ * jQuery UI Resizable 1.8.14
  *
- * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Resizable#theming
+ */
+.ui-resizable { position: relative;}
+.ui-resizable-handle { position: absolute;font-size: 0.1px;z-index: 99999; display: block; }
+.ui-resizable-disabled .ui-resizable-handle, .ui-resizable-autohide .ui-resizable-handle { display: none; }
+.ui-resizable-n { cursor: n-resize; height: 7px; width: 100%; top: -5px; left: 0; }
+.ui-resizable-s { cursor: s-resize; height: 7px; width: 100%; bottom: -5px; left: 0; }
+.ui-resizable-e { cursor: e-resize; width: 7px; right: -5px; top: 0; height: 100%; }
+.ui-resizable-w { cursor: w-resize; width: 7px; left: -5px; top: 0; height: 100%; }
+.ui-resizable-se { cursor: se-resize; width: 12px; height: 12px; right: 1px; bottom: 1px; }
+.ui-resizable-sw { cursor: sw-resize; width: 9px; height: 9px; left: -5px; bottom: -5px; }
+.ui-resizable-nw { cursor: nw-resize; width: 9px; height: 9px; left: -5px; top: -5px; }
+.ui-resizable-ne { cursor: ne-resize; width: 9px; height: 9px; right: -5px; top: -5px;}/*
+ * jQuery UI Selectable 1.8.14
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Selectable#theming
+ */
+.ui-selectable-helper { position: absolute; z-index: 100; border:1px dotted black; }
+/*
+ * jQuery UI Accordion 1.8.14
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Accordion#theming
+ */
+/* IE/Win - Fix animation bug - #4615 */
+.ui-accordion { width: 100%; }
+.ui-accordion .ui-accordion-header { cursor: pointer; position: relative; margin-top: 1px; zoom: 1; }
+.ui-accordion .ui-accordion-li-fix { display: inline; }
+.ui-accordion .ui-accordion-header-active { border-bottom: 0 !important; }
+.ui-accordion .ui-accordion-header a { display: block; font-size: 1em; padding: .5em .5em .5em .7em; }
+.ui-accordion-icons .ui-accordion-header a { padding-left: 2.2em; }
+.ui-accordion .ui-accordion-header .ui-icon { position: absolute; left: .5em; top: 50%; margin-top: -8px; }
+.ui-accordion .ui-accordion-content { padding: 1em 2.2em; border-top: 0; margin-top: -2px; position: relative; top: 1px; margin-bottom: 2px; overflow: auto; display: none; zoom: 1; }
+.ui-accordion .ui-accordion-content-active { display: block; }
+/*
+ * jQuery UI Autocomplete 1.8.14
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
  * http://jquery.org/license
  *
@@ -307,7 +350,7 @@
 * html .ui-autocomplete { width:1px; } /* without this, the menu expands to 100% in IE6 */
 
 /*
- * jQuery UI Menu 1.8.7
+ * jQuery UI Menu 1.8.14
  *
  * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
@@ -346,17 +389,55 @@
 	margin: -1px;
 }
 /*
- * jQuery UI Dialog 1.8.7
+ * jQuery UI Button 1.8.14
  *
- * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Button#theming
+ */
+.ui-button { display: inline-block; position: relative; padding: 0; margin-right: .1em; text-decoration: none !important; cursor: pointer; text-align: center; zoom: 1; overflow: visible; } /* the overflow property removes extra width in IE */
+.ui-button-icon-only { width: 2.2em; } /* to make room for the icon, a width needs to be set here */
+button.ui-button-icon-only { width: 2.4em; } /* button elements seem to need a little more width */
+.ui-button-icons-only { width: 3.4em; } 
+button.ui-button-icons-only { width: 3.7em; } 
+
+/*button text element */
+.ui-button .ui-button-text { display: block; line-height: 1.4;  }
+.ui-button-text-only .ui-button-text { padding: .4em 1em; }
+.ui-button-icon-only .ui-button-text, .ui-button-icons-only .ui-button-text { padding: .4em; text-indent: -9999999px; }
+.ui-button-text-icon-primary .ui-button-text, .ui-button-text-icons .ui-button-text { padding: .4em 1em .4em 2.1em; }
+.ui-button-text-icon-secondary .ui-button-text, .ui-button-text-icons .ui-button-text { padding: .4em 2.1em .4em 1em; }
+.ui-button-text-icons .ui-button-text { padding-left: 2.1em; padding-right: 2.1em; }
+/* no icon support for input elements, provide padding by default */
+input.ui-button { padding: .4em 1em; }
+
+/*button icon element(s) */
+.ui-button-icon-only .ui-icon, .ui-button-text-icon-primary .ui-icon, .ui-button-text-icon-secondary .ui-icon, .ui-button-text-icons .ui-icon, .ui-button-icons-only .ui-icon { position: absolute; top: 50%; margin-top: -8px; }
+.ui-button-icon-only .ui-icon { left: 50%; margin-left: -8px; }
+.ui-button-text-icon-primary .ui-button-icon-primary, .ui-button-text-icons .ui-button-icon-primary, .ui-button-icons-only .ui-button-icon-primary { left: .5em; }
+.ui-button-text-icon-secondary .ui-button-icon-secondary, .ui-button-text-icons .ui-button-icon-secondary, .ui-button-icons-only .ui-button-icon-secondary { right: .5em; }
+.ui-button-text-icons .ui-button-icon-secondary, .ui-button-icons-only .ui-button-icon-secondary { right: .5em; }
+
+/*button sets*/
+.ui-buttonset { margin-right: 7px; }
+.ui-buttonset .ui-button { margin-left: 0; margin-right: -.3em; }
+
+/* workarounds */
+button.ui-button::-moz-focus-inner { border: 0; padding: 0; } /* reset extra padding in Firefox */
+/*
+ * jQuery UI Dialog 1.8.14
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
  * http://jquery.org/license
  *
  * http://docs.jquery.com/UI/Dialog#theming
  */
 .ui-dialog { position: absolute; padding: .2em; width: 300px; overflow: hidden; }
-.ui-dialog .ui-dialog-titlebar { padding: .5em 1em .3em; position: relative;  }
-.ui-dialog .ui-dialog-title { float: left; margin: .1em 16px .2em 0; } 
+.ui-dialog .ui-dialog-titlebar { padding: .4em 1em; position: relative;  }
+.ui-dialog .ui-dialog-title { float: left; margin: .1em 16px .1em 0; } 
 .ui-dialog .ui-dialog-titlebar-close { position: absolute; right: .3em; top: 50%; width: 19px; margin: -10px 0 0 0; padding: 1px; height: 18px; }
 .ui-dialog .ui-dialog-titlebar-close span { display: block; margin: 1px; }
 .ui-dialog .ui-dialog-titlebar-close:hover, .ui-dialog .ui-dialog-titlebar-close:focus { padding: 0; }
@@ -367,9 +448,32 @@
 .ui-dialog .ui-resizable-se { width: 14px; height: 14px; right: 3px; bottom: 3px; }
 .ui-draggable .ui-dialog-titlebar { cursor: move; }
 /*
- * jQuery UI Tabs 1.8.7
+ * jQuery UI Slider 1.8.14
  *
- * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Slider#theming
+ */
+.ui-slider { position: relative; text-align: left; }
+.ui-slider .ui-slider-handle { position: absolute; z-index: 2; width: 1.2em; height: 1.2em; cursor: default; }
+.ui-slider .ui-slider-range { position: absolute; z-index: 1; font-size: .7em; display: block; border: 0; background-position: 0 0; }
+
+.ui-slider-horizontal { height: .8em; }
+.ui-slider-horizontal .ui-slider-handle { top: -.3em; margin-left: -.6em; }
+.ui-slider-horizontal .ui-slider-range { top: 0; height: 100%; }
+.ui-slider-horizontal .ui-slider-range-min { left: 0; }
+.ui-slider-horizontal .ui-slider-range-max { right: 0; }
+
+.ui-slider-vertical { width: .8em; height: 100px; }
+.ui-slider-vertical .ui-slider-handle { left: -.3em; margin-left: 0; margin-bottom: -.6em; }
+.ui-slider-vertical .ui-slider-range { left: 0; width: 100%; }
+.ui-slider-vertical .ui-slider-range-min { bottom: 0; }
+.ui-slider-vertical .ui-slider-range-max { top: 0; }/*
+ * jQuery UI Tabs 1.8.14
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
  * http://jquery.org/license
  *
@@ -385,9 +489,76 @@
 .ui-tabs .ui-tabs-panel { display: block; border-width: 0; padding: 1em 1.4em; background: none; }
 .ui-tabs .ui-tabs-hide { display: none !important; }
 /*
- * jQuery UI Progressbar 1.8.7
+ * jQuery UI Datepicker 1.8.14
  *
- * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ * http://jquery.org/license
+ *
+ * http://docs.jquery.com/UI/Datepicker#theming
+ */
+.ui-datepicker { width: 17em; padding: .2em .2em 0; display: none; }
+.ui-datepicker .ui-datepicker-header { position:relative; padding:.2em 0; }
+.ui-datepicker .ui-datepicker-prev, .ui-datepicker .ui-datepicker-next { position:absolute; top: 2px; width: 1.8em; height: 1.8em; }
+.ui-datepicker .ui-datepicker-prev-hover, .ui-datepicker .ui-datepicker-next-hover { top: 1px; }
+.ui-datepicker .ui-datepicker-prev { left:2px; }
+.ui-datepicker .ui-datepicker-next { right:2px; }
+.ui-datepicker .ui-datepicker-prev-hover { left:1px; }
+.ui-datepicker .ui-datepicker-next-hover { right:1px; }
+.ui-datepicker .ui-datepicker-prev span, .ui-datepicker .ui-datepicker-next span { display: block; position: absolute; left: 50%; margin-left: -8px; top: 50%; margin-top: -8px;  }
+.ui-datepicker .ui-datepicker-title { margin: 0 2.3em; line-height: 1.8em; text-align: center; }
+.ui-datepicker .ui-datepicker-title select { font-size:1em; margin:1px 0; }
+.ui-datepicker select.ui-datepicker-month-year {width: 100%;}
+.ui-datepicker select.ui-datepicker-month, 
+.ui-datepicker select.ui-datepicker-year { width: 49%;}
+.ui-datepicker table {width: 100%; font-size: .9em; border-collapse: collapse; margin:0 0 .4em; }
+.ui-datepicker th { padding: .7em .3em; text-align: center; font-weight: bold; border: 0;  }
+.ui-datepicker td { border: 0; padding: 1px; }
+.ui-datepicker td span, .ui-datepicker td a { display: block; padding: .2em; text-align: right; text-decoration: none; }
+.ui-datepicker .ui-datepicker-buttonpane { background-image: none; margin: .7em 0 0 0; padding:0 .2em; border-left: 0; border-right: 0; border-bottom: 0; }
+.ui-datepicker .ui-datepicker-buttonpane button { float: right; margin: .5em .2em .4em; cursor: pointer; padding: .2em .6em .3em .6em; width:auto; overflow:visible; }
+.ui-datepicker .ui-datepicker-buttonpane button.ui-datepicker-current { float:left; }
+
+/* with multiple calendars */
+.ui-datepicker.ui-datepicker-multi { width:auto; }
+.ui-datepicker-multi .ui-datepicker-group { float:left; }
+.ui-datepicker-multi .ui-datepicker-group table { width:95%; margin:0 auto .4em; }
+.ui-datepicker-multi-2 .ui-datepicker-group { width:50%; }
+.ui-datepicker-multi-3 .ui-datepicker-group { width:33.3%; }
+.ui-datepicker-multi-4 .ui-datepicker-group { width:25%; }
+.ui-datepicker-multi .ui-datepicker-group-last .ui-datepicker-header { border-left-width:0; }
+.ui-datepicker-multi .ui-datepicker-group-middle .ui-datepicker-header { border-left-width:0; }
+.ui-datepicker-multi .ui-datepicker-buttonpane { clear:left; }
+.ui-datepicker-row-break { clear:both; width:100%; font-size:0em; }
+
+/* RTL support */
+.ui-datepicker-rtl { direction: rtl; }
+.ui-datepicker-rtl .ui-datepicker-prev { right: 2px; left: auto; }
+.ui-datepicker-rtl .ui-datepicker-next { left: 2px; right: auto; }
+.ui-datepicker-rtl .ui-datepicker-prev:hover { right: 1px; left: auto; }
+.ui-datepicker-rtl .ui-datepicker-next:hover { left: 1px; right: auto; }
+.ui-datepicker-rtl .ui-datepicker-buttonpane { clear:right; }
+.ui-datepicker-rtl .ui-datepicker-buttonpane button { float: left; }
+.ui-datepicker-rtl .ui-datepicker-buttonpane button.ui-datepicker-current { float:right; }
+.ui-datepicker-rtl .ui-datepicker-group { float:right; }
+.ui-datepicker-rtl .ui-datepicker-group-last .ui-datepicker-header { border-right-width:0; border-left-width:1px; }
+.ui-datepicker-rtl .ui-datepicker-group-middle .ui-datepicker-header { border-right-width:0; border-left-width:1px; }
+
+/* IE6 IFRAME FIX (taken from datepicker 1.5.3 */
+.ui-datepicker-cover {
+    display: none; /*sorry for IE5*/
+    display/**/: block; /*sorry for IE5*/
+    position: absolute; /*must have*/
+    z-index: -1; /*must have*/
+    filter: mask(); /*must have*/
+    top: -4px; /*must have*/
+    left: -4px; /*must have*/
+    width: 200px; /*must have*/
+    height: 200px; /*must have*/
+}/*
+ * jQuery UI Progressbar 1.8.14
+ *
+ * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
  * Dual licensed under the MIT or GPL Version 2 licenses.
  * http://jquery.org/license
  *