Changeset 240:f1aec5ab5c31 for uwsgi.c

Timestamp:

03/01/10 14:02:36 (5 months ago)

Author:

roberto@…

Branch:

default

Message:

useful XML support, first commit of uwsgiconfig.py

Files:

• uwsgi.c (modified) (30 diffs)

uwsgi.c

@@ -30 +30 @@
 
 
-
-#ifndef UNBIT
-
-#ifndef ROCK_SOLID
-#include <libxml/parser.h>
-#include <libxml/tree.h>
-#endif
-
-#endif
-
-
 #include "uwsgi.h"
 
@@ -52 +41 @@
 static char *h_sep = ": ";
 static const char *http_protocol = "HTTP/1.1";
-#ifndef ROCK_SOLID
 static const char *app_slash = "/";
-#endif
 
 extern char **environ;
@@ -86 +73 @@
 
 
-#ifdef ROCK_SOLID
 struct uwsgi_app *wi;
-#endif
 
 void warn_pipe () {
@@ -96 +81 @@
 void gracefully_kill () {
         fprintf (stderr, "Gracefully killing worker %d...\n", uwsgi.mypid);
-        if (uwsgi.workers[uwsgi.mywid].in_request) {
+        if (UWSGI_IS_IN_REQUEST) {
                 uwsgi.workers[uwsgi.mywid].manage_next_request = 0;
         }
@@ -172 +157 @@
 
 #ifndef UNBIT
-#ifndef ROCK_SOLID
 void stats () {
         struct uwsgi_app *ua = NULL;
@@ -188 +172 @@
 }
 #endif
-#endif
 
 void internal_server_error (int fd, char *message) {
 #ifndef UNBIT
-#ifndef ROCK_SOLID
         if (uwsgi.options[UWSGI_OPTION_CGI_MODE] == 0) {
 #endif
-#endif
                 wsgi_req.headers_size = write (fd, "HTTP/1.1 500 Internal Server Error\r\nContent-type: text/html\r\n\r\n", 63);
 #ifndef UNBIT
-#ifndef ROCK_SOLID
         }
         else {
                 wsgi_req.headers_size = write (fd, "Status: 500 Internal Server Error\r\nContent-type: text/html\r\n\r\n", 62);
         }
-#endif
         wsgi_req.header_cnt = 2;
 #endif
@@ -281 +260 @@
 
 #ifndef UNBIT
-#ifndef ROCK_SOLID
         if (uwsgi.options[UWSGI_OPTION_CGI_MODE] == 0) {
                 base = 4;
-#endif
 #endif
 
@@ -310 +287 @@
                 uwsgi.hvec[3].iov_len = NL_SIZE;
 #ifndef UNBIT
-#ifndef ROCK_SOLID
         }
         else {
@@ -329 +305 @@
         }
 #endif
-#endif
 
 
@@ -428 +403 @@
 }
 
-#ifndef ROCK_SOLID
+#ifdef UWSGI_SENDFILE
 PyObject *py_uwsgi_sendfile (PyObject * self, PyObject * args) {
 
@@ -458 +433 @@
 };
 
-#ifndef ROCK_SOLID
+#ifdef UWSGI_SENDFILE
 PyMethodDef uwsgi_sendfile_method[] = { {"uwsgi_sendfile", py_uwsgi_sendfile, METH_VARARGS, ""}
 };
@@ -503 +478 @@
         int ret;
 
-#ifndef ROCK_SOLID
         int rlen;
-#ifdef SCTP
+
+#ifdef UWSGI_SCTP
         int i_am_sctp = 0;
         struct sctp_sndrcvinfo sctp_ss;
@@ -515 +490 @@
         socklen_t udp_len;
         char udp_client_addr[16];
-#endif
+
         pid_t pid;
         int no_server = 0;
 
 #ifndef UNBIT
-        char *socket_name = NULL;
-#ifndef ROCK_SOLID
         FILE *pidfile;
-#endif
 #endif
 
@@ -530 +502 @@
 
         char *cwd;
-        char *binary_path;
         int ready_to_reload = 0;
         int ready_to_die = 0;
@@ -536 +507 @@
         char *env_reloads ;
         unsigned int reloads = 0;
-        int is_a_reload = 0;
         char env_reload_buf[11];
 
         char *buffer;
-
-        struct rlimit rl;
 
 #ifdef UNBIT
@@ -585 +553 @@
         }
 
-#ifndef ROCK_SOLID
         uwsgi.wsgi_cnt = 1;
         uwsgi.default_app = -1;
-#endif
+
         uwsgi.buffer_size = 4096;
         uwsgi.numproc = 1;
@@ -595 +562 @@
 #endif
 
-        uwsgi.maxworkers = 64;
-
         uwsgi.max_vars = MAX_VARS;
         uwsgi.vec_size = 4 + 1 + (4 * MAX_VARS);
@@ -603 +568 @@
         uwsgi.options[UWSGI_OPTION_LOGGING] = 1;
 
-#ifndef ROCK_SOLID
-        uwsgi.i_have_gil = 1;
-#endif
-
-#ifndef UNBIT
-#ifndef ROCK_SOLID
+#ifndef UNBIT
         int option_index = 0;
         struct option long_options[] = {
@@ -652 +612 @@
                 {"udp", required_argument, 0, LONG_ARGS_UDP},
                 {"check-interval", required_argument, 0, LONG_ARGS_CHECK_INTERVAL},
+                {"erlang", required_argument, 0, LONG_ARGS_ERLANG},
                 {0, 0, 0, 0}
         };
 #endif
-#endif
 
 
@@ -662 +622 @@
         setlinebuf (stdout);
 
-        rl.rlim_cur = 0;
-        rl.rlim_max = 0;
+        uwsgi.rl.rlim_cur = 0;
+        uwsgi.rl.rlim_max = 0;
 
         cwd = uwsgi_get_cwd ();
-        binary_path = malloc (strlen (argv[0]) + 1);
-        if (binary_path == NULL) {
+        uwsgi.binary_path = malloc (strlen (argv[0]) + 1);
+        if (uwsgi.binary_path == NULL) {
                 perror ("malloc()");
                 exit (1);
         }
-        strcpy (binary_path, argv[0]);
+        strcpy (uwsgi.binary_path, argv[0]);
 
         env_reloads = getenv("UWSGI_RELOADS");
@@ -688 +648 @@
         }
         else {
-                fprintf(stderr,"setting UWSGI_RELOADS\n");
                 if (setenv("UWSGI_RELOADS","0", 1)) {
                         perror("setenv()");
@@ -698 +657 @@
                 if (socket_type == SOCK_STREAM && reloads > 0) { 
                         fprintf (stderr, "...fd 3 is a socket, i suppose this is a graceful reload of uWSGI, i will try to do my best...\n");
-                        is_a_reload = 1;
+                        uwsgi.is_a_reload = 1;
 #ifdef UNBIT
                         /* discard the 3'th fd as we will use the fd 0 */
@@ -709 +668 @@
 
 #ifndef UNBIT
-#ifndef ROCK_SOLID
         while ((i = getopt_long (argc, argv, "s:p:t:x:d:l:O:v:b:mcaCTPiMhrR:z:w:j:H:A:Q:L", long_options, &option_index)) != -1) {
 #else
-        while ((i = getopt (argc, argv, "s:p:t:d:l:v:b:aCMhrR:z:j:H:A:L")) != -1) {
-#endif
+        while ((i = getopt (argc, argv, "p:t:mTPiv:b:rMR:Sz:w:C:j:H:A:EQ:L")) != -1) {
+#endif
+                manage_opt(i, optarg);
+
+        }
+
+#ifdef UWSGI_XML
+        if (uwsgi.xml_config != NULL) {
+                uwsgi_xml_config (&wsgi_req, long_options);
+        }
+#endif
+
+#ifndef UNBIT
+#ifndef ROCK_SOLID
+        if (uwsgi.options[UWSGI_OPTION_CGI_MODE] == 0) {
+#endif
+#endif
+                if (uwsgi.test_module == NULL) {
+                        fprintf (stderr, "*** Starting uWSGI (%dbit) on [%.*s] ***\n", (int) (sizeof (void *)) * 8, 24, ctime ((const time_t *) &uwsgi.start_tv.tv_sec));
+                }
+#ifndef UNBIT
+        }
+        else {
+                fprintf (stderr, "*** Starting uWSGI (CGI mode) (%dbit) on [%.*s] ***\n", (int) (sizeof (void *)) * 8, 24, ctime ((const time_t *) &uwsgi.start_tv.tv_sec));
+        }
+#endif
+
+#ifdef __BIG_ENDIAN__
+        fprintf (stderr, "*** big endian arch detected ***\n");
+#endif
+
+#ifdef PYTHREE
+        fprintf (stderr, "*** Warning Python3.x support is experimental, do not use it in production environment ***\n");
+#endif
+
+        fprintf (stderr, "Python version: %s\n", Py_GetVersion ());
+
+#ifndef UNBIT
+        if (!getuid ()) {
+                fprintf (stderr, "uWSGI running as root, you can use --uid/--gid/--chroot options\n");
+                if (uwsgi.chroot) {
+                        fprintf (stderr, "chroot() to %s\n", uwsgi.chroot);
+                        if (chroot (uwsgi.chroot)) {
+                                perror ("chroot()");
+                                exit (1);
+                        }
+#ifdef __linux__
+                        if (uwsgi.options[UWSGI_OPTION_MEMORY_DEBUG]) {
+                                fprintf (stderr, "*** Warning, on linux system you have to bind-mount the /proc fs in your chroot to get memory debug/report.\n");
+                        }
+#endif
+                }
+                if (uwsgi.gid) {
+                        fprintf (stderr, "setgid() to %d\n", uwsgi.gid);
+                        if (setgid (uwsgi.gid)) {
+                                perror ("setgid()");
+                                exit (1);
+                        }
+                }
+                if (uwsgi.uid) {
+                        fprintf (stderr, "setuid() to %d\n", uwsgi.uid);
+                        if (setuid (uwsgi.uid)) {
+                                perror ("setuid()");
+                                exit (1);
+                        }
+                }
+
+                if (!getuid()) {
+                        fprintf(stderr," *** WARNING: you are running uWSGI as root !!! (use the --uid flag) *** \n");
+                }
+        }
+        else {
+                if (uwsgi.chroot) {
+                        fprintf (stderr, "cannot chroot() as non-root user\n");
+                        exit (1);
+                }
+                if (uwsgi.gid) {
+                        fprintf (stderr, "cannot setgid() as non-root user\n");
+                        exit (1);
+                }
+                if (uwsgi.uid) {
+                        fprintf (stderr, "cannot setuid() as non-root user\n");
+                        exit (1);
+                }
+        }
+
+        
+
+#endif
+
+#ifndef UNBIT
+        if (uwsgi.rl.rlim_max > 0) {
+                fprintf (stderr, "limiting address space of processes...\n");
+                if (setrlimit (RLIMIT_AS, &uwsgi.rl)) {
+                        perror ("setrlimit()");
+                }
+        }
+#endif
+
+        if (!getrlimit (RLIMIT_AS, &uwsgi.rl)) {
+#ifndef UNBIT
+                // check for overflow
+                if ((sizeof (void *) == 4 && (uint32_t) uwsgi.rl.rlim_max < UINT32_MAX) || (sizeof (void *) == 8 && (uint64_t) uwsgi.rl.rlim_max < UINT64_MAX)) {
+#endif
+                        fprintf (stderr, "your process address space limit is %lld bytes (%lld MB)\n", (long long) uwsgi.rl.rlim_max, (long long) uwsgi.rl.rlim_max / 1024 / 1024);
+#ifndef UNBIT
+                }
+#endif
+        }
+
+        uwsgi.page_size = getpagesize ();
+        fprintf (stderr, "your memory page size is %d bytes\n", uwsgi.page_size);
+
+#ifndef UNBIT
+        fprintf (stderr, "your server socket listen backlog is limited to %d connections\n", uwsgi.listen_queue);
+#endif
+
+        if (uwsgi.synclog) {
+                fprintf (stderr, "allocating a memory page for synced logging.\n");
+                uwsgi.sync_page = malloc (uwsgi.page_size);
+                if (!uwsgi.sync_page) {
+                        perror ("malloc()");
+                        exit (1);
+                }
+        }
+
+        if (uwsgi.pyhome != NULL) {
+                fprintf (stderr, "Setting PythonHome to %s...\n", uwsgi.pyhome);
+#ifdef PYTHREE
+                wchar_t *wpyhome;
+                wpyhome = malloc ((sizeof (wchar_t) * strlen (uwsgi.pyhome)) + 2);
+                if (!wpyhome) {
+                        perror ("malloc()");
+                        exit (1);
+                }
+                mbstowcs (wpyhome, uwsgi.pyhome, strlen (uwsgi.pyhome));
+                Py_SetPythonHome (wpyhome);
+                free (wpyhome);
 #else
-        while ((i = getopt (argc, argv, "p:t:mTPiv:b:rMR:Sz:w:C:j:H:A:EQ:L")) != -1) {
-#endif
+                Py_SetPythonHome (uwsgi.pyhome);
+#endif
+        }
+
+
+
+
+#ifdef PYTHREE
+        wchar_t pname[6];
+        mbstowcs (pname, "uWSGI", 6);
+        Py_SetProgramName (pname);
+#else
+        Py_SetProgramName ("uWSGI");
+#endif
+
+
+        Py_Initialize ();
+
+        pyargv[0] = "uwsgi";
+
+        if (uwsgi.pyargv != NULL) {
+                char *ap;
+                while ((ap = strsep (&uwsgi.pyargv, " \t")) != NULL) {
+                        if (*ap != '\0') {
+                                pyargv[pyargc] = ap;
+                                pyargc++;
+                        }
+                        if (pyargc + 1 > MAX_PYARGV)
+                                break;
+                }
+        }
+
+        PySys_SetArgv (pyargc, pyargv);
+
+
+        uwsgi.py_apps = PyDict_New ();
+        if (!uwsgi.py_apps) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+
+        wsgi_spitout = PyCFunction_New (uwsgi_spit_method, NULL);
+        wsgi_writeout = PyCFunction_New (uwsgi_write_method, NULL);
+
+#ifndef PYTHREE
+#ifndef ROCK_SOLID
+        uwsgi_module = Py_InitModule ("uwsgi", null_methods);
+        if (uwsgi_module == NULL) {
+                fprintf (stderr, "could not initialize the uwsgi python module\n");
+                exit (1);
+        }
+        if (uwsgi.sharedareasize > 0) {
+#ifndef __OpenBSD__
+                uwsgi.sharedareamutex = mmap (NULL, sizeof (pthread_mutexattr_t) + sizeof (pthread_mutex_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                if (!uwsgi.sharedareamutex) {
+                        perror ("mmap()");
+                        exit (1);
+                }
+#else
+                fprintf (stderr, "***WARNING*** the sharedarea on OpenBSD is not SMP-safe. Beware of race conditions !!!\n");
+#endif
+                uwsgi.sharedarea = mmap (NULL, uwsgi.page_size * uwsgi.sharedareasize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+                if (uwsgi.sharedarea) {
+                        fprintf (stderr, "shared area mapped at %p, you can access it with uwsgi.sharedarea* functions.\n", uwsgi.sharedarea);
+
+#ifdef __APPLE__
+                        memset (uwsgi.sharedareamutex, 0, sizeof (OSSpinLock));
+#else
+#ifndef __OpenBSD__
+                        if (pthread_mutexattr_init ((pthread_mutexattr_t *) uwsgi.sharedareamutex)) {
+                                fprintf (stderr, "unable to allocate mutexattr structure\n");
+                                exit (1);
+                        }
+                        if (pthread_mutexattr_setpshared ((pthread_mutexattr_t *) uwsgi.sharedareamutex, PTHREAD_PROCESS_SHARED)) {
+                                fprintf (stderr, "unable to share mutex\n");
+                                exit (1);
+                        }
+                        if (pthread_mutex_init ((pthread_mutex_t *) uwsgi.sharedareamutex + sizeof (pthread_mutexattr_t), (pthread_mutexattr_t *) uwsgi.sharedareamutex)) {
+                                fprintf (stderr, "unable to initialize mutex\n");
+                                exit (1);
+                        }
+#endif
+#endif
+
+                }
+                else {
+                        perror ("mmap()");
+                        exit (1);
+                }
+
+        }
+
+        init_uwsgi_embedded_module ();
+#endif
+#endif
+
+
+
+#ifdef UWSGI_ONEAPP
+
+
+        wi = malloc (sizeof (struct uwsgi_app));
+        if (wi == NULL) {
+                perror ("malloc()");
+                exit (1);
+        }
+        memset (wi, 0, sizeof (struct uwsgi_app));
+
+        // load wsgi module/script
+        for (i = optind; i < argc; i++) {
+                init_uwsgi_vars ();
+                wi->wsgi_module = PyImport_ImportModule (argv[i]);
+                if (!wi->wsgi_module) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                wi->wsgi_dict = PyModule_GetDict (wi->wsgi_module);
+                if (!wi->wsgi_dict) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                wi->wsgi_callable = PyDict_GetItemString (wi->wsgi_dict, "application");
+                if (!wi->wsgi_callable) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                wi->wsgi_environ = PyDict_New ();
+                if (!wi->wsgi_environ) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+
+                wi->wsgi_harakiri = PyDict_GetItemString (wi->wsgi_dict, "harakiri");
+
+                wi->wsgi_args = PyTuple_New (2);
+                if (!wi->wsgi_args) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                if (PyTuple_SetItem (wi->wsgi_args, 0, wi->wsgi_environ)) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                if (PyTuple_SetItem (wi->wsgi_args, 1, wsgi_spitout)) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                break;
+        }
+
+        if (!wi->wsgi_module) {
+                fprintf (stderr, "unable to find the wsgi script. Have you specified it ?\n");
+                exit (1);
+        }
+#endif
+
+        Py_OptimizeFlag = uwsgi.py_optimize;
+
+        uwsgi.main_thread = PyThreadState_Get ();
+
+
+#ifdef UWSGI_THREADING
+        if (uwsgi.has_threads) {
+                PyEval_InitThreads ();
+                fprintf (stderr, "threads support enabled\n");
+        }
+
+#endif
+
+        if (!no_server) {
+#ifndef UNBIT
+                if (uwsgi.socket_name != NULL && !uwsgi.is_a_reload) {
+#ifdef UWSGI_SCTP
+                        if (!strncmp (uwsgi.socket_name, "sctp:", 5)) {
+                                char *sctp_port = strchr (uwsgi.socket_name + 5, ':');
+                                if (sctp_port == NULL) {
+                                        fprintf (stderr, "invalid SCTP port ! syntax: sctp:ip1,ip2,ipN:port\n");
+                                        exit (1);
+                                }
+                                uwsgi.serverfd = bind_to_sctp (uwsgi.socket_name + 5, uwsgi.listen_queue, sctp_port);
+                                i_am_sctp = 1;
+                        }
+                        else {
+#endif
+                                char *tcp_port = strchr (uwsgi.socket_name, ':');
+                                if (tcp_port == NULL) {
+                                        uwsgi.serverfd = bind_to_unix (uwsgi.socket_name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
+                                }
+                                else {
+                                        uwsgi.serverfd = bind_to_tcp (uwsgi.socket_name, uwsgi.listen_queue, tcp_port);
+                                }
+
+                                if (uwsgi.serverfd < 0) {
+                                        fprintf (stderr, "unable to create the server socket.\n");
+                                        exit (1);
+                                }
+#ifdef UWSGI_SCTP
+                        }
+#endif
+                }
+#endif
+
+                socket_type_len = sizeof (int);
+                if (getsockopt (uwsgi.serverfd, SOL_SOCKET, SO_TYPE, &socket_type, &socket_type_len)) {
+                        perror ("getsockopt()");
+                        fprintf(stderr, "The -s/--socket option is missing and stdin is not a socket.\n");
+                        exit (1);
+                }
+
+        }
+
+
+
+        if (uwsgi.single_interpreter == 1) {
+                init_uwsgi_vars ();
+        }
+
+        memset (uwsgi.wsgi_apps, 0, sizeof (uwsgi.wsgi_apps));
+
+
+
+        uwsgi.poll.events = POLLIN;
+
+        memset (&wsgi_req, 0, sizeof (struct wsgi_request));
+
+        /* shared area for workers */
+        uwsgi.workers = (struct uwsgi_worker *) mmap (NULL, sizeof (struct uwsgi_worker) * uwsgi.numproc + 1, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+        if (!uwsgi.workers) {
+                perror ("mmap()");
+                exit (1);
+        }
+        memset (uwsgi.workers, 0, sizeof (struct uwsgi_worker) * uwsgi.numproc + 1);
+
+        uwsgi.mypid = getpid ();
+        masterpid = uwsgi.mypid;
+
+#ifndef UNBIT
+        if (uwsgi.pidfile) {
+                fprintf (stderr, "writing pidfile to %s\n", uwsgi.pidfile);
+                pidfile = fopen (uwsgi.pidfile, "w");
+                if (!pidfile) {
+                        perror ("fopen");
+                        exit (1);
+                }
+                if (fprintf (pidfile, "%d\n", masterpid) < 0) {
+                        fprintf (stderr, "could not write pidfile.\n");
+                }
+                fclose (pidfile);
+        }
+#endif
+
+        if (uwsgi.buffer_size > 65536) {
+                fprintf (stderr, "invalid buffer size.\n");
+                exit (1);
+        }
+        buffer = malloc (uwsgi.buffer_size);
+        if (buffer == NULL) {
+                fprintf (stderr, "unable to allocate memory for buffer.\n");
+                exit (1);
+        }
+
+        fprintf (stderr, "request/response buffer (%d bytes) allocated.\n", uwsgi.buffer_size);
+
+        /* save the masterpid */
+        uwsgi.workers[0].pid = masterpid;
+
+        fprintf(stderr,"initializing hooks...");
+
+        uwsgi.hooks[0] = uwsgi_request_wsgi ; 
+        uwsgi.after_hooks[0] = uwsgi_after_request_wsgi ; 
+
+        uwsgi.hooks[UWSGI_MODIFIER_ADMIN_REQUEST] = uwsgi_request_admin ; //10
+#ifdef UWSGI_SPOOLER
+        uwsgi.hooks[UWSGI_MODIFIER_SPOOL_REQUEST] = uwsgi_request_spooler ; //17
+#endif
+        uwsgi.hooks[UWSGI_MODIFIER_FASTFUNC] = uwsgi_request_fastfunc ; //26
+
+        uwsgi.hooks[UWSGI_MODIFIER_MANAGE_PATH_INFO] = uwsgi_request_wsgi ; // 30
+        uwsgi.after_hooks[UWSGI_MODIFIER_MANAGE_PATH_INFO] = uwsgi_after_request_wsgi; // 30
+
+        uwsgi.hooks[UWSGI_MODIFIER_MESSAGE_MARSHAL] = uwsgi_request_marshal ; //33
+        uwsgi.hooks[UWSGI_MODIFIER_PING] = uwsgi_request_ping ; //100
+
+        fprintf(stderr,"done.\n");
+
+#ifdef UWSGI_ERLANG
+        if (uwsgi.erlang_node) {
+                uwsgi.erlangfd = init_erlang(uwsgi.erlang_node);
+        }
+#endif
+
+
+
+        if (uwsgi.wsgi_config != NULL) {
+                uwsgi_wsgi_config ();
+        }
+#ifdef UWSGI_XML
+        else if (uwsgi.xml_config != NULL) {
+                uwsgi_xml_config (&wsgi_req, NULL);
+        }
+#endif
+
+#ifdef UWSGI_PASTE
+        else if (uwsgi.paste != NULL) {
+                uwsgi_paste_config ();
+        }
+#endif
+
+        if (uwsgi.test_module != NULL) {
+                if (PyImport_ImportModule (uwsgi.test_module)) {
+                        exit (0);
+                }
+                exit (1);
+        }
+
+
+
+#ifndef UNBIT
+#ifndef ROCK_SOLID
+        if (no_server) {
+                fprintf (stderr, "no-server mode requested. Goodbye.\n");
+                exit (0);
+        }
+#endif
+#endif
+
+        if (!uwsgi.single_interpreter) {
+                fprintf(stderr,"*** uWSGI is running in multiple interpreter mode !!! ***\n");
+        }
+
+        /* preforking() */
+        if (uwsgi.master_process) {
+                if (uwsgi.is_a_reload) {
+                        fprintf (stderr, "gracefully (RE)spawned uWSGI master process (pid: %d)\n", uwsgi.mypid);
+                }
+                else {
+                        fprintf (stderr, "spawned uWSGI master process (pid: %d)\n", uwsgi.mypid);
+                }
+        }
+
+#ifdef UNBIT
+        if (single_app_mode == 1) {
+                wsgi_req.wsgi_script = getenv ("UWSGI_SCRIPT");
+                if (wsgi_req.wsgi_script) {
+                        wsgi_req.wsgi_script_len = strlen (wsgi_req.wsgi_script);
+                }
+                else {
+                        fprintf (stderr, "UWSGI_SCRIPT env var not set !\n");
+                        exit (1);
+                }
+
+                init_uwsgi_app (NULL, NULL);
+        }
+#endif
+
+#ifdef UWSGI_SPOOLER
+        if (spool_dir != NULL) {
+                uwsgi.workers[0].spooler_pid = spooler_start (uwsgi.serverfd, uwsgi_module);
+        }
+#endif
+
+
+        if (!uwsgi.master_process) {
+                if (uwsgi.numproc == 1) {
+                        fprintf (stderr, "spawned uWSGI worker 1 (and the only) (pid: %d)\n", masterpid);
+                }
+                else {
+                        fprintf (stderr, "spawned uWSGI worker 1 (pid: %d)\n", masterpid);
+                }
+                uwsgi.workers[1].pid = masterpid;
+                uwsgi.workers[1].id = 1;
+                uwsgi.workers[1].last_spawn = time (NULL);
+                uwsgi.workers[1].manage_next_request = 1;
+#ifdef UWSGI_THREADING
+                uwsgi.workers[1].i_have_gil = 1;
+#endif
+                uwsgi.mywid = 1;
+                gettimeofday (&last_respawn, NULL);
+                respawn_delta = last_respawn.tv_sec;
+        }
+
+
+                for (i = 2-uwsgi.master_process ; i < uwsgi.numproc + 1; i++) {
+                        /* let the worker know his worker_id (wid) */
+                        pid = fork ();
+                        if (pid == 0) {
+                                uwsgi.mypid = getpid ();
+                                uwsgi.workers[i].pid = uwsgi.mypid;
+                                uwsgi.workers[i].id = i;
+                                uwsgi.workers[i].last_spawn = time (NULL);
+                                uwsgi.workers[i].manage_next_request = 1;
+#ifdef UWSGI_THREADING
+                                uwsgi.workers[i].i_have_gil = 1;
+#endif
+                                uwsgi.mywid = i;
+                                if (uwsgi.serverfd != 0 && uwsgi.master_process == 1) {
+                                        /* close STDIN for workers */
+                                        close (0);
+                                }
+                                break;
+                        }
+                        else if (pid < 1) {
+                                perror ("fork()");
+                                exit (1);
+                        }
+                        else {
+                                fprintf (stderr, "spawned uWSGI worker %d (pid: %d)\n", i, pid);
+                                gettimeofday (&last_respawn, NULL);
+                                respawn_delta = last_respawn.tv_sec;
+                        }
+                }
+
+
+        if (getpid () == masterpid && uwsgi.master_process == 1) {
+                /* route signals to workers... */
+                signal (SIGHUP, (void *) &grace_them_all);
+                signal (SIGTERM, (void *) &reap_them_all);
+                signal (SIGINT, (void *) &kill_them_all);
+                signal (SIGQUIT, (void *) &kill_them_all);
+                /* used only to avoid human-errors */
+#ifndef UNBIT
+                signal (SIGUSR1, (void *) &stats);
+#endif
+
+                if (udp_socket) {
+                        udp_poll.fd = bind_to_udp (udp_socket);
+                        if (udp_poll.fd < 0) {
+                                fprintf (stderr, "unable to bind to udp socket. SNMP and cluster management services will be disabled.\n");
+                        }
+                        else {
+                                fprintf (stderr, "UDP server enabled.\n");
+                                udp_poll.events = POLLIN;
+                        }
+                }
+                for (;;) {
+                        if (ready_to_die >= uwsgi.numproc && uwsgi.to_hell) {
+#ifdef UWSGI_SPOOLER
+                                if (spool_dir && uwsgi.workers[0].spooler_pid > 0) {
+                                        kill (uwsgi.workers[0].spooler_pid, SIGKILL);
+                                        fprintf(stderr,"killed the spooler with pid %d\n", uwsgi.workers[0].spooler_pid);
+                                }
+
+#endif
+                                fprintf (stderr, "goodbye to uWSGI.\n");
+                                exit (0);
+                        }
+                        if (ready_to_reload >= uwsgi.numproc && uwsgi.to_heaven) {
+#ifdef UWSGI_SPOOLER
+                                if (spool_dir && uwsgi.workers[0].spooler_pid > 0) {
+                                        kill (uwsgi.workers[0].spooler_pid, SIGKILL);
+                                        fprintf(stderr,"wait4() the spooler with pid %d...", uwsgi.workers[0].spooler_pid);
+                                        diedpid = waitpid(uwsgi.workers[0].spooler_pid, &waitpid_status, 0);
+                                        fprintf(stderr,"done.");
+                                }
+#endif
+                                fprintf (stderr, "binary reloading uWSGI...\n");
+                                if (chdir (cwd)) {
+                                        perror ("chdir()");
+                                        exit (1);
+                                }
+                                /* check fd table (a module can obviosly open some fd on initialization...) */
+                                fprintf (stderr, "closing all fds > 2 (_SC_OPEN_MAX = %ld)...\n", sysconf (_SC_OPEN_MAX));
+                                for (i = 3; i < sysconf (_SC_OPEN_MAX); i++) {
+                                        if (i == uwsgi.serverfd) {
+                                                continue;
+                                        }
+                                        close (i);
+                                }
+                                if (uwsgi.serverfd != 3) {
+                                        if (dup2 (uwsgi.serverfd, 3) < 0) {
+                                                perror ("dup2()");
+                                                exit (1);
+                                        }
+                                }
+                                fprintf (stderr, "running %s\n", uwsgi.binary_path);
+                                strcpy (argv[0], uwsgi.binary_path);
+                                execve (uwsgi.binary_path, argv, environ);
+                                perror ("execve()");
+                                // never here
+                                exit (1);
+                        }
+                        diedpid = waitpid (WAIT_ANY, &waitpid_status, WNOHANG);
+                        if (diedpid == -1) {
+                                perror ("waitpid()");
+                                /* here is better to reload all the uWSGI stack */
+                                fprintf (stderr, "something horrible happened...\n");
+                                reap_them_all ();
+                                exit (1);
+                        }
+                        else if (diedpid == 0) {
+                                /* PLEASE, do not run python threads in the master process, you can potentially destroy the world,
+                                   we support this for hyperultramegagodprogrammer and systems
+                                 */
+#ifdef UWSGI_THREADING
+                                if (uwsgi.has_threads && uwsgi.options[UWSGI_OPTION_THREADS] == 1) {
+                                        uwsgi._save = PyEval_SaveThread ();
+                                        uwsgi.workers[uwsgi.mywid].i_have_gil = 0;
+                                }
+#endif
+                                /* all processes ok, doing status scan after N seconds */
+                                check_interval.tv_sec = uwsgi.options[UWSGI_OPTION_MASTER_INTERVAL];
+                                if (!check_interval.tv_sec)
+                                        check_interval.tv_sec = 1;
+                                
+                                if (udp_socket && udp_poll.fd >= 0) {
+                                        rlen = poll (&udp_poll, 1, check_interval.tv_sec * 1000);
+                                        if (rlen < 0) {
+                                                perror ("poll()");
+                                        }
+                                        else if (rlen > 0) {
+                                                udp_len = sizeof (udp_client);
+                                                rlen = recvfrom (udp_poll.fd, buffer, uwsgi.buffer_size, 0, (struct sockaddr *) &udp_client, &udp_len);
+                                                if (rlen < 0) {
+                                                        perror ("recvfrom()");
+                                                }
+                                                else if (rlen > 0) {
+                                                        memset (udp_client_addr, 0, 16);
+                                                        if (inet_ntop (AF_INET, &udp_client.sin_addr.s_addr, udp_client_addr, 16)) {
+                                                                fprintf (stderr, "received udp packet of %d bytes from %s:%d\n", rlen, udp_client_addr, ntohs (udp_client.sin_port));
+                                                                if (buffer[0] == 0x30) {
+                                                                        manage_snmp (udp_poll.fd, (uint8_t *) buffer, rlen, &udp_client);
+                                                                }
+                                                        }
+                                                        else {
+                                                                perror ("inet_ntop()");
+                                                        }
+                                                }
+                                        }
+                                }
+                                else {
+                                        select (0, NULL, NULL, NULL, &check_interval);
+                                }
+                                working_workers = 0;
+                                blocking_workers = 0;
+#ifdef UWSGI_THREADING
+                                if (uwsgi.has_threads && !uwsgi.workers[uwsgi.mywid].i_have_gil) {
+                                        PyEval_RestoreThread (uwsgi._save);
+                                        uwsgi.workers[uwsgi.mywid].i_have_gil = 1;
+                                }
+#endif
+                                check_interval.tv_sec = uwsgi.options[UWSGI_OPTION_MASTER_INTERVAL];
+                                if (!check_interval.tv_sec)
+                                        check_interval.tv_sec = 1;
+                                for (i = 1; i <= uwsgi.numproc; i++) {
+                                        /* first check for harakiri */
+                                        if (uwsgi.workers[i].harakiri > 0) {
+                                                if (uwsgi.workers[i].harakiri < time (NULL)) {
+                                                        /* first try to invoke the harakiri() custom handler */
+                                                        /* TODO */
+                                                        /* then brutally kill the worker */
+                                                        kill (uwsgi.workers[i].pid, SIGKILL);
+                                                }
+                                        }
+                                        /* load counters */
+                                        if (uwsgi.workers[i].status & UWSGI_STATUS_IN_REQUEST)
+                                                working_workers++;
+
+                                        if (uwsgi.workers[i].status & UWSGI_STATUS_BLOCKING)
+                                                blocking_workers++;
+
+                                        uwsgi.workers[i].last_running_time = uwsgi.workers[i].running_time;
+                                }
+
+                                continue;
+
+                        }
+#ifdef UWSGI_SPOOLER
+                        /* reload the spooler */
+                        if (spool_dir && uwsgi.workers[0].spooler_pid > 0) {
+                                if (diedpid == uwsgi.workers[0].spooler_pid) {
+                                        fprintf(stderr,"OOOPS the spooler is no more...trying respawn...\n");
+                                        uwsgi.workers[0].spooler_pid = spooler_start (uwsgi.serverfd, uwsgi_module);
+                                        continue;
+                                }
+                        }
+#endif
+                        /* check for reloading */
+                        if (WIFEXITED (waitpid_status)) {
+                                if (WEXITSTATUS (waitpid_status) == UWSGI_RELOAD_CODE && uwsgi.to_heaven) {
+                                        ready_to_reload++;
+                                        continue;
+                                }
+                                else if (WEXITSTATUS (waitpid_status) == UWSGI_END_CODE && uwsgi.to_hell) {
+                                        ready_to_die++;
+                                        continue;
+                                }
+                        }
+
+                        fprintf (stderr, "DAMN ! process %d died :( trying respawn ...\n", diedpid);
+                        gettimeofday (&last_respawn, NULL);
+                        if (last_respawn.tv_sec == respawn_delta) {
+                                fprintf (stderr, "worker respawning too fast !!! i have to sleep a bit...\n");
+                                /* TODO, user configurable fork throttler */
+                                sleep (2);
+                        }
+                        gettimeofday (&last_respawn, NULL);
+                        respawn_delta = last_respawn.tv_sec;
+                        uwsgi.mywid = find_worker_id (diedpid);
+                        pid = fork ();
+                        if (pid == 0) {
+                                uwsgi.mypid = getpid ();
+                                uwsgi.workers[uwsgi.mywid].pid = uwsgi.mypid;
+                                uwsgi.workers[uwsgi.mywid].harakiri = 0;
+                                uwsgi.workers[uwsgi.mywid].requests = 0;
+                                uwsgi.workers[uwsgi.mywid].failed_requests = 0;
+                                uwsgi.workers[uwsgi.mywid].respawn_count++;
+                                uwsgi.workers[uwsgi.mywid].last_spawn = time (NULL);
+                                uwsgi.workers[uwsgi.mywid].manage_next_request = 1;
+                                uwsgi.workers[uwsgi.mywid].i_have_gil = 1;
+                                break;
+                        }
+                        else if (pid < 1) {
+                                perror ("fork()");
+                        }
+                        else {
+                                fprintf (stderr, "Respawned uWSGI worker (new pid: %d)\n", pid);
+#ifdef UWSGI_SPOOLER
+                                if (uwsgi.mywid <= 0 && diedpid != uwsgi.workers[0].spooler_pid) {
+#else
+                                if (uwsgi.mywid <= 0) {
+#endif
+                                        fprintf (stderr, "warning the died pid was not in the workers list. Probably you hit a BUG of uWSGI\n");
+                                }
+                        }
+                }
+        }
+
+
+
+
+        uwsgi.hvec = malloc (sizeof (struct iovec) * uwsgi.vec_size);
+        if (uwsgi.hvec == NULL) {
+                fprintf (stderr, "unable to allocate memory for iovec.\n");
+                exit (1);
+        }
+
+        if (uwsgi.options[UWSGI_OPTION_HARAKIRI] > 0 && !uwsgi.master_process) {
+                signal (SIGALRM, (void *) &harakiri);
+        }
+
+        /* gracefully reload */
+        signal (SIGHUP, (void *) &gracefully_kill);
+        /* close the process (useful for master INT) */
+        signal (SIGINT, (void *) &end_me);
+        /* brutally reload */
+        signal (SIGTERM, (void *) &reload_me);
+
+
+#ifndef UNBIT
+        signal (SIGUSR1, (void *) &stats);
+#endif
+
+
+        signal (SIGPIPE, (void *) &warn_pipe);
+
+
+#ifdef UWSGI_ERLANG
+        if (uwsgi.erlang_nodes > 0) {
+                if ( (uwsgi.mywid - uwsgi.erlang_nodes) <= (uwsgi.numproc - uwsgi.erlang_nodes)) {
+                        erlang_loop(buffer);
+                        // NEVER HERE
+                        exit(1);
+                }
+        }
+        else {
+                // close the erlang server fd for python workers
+                close(uwsgi.erlangfd);
+        }
+#endif
+
+#ifdef UWSGI_THREADING
+        // release the GIL
+        if (uwsgi.has_threads) {
+                uwsgi._save = PyEval_SaveThread ();
+                uwsgi.workers[uwsgi.mywid].i_have_gil = 0;
+        }
+#endif
+
+
+        while (uwsgi.workers[uwsgi.mywid].manage_next_request) {
+
+
+                wsgi_req.app_id = uwsgi.default_app;
+#ifdef UWSGI_SENDFILE
+                wsgi_req.sendfile_fd = -1;
+#endif
+                // clear all status bits
+                UWSGI_CLEAR_STATUS ;
+
+                uwsgi.poll.fd = accept (uwsgi.serverfd, (struct sockaddr *) &c_addr, (socklen_t *) & c_len);
+
+                if (uwsgi.poll.fd < 0) {
+                        perror ("accept()");
+                        continue;
+                }
+
+                UWSGI_SET_IN_REQUEST;
+
+                if (uwsgi.options[UWSGI_OPTION_LOGGING])
+                        gettimeofday (&wsgi_req.start_of_request, NULL);
+
+                
+
+#ifdef UWSGI_SCTP
+                if (i_am_sctp == 1) {
+                        // get stream id, and map it to uwsgi modifiers
+                        struct sctp_status sstatus;
+                        memset (&sstatus, 0, sizeof (sstatus));
+                        socklen_t slen = sizeof (sstatus);
+                        sstatus.sstat_assoc_id = 1;
+                        if (getsockopt (uwsgi.poll.fd, IPPROTO_SCTP, SCTP_STATUS, &sstatus, &slen)) {
+                                perror ("getsockopt()");
+                        }
+
+                        memset (&sctp_ss, 0, sizeof (sctp_ss));
+
+                        fprintf (stderr, "%d %d\n", sstatus.sstat_instrms, sstatus.sstat_outstrms);
+
+                        i = 0;
+                        wsgi_req.size = sctp_recvmsg (uwsgi.poll.fd, buffer, uwsgi.buffer_size, 0, 0, &sctp_ss, 0);
+                        if (wsgi_req.size < 0) {
+                                perror ("sctp_recvmsg()");
+                        }
+                        fprintf (stderr, "received uwsgi message of %d bytes on stream id %d flags %d\n", wsgi_req.size, ntohs (sctp_ss.sinfo_stream), i);
+
+                }
+                else {
+#endif
+                        if (!uwsgi_parse_response (&uwsgi.poll, uwsgi.options[UWSGI_OPTION_SOCKET_TIMEOUT], (struct uwsgi_header *) &wsgi_req, buffer)) {
+                                continue;
+                        }
+#ifdef UWSGI_SCTP
+                }
+#endif
+
+                // enter harakiri mode
+                if (uwsgi.options[UWSGI_OPTION_HARAKIRI] > 0) {
+                        set_harakiri(uwsgi.options[UWSGI_OPTION_HARAKIRI]);
+                }
+
+                ret = (*uwsgi.hooks[wsgi_req.modifier])(&uwsgi, &wsgi_req, buffer);
+                // calculate execution time
+                gettimeofday(&wsgi_req.end_of_request, NULL) ;
+                uwsgi.workers[uwsgi.mywid].running_time += (double) (( (double)(wsgi_req.end_of_request.tv_sec*1000000+wsgi_req.end_of_request.tv_usec)-(double)(wsgi_req.start_of_request.tv_sec*1000000+wsgi_req.start_of_request.tv_usec))/ (double)1000.0) ;
+
+
+                // get memory usage
+                if (uwsgi.options[UWSGI_OPTION_MEMORY_DEBUG] == 1)
+                        get_memusage();
+
+                // close the connection with the webserver
+                close(uwsgi.poll.fd);
+                uwsgi.workers[0].requests++;
+                uwsgi.workers[uwsgi.mywid].requests++;
+
+                if (!ret)
+                        (*uwsgi.after_hooks[wsgi_req.modifier])(&uwsgi, &wsgi_req, buffer);
+
+
+                // leave harakiri mode
+                if (uwsgi.workers[uwsgi.mywid].harakiri > 0) {
+                        set_harakiri(0);
+                }
+
+
+                // defunct process reaper
+                if (uwsgi.options[UWSGI_OPTION_REAPER] == 1) {
+                        waitpid (-1, &waitpid_status, WNOHANG);
+                }
+                // reset request
+                memset (&wsgi_req, 0, sizeof (struct wsgi_request));
+#ifdef UNBIT
+                if (tmp_filename && tmp_dir_fd >= 0) {
+                        tmp_filename[0] = 0;
+                }
+#endif
+
+                if (uwsgi.options[UWSGI_OPTION_MAX_REQUESTS] > 0 && uwsgi.workers[uwsgi.mywid].requests >= uwsgi.options[UWSGI_OPTION_MAX_REQUESTS]) {
+                        goodbye_cruel_world ();
+                }
+
+#ifdef UNBIT
+                if (check_for_memory_errors) {
+                        if (syscall (357, &us, 0) > 0) {
+                                if (us.memory_errors > 0) {
+                                        fprintf (stderr, "Unbit Kernel found a memory allocation error for process %d.\n", uwsgi.mypid);
+                                        goodbye_cruel_world ();
+                                }
+                        }
+                }
+#endif
+
+        }
+
+        if (uwsgi.workers[uwsgi.mywid].manage_next_request == 0) {
+                reload_me ();
+        }
+        else {
+                goodbye_cruel_world ();
+        }
+
+        /* never here */
+        return 0;
+}
+
+void init_uwsgi_vars () {
+
+#ifndef UNBIT
+        int i;
+#endif
+        PyObject *pysys, *pysys_dict, *pypath;
+
+        /* add cwd to pythonpath */
+        pysys = PyImport_ImportModule ("sys");
+        if (!pysys) {
+                PyErr_Print ();
+                exit (1);
+        }
+        pysys_dict = PyModule_GetDict (pysys);
+        pypath = PyDict_GetItemString (pysys_dict, "path");
+        if (!pypath) {
+                PyErr_Print ();
+                exit (1);
+        }
+        if (PyList_Insert (pypath, 0, PyString_FromString (".")) != 0) {
+                PyErr_Print ();
+        }
+
+#ifndef UNBIT
+        for (i = 0; i < uwsgi.python_path_cnt; i++) {
+                if (PyList_Insert (pypath, 0, PyString_FromString (uwsgi.python_path[i])) != 0) {
+                        PyErr_Print ();
+                }
+                else {
+                        fprintf (stderr, "added %s to pythonpath.\n", uwsgi.python_path[i]);
+                }
+        }
+#endif
+
+}
+
+#ifndef ROCK_SOLID
+int init_uwsgi_app (PyObject * force_wsgi_dict, PyObject * my_callable) {
+        PyObject *wsgi_module, *wsgi_dict = NULL;
+        PyObject *pymain, *zero;
+        PyObject *pycprof, *pycprof_dict;
+        char tmpstring[256];
+        int id;
+
+        struct uwsgi_app *wi;
+
+        memset (tmpstring, 0, 256);
+
+
+        if (wsgi_req.wsgi_script_len == 0 && ((wsgi_req.wsgi_module_len == 0 || wsgi_req.wsgi_callable_len == 0) && uwsgi.wsgi_config == NULL && my_callable == NULL)) {
+                fprintf (stderr, "invalid application (%.*s). skip.\n", wsgi_req.script_name_len, wsgi_req.script_name);
+                return -1;
+        }
+
+        if (uwsgi.wsgi_config && wsgi_req.wsgi_callable_len == 0 && my_callable == NULL) {
+                fprintf (stderr, "invalid application (%.*s). skip.\n", wsgi_req.script_name_len, wsgi_req.script_name);
+                return -1;
+        }
+
+        if (wsgi_req.wsgi_script_len > 255 || wsgi_req.wsgi_module_len > 255 || wsgi_req.wsgi_callable_len > 255) {
+                fprintf (stderr, "invalid application's string size. skip.\n");
+                return -1;
+        }
+
+        id = uwsgi.wsgi_cnt;
+
+
+        if (wsgi_req.script_name_len == 0) {
+                wsgi_req.script_name_len = 1;
+                wsgi_req.script_name = (char *) app_slash;
+                id = 0;
+        }
+        else if (wsgi_req.script_name_len == 1) {
+                if (wsgi_req.script_name[0] == '/') {
+                        id = 0;
+                }
+        }
+
+
+        zero = PyString_FromStringAndSize (wsgi_req.script_name, wsgi_req.script_name_len);
+        if (!zero) {
+                Py_FatalError ("cannot get mountpoint python object !\n");
+        }
+
+        if (PyDict_GetItem (uwsgi.py_apps, zero) != NULL) {
+                Py_DECREF (zero);
+                fprintf (stderr, "mountpoint %.*s already configured. skip.\n", wsgi_req.script_name_len, wsgi_req.script_name);
+                return -1;
+        }
+
+        Py_DECREF (zero);
+
+        wi = &uwsgi.wsgi_apps[id];
+
+        memset (wi, 0, sizeof (struct uwsgi_app));
+
+        if (uwsgi.single_interpreter == 0) {
+                wi->interpreter = Py_NewInterpreter ();
+                if (!wi->interpreter) {
+                        fprintf (stderr, "unable to initialize the new interpreter\n");
+                        exit (1);
+                }
+                PyThreadState_Swap (wi->interpreter);
+#ifndef PYTHREE
+                init_uwsgi_embedded_module ();
+#endif
+                init_uwsgi_vars ();
+                fprintf (stderr, "interpreter for app %d initialized.\n", id);
+        }
+
+        if (uwsgi.paste) {
+                wi->wsgi_callable = my_callable;
+                Py_INCREF (my_callable);
+        }
+
+        else {
+
+                if (uwsgi.wsgi_config == NULL) {
+                        if (wsgi_req.wsgi_script_len > 0) {
+                                memcpy (tmpstring, wsgi_req.wsgi_script, wsgi_req.wsgi_script_len);
+                                wsgi_module = PyImport_ImportModule (tmpstring);
+                                if (!wsgi_module) {
+                                        PyErr_Print ();
+                                        if (uwsgi.single_interpreter == 0) {
+                                                Py_EndInterpreter (wi->interpreter);
+                                                PyThreadState_Swap (uwsgi.main_thread);
+                                        }
+                                        return -1;
+                                }
+                                wsgi_req.wsgi_callable = "application";
+                                wsgi_req.wsgi_callable_len = 11;
+                        }
+                        else {
+                                memcpy (tmpstring, wsgi_req.wsgi_module, wsgi_req.wsgi_module_len);
+                                wsgi_module = PyImport_ImportModule (tmpstring);
+                                if (!wsgi_module) {
+                                        PyErr_Print ();
+                                        if (uwsgi.single_interpreter == 0) {
+                                                Py_EndInterpreter (wi->interpreter);
+                                                PyThreadState_Swap (uwsgi.main_thread);
+                                        }
+                                        return -1;
+                                }
+                        }
+
+                        wsgi_dict = PyModule_GetDict (wsgi_module);
+                        if (!wsgi_dict) {
+                                PyErr_Print ();
+                                if (uwsgi.single_interpreter == 0) {
+                                        Py_EndInterpreter (wi->interpreter);
+                                        PyThreadState_Swap (uwsgi.main_thread);
+                                }
+                                return -1;
+                        }
+
+                }
+                else {
+                        wsgi_dict = force_wsgi_dict;
+                }
+
+
+                memset (tmpstring, 0, 256);
+                memcpy (tmpstring, wsgi_req.wsgi_callable, wsgi_req.wsgi_callable_len);
+                if (my_callable) {
+                        wi->wsgi_callable = my_callable;
+                        Py_INCREF (my_callable);
+                }
+                else if (wsgi_dict) {
+                        wi->wsgi_callable = PyDict_GetItemString (wsgi_dict, tmpstring);
+                }
+                else {
+                        return -1;
+                }
+
+        }
+
+
+        if (!wi->wsgi_callable) {
+                PyErr_Print ();
+                if (uwsgi.single_interpreter == 0) {
+                        Py_EndInterpreter (wi->interpreter);
+                        PyThreadState_Swap (uwsgi.main_thread);
+                }
+                return -1;
+        }
+
+
+        wi->wsgi_environ = PyDict_New ();
+        if (!wi->wsgi_environ) {
+                PyErr_Print ();
+                if (uwsgi.single_interpreter == 0) {
+                        Py_EndInterpreter (wi->interpreter);
+                        PyThreadState_Swap (uwsgi.main_thread);
+                }
+                return -1;
+        }
+
+        if (wsgi_dict) {
+                wi->wsgi_harakiri = PyDict_GetItemString (wsgi_dict, "harakiri");
+                if (wi->wsgi_harakiri) {
+                        fprintf (stderr, "initialized Harakiri custom handler: %p.\n", wi->wsgi_harakiri);
+                }
+        }
+
+
+
+#ifdef UWSGI_PROFILER
+        if (uwsgi.enable_profiler) {
+                pymain = PyImport_AddModule ("__main__");
+                if (!pymain) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                wi->pymain_dict = PyModule_GetDict (pymain);
+                if (!wi->pymain_dict) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                if (PyDict_SetItem (wi->pymain_dict, PyString_FromFormat ("uwsgi_application__%d", id), wi->wsgi_callable)) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                if (PyDict_SetItem (wi->pymain_dict, PyString_FromFormat ("uwsgi_environ__%d", id), wi->wsgi_environ)) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                if (PyDict_SetItem (wi->pymain_dict, PyString_FromFormat ("uwsgi_spit__%d", id), wsgi_spitout)) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+
+                pycprof = PyImport_ImportModule ("cProfile");
+                if (!pycprof) {
+                        PyErr_Print ();
+                        fprintf (stderr, "trying old profile module... ");
+                        pycprof = PyImport_ImportModule ("profile");
+                        if (!pycprof) {
+                                fprintf (stderr, "doh!!!\n");
+                                PyErr_Print ();
+                                exit (1);
+                        }
+                        else {
+                                fprintf (stderr, "ok and set stdout to linebuf mode.\n");
+                        }
+                }
+                pycprof_dict = PyModule_GetDict (pycprof);
+                if (!pycprof_dict) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+                wi->wsgi_cprofile_run = PyDict_GetItemString (pycprof_dict, "run");
+                if (!wi->wsgi_cprofile_run) {
+                        PyErr_Print ();
+                        exit (1);
+                }
+
+                wi->wsgi_args = PyTuple_New (1);
+                if (PyTuple_SetItem (wi->wsgi_args, 0, PyString_FromFormat ("uwsgi_out = uwsgi_application__%d(uwsgi_environ__%d,uwsgi_spit__%d)", id, id, id))) {
+                        PyErr_Print ();
+                        if (uwsgi.single_interpreter == 0) {
+                                Py_EndInterpreter (wi->interpreter);
+                                PyThreadState_Swap (uwsgi.main_thread);
+                        }
+                        return -1;
+                }
+        }
+        else {
+#endif
+                wi->wsgi_args = PyTuple_New (2);
+                if (PyTuple_SetItem (wi->wsgi_args, 0, wi->wsgi_environ)) {
+                        PyErr_Print ();
+                        if (uwsgi.single_interpreter == 0) {
+                                Py_EndInterpreter (wi->interpreter);
+                                PyThreadState_Swap (uwsgi.main_thread);
+                        }
+                        return -1;
+                }
+                if (PyTuple_SetItem (wi->wsgi_args, 1, wsgi_spitout)) {
+                        PyErr_Print ();
+                        if (uwsgi.single_interpreter == 0) {
+                                Py_EndInterpreter (wi->interpreter);
+                                PyThreadState_Swap (uwsgi.main_thread);
+                        }
+                        return -1;
+                }
+#ifdef UWSGI_PROFILER
+        }
+#endif
+
+#ifdef UWSGI_SENDFILE
+        // prepare sendfile()
+        wi->wsgi_sendfile = PyCFunction_New (uwsgi_sendfile_method, NULL);
+#endif
+
+        if (uwsgi.single_interpreter == 0) {
+                PyThreadState_Swap (uwsgi.main_thread);
+        }
+
+        memset (tmpstring, 0, 256);
+        memcpy (tmpstring, wsgi_req.script_name, wsgi_req.script_name_len);
+        PyDict_SetItemString (uwsgi.py_apps, tmpstring, PyInt_FromLong (id));
+        PyErr_Print ();
+
+        fprintf (stderr, "application %d (%s) ready\n", id, tmpstring);
+
+        if (id == 0) {
+                fprintf (stderr, "setting default application to 0\n");
+                uwsgi.default_app = 0;
+        }
+        else {
+                uwsgi.wsgi_cnt++;
+        }
+
+        return id;
+}
+
+#ifdef UWSGI_PASTE
+void uwsgi_paste_config () {
+        PyObject *paste_module, *paste_dict, *paste_loadapp;
+        PyObject *paste_arg, *paste_app;
+
+        fprintf (stderr, "Loading paste environment: %s\n", uwsgi.paste);
+        paste_module = PyImport_ImportModule ("paste.deploy");
+        if (!paste_module) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        paste_dict = PyModule_GetDict (paste_module);
+        if (!paste_dict) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        paste_loadapp = PyDict_GetItemString (paste_dict, "loadapp");
+        if (!paste_loadapp) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        paste_arg = PyTuple_New (1);
+        if (!paste_arg) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyTuple_SetItem (paste_arg, 0, PyString_FromString (uwsgi.paste))) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        paste_app = PyEval_CallObject (paste_loadapp, paste_arg);
+        if (!paste_app) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        init_uwsgi_app (NULL, paste_app);
+}
+
+#endif
+
+void uwsgi_wsgi_config () {
+
+        PyObject *wsgi_module, *wsgi_dict;
+#ifndef PYTHREE
+        PyObject *uwsgi_module, *uwsgi_dict;
+#endif
+        PyObject *applications;
+        PyObject *app_list;
+        int ret ;
+        Py_ssize_t i;
+        PyObject *app_mnt, *app_app;
+
+        wsgi_module = PyImport_ImportModule (uwsgi.wsgi_config);
+        if (!wsgi_module) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        wsgi_dict = PyModule_GetDict (wsgi_module);
+        if (!wsgi_dict) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        fprintf (stderr, "...getting the applications list from the '%s' module...\n", uwsgi.wsgi_config);
+
+#ifndef PYTHREE
+        uwsgi_module = PyImport_ImportModule ("uwsgi");
+        if (!uwsgi_module) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        uwsgi_dict = PyModule_GetDict (uwsgi_module);
+        if (!uwsgi_dict) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+
+
+        applications = PyDict_GetItemString (uwsgi_dict, "applications");
+        if (!PyDict_Check (applications)) {
+                fprintf (stderr, "uwsgi.applications dictionary is not defined, trying with the (deprecated) \"applications\" one...\n");
+#endif
+                applications = PyDict_GetItemString (wsgi_dict, "applications");
+                if (!applications) {
+                        fprintf (stderr, "applications dictionary is not defined, trying with the \"application\" callable.\n");
+                        app_app = PyDict_GetItemString (wsgi_dict, "application");
+                        if (app_app) {
+                                applications = PyDict_New ();
+                                if (!applications) {
+                                        fprintf (stderr, "could not initialize applications dictionary\n");
+                                        exit (1);
+                                }
+                                if (PyDict_SetItemString (applications, "/", app_app)) {
+                                        PyErr_Print ();
+                                        fprintf (stderr, "unable to set default application\n");
+                                        exit (1);
+                                }
+                        }
+                        else {
+                                fprintf (stderr, "static applications not defined, you have to used the dynamic one...\n");
+                                return;
+                        }
+                }
+#ifndef PYTHREE
+        }
+#endif
+
+        if (!PyDict_Check (applications)) {
+                fprintf (stderr, "The 'applications' object must be a dictionary.\n");
+                exit (1);
+        }
+
+        app_list = PyDict_Keys (applications);
+        if (!app_list) {
+                PyErr_Print ();
+                exit (1);
+        }
+        if (PyList_Size (app_list) < 1) {
+                fprintf (stderr, "You must define an app.\n");
+                exit (1);
+        }
+
+        for (i = 0; i < PyList_Size (app_list); i++) {
+                app_mnt = PyList_GetItem (app_list, i);
+
+                if (!PyString_Check (app_mnt)) {
+                        fprintf (stderr, "the app mountpoint must be a string.\n");
+                        exit (1);
+                }
+
+                wsgi_req.script_name = PyString_AsString (app_mnt);
+                wsgi_req.script_name_len = strlen (wsgi_req.script_name);
+
+                app_app = PyDict_GetItem (applications, app_mnt);
+
+                if (!PyString_Check (app_app) && !PyFunction_Check (app_app) && !PyCallable_Check (app_app)) {
+                        fprintf (stderr, "the app callable must be a string, a function or a callable. (found %s)\n", app_app->ob_type->tp_name);
+                        exit (1);
+                }
+
+                if (PyString_Check (app_app)) {
+                        wsgi_req.wsgi_callable = PyString_AsString (app_app);
+                        wsgi_req.wsgi_callable_len = strlen (wsgi_req.wsgi_callable);
+                        fprintf (stderr, "initializing [%s => %s] app...\n", wsgi_req.script_name, wsgi_req.wsgi_callable);
+                        ret = init_uwsgi_app (wsgi_dict, NULL);
+                }
+                else {
+                        fprintf (stderr, "initializing [%s] app...\n", wsgi_req.script_name);
+                        ret = init_uwsgi_app (wsgi_dict, app_app);
+                }
+
+                if (ret < 0) {
+                        fprintf (stderr, "...goodbye cruel world...\n");
+                        exit (1);
+                }
+                Py_DECREF (app_mnt);
+                Py_DECREF (app_app);
+        }
+
+}
+
+#endif
+
+#ifdef UNBIT
+int uri_to_hex () {
+        int i = 0, j = 0;
+
+        if (wsgi_req.uri_len < 1) {
+                return 0;
+        }
+
+        if (wsgi_req.uri_len * 2 > 8192) {
+                return 0;
+        }
+
+        for (i = 0; i < wsgi_req.uri_len; i++) {
+                sprintf (tmp_filename + j, "%02X", wsgi_req.uri[i]);
+                j += 2;
+        }
+
+        return j;
+}
+#endif
+
+#ifdef UWSGI_EMBEDDED
+void init_uwsgi_embedded_module () {
+        PyObject *new_uwsgi_module, *zero;
+        int i;
+
+        /* initialize for stats */
+        uwsgi.workers_tuple = PyTuple_New (uwsgi.numproc);
+        for (i = 0; i < uwsgi.numproc; i++) {
+                zero = PyDict_New ();
+                Py_INCREF (zero);
+                PyTuple_SetItem (uwsgi.workers_tuple, i, zero);
+        }
+
+
+
+        new_uwsgi_module = Py_InitModule ("uwsgi", null_methods);
+        if (new_uwsgi_module == NULL) {
+                fprintf (stderr, "could not initialize the uwsgi python module\n");
+                exit (1);
+        }
+
+        uwsgi.embedded_dict = PyModule_GetDict (new_uwsgi_module);
+        if (!uwsgi.embedded_dict) {
+                fprintf (stderr, "could not get uwsgi module __dict__\n");
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "SPOOL_RETRY", PyInt_FromLong (17))) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "numproc", PyInt_FromLong (uwsgi.numproc))) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+#ifdef UNBIT
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "unbit", Py_True)) {
+#else
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "unbit", Py_None)) {
+#endif
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "buffer_size", PyInt_FromLong (uwsgi.buffer_size))) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "started_on", PyInt_FromLong (uwsgi.start_tv.tv_sec))) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "start_response", wsgi_spitout)) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "fastfuncs", PyList_New (256))) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "applist", uwsgi.py_apps)) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "applications", Py_None)) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        uwsgi.embedded_args = PyTuple_New (2);
+        if (!uwsgi.embedded_args) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        if (PyDict_SetItemString (uwsgi.embedded_dict, "message_manager_marshal", Py_None)) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        uwsgi.fastfuncslist = PyDict_GetItemString (uwsgi.embedded_dict, "fastfuncs");
+        if (!uwsgi.fastfuncslist) {
+                PyErr_Print ();
+                exit (1);
+        }
+
+        init_uwsgi_module_advanced (new_uwsgi_module);
+
+#ifdef UWSGI_SPOOLER
+        if (spool_dir != NULL) {
+                init_uwsgi_module_spooler (new_uwsgi_module);
+        }
+#endif
+
+
+        if (uwsgi.sharedareasize > 0 && uwsgi.sharedarea) {
+                init_uwsgi_module_sharedarea (new_uwsgi_module);
+        }
+}
+#endif
+
+#ifdef UWSGI_SPOOLER
+pid_t spooler_start (int serverfd, PyObject * uwsgi_module) {
+        pid_t pid;
+
+        pid = fork ();
+        if (pid < 0) {
+                perror ("fork()");
+                exit (1);
+        }
+        else if (pid == 0) {
+                close (serverfd);
+                spooler (uwsgi_module);
+        }
+        else if (pid > 0) {
+                fprintf (stderr, "spawned the uWSGI spooler on dir %s with pid %d\n", spool_dir, pid);
+        }
+
+        return pid;
+}
+#endif
+
+void manage_opt(int i, char *optarg) {
+
                 switch (i) {
 #ifndef ROCK_SOLID
@@ -724 +2263 @@
                         break;
                 case LONG_ARGS_UDP:
-                        udp_socket = optarg;
+                        uwsgi.udp_socket = optarg;
                         uwsgi.master_process = 1;
                         break;
@@ -736 +2275 @@
                         uwsgi.uid = atoi (optarg);
                         break;
+#ifdef UWSGI_ERLANG
+                case LONG_ARGS_ERLANG:
+                        uwsgi.erlang_node = optarg;
+                        break;
+#endif
                 case LONG_ARGS_PYTHONPATH:
                         if (uwsgi.python_path_cnt < 63) {
@@ -746 +2290 @@
                         break;
                 case LONG_ARGS_LIMIT_AS:
-                        rl.rlim_cur = (atoi (optarg)) * 1024 * 1024;
-                        rl.rlim_max = rl.rlim_cur;
+                        uwsgi.rl.rlim_cur = (atoi (optarg)) * 1024 * 1024;
+                        uwsgi.rl.rlim_max = uwsgi.rl.rlim_cur;
                         break;
 #endif
@@ -773 +2317 @@
                         uwsgi.options[UWSGI_OPTION_LOGGING] = 0;
                         break;
-#ifndef ROCK_SOLID
+#ifdef UWSGI_SPOOLER
                 case 'Q':
                         spool_dir = optarg;
@@ -808 +2352 @@
 #ifndef UNBIT
                 case 'd':
-                        if (!is_a_reload) {
+                        if (!uwsgi.is_a_reload) {
                                 daemonize (optarg);
                         }
                         break;
                 case 's':
-                        socket_name = optarg;
-                        break;
-#ifndef ROCK_SOLID
+                        uwsgi.socket_name = optarg;
+                        break;
+#ifdef UWSGI_XML
                 case 'x':
                         uwsgi.xml_config = optarg;
@@ -930 +2474 @@
 \t--limit-as <MB>\t\t\tlimit the address space of processes to MB megabytes\n\
 \t--udp <ip:port>\t\t\tbind master process to udp socket on ip:port\n\
-\t-d|--daemonize <logfile>\tdaemonize and log into <logfile>\n", argv[0]);
+\t-d|--daemonize <logfile>\tdaemonize and log into <logfile>\n", uwsgi.binary_path);
                         exit (1);
                 case 0:
@@ -940 +2484 @@
         }
 
-#ifndef UNBIT
-#ifndef ROCK_SOLID
-        if (uwsgi.options[UWSGI_OPTION_CGI_MODE] == 0) {
-#endif
-#endif
-                if (uwsgi.test_module == NULL) {
-                        fprintf (stderr, "*** Starting uWSGI (%dbit) on [%.*s] ***\n", (int) (sizeof (void *)) * 8, 24, ctime ((const time_t *) &uwsgi.start_tv.tv_sec));
-                }
-#ifndef UNBIT
-#ifndef ROCK_SOLID
-        }
-        else {
-                fprintf (stderr, "*** Starting uWSGI (CGI mode) (%dbit) on [%.*s] ***\n", (int) (sizeof (void *)) * 8, 24, ctime ((const time_t *) &uwsgi.start_tv.tv_sec));
-        }
-#endif
-#endif
-
-#ifdef __BIG_ENDIAN__
-        fprintf (stderr, "*** big endian arch detected ***\n");
-#endif
-
-#ifdef PYTHREE
-        fprintf (stderr, "*** Warning Python3.x support is experimental, do not use it in production environment ***\n");
-#endif
-
-        fprintf (stderr, "Python version: %s\n", Py_GetVersion ());
-
-#ifndef UNBIT
-        if (!getuid ()) {
-                fprintf (stderr, "uWSGI running as root, you can use --uid/--gid/--chroot options\n");
-                if (uwsgi.chroot) {
-                        fprintf (stderr, "chroot() to %s\n", uwsgi.chroot);
-                        if (chroot (uwsgi.chroot)) {
-                                perror ("chroot()");
-                                exit (1);
-                        }
-#ifdef __linux__
-                        if (uwsgi.options[UWSGI_OPTION_MEMORY_DEBUG]) {
-                                fprintf (stderr, "*** Warning, on linux system you have to bind-mount the /proc fs in your chroot to get memory debug/report.\n");
-                        }
-#endif
-                }
-                if (uwsgi.gid) {
-                        fprintf (stderr, "setgid() to %d\n", uwsgi.gid);
-                        if (setgid (uwsgi.gid)) {
-                                perror ("setgid()");
-                                exit (1);
-                        }
-                }
-                if (uwsgi.uid) {
-                        fprintf (stderr, "setuid() to %d\n", uwsgi.uid);
-                        if (setuid (uwsgi.uid)) {
-                                perror ("setuid()");
-                                exit (1);
-                        }
-                }
-
-                if (!getuid()) {
-                        fprintf(stderr," *** WARNING: you are running uWSGI as root !!! (use the --uid flag) *** \n");
-                }
-        }
-        else {
-                if (uwsgi.chroot) {
-                        fprintf (stderr, "cannot chroot() as non-root user\n");
-                        exit (1);
-                }
-                if (uwsgi.gid) {
-                        fprintf (stderr, "cannot setgid() as non-root user\n");
-                        exit (1);
-                }
-                if (uwsgi.uid) {
-                        fprintf (stderr, "cannot setuid() as non-root user\n");
-                        exit (1);
-                }
-        }
-
-        
-
-#endif
-
-#ifndef UNBIT
-        if (rl.rlim_max > 0) {
-                fprintf (stderr, "limiting address space of processes...\n");
-                if (setrlimit (RLIMIT_AS, &rl)) {
-                        perror ("setrlimit()");
-                }
-        }
-#endif
-
-        if (!getrlimit (RLIMIT_AS, &rl)) {
-#ifndef UNBIT
-                // check for overflow
-                if ((sizeof (void *) == 4 && (uint32_t) rl.rlim_max < UINT32_MAX) || (sizeof (void *) == 8 && (uint64_t) rl.rlim_max < UINT64_MAX)) {
-#endif
-                        fprintf (stderr, "your process address space limit is %lld bytes (%lld MB)\n", (long long) rl.rlim_max, (long long) rl.rlim_max / 1024 / 1024);
-#ifndef UNBIT
-                }
-#endif
-        }
-
-        uwsgi.page_size = getpagesize ();
-        fprintf (stderr, "your memory page size is %d bytes\n", uwsgi.page_size);
-
-#ifndef UNBIT
-        fprintf (stderr, "your server socket listen backlog is limited to %d connections\n", uwsgi.listen_queue);
-#endif
-
-        if (uwsgi.synclog) {
-                fprintf (stderr, "allocating a memory page for synced logging.\n");
-                uwsgi.sync_page = malloc (uwsgi.page_size);
-                if (!uwsgi.sync_page) {
-                        perror ("malloc()");
-                        exit (1);
-                }
-        }
-
-        if (uwsgi.pyhome != NULL) {
-                fprintf (stderr, "Setting PythonHome to %s...\n", uwsgi.pyhome);
-#ifdef PYTHREE
-                wchar_t *wpyhome;
-                wpyhome = malloc ((sizeof (wchar_t) * strlen (uwsgi.pyhome)) + 2);
-                if (!wpyhome) {
-                        perror ("malloc()");
-                        exit (1);
-                }
-                mbstowcs (wpyhome, uwsgi.pyhome, strlen (uwsgi.pyhome));
-                Py_SetPythonHome (wpyhome);
-                free (wpyhome);
-#else
-                Py_SetPythonHome (uwsgi.pyhome);
-#endif
-        }
-
-
-
-
-#ifdef PYTHREE
-        wchar_t pname[6];
-        mbstowcs (pname, "uWSGI", 6);
-        Py_SetProgramName (pname);
-#else
-        Py_SetProgramName ("uWSGI");
-#endif
-
-
-        Py_Initialize ();
-
-        pyargv[0] = "uwsgi";
-
-        if (uwsgi.pyargv != NULL) {
-                char *ap;
-                while ((ap = strsep (&uwsgi.pyargv, " \t")) != NULL) {
-                        if (*ap != '\0') {
-                                pyargv[pyargc] = ap;
-                                pyargc++;
-                        }
-                        if (pyargc + 1 > MAX_PYARGV)
-                                break;
-                }
-        }
-
-        PySys_SetArgv (pyargc, pyargv);
-
-
-#ifndef ROCK_SOLID
-        uwsgi.py_apps = PyDict_New ();
-        if (!uwsgi.py_apps) {
-                PyErr_Print ();
-                exit (1);
-        }
-
-#endif
-
-
-        wsgi_spitout = PyCFunction_New (uwsgi_spit_method, NULL);
-        wsgi_writeout = PyCFunction_New (uwsgi_write_method, NULL);
-
-#ifndef PYTHREE
-#ifndef ROCK_SOLID
-        uwsgi_module = Py_InitModule ("uwsgi", null_methods);
-        if (uwsgi_module == NULL) {
-                fprintf (stderr, "could not initialize the uwsgi python module\n");
-                exit (1);
-        }
-        if (uwsgi.sharedareasize > 0) {
-#ifndef __OpenBSD__
-                uwsgi.sharedareamutex = mmap (NULL, sizeof (pthread_mutexattr_t) + sizeof (pthread_mutex_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-                if (!uwsgi.sharedareamutex) {
-                        perror ("mmap()");
-                        exit (1);
-                }
-#else
-                fprintf (stderr, "***WARNING*** the sharedarea on OpenBSD is not SMP-safe. Beware of race conditions !!!\n");
-#endif
-                uwsgi.sharedarea = mmap (NULL, uwsgi.page_size * uwsgi.sharedareasize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-                if (uwsgi.sharedarea) {
-                        fprintf (stderr, "shared area mapped at %p, you can access it with uwsgi.sharedarea* functions.\n", uwsgi.sharedarea);
-
-#ifdef __APPLE__
-                        memset (uwsgi.sharedareamutex, 0, sizeof (OSSpinLock));
-#else
-#ifndef __OpenBSD__
-                        if (pthread_mutexattr_init ((pthread_mutexattr_t *) uwsgi.sharedareamutex)) {
-                                fprintf (stderr, "unable to allocate mutexattr structure\n");
-                                exit (1);
-                        }
-                        if (pthread_mutexattr_setpshared ((pthread_mutexattr_t *) uwsgi.sharedareamutex, PTHREAD_PROCESS_SHARED)) {
-                                fprintf (stderr, "unable to share mutex\n");
-                                exit (1);
-                        }
-                        if (pthread_mutex_init ((pthread_mutex_t *) uwsgi.sharedareamutex + sizeof (pthread_mutexattr_t), (pthread_mutexattr_t *) uwsgi.sharedareamutex)) {
-                                fprintf (stderr, "unable to initialize mutex\n");
-                                exit (1);
-                        }
-#endif
-#endif
-
-                }
-                else {
-                        perror ("mmap()");
-                        exit (1);
-                }
-
-        }
-
-        init_uwsgi_embedded_module ();
-#endif
-#endif
-
-
-
-#ifdef ROCK_SOLID
-
-
-        wi = malloc (sizeof (struct uwsgi_app));
-        if (wi == NULL) {
-                perror ("malloc()");
-                exit (1);
-        }
-        memset (wi, 0, sizeof (struct uwsgi_app));
-
-        // load wsgi module/script
-        for (i = optind; i < argc; i++) {
-                init_uwsgi_vars ();
-                wi->wsgi_module = PyImport_ImportModule (argv[i]);
-                if (!wi->wsgi_module) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-                wi->wsgi_dict = PyModule_GetDict (wi->wsgi_module);
-                if (!wi->wsgi_dict) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-                wi->wsgi_callable = PyDict_GetItemString (wi->wsgi_dict, "application");
-                if (!wi->wsgi_callable) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-                wi->wsgi_environ = PyDict_New ();
-                if (!wi->wsgi_environ) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-
-                wi->wsgi_harakiri = PyDict_GetItemString (wi->wsgi_dict, "harakiri");
-
-                wi->wsgi_args = PyTuple_New (2);
-                if (!wi->wsgi_args) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-                if (PyTuple_SetItem (wi->wsgi_args, 0, wi->wsgi_environ)) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-                if (PyTuple_SetItem (wi->wsgi_args, 1, wsgi_spitout)) {
-                        PyErr_Print ();
-                        exit (1);
-                }
-                break;
-        }
-
-        if (!wi->wsgi_module) {
-                fprintf (stderr, "unable to find the wsgi script. Have you specified it ?\n");
-                exit (1);
-        }
-#endif
-
-#ifndef ROCK_SOLID
-        Py_OptimizeFlag = uwsgi.py_optimize;
-
-        uwsgi.main_thread = PyThreadState_Get ();
-
-
-        if (uwsgi.has_threads) {
-                PyEval_InitThreads ();
-                fprintf (stderr, "threads support enabled\n");
-        }
-
-#endif
-
-        if (!no_server) {
-#ifndef UNBIT
-                if (socket_name != NULL && !is_a_reload) {
-#ifdef SCTP
-                        if (!strncmp (socket_name, "sctp:", 5)) {
-                                char *sctp_port = strchr (socket_name + 5, ':');
-                                if (sctp_port == NULL) {
-                                        fprintf (stderr, "invalid SCTP port ! syntax: sctp:ip1,ip2,ipN:port\n");
-                                        exit (1);
-                                }
-                                uwsgi.serverfd = bind_to_sctp (socket_name + 5, uwsgi.listen_queue, sctp_port);
-                                i_am_sctp = 1;
-                        }
-                        else {
-#endif
-                                char *tcp_port = strchr (socket_name, ':');
-                                if (tcp_port == NULL) {
-                                        uwsgi.serverfd = bind_to_unix (socket_name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
-                                }
-                                else {
-                                        uwsgi.serverfd = bind_to_tcp (socket_name, uwsgi.listen_queue, tcp_port);
-                                }
-
-                                if (uwsgi.serverfd < 0) {
-                                        fprintf (stderr, "unable to create the server socket.\n");
-                                        exit (1);
-                                }
-#ifdef SCTP
-                        }
-#endif
-                }
-#endif
-
-                socket_type_len = sizeof (int);
-                if (getsockopt (uwsgi.serverfd, SOL_SOCKET, SO_TYPE, &socket_type, &socket_type_len)) {
-                        perror ("getsockopt()");
-                        fprintf(stderr, "The -s/--socket option is missing and stdin is not a socket.\n");
-                        exit (1);
-                }
-
-        }
-
-
-
-#ifndef ROCK_SOLID
-        if (uwsgi.single_interpreter == 1) {
-                init_uwsgi_vars ();
-        }
-
-        memset (uwsgi.wsgi_apps, 0, sizeof (uwsgi.wsgi_apps));
-
-
-#endif
-
-
-
-        uwsgi.poll.events = POLLIN;
-
-        memset (&wsgi_req, 0, sizeof (struct wsgi_request));
-
-        /* shared area for workers */
-        uwsgi.workers = (struct uwsgi_worker *) mmap (NULL, sizeof (struct uwsgi_worker) * uwsgi.maxworkers + 1, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
-        if (!uwsgi.workers) {
-                perror ("mmap()");
-                exit (1);
-        }
-        memset (uwsgi.workers, 0, sizeof (struct uwsgi_worker) * uwsgi.maxworkers + 1);
-
-        uwsgi.mypid = getpid ();
-        masterpid = uwsgi.mypid;
-
-#ifndef ROCK_SOLID
-#ifndef UNBIT
-        if (uwsgi.pidfile) {
-                fprintf (stderr, "writing pidfile to %s\n", uwsgi.pidfile);
-                pidfile = fopen (uwsgi.pidfile, "w");
-                if (!pidfile) {
-                        perror ("fopen");
-                        exit (1);
-                }
-                if (fprintf (pidfile, "%d\n", masterpid) < 0) {
-                        fprintf (stderr, "could not write pidfile.\n");
-                }
-                fclose (pidfile);
-        }
-#endif
-#endif
-
-        if (uwsgi.buffer_size > 65536) {
-                fprintf (stderr, "invalid buffer size.\n");
-                exit (1);
-        }
-        buffer = malloc (uwsgi.buffer_size);
-        if (buffer == NULL) {
-                fprintf (stderr, "unable to allocate memory for buffer.\n");
-                exit (1);
-        }
-
-        fprintf (stderr, "request/response buffer (%d bytes) allocated.\n", uwsgi.buffer_size);
-
-        /* save the masterpid */
-        uwsgi.workers[0].pid = masterpid;
-
-        uwsgi.workers[0].current_workers = uwsgi.numproc;
-
-        fprintf(stderr,"initializing hooks...");
-
-        uwsgi.hooks[0] = uwsgi_request_wsgi ; 
-        uwsgi.after_hooks[0] = uwsgi_after_request_wsgi ; 
-
-        uwsgi.hooks[UWSGI_MODIFIER_ADMIN_REQUEST] = uwsgi_request_admin ; //10
-        uwsgi.hooks[UWSGI_MODIFIER_SPOOL_REQUEST] = uwsgi_request_spooler ; //17
-        uwsgi.hooks[UWSGI_MODIFIER_FASTFUNC] = uwsgi_request_fastfunc ; //26
-
-        uwsgi.hooks[UWSGI_MODIFIER_MANAGE_PATH_INFO] = uwsgi_request_wsgi ; // 30
-        uwsgi.after_hooks[UWSGI_MODIFIER_MANAGE_PATH_INFO] = uwsgi_after_request_wsgi; // 30
-
-        uwsgi.hooks[UWSGI_MODIFIER_MESSAGE_MARSHAL] = uwsgi_request_marshal ; //33
-        uwsgi.hooks[UWSGI_MODIFIER_PING] = uwsgi_request_ping ; //100
-
-        fprintf(stderr,"done.\n");
-
-
-#ifndef ROCK_SOLID
-        if (uwsgi.wsgi_config != NULL) {
-                uwsgi_wsgi_config ();
-        }
-#endif
-
-#ifndef UNBIT
-#ifndef ROCK_SOLID
-        else if (uwsgi.xml_config != NULL) {
-                uwsgi_xml_config ();
-        }
-#endif
-#endif
-
-#ifndef ROCK_SOLID
-        else if (uwsgi.paste != NULL) {
-                uwsgi_paste_config ();
-        }
-#endif
-
-        if (uwsgi.test_module != NULL) {
-                if (PyImport_ImportModule (uwsgi.test_module)) {
-                        exit (0);
-                }
-                exit (1);
-        }
-
-
-
-#ifndef UNBIT
-#ifndef ROCK_SOLID
-        if (no_server) {
-                fprintf (stderr, "no-server mode requested. Goodbye.\n");
-                exit (0);
-        }
-#endif
-#endif
-
-        /* preforking() */
-        if (uwsgi.master_process) {
-                if (is_a_reload) {
-                        fprintf (stderr, "gracefully (RE)spawned uWSGI master process (pid: %d)\n", uwsgi.mypid);
-                }
-                else {
-                        fprintf (stderr, "spawned uWSGI master process (pid: %d)\n", uwsgi.mypid);
-                }
-        }
-
-#ifdef UNBIT
-        if (single_app_mode == 1) {
-                wsgi_req.wsgi_script = getenv ("UWSGI_SCRIPT");
-                if (wsgi_req.wsgi_script) {
-                        wsgi_req.wsgi_script_len = strlen (wsgi_req.wsgi_script);
-                }
-                else {
-                        fprintf (stderr, "UWSGI_SCRIPT env var not set !\n");
-                        exit (1);
-                }
-
-                init_uwsgi_app (NULL, NULL);
-        }
-#endif
-
-#ifndef ROCK_SOLID
-#ifndef PYTHREE
-        if (spool_dir != NULL) {
-                uwsgi.workers[0].spooler_pid = spooler_start (uwsgi.serverfd, uwsgi_module);
-        }
-#endif
-#endif
-
-
-        if (!uwsgi.master_process) {
-                if (uwsgi.numproc == 1) {
-                        fprintf (stderr, "spawned uWSGI worker 1 (and the only) (pid: %d)\n", masterpid);
-                }
-                else {
-                        fprintf (stderr, "spawned uWSGI worker 1 (pid: %d)\n", masterpid);
-                }
-                uwsgi.workers[1].pid = masterpid;
-                uwsgi.workers[1].id = 1;
-                uwsgi.workers[1].last_spawn = time (NULL);
-                uwsgi.workers[1].manage_next_request = 1;
-                uwsgi.mywid = 1;
-                gettimeofday (&last_respawn, NULL);
-                respawn_delta = last_respawn.tv_sec;
-        }
-
-
-                for (i = 2-uwsgi.master_process ; i < uwsgi.numproc + 1; i++) {
-                        /* let the worker know his worker_id (wid) */
-                        pid = fork ();
-                        if (pid == 0) {
-                                uwsgi.mypid = getpid ();
-                                uwsgi.workers[i].pid = uwsgi.mypid;
-                                uwsgi.workers[i].id = i;
-                                uwsgi.workers[i].last_spawn = time (NULL);
-                                uwsgi.workers[i].manage_next_request = 1;
-                                uwsgi.mywid = i;
-                                if (uwsgi.serverfd != 0 && uwsgi.master_process == 1) {
-                                        /* close STDIN for workers */
-                                        close (0);
-                                }
-                                break;
-                        }
-                        else if (pid < 1) {
-                                perror ("fork()");
-                                exit (1);
-                        }
-                        else {
-                                fprintf (stderr, "spawned uWSGI worker %d (pid: %d)\n", i, pid);
-                                gettimeofday (&last_respawn, NULL);
-                                respawn_delta = last_respawn.tv_sec;
-                        }
-                }
-
-
-        if (getpid () == masterpid && uwsgi.master_process == 1) {
-                /* route signals to workers... */
-                signal (SIGHUP, (void *) &grace_them_all);
-                signal (SIGTERM, (void *) &reap_them_all);
-                signal (SIGINT, (void *) &kill_them_all);
-                signal (SIGQUIT, (void *) &kill_them_all);
-                /* used only to avoid human-errors */
-#ifndef ROCK_SOLID
-#ifndef UNBIT
-                signal (SIGUSR1, (void *) &stats);
-#endif
-#endif
-
-                if (udp_socket) {
-                        udp_poll.fd = bind_to_udp (udp_socket);
-                        if (udp_poll.fd < 0) {
-                                fprintf (stderr, "unable to bind to udp socket. SNMP and cluster management services will be disabled.\n");
-                        }
-                        else {
-                                fprintf (stderr, "UDP server enabled.\n");
-                                udp_poll.events = POLLIN;
-                        }
-                }
-                for (;;) {
-                        if (ready_to_die >= uwsgi.numproc && uwsgi.to_hell) {
-#ifndef ROCK_SOLID
-                                if (spool_dir && uwsgi.workers[0].spooler_pid > 0) {
-                                        kill (uwsgi.workers[0].spooler_pid, SIGKILL);
-                                }
-
-#endif
-                                fprintf (stderr, "goodbye to uWSGI.\n");
-                                exit (0);
-                        }
-                        if (ready_to_reload >= uwsgi.numproc && uwsgi.to_heaven) {
-#ifndef ROCK_SOLID
-                                if (spool_dir && uwsgi.workers[0].spooler_pid > 0) {
-                                        kill (uwsgi.workers[0].spooler_pid, SIGKILL);
-                                }
-#endif
-                                fprintf (stderr, "binary reloading uWSGI...\n");
-                                if (chdir (cwd)) {
-                                        perror ("chdir()");
-                                        exit (1);
-                                }
-                                /* check fd table (a module can obviosly open some fd on initialization...) */
-                                fprintf (stderr, "closing all fds > 2 (_SC_OPEN_MAX = %ld)...\n", sysconf (_SC_OPEN_MAX));
-                                for (i = 3; i < sysconf (_SC_OPEN_MAX); i++) {
-                                        if (i == uwsgi.serverfd) {
-                                                continue;
-                                        }
-                                        close (i);
-                                }
-                                if (uwsgi.serverfd != 3) {
-                                        if (dup2 (uwsgi.serverfd, 3) < 0) {
-                                                perror ("dup2()");
-                                                exit (1);
-                                        }
-                                }
-                                fprintf (stderr, "running %s\n", binary_path);
-                                strcpy (argv[0], binary_path);
-                                execve (binary_path, argv, environ);
-                                perror ("execve()");
-                                exit (1);
-                        }
-                        diedpid = waitpid (WAIT_ANY, &waitpid_status, WNOHANG);
-                        if (diedpid == -1) {
-                                perror ("waitpid()");
-                                /* here is better to reload all the uWSGI stack */
-                                fprintf (stderr, "something horrible happened...\n");
-                                reap_them_all ();
-                                exit (1);
-                        }
-                        else if (diedpid == 0) {
-                                /* PLEASE, do not run python threads in the master process, you can potentially destroy the world,
-                                   we support this for hyperultramegagodprogrammer and systems
-                                 */
-#ifndef ROCK_SOLID
-                                if (uwsgi.has_threads && uwsgi.options[UWSGI_OPTION_THREADS] == 1) {
-                                        uwsgi._save = PyEval_SaveThread ();
-                                        uwsgi.i_have_gil = 0;
-                                }
-#endif
-                                /* all processes ok, doing status scan after N seconds */
-                                check_interval.tv_sec = uwsgi.options[UWSGI_OPTION_MASTER_INTERVAL];
-                                if (!check_interval.tv_sec)
-                                        check_interval.tv_sec = 1;
-                                
-                                if (udp_socket && udp_poll.fd >= 0) {
-                                        rlen = poll (&udp_poll, 1, check_interval.tv_sec * 1000);
-                                        if (rlen < 0) {
-                                                perror ("poll()");
-                                        }
-                                        else if (rlen > 0) {
-                                                udp_len = sizeof (udp_client);
-                                                rlen = recvfrom (udp_poll.fd, buffer, uwsgi.buffer_size, 0, (struct sockaddr *) &udp_client, &udp_len);
-                                                if (rlen < 0) {
-                                                        perror ("recvfrom()");
-                                                }
-                                                else if (rlen > 0) {
-                                                        memset (udp_client_addr, 0, 16);
-                                                        if (inet_ntop (AF_INET, &udp_client, udp_client_addr, 16)) {
-                                                                fprintf (stderr, "received udp packet of %d bytes from %s:%d\n", rlen, udp_client_addr, ntohs (udp_client.sin_port));
-                                                                if (buffer[0] == 0x30) {
-                                                                        manage_snmp (udp_poll.fd, (uint8_t *) buffer, rlen, &udp_client);
-                                                                }
-                                                        }
-                                                        else {
-                                                                perror ("inet_ntop()");
-                                                        }
-                                                }
-                                        }
-                                }
-                                else {
-                                        select (0, NULL, NULL, NULL, &check_interval);
-                                }
-                                working_workers = 0;
-                                blocking_workers = 0;
-#ifndef ROCK_SOLID
-                                if (uwsgi.has_threads && !uwsgi.i_have_gil) {
-                                        PyEval_RestoreThread (uwsgi._save);
-                                        uwsgi.i_have_gil = 1;
-                                }
-#endif
-                                check_interval.tv_sec = uwsgi.options[UWSGI_OPTION_MASTER_INTERVAL];
-                                if (!check_interval.tv_sec)
-                                        check_interval.tv_sec = 1;
-                                for (i = 1; i <= uwsgi.workers[0].current_workers; i++) {
-                                        /* first check for harakiri */
-                                        if (uwsgi.workers[i].harakiri > 0) {
-                                                if (uwsgi.workers[i].harakiri < time (NULL)) {
-                                                        /* first try to invoke the harakiri() custom handler */
-                                                        /* TODO */
-                                                        /* then brutally kill the worker */
-                                                        kill (uwsgi.workers[i].pid, SIGKILL);
-                                                }
-                                        }
-                                        /* load counters */
-                                        if (uwsgi.workers[i].in_request)
-                                                working_workers++;
-
-                                        if (uwsgi.workers[i].blocking)
-                                                blocking_workers++;
-
-                                        uwsgi.workers[i].last_running_time = uwsgi.workers[i].running_time;
-                                }
-
-                                /* check if i need to add a subworker */
-                                //fprintf(stderr,"working workers: %d\n",  working_workers);
-                                if (working_workers >= uwsgi.workers[0].current_workers) {
-                                        /* ok the system is overloaded, check if some worker is in blocking mode */
-                                        if (blocking_workers > 0) {
-                                                /* check if is it safe to add a new worker (for now check only for enough free memory) */
-                                                fprintf (stderr, "adding a new subworker as there are workers in blocking mode...\n");
-                                                uwsgi.mywid = uwsgi.workers[0].current_workers + 1;
-                                                pid = fork ();
-                                                if (pid < 0) {
-                                                        perror ("fork()");
-                                                }
-                                                else if (pid > 0) {
-                                                        fprintf (stderr, "spawned uWSGI subworker (pid: %d)\n", pid);
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].id = uwsgi.workers[0].current_workers + 1;
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].pid = pid;
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].harakiri = 0;
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].requests = 0;
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].failed_requests = 0;
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].respawn_count++;
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].last_spawn = time (NULL);
-                                                        uwsgi.workers[uwsgi.workers[0].current_workers + 1].manage_next_request = 1;
-                                                        uwsgi.workers[0].current_workers++;
-                                                }
-                                                else if (pid == 0) {
-                                                        uwsgi.mypid = getpid ();
-                                                        break;
-                                                }
-                                        }
-                                }
-                                else {
-                                        /* the system is no more overloaded, mark subworkers */
-                                        for (i = uwsgi.numproc + 1; i <= uwsgi.workers[0].current_workers; i++) {
-                                                uwsgi.workers[i].manage_next_request = 0;
-                                        }
-                                }
-
-                                /* now check for subworkers to remove */
-                                for (i = uwsgi.workers[0].current_workers; i > uwsgi.numproc; i--) {
-                                        if (uwsgi.workers[i].manage_next_request)
-                                                break;
-                                        /* reset this worker (no interest in killing it) */
-                                        memset (&uwsgi.workers[i], 0, sizeof (struct uwsgi_worker));
-                                        uwsgi.workers[0].current_workers--;
-                                }
-                                continue;
-                        }
-#ifndef ROCK_SOLID
-#ifndef PYTHREE
-                        /* reload the spooler */
-                        if (spool_dir && uwsgi.workers[0].spooler_pid > 0) {
-                                if (diedpid == uwsgi.workers[0].spooler_pid) {
-                                        fprintf(stderr,"OOOPS the spooler is no more...trying respawn...\n");
-                                        uwsgi.workers[0].spooler_pid = spooler_start (uwsgi.serverfd, uwsgi_module);
-                                        continue;
-                                }
-                        }
-#endif
-#endif
-                        /* check for reloading */
-                        if (WIFEXITED (waitpid_status)) {
-                                if (WEXITSTATUS (waitpid_status) == UWSGI_RELOAD_CODE && uwsgi.to_heaven) {
-                                        ready_to_reload++;
-                                        continue;
-                                }
-                                else if (WEXITSTATUS (waitpid_status) == UWSGI_END_CODE && uwsgi.to_hell) {
-                                        ready_to_die++;
-                                        continue;
-                                }
-                        }
-
-                        /* subworkers need to be respawned ? i do not think so */
-                        if (find_worker_id (diedpid) > uwsgi.numproc) {
-                                fprintf (stderr, "OOPS ! process %d (subworker id %d) died :( i will not respawn it.\n", diedpid, find_worker_id (diedpid));
-                                /* decrease the number of workers */
-                                if (uwsgi.workers[0].current_workers > uwsgi.numproc) {
-                                        uwsgi.workers[find_worker_id (diedpid)].manage_next_request = 0;
-                                }
-                                continue;
-                        }
-                        fprintf (stderr, "DAMN ! process %d died :( trying respawn ...\n", diedpid);
-                        gettimeofday (&last_respawn, NULL);
-                        if (last_respawn.tv_sec == respawn_delta) {
-                                fprintf (stderr, "worker respawning too fast !!! i have to sleep a bit...\n");
-                                /* TODO, user configurable fork throttler */
-                                sleep (2);
-                        }
-                        gettimeofday (&last_respawn, NULL);
-                        respawn_delta = last_respawn.tv_sec;
-                        uwsgi.mywid = find_worker_id (diedpid);
-                        pid = fork ();
-                        if (pid == 0) {
-                                uwsgi.mypid = getpid ();