diff --git a/INSTALL b/INSTALL
new file mode 100644
index 00000000..e69de29b
diff --git a/mod_uwsgi.c b/mod_uwsgi.c
new file mode 100644
index 00000000..e69de29b
diff --git a/uwsgi.c b/uwsgi.c
new file mode 100644
index 00000000..51b1b2b8
--- /dev/null
+++ b/uwsgi.c
@@ -0,0 +1,947 @@
+/*
+
+ *** uWSGI ***
+
+ Copyright 2009 Unbit S.a.s.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see .
+
+
+Compile on Linux 2.6
+gcc -o uwsgi -O2 `python2.5-config --includes` `python2.5-config --libs` -Wall uwsgi.c
+gcc -o uwsgi24 -O2 `python2.4-config --includes` `python2.4-config --libs` -Wall uwsgi.c
+gcc -o uwsgi26 -O2 `python2.6-config --includes` `python2.6-config --libs` -Wall uwsgi.c
+Compile on *BSD (FreeBSD and OSX)
+gcc -o uwsgi -O2 `python2.5-config --includes` `python2.5-config --libs` -Wall -DBSD uwsgi.c
+
+
+********* Note for OSX/BSD *********
+the sockaddr_un structure is defined as
+struct sockaddr_un {
+ unsigned char sun_len;
+ sa_family_t sun_family;
+ char sun_path[104];
+};
+
+to get the size of addr:
+ s_addr.sun_path-s_addr
+
+the sendfile() prototype on BSD is different
+************************************
+
+********* Note for Linux users *********
+uWSGI supports UNIX socket on abstract namespace.
+Use them if you have filesystem permission problems.
+
+********* Note for Unbit users *********
+Try to keep the same configuration on your unbit account (threading mode
+in particular)
+
+*/
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#ifndef BSD
+ #include
+#endif
+
+#include
+
+int init_uwsgi_interpreter(char *mountpoint, char *module, char *callable, char *wsgi_script, int interpreter) ;
+
+
+char *nl = "\r\n";
+#define NL_SIZE 2
+char *h_sep = ": " ;
+#define H_SEP_SIZE 2
+
+#define PAGE_SIZE 4096
+
+int requests = 0 ;
+int has_threads = 0 ;
+int wsgi_cnt = 1;
+int default_interpreter = -1 ;
+
+struct timeval start_of_uwsgi ;
+
+int cgi_mode = 0 ;
+int abstract_socket = 0 ;
+int chmod_socket = 0 ;
+
+PyObject *py_sendfile ;
+
+struct pollfd wsgi_poll;
+
+PyThreadState *wsgi_thread ;
+
+int harakiri_timeout = 60 ;
+
+PyObject *wsgi_writeout ;
+
+#define VEC_SIZE 64
+
+void log_request() ;
+void get_memusage() ;
+
+struct __attribute__((packed)) wsgi_request {
+ unsigned char version;
+ unsigned short size ;
+ // temporary attr
+ unsigned char interpreter ;
+ struct timeval start_of_request ;
+ char *uri;
+ unsigned short uri_len;
+ char *remote_addr;
+ unsigned short remote_addr_len;
+ char *remote_user;
+ unsigned short remote_user_len;
+ char *query_string;
+ unsigned short query_string_len;
+ char *protocol;
+ unsigned short protocol_len;
+ char *method;
+ unsigned short method_len;
+ char *wsgi_script;
+ unsigned short wsgi_script_len;
+ char *wsgi_module;
+ unsigned short wsgi_module_len;
+ char *wsgi_callable;
+ unsigned short wsgi_callable_len;
+ char *script_name;
+ unsigned short script_name_len;
+ int sendfile_fd;
+ unsigned short var_cnt;
+ unsigned short header_cnt;
+ int status;
+ int response_size;
+ int headers_size;
+ // memory debug
+ unsigned long vsz_size;
+ long rss_size;
+ // iovec
+ struct iovec hvec[4+1+4*VEC_SIZE] ;
+} wsgi_req;
+
+
+void harakiri() {
+ PyThreadState *_myself ;
+ _myself = PyThreadState_Get();
+ fprintf(stderr,"\nF*CK !!! i must kill myself %p %p...\n", _myself, _myself->frame);
+ Py_FatalError("HARAKIRI !\n");
+}
+
+void internal_server_error(int fd, char *message) {
+ if (cgi_mode == 0) {
+ wsgi_req.headers_size = write(fd, "HTTP/1.1 500 Internal Server Error\r\n\r\n", 38);
+ }
+ else {
+ wsgi_req.headers_size = write(fd, "Status: 500 Internal Server Error\r\nContent-type: text/html\r\n\r\n", 62);
+ }
+ wsgi_req.response_size = write(fd, "uWSGI Error
", 20);
+ wsgi_req.response_size += write(fd, message, strlen(message));
+}
+
+PyObject *py_uwsgi_sendfile(PyObject *self, PyObject *args) {
+
+ PyObject *zero ;
+
+ py_sendfile = PyTuple_GetItem(args, 0);
+
+ if (PyFile_Check(py_sendfile)) {
+ zero = PyFile_Name(py_sendfile) ;
+ //fprintf(stderr,"->serving %s as static file...", PyString_AsString(zero));
+ wsgi_req.sendfile_fd = PyObject_AsFileDescriptor(py_sendfile);
+ Py_INCREF(py_sendfile);
+ }
+
+
+ return PyTuple_New(0);
+}
+
+PyObject *py_uwsgi_write(PyObject *self, PyObject *args) {
+ PyObject *data;
+ char *content ;
+ int len;
+ data = PyTuple_GetItem(args, 0);
+ if (PyString_Check(data)) {
+ content = PyString_AsString(data) ;
+ len = PyString_Size(data);
+ if (has_threads) {
+ Py_BEGIN_ALLOW_THREADS
+ wsgi_req.response_size = write(wsgi_poll.fd, content, len);
+ Py_END_ALLOW_THREADS
+ }
+ else {
+ wsgi_req.response_size = write(wsgi_poll.fd, content, len);
+ }
+ }
+ Py_INCREF(Py_None);
+ return Py_None;
+}
+
+
+PyObject *wsgi_spitout;
+
+PyObject *py_uwsgi_spit(PyObject *self, PyObject *args) {
+ PyObject *headers, *head ;
+ PyObject *h_key, *h_value;
+ int i,j ;
+ int base = 0 ;
+
+ // use writev()
+
+ // drop http status on cgi mode
+ if (cgi_mode == 0) {
+ base = 4 ;
+ head = PyTuple_GetItem(args,0) ;
+
+ wsgi_req.hvec[0].iov_base = wsgi_req.protocol ;
+ wsgi_req.hvec[0].iov_len = wsgi_req.protocol_len ;
+ wsgi_req.hvec[1].iov_base = " " ;
+ wsgi_req.hvec[1].iov_len = 1 ;
+ wsgi_req.hvec[2].iov_base = PyString_AsString(head) ;
+ wsgi_req.hvec[2].iov_len = PyString_Size(head) ;
+ wsgi_req.status = atoi(wsgi_req.hvec[2].iov_base) ;
+ wsgi_req.hvec[3].iov_base = nl ;
+ wsgi_req.hvec[3].iov_len = NL_SIZE ;
+ }
+
+ headers = PyTuple_GetItem(args,1) ;
+ wsgi_req.header_cnt = PyList_Size(headers) ;
+
+ if (wsgi_req.header_cnt > VEC_SIZE) {
+ wsgi_req.header_cnt = VEC_SIZE ;
+ }
+ for(i=0;i 104 bsd/mac)
+ if (strlen(socket_name) > 102) {
+ fprintf(stderr, "invalid socket name\n");
+ exit(1);
+ }
+ break;
+ case 'p':
+ numproc = atoi(optarg);
+ break;
+ case 'm':
+ memory_debug = 1 ;
+ break;
+ case 't':
+ harakiri_timeout = atoi(optarg);
+ break;
+ case 'c':
+ fprintf(stderr, "setting cgi mode\n");
+ cgi_mode = 1;
+ break;
+ case 'a':
+ fprintf(stderr, "setting abstract socket mode (warning: only Linux supports this)\n");
+ abstract_socket = 1;
+ break;
+ case 'T':
+ has_threads = 1;
+ break;
+ case 'C':
+ chmod_socket = 1;
+ break;
+ }
+ }
+
+ Py_SetProgramName("uWSGI");
+ Py_Initialize() ;
+
+ wsgi_thread = PyThreadState_Get();
+
+
+ if (has_threads) {
+ PyEval_InitThreads() ;
+ fprintf(stderr, "threads support enabled\n");
+ }
+
+ if (socket_name != NULL) {
+ fprintf(stderr, "binding on UNIX socket: %s\n", socket_name);
+ s_addr = malloc(sizeof(struct sockaddr_un));
+ if (s_addr == NULL) {
+ perror("malloc()");
+ exit(1);
+ }
+ memset(s_addr, 0, sizeof(struct sockaddr_un)) ;
+ serverfd = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (serverfd < 0) {
+ perror("socket()");
+ exit(1);
+ }
+ if (abstract_socket == 0) {
+ if (unlink(socket_name) != 0) {
+ perror("unlink()");
+ }
+ }
+ s_addr->sun_family = AF_UNIX;
+ strcpy(s_addr->sun_path+abstract_socket, socket_name);
+
+ if (bind(serverfd, (struct sockaddr *) s_addr, strlen(socket_name)+ abstract_socket + ( (void *)s_addr->sun_path - (void *)s_addr) ) != 0) {
+ perror("bind()");
+ exit(1);
+ }
+
+ if (listen(serverfd, 64) != 0) {
+ perror("listen()");
+ exit(1);
+ }
+
+ // chmod unix socket for lazy users
+ if (chmod_socket == 1 && abstract_socket == 0) {
+ fprintf(stderr, "chmod() socket to 666 for lazy and brave users\n");
+ if (chmod(socket_name, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH) != 0) {
+ perror("chmod()");
+ }
+ }
+
+ }
+
+ py_interpreters = PyDict_New();
+ if (!py_interpreters) {
+ PyErr_Print();
+ exit(1);
+ }
+
+ wsgi_spitout = PyCFunction_New(uwsgi_spit_method,NULL) ;
+ wsgi_writeout = PyCFunction_New(uwsgi_write_method,NULL) ;
+
+ memset(wsgi_interpreters, 0, sizeof(wsgi_interpreters));
+
+
+ if (has_threads) {
+ _save = PyEval_SaveThread();
+ }
+
+ if (harakiri_timeout > 0) {
+ signal(SIGALRM, harakiri);
+ }
+
+ signal(SIGINT, harakiri);
+
+ wsgi_poll.events = POLLIN ;
+
+ memset(&wsgi_req, 0, sizeof(struct wsgi_request));
+ wsgi_req.sendfile_fd = -1 ;
+
+ mypid = getpid();
+
+ /* preforking() */
+ fprintf(stderr, "spawned uWSGI worker 0 (pid: %d)\n", mypid);
+ for(i=1;i 4096) {
+ fprintf(stderr,"invalid request block size: %d...skip\n", wsgi_req.size);
+ continue;
+ }
+
+ /* http headers parser */
+ rlen = poll(&wsgi_poll, 1, 4000) ;
+ if (rlen < 0) {
+ perror("poll()");
+ exit(1);
+ }
+ else if (rlen == 0) {
+ fprintf(stderr, "timeout. skip request\n");
+ close(wsgi_poll.fd);
+ continue ;
+ }
+ rlen = read(wsgi_poll.fd, buffer, wsgi_req.size);
+ if (rlen != wsgi_req.size){
+ fprintf(stderr,"invalid request var size: %d...skip\n", rlen);
+ continue;
+ }
+
+
+ ptrbuf = buffer ;
+ bufferend = ptrbuf+wsgi_req.size ;
+
+
+ // pluginIZE this part (ucgi, fastcgi, scgi, http...)
+ while(ptrbuf < bufferend) {
+ if (ptrbuf+2 < bufferend) {
+ memcpy(&strsize,ptrbuf,2);
+ ptrbuf+=2;
+ if (ptrbuf+strsize < bufferend) {
+ // var key
+ wsgi_req.hvec[wsgi_req.var_cnt].iov_base = ptrbuf ;
+ wsgi_req.hvec[wsgi_req.var_cnt].iov_len = strsize ;
+ ptrbuf+=strsize;
+ if (ptrbuf+2 < bufferend) {
+ memcpy(&strsize,ptrbuf,2);
+ ptrbuf+=2 ;
+ if ( ptrbuf+strsize <= bufferend) {
+ if (!strncmp("SCRIPT_NAME", wsgi_req.hvec[wsgi_req.var_cnt].iov_base , wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ // set the subinterpreter
+ // LOCKED SECTION
+ if (strsize > 0) {
+ if (has_threads) {
+ PyEval_RestoreThread(_save);
+ }
+ zero = PyString_FromStringAndSize(ptrbuf, strsize) ;
+ if (PyDict_Contains(py_interpreters, zero)) {
+ interpreter = PyInt_AsLong( PyDict_GetItem(py_interpreters, zero) );
+ }
+ else {
+ /* unavailable interpreter for this SCRIPT_NAME */
+ interpreter = -1 ;
+ }
+ Py_DECREF(zero);
+ if (has_threads) {
+ _save = PyEval_SaveThread();
+ }
+ }
+ // UNLOCK
+ }
+ else if (!strncmp("SERVER_PROTOCOL", wsgi_req.hvec[wsgi_req.var_cnt].iov_base , wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ wsgi_req.protocol = ptrbuf ;
+ wsgi_req.protocol_len = strsize ;
+ }
+ else if (!strncmp("REQUEST_URI", wsgi_req.hvec[wsgi_req.var_cnt].iov_base, wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ wsgi_req.uri = ptrbuf ;
+ wsgi_req.uri_len = strsize ;
+ }
+ else if (!strncmp("QUERY_STRING", wsgi_req.hvec[wsgi_req.var_cnt].iov_base, wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ wsgi_req.query_string = ptrbuf ;
+ wsgi_req.query_string_len = strsize ;
+ }
+ else if (!strncmp("REQUEST_METHOD", wsgi_req.hvec[wsgi_req.var_cnt].iov_base, wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ wsgi_req.method = ptrbuf ;
+ wsgi_req.method_len = strsize ;
+ }
+ else if (!strncmp("REMOTE_ADDR", wsgi_req.hvec[wsgi_req.var_cnt].iov_base, wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ wsgi_req.remote_addr = ptrbuf ;
+ wsgi_req.remote_addr_len = strsize ;
+ }
+ else if (!strncmp("REMOTE_USER", wsgi_req.hvec[wsgi_req.var_cnt].iov_base, wsgi_req.hvec[wsgi_req.var_cnt].iov_len)) {
+ wsgi_req.remote_user = ptrbuf ;
+ wsgi_req.remote_user_len = strsize ;
+ }
+ wsgi_req.var_cnt++ ;
+ // var value
+ wsgi_req.hvec[wsgi_req.var_cnt].iov_base = ptrbuf ;
+ wsgi_req.hvec[wsgi_req.var_cnt].iov_len = strsize ;
+ wsgi_req.var_cnt++ ;
+ ptrbuf+=strsize;
+ }
+ else {
+ break;
+ }
+ }
+ else {
+ break;
+ }
+ }
+ }
+ else {
+ break;
+ }
+ }
+
+ if (has_threads) {
+ PyEval_RestoreThread(_save);
+ }
+
+ wsgi_file = fdopen(wsgi_poll.fd,"r") ;
+
+ if (interpreter == -1) {
+ for(i=0;i 0) {
+ if (wsgi_req.script_name_len > 0) {
+ if (init_uwsgi_interpreter(wsgi_req.script_name, NULL, NULL, wsgi_req.wsgi_script, wsgi_cnt)) {
+ interpreter = wsgi_cnt-1 ;
+ }
+ }
+ else {
+
+ if (init_uwsgi_interpreter("/", NULL, NULL, wsgi_req.wsgi_script, 0)) {
+ interpreter = 0 ;
+ }
+ }
+ }
+ else if (wsgi_req.wsgi_module_len > 0 && wsgi_req.wsgi_callable_len > 0) {
+ if (wsgi_req.script_name_len > 0) {
+ if (init_uwsgi_interpreter(wsgi_req.script_name, wsgi_req.wsgi_module, wsgi_req.wsgi_callable, NULL, wsgi_cnt)) {
+ interpreter = wsgi_cnt-1 ;
+ }
+ }
+ else {
+ if (init_uwsgi_interpreter("/", wsgi_req.wsgi_module, wsgi_req.wsgi_callable, NULL, 0)) {
+ interpreter = 0 ;
+ }
+ }
+ }
+ else {
+ internal_server_error(wsgi_poll.fd, "wsgi application not found");
+ goto clean ;
+ }
+ }
+
+ if (interpreter == -1) {
+ internal_server_error(wsgi_poll.fd, "wsgi application not found");
+ goto clean;
+ }
+
+ wi = &wsgi_interpreters[interpreter] ;
+
+ if (!wi->interpreter) {
+ internal_server_error(wsgi_poll.fd, "wsgi application not found");
+ goto clean;
+ }
+
+ // set the interpreter
+ PyThreadState_Swap(wi->interpreter) ;
+
+ /* max 1 minute before harakiri */
+ if (harakiri_timeout > 0) {
+ alarm(harakiri_timeout);
+ }
+
+ for(i=0;iwsgi_environ, pydictkey, pydictvalue);
+ Py_DECREF(pydictkey);
+ Py_DECREF(pydictvalue);
+ }
+
+ // set wsgi vars
+
+ wsgi_socket = PyFile_FromFile(wsgi_file,"wsgi_input","r", NULL) ;
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.input", wsgi_socket );
+ Py_DECREF(wsgi_socket) ;
+
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.file_wrapper", wi->wsgi_sendfile );
+
+ zero = PyTuple_New(2);
+ PyTuple_SetItem(zero, 0 , PyInt_FromLong(1));
+ PyTuple_SetItem(zero, 1 , PyInt_FromLong(0));
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.version", zero);
+ Py_DECREF(zero);
+
+ zero = PyFile_FromFile(stderr, "wsgi_input","w", NULL) ;
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.errors", zero );
+ Py_DECREF(zero) ;
+
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.run_once", Py_False);
+
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.multithread", Py_False);
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.multiprocess", Py_True);
+
+ zero = PyString_FromString("http") ;
+ PyDict_SetItemString(wi->wsgi_environ, "wsgi.url_scheme", zero);
+ Py_DECREF(zero);
+
+
+ // call
+ wsgi_result = PyEval_CallObject(wi->wsgi_callable, wi->wsgi_args);
+
+ if (PyErr_Occurred()) {
+ PyErr_Print();
+ }
+
+ if (wsgi_result) {
+ if (wsgi_req.sendfile_fd > -1) {
+ rlen = lseek(wsgi_req.sendfile_fd, 0, SEEK_END) ;
+ if (rlen > 0) {
+ lseek(wsgi_req.sendfile_fd, 0, SEEK_SET) ;
+#ifdef BSD
+ wsgi_req.response_size = sendfile(wsgi_req.sendfile_fd, wsgi_poll.fd, 0, (off_t *) &rlen, NULL, 0) ;
+#else
+ wsgi_req.response_size = sendfile(wsgi_poll.fd, wsgi_req.sendfile_fd, NULL, rlen) ;
+#endif
+ }
+ Py_DECREF(py_sendfile);
+ }
+ else {
+ wsgi_chunks = PyObject_GetIter(wsgi_result);
+ if (wsgi_chunks) {
+ while((wchunk = PyIter_Next(wsgi_chunks))) {
+ if (PyString_Check(wchunk)) {
+ wsgi_req.response_size += write(wsgi_poll.fd, PyString_AsString(wchunk), PyString_Size(wchunk)) ;
+ }
+ Py_DECREF(wchunk);
+ }
+ Py_DECREF(wsgi_chunks);
+ }
+ }
+ Py_DECREF(wsgi_result);
+ }
+
+
+ PyDict_Clear(wi->wsgi_environ);
+ wi->requests++;
+ PyErr_Clear();
+ if (harakiri_timeout > 0) {
+ alarm(0);
+ }
+ PyThreadState_Swap(wsgi_thread);
+clean:
+ fclose(wsgi_file);
+ /* default interpreter */
+ if (has_threads) {
+ _save = PyEval_SaveThread();
+ }
+ requests++ ;
+ // GO LOGGING...
+ log_request() ;
+ // reset to default interpreter
+ interpreter = default_interpreter ;
+ memset(&wsgi_req, 0, sizeof(struct wsgi_request));
+ wsgi_req.sendfile_fd = -1 ;
+
+ }
+
+ return 0 ;
+
+}
+
+void log_request() {
+ char *time_request ;
+ struct timeval end_request ;
+ time_t microseconds, microseconds2;
+
+ char *msg1 = " via sendfile() " ;
+ char *msg2 = " " ;
+ char *msg3 = "?" ;
+ char *msg4 = "" ;
+
+ char *via ;
+ char *qs_sep;
+
+ via = msg2 ;
+ if (wsgi_req.sendfile_fd > -1) {
+ via = msg1 ;
+ }
+
+ qs_sep = msg4 ;
+ if (wsgi_req.query_string_len > 0) {
+ qs_sep = msg3 ;
+ }
+
+ time_request = ctime(&wsgi_req.start_of_request.tv_sec);
+ gettimeofday(&end_request, NULL) ;
+ microseconds = end_request.tv_sec*1000000+end_request.tv_usec ;
+ microseconds2 = wsgi_req.start_of_request.tv_sec*1000000+wsgi_req.start_of_request.tv_usec ;
+ if (memory_debug == 1) {
+ get_memusage();
+ fprintf(stderr,"{address space usage: %ld bytes/%luMB} {rss usage: %lu bytes/%luMB} ", wsgi_req.vsz_size, wsgi_req.vsz_size/1024/1024, wsgi_req.rss_size*PAGE_SIZE, (wsgi_req.rss_size*PAGE_SIZE)/1024/1024) ;
+ }
+ fprintf(stderr, "[%d/%d] %.*s (%.*s) {%d vars in %d bytes} [%.*s] %.*s %.*s%s%.*s => generated %d bytes in %ld msecs%s(%.*s %d) %d headers in %d bytes\n",
+ mypid, requests, wsgi_req.remote_addr_len, wsgi_req.remote_addr,
+ wsgi_req.remote_user_len, wsgi_req.remote_user, wsgi_req.var_cnt, wsgi_req.size, 24, time_request,
+ wsgi_req.method_len, wsgi_req.method, wsgi_req.uri_len, wsgi_req.uri, qs_sep, wsgi_req.query_string_len, wsgi_req.query_string, wsgi_req.response_size,
+ (microseconds-microseconds2)/1000, via,
+ wsgi_req.protocol_len, wsgi_req.protocol, wsgi_req.status, wsgi_req.header_cnt, wsgi_req.headers_size) ;
+
+}
+
+void get_memusage() {
+ FILE *procfile;
+ int i;
+
+ procfile = fopen("/proc/self/stat","r");
+ if (procfile) {
+ i = fscanf(procfile,"%*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %*s %lu %ld",&wsgi_req.vsz_size, &wsgi_req.rss_size) ;
+ if (i != 2) {
+ fprintf(stderr, "warning: invalid record in /proc/self/stat\n");
+ }
+ fclose(procfile);
+ }
+}
+
+int init_uwsgi_interpreter(char *mountpoint, char *module, char *callable, char *wsgi_script, int interpreter) {
+ PyObject *wsgi_module, *wsgi_dict, *wsgi_argv, *zero ;
+ PyObject *pysys, *pysys_dict, *pypath;
+ char tmpstring[256] ;
+
+ struct uwsgi_interpreter *wi ;
+
+ memset(tmpstring,0, 256) ;
+
+ wi = &wsgi_interpreters[interpreter] ;
+
+ wi->interpreter = Py_NewInterpreter();
+
+
+ PyThreadState_Swap(wi->interpreter) ;
+
+ /* stolen from mod_wsgi, sorry ;) */
+ wsgi_argv = PyList_New(0);
+ zero = PyString_FromString("uwsgi");
+ PyList_Append(wsgi_argv, zero);
+ PySys_SetObject("argv", wsgi_argv);
+ Py_DECREF(zero);
+ Py_DECREF(wsgi_argv);
+
+
+ /* add cwd and cvalue 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);
+ }
+ PyList_Insert(pypath,0,PyString_FromString("."));
+
+
+ if (wsgi_script) {
+ memcpy(tmpstring, wsgi_script, wsgi_req.wsgi_script_len) ;
+ wsgi_module = PyImport_ImportModule(tmpstring) ;
+ if (!wsgi_module) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+ callable = "application" ;
+ wsgi_req.wsgi_callable_len = 11;
+ }
+ else {
+ memcpy(tmpstring, module, wsgi_req.wsgi_module_len) ;
+ wsgi_module = PyImport_ImportModule(tmpstring) ;
+ if (!wsgi_module) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+
+ }
+
+ wsgi_dict = PyModule_GetDict(wsgi_module);
+ if (!wsgi_dict) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+
+ memset(tmpstring, 0, 256);
+ memcpy(tmpstring, callable, wsgi_req.wsgi_callable_len) ;
+ wi->wsgi_callable = PyDict_GetItemString(wsgi_dict, tmpstring);
+ if (!wi->wsgi_callable) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+
+
+ wi->wsgi_environ = PyDict_New();
+ if (!wi->wsgi_environ) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+
+ wi->wsgi_args = PyTuple_New(2) ;
+ if (PyTuple_SetItem(wi->wsgi_args,0, wi->wsgi_environ)) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+ if (PyTuple_SetItem(wi->wsgi_args,1, wsgi_spitout)) {
+ PyErr_Print();
+ Py_EndInterpreter(wi->interpreter);
+ PyThreadState_Swap(wsgi_thread) ;
+ return 0 ;
+ }
+
+ wi->wsgi_sendfile = PyCFunction_New(uwsgi_sendfile_method,NULL) ;
+
+ PyThreadState_Swap(wsgi_thread);
+ memset(tmpstring, 0, 256);
+ if (wsgi_req.script_name_len > 0) {
+ memcpy(tmpstring, mountpoint, wsgi_req.script_name_len);
+ }
+ else {
+ memcpy(tmpstring, mountpoint, 1);
+ }
+ PyDict_SetItemString(py_interpreters, tmpstring, PyInt_FromLong(interpreter));
+ PyErr_Print();
+
+ fprintf(stderr,"interpreter %d (%s) ready\n", interpreter, tmpstring);
+
+ if (interpreter == 0){
+ fprintf(stderr,"setting default interpreter to 0\n");
+ default_interpreter = 0 ;
+ }
+
+ wsgi_cnt++;
+
+ return 1 ;
+}
+
+
+
+
+
diff --git a/uwsgi_client.c b/uwsgi_client.c
new file mode 100644
index 00000000..3b5fb06c
--- /dev/null
+++ b/uwsgi_client.c
@@ -0,0 +1,95 @@
+/*
+
+ *** uWSGI cgi client ***
+
+to compile:
+ gcc -Wall -o uwsgi_client.cgi uwsgi_client.c
+
+*/
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+
+#define UWSGI_SOCK "/tmp/uwsgi.sock"
+#define UWSGI_SCRIPT "django_wsgi"
+
+int main() {
+ extern char **environ;
+ char *env ;
+ struct sockaddr_un s_addr ;
+ int uwsgi_socket ;
+ int res, cnt;
+ char *place_holder;
+
+ unsigned short len ;
+ char message[4096];
+ char *mptr;
+
+ memset(&s_addr, 0, sizeof(struct sockaddr_un)) ;
+
+ s_addr.sun_family = AF_UNIX;
+ strcpy(s_addr.sun_path, UWSGI_SOCK);
+
+ uwsgi_socket = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (uwsgi_socket < 0) {
+ perror("socket()");
+ exit(1);
+ }
+
+ if (connect(uwsgi_socket, (struct sockaddr *) &s_addr, strlen(UWSGI_SOCK) + ( (void *)&s_addr.sun_path - (void *)&s_addr) ) != 0) {
+ perror("connect()");
+ exit(1);
+ }
+
+ memset(message, 0, 4096);
+
+ mptr = message+4;
+ if (setenv("UWSGI_SCRIPT", UWSGI_SCRIPT, 1) != 0) {
+ perror("setenv()");
+ exit(1);
+ }
+ if (**environ) {
+ while( (env = *environ) ) {
+ place_holder = strchr(env,'=');
+ // key
+ len = place_holder-env ;
+ memcpy(mptr, &len, 2);
+ mptr+=2;
+ memcpy(mptr, env, len);
+ mptr+=len ;
+ // value
+ len = (unsigned short) (env+strlen(env) - (place_holder+1)) ;
+ memcpy(mptr, &len, 2);
+ mptr+=2;
+ memcpy(mptr, place_holder+1, len);
+ mptr+= len ;
+ *environ++;
+ }
+ }
+
+ message[0] = 0;
+ len = (mptr-message)-4 ;
+ memcpy(message+1, &len, 2) ;
+ message[3] = 0 ;
+
+ res = send(uwsgi_socket, message, mptr-message, 0);
+
+ while( (cnt = read(0, message, 4096)) ) {
+ send(uwsgi_socket, message, cnt, 0) ;
+ }
+
+ if (res == mptr-message) {
+ while( (res = recv(uwsgi_socket, message, 4096,0)) ) {
+ write(1, message, res) ;
+ }
+ }
+
+ return 0;
+
+}
+