1st fonctionnal implementation of both python<->C IPC

foo.py

@@ -4,8 +4,8 @@ import time
 
 def entrypoint():
 	import os
-	sys.stderr.write('Called ! req by %s' % os.getenv('REMOTE_ADDR'))
+	#sys.stderr.write('Called ! req by %s' % os.getenv('REMOTE_ADDR'))
 	env = "foo"
 	env = '<br/>'.join(["'%s'='%s'" % (k, os.environ[k]) for k in os.environ.keys()])
-	msg = "Content-Type: text/html\r\n\r\nHello world !(%0.2f)\nenv : %s" % (time.time(), env)
+	msg = "Content-Type: text/html\r\nStatus: 404 Not Found\r\n\r\nHello world !(%0.2f)\nenv : %s" % (time.time(), env)
 	sys.stdout.write(msg)

foo_pep333.py

@@ -0,0 +1,8 @@
+import sys
+import os
+import time
+
+def entrypoint(env, start_response):
+	write_body = start_response("200 OK", [('Content-type', 'text/plain')])
+	write_body('Hello world !')
+	return ['Hello world !']

include/python_pyfcgi.h

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2019 Weber Yann
+ * 
+ * This file is part of PyFCGI.
+ * 
+ * PyFCGI is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * any later version.
+ * 
+ * PyFCGI 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with PyFCGI.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/**@defgroup libpyfcgi libpyfcgi python module
+ * @brief The libpyfcgi python module
+ *
+ * PyFCGI defines a python module : libpyfcgi for PEP333 implementation.
+ * This module contains 2 methods : start_response() and write_body()
+ *
+ * The first one is given as argument to the application function, and
+ * the second one is returned when start_method() is called.
+ */
+
+/**@file python_pyfcgi.h
+ * @ingroup libpyfcgi
+ */
+#ifndef _PYTHON_PYFCGI__H__
+#define _PYTHON_PYFCGI__H__
+
+#include "config.h"
+
+#include <fcgiapp.h>
+#include <fcgi_stdio.h> /* fcgi library; put it first*/
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "structmember.h"
+
+#include "logger.h"
+
+#define LIBPYFCGI_DEFAULT_HEADERS "Content-Type: text/html\r\nStatus: %s\r\n\r\n"
+#define LIBPYFCGI_DEFAULT_STATUS "200 OK"
+#define LIBPYFCGI_DEFAULT_CTYPE "Content-Type: text/html\r\n"
+#define LIBPYFCGI_STATUS_SZ 128
+
+struct libpyfcgi_context_s
+{
+	/**@brief PEP333 handling python module reference
+	 * @ingroup libpyfcgi */
+	PyObject *self;
+	/**@brief PEP333 status ref
+	 * @ingroup libpyfcgi */
+	PyObject *status;
+	/**@brief PEP333 headers ref
+	 * @ingroup libpyfcgi */
+	PyObject *headers;
+	/**@brief Indicate if headers was sent in a PEP333 application
+	 * @ingroup libpyfcgi */
+	short headers_sent;
+	/**@brief Stores the libFCGI stream for PEP333 application
+	 * @ingroup libpyfcgi */
+	FCGX_Stream *out;
+	/**@brief Persistent buffer (avoid malloc) for PEP333 headers */
+	char *heads_buf;
+	/**@brief Buffer size */
+	size_t heads_buf_sz;
+	/**@brief Persistent buffer for PEP333 status */
+	char status_buf[LIBPYFCGI_STATUS_SZ];
+};
+
+typedef struct libpyfcgi_context_s libpyfcgi_context_t;
+
+/**@brief Stores python module context */
+extern libpyfcgi_context_t libpyfcgi;
+/**@brief libpyfcgi methods */
+extern PyMethodDef pyfcgimodule_methods[];
+/**@brief libpyfcgi module structure */
+extern PyModuleDef pyfcgimodule;
+
+/**@brief Clean response_status & response_headers globals */
+inline void libpyfcgi_clean_response()
+{
+	if(libpyfcgi.status) { Py_DECREF(libpyfcgi.status); }
+	libpyfcgi.status = NULL;
+	if(libpyfcgi.headers) { Py_DECREF(libpyfcgi.headers); }
+	libpyfcgi.headers = NULL;
+	libpyfcgi.headers_sent = 0;
+}
+
+/**@brief Send headers stored in @ref libpyfcgi context
+ * @note Set python error if called from outside a valid context
+ */
+void libpyfcgi_send_headers();
+
+/**@brief Send body to fcgi
+ * @param PyObject* the body data object (returned by PEP333 app)
+ * @return Python None
+ */
+PyObject* _pyfcgi_write_body(PyObject *body_data);
+
+/* Defining Python module */
+
+/**@brief Public module initialisation function
+ * @ingroup libpyfcgi
+ * @return A python module (PyObject*)
+ */
+PyMODINIT_FUNC PyInit_libpyfcgi(void);
+
+/**@brief libpyfcgi.start_response() python callable
+ * @ingroup libpyfcgi
+ * @note This python callable is a fastcall C method of libpyfcgi module.
+ * 
+ * The python function header is : start_response(status, response_headers, exc_info = None)
+ * @param PyObject* self
+ * @param PyObject* argv
+ * @param Py_ssize_t argc
+ * @return A PyObject* referencing a callable allowing to write data without
+ * cache : libpyfcgi.write_body()
+ */
+PyObject* pyfcgi_start_response(PyObject*, PyObject**, Py_ssize_t);
+
+/**@brief libpyfcgi.write_body() python callable
+ * @ingroup libpyfcgi
+ * @note This python callable is a fastcall C method of libpyfcgi module.
+ *
+ * The python function header is : write_body(body_data)
+ * @param PyObject* self
+ * @param PyObject* argv
+ * @param Py_ssize_t argc
+ * @return ???
+ */
+PyObject* pyfcgi_write_body(PyObject*, PyObject**, Py_ssize_t);
+
+#endif

include/pyutils.h

@@ -30,8 +30,11 @@
 #include "logger.h"
 #include "python_pyfcgi.h"
 
+/* Imports from libpyfcgi python module header */
 extern PyObject* response_status;
 extern PyObject* response_headers;
+extern PyObject* libpyfcgi_self;
+
 /**@brief Call Py_Initialize & update_python_path
  */
 void pyinit();
@@ -71,13 +74,6 @@ PyObject* import_entrypoint();
 /**@brief Return the start_response() python function for pep333 worker */
 PyObject* get_start_response();
 
-/**@brief Clean response_status & response_headers globals */
-inline void libpyfcgi_clean_response()
-{
-	if(response_status) { Py_DECREF(response_status); }
-	if(response_headers) { Py_DECREF(response_headers); }
-}
-
 
 /**@brief Logs an exception */
 void log_expt(int priority);

include/pyworker.h

@@ -80,6 +80,7 @@
 
 #include "logger.h"
 #include "pyutils.h"
+#include "python_pyfcgi.h"
 
 #define WPIPER_SIG 30
 #define PIPER_STACK_SZ (1024 * 1024 * 4)
@@ -103,6 +104,19 @@ extern PyObject* response_headers;
 /**@todo TODO on all request (when updating env ?) update stdin so
  * python will be able to read the request content */
 
+/**@brief The function that initialize the alternate python worker
+ * @ingroup worker_process
+ *
+ * This function handles python worker by running a PEP333 application function.
+ * The start_response() function set @ref response_status and
+ * @ref response_headers globals.
+ * @param char* python_entrypoint a path to a python entrypoint
+ * @param int worker uid
+ * @param int semid for FCGI access
+ * @return 0 if exit avec max requests
+ */
+int work333(int, int);
+
 /**@brief the function that initialize the alternate python worker
  * @ingroup worker_process
  *

src/python_pyfcgi.c

@@ -19,30 +19,453 @@
 
 #include "python_pyfcgi.h"
 
+/* Globals definitions */
+/* libpyfcgi context */
+libpyfcgi_context_t libpyfcgi = { NULL, NULL, NULL, 0, NULL, NULL, 0 };
+/* Python module methods specs */
+PyMethodDef pyfcgimodule_methods[] = {
+	{"start_response", (PyCFunction)pyfcgi_start_response, METH_FASTCALL, NULL},
+	{"write_body", (PyCFunction)pyfcgi_write_body, METH_FASTCALL, NULL},
+	{NULL} // Sentinel
+};
+/* Python module specs */
+PyModuleDef pyfcgimodule = {
+	PyModuleDef_HEAD_INIT,
+	"libpyfcgi",
+	"Python librarie for PyFCGi",
+	-1,
+	pyfcgimodule_methods,
+	NULL, NULL, NULL, NULL
+};
+
+/* Function definition */
+
+/**@brief Forge & send default headers */
+static void _default_headers()
+{
+	size_t sz;
+	void *tmp;
+	while(1)
+	{
+		sz = snprintf(libpyfcgi.heads_buf, libpyfcgi.heads_buf_sz,
+			LIBPYFCGI_DEFAULT_HEADERS, libpyfcgi.status_buf);
+
+		if(sz < libpyfcgi.heads_buf_sz) { break; }
+
+		sz = ((sz>>11)+1)<<11; // 2048 alloc blocks
+		tmp = realloc(libpyfcgi.heads_buf, sz);
+		if(!tmp)
+		{
+			pyfcgi_log(LOG_ALERT,
+				"Unable to realloc headers buffer : %s",
+				strerror(errno));
+			exit(PYFCGI_FATAL);
+		}
+		libpyfcgi.heads_buf = tmp;
+		libpyfcgi.heads_buf_sz = sz;
+	}
+}
+
+static void _set_status_buf()
+{
+	PyObject *bytes;
+
+	short decref = 1;
+	if(!libpyfcgi.status)
+	{
+		libpyfcgi.status = Py_BuildValue(LIBPYFCGI_DEFAULT_STATUS);
+		return;
+	}
+	if(PyBytes_Check(libpyfcgi.status))
+	{
+		bytes = libpyfcgi.status;
+		decref = 0;
+	}
+	else if(PyUnicode_Check(libpyfcgi.status))
+	{
+		
+		bytes = PyUnicode_AsUTF8String(libpyfcgi.status);
+		if(!bytes)
+		{
+			pyfcgi_log(LOG_ERR, "Unable to encode status using UTF8 codec");
+			log_expt(LOG_ERR);
+		}
+	}
+	else
+	{
+		bytes = PyObject_Bytes(libpyfcgi.status);
+		if(!bytes)
+		{
+			pyfcgi_log(LOG_ERR, "Unable to convert status to bytes");
+			log_expt(LOG_ERR);
+		}
+	}
+	strncpy(libpyfcgi.status_buf, PyBytes_AsString(bytes), LIBPYFCGI_STATUS_SZ);
+	libpyfcgi.status_buf[LIBPYFCGI_STATUS_SZ-1] = '\0';
+	if(decref) { Py_DECREF(bytes); }
+}
+
+void libpyfcgi_set_headers_buf()
+{
+	PyObject *heads_iter, *head_tuple, *head_seq, **head, *bytes[2], *repr;
+	Py_ssize_t tsz, n_head, sz, buf_sz, buf_left, buf_off;
+	char errstr[256];
+	char *head_str[2], *buf_ptr;
+	int i;
+	void *tmp;
+	short content_type; // indicate if headers contains content-type field
+
+	_set_status_buf();
+
+	if(!libpyfcgi.headers)
+	{
+		_default_headers();
+		return;
+	}
+
+repr = PyObject_ASCII(libpyfcgi.headers);
+pyfcgi_log(LOG_DEBUG, "Sending headers : '%s'", PyUnicode_AsUTF8(repr));
+Py_DECREF(repr);
+
+
+	heads_iter = PyObject_GetIter(libpyfcgi.headers);
+	if(!heads_iter)
+	{
+		pyfcgi_log(LOG_ERR, "Unable to get iterator from given headers");
+		return;
+	}
+
+	n_head = 0;
+	buf_ptr = libpyfcgi.heads_buf; //buffer pointer
+	buf_sz = libpyfcgi.heads_buf_sz; //buffer size
+	buf_left = buf_sz; //buffer size left
+	buf_off = 0; //buffer pointer offset
+	while((head_tuple = PyIter_Next(heads_iter)))
+	{
+		head_seq = PySequence_Fast(head_tuple, "Headers element is not a sequence");
+		if((tsz = PySequence_Fast_GET_SIZE(head_seq)) != 2)
+		{
+			repr = PyObject_ASCII(head_tuple);
+			snprintf(errstr, 256,
+				"Headers element expected to have len == 2, but got len %ld for element %ld : %s", tsz, n_head, PyUnicode_AsUTF8(repr));
+			Py_DECREF(repr);
+			PyErr_SetString(PyExc_TypeError, errstr);
+			return;
+		}
+		head = PySequence_Fast_ITEMS(head_seq);
+		for(i=0; i<2; i++)
+		{
+			if(PyUnicode_Check(libpyfcgi.status))
+			{
+				bytes[i] = PyUnicode_AsUTF8String(head[i]);
+				if(!bytes[i])
+				{
+					//Error encoding header field
+					pyfcgi_log(LOG_ERR, "Unable to encode header field using UTF8 codec");
+					goto head_decode_err;
+				}
+			}
+			else
+			{
+				bytes[i] = PyObject_Bytes(head[i]);
+				if(!bytes[i])
+				{
+					pyfcgi_log(LOG_ERR, "Unable to convert header field to bytes");
+					goto head_decode_err;
+				}
+			}
+			head_str[i] = PyBytes_AsString(bytes[i]);
+			
+		}
+		if(!strcmp(head_str[0], "Content-Type"))
+		{
+			content_type = 1;
+		}
+		// Writing current headers field & value in header buffer
+		while(1)
+		{
+			sz = snprintf(buf_ptr, buf_left,
+				"%s: %s\r\n", head_str[0], head_str[1]);
+			if(sz < buf_left)
+			{
+				buf_off += sz+1;
+				buf_ptr += sz;
+				break;
+			}
+
+			// 2048 alloc bloc
+			sz = (((buf_sz+sz)>>11)+1)<<11;
+			tmp = realloc(libpyfcgi.heads_buf, sz);
+			if(!tmp)
+			{
+				pyfcgi_log(LOG_ALERT,
+					"Unable to realloc headers buffer from iterator : %s",
+					strerror(errno));
+				exit(PYFCGI_FATAL);
+			}
+			buf_ptr = tmp + buf_off;
+			buf_left = sz - buf_off;
+			libpyfcgi.heads_buf = tmp;
+			libpyfcgi.heads_buf_sz = sz;
+		}
+
+		n_head++;
+		Py_DECREF(head_seq);
+		Py_DECREF(head_tuple);
+	}
+	Py_DECREF(heads_iter);
+	while(!content_type)
+	{
+		//Append text/html default content-type
+		/**@todo Autodetect content type ?? **/
+		sz = sizeof(LIBPYFCGI_DEFAULT_CTYPE)-1;
+		if(sz < buf_left)
+		{
+			buf_off += sz +1;
+			strncpy(buf_ptr, LIBPYFCGI_DEFAULT_CTYPE, buf_left);
+			buf_ptr += sz;
+			break;
+		}
+		sz = (((buf_sz+sz)>>11)+1)<<11;
+		tmp = realloc(libpyfcgi.heads_buf, sz);
+		if(!tmp)
+		{
+				pyfcgi_log(LOG_ALERT,
+					"Unable to realloc headers buffer from default Content-Type",
+					strerror(errno));
+				exit(PYFCGI_FATAL);
+		}
+		buf_ptr = tmp+buf_off;
+		buf_left = sz - buf_off;
+		libpyfcgi.heads_buf = tmp;
+		libpyfcgi.heads_buf_sz = sz;
+	}
+	
+	return;
+head_decode_err:
+	Py_DECREF(head_seq);
+	Py_DECREF(head_tuple);
+	Py_DECREF(heads_iter);
+}
+
+void libpyfcgi_send_headers()
+{
+	if(!libpyfcgi.out)
+	{
+		// invalid context
+		PyErr_SetString(PyExc_RuntimeError,
+			"Trying to send headers but not in FCGI context");
+		return;
+	}
+
+	if(libpyfcgi.headers_sent)
+	{
+		PyErr_SetString(PyExc_RuntimeError,
+			"Headers allready sent...");
+		return;
+	}
+	
+	libpyfcgi_set_headers_buf();
+	if(PyErr_Occurred())
+	{
+		/**@todo Better exception/error handling ? */
+		log_expt(LOG_ALERT);
+		exit(PYFCGI_FATAL);
+	}
+pyfcgi_log(LOG_DEBUG, "Headers ready to be sent : '%s'", libpyfcgi.heads_buf);
+	FCGX_PutStr(libpyfcgi.heads_buf, strlen(libpyfcgi.heads_buf),
+		libpyfcgi.out);
+pyfcgi_log(LOG_DEBUG, "Headers sent...");
+	FCGX_PutStr("\r\n", 2, libpyfcgi.out);
+	libpyfcgi.headers_sent = 1;
+}
+
 PyMODINIT_FUNC
 PyInit_libpyfcgi(void)
 {
-	PyObject *module;
-	module = PyModule_Create(&pyfcgimodule);
-	if(module == NULL) { return NULL; }
-	return module;
+	if(libpyfcgi.self != NULL)
+	{
+		return libpyfcgi.self;
+	}
+	// init module & globals
+	libpyfcgi.status = NULL;
+	libpyfcgi.headers = NULL;
+	libpyfcgi.self = PyModule_Create(&pyfcgimodule);
+	if(libpyfcgi.self == NULL) { return NULL; }
+	return libpyfcgi.self;
 }
 
 PyObject* pyfcgi_start_response(PyObject* self, PyObject** argv, Py_ssize_t argc)
 {
-	char err[64];
-	if(argc != 2)
+	char err[128];
+	PyObject *exc_info;
+	if(argc != 2 && argc != 3)
 	{
-		snprintf(err, 64,
-			"libpyfcgi.start_response() expected 2 arguments but %d given",
+		snprintf(err, 128,
+			"libpyfcgi.start_response() expected 2 to 3 arguments but %ld given",
 			argc);
 		PyErr_SetString(PyExc_ValueError, err);
 		Py_RETURN_NONE;
 	}
 
-	libpyfcgi_clean_response();
+	if(libpyfcgi.status)
+	{
+		Py_DECREF(libpyfcgi.status);
+	}
+	if(libpyfcgi.headers)
+	{
+		Py_DECREF(libpyfcgi.headers);
+	}
+
+	libpyfcgi.status = argv[0];
+	libpyfcgi.headers = argv[1];
+	Py_INCREF(argv[0]);
+	Py_INCREF(argv[1]);
+	exc_info = argc>2?argv[2]:NULL;
+	if(exc_info)
+	{
+		Py_INCREF(argv[2]);
+		/* check if headers are sent, if yes re-raise the exception using
+		   exc_info */
+	}
+
+PyObject *repr = PyObject_ASCII(libpyfcgi.headers);
+pyfcgi_log(LOG_DEBUG, "start_response called, headers : '%s'", PyUnicode_AsUTF8(repr));
+Py_DECREF(repr);
+
+	return PyObject_GetAttrString(self, "write_body");
+}
+
+PyObject* pyfcgi_write_body(PyObject* self, PyObject** argv, Py_ssize_t argc)
+{
+	char err[128];
+
+pyfcgi_log(LOG_DEBUG, "Write body called...");
+	if(argc != 1)
+	{
+		snprintf(err, 128,
+			"libpyfcgi.write_body() excpeted 1 argument but %ld given",
+			argc);
+		PyErr_SetString(PyExc_ValueError, err);
+		Py_RETURN_NONE;
+	}
+
+	return _pyfcgi_write_body(argv[0]);
+}
+
+PyObject* _pyfcgi_write_body(PyObject *body_data)
+{
+	char err[128];
+	const char *dat;
+	PyObject *bytes, *cur, *iter, *repr;
+	Py_ssize_t sz;
+
+
+	if(!libpyfcgi.out)
+	{
+		// invalid context
+		PyErr_SetString(PyExc_RuntimeError,
+			"Trying to send body data but not in FCGI context");
+		Py_RETURN_NONE;
+	}
+
+	cur = NULL;
+	iter = NULL;
+	if(PyUnicode_Check(body_data) || PyBytes_Check(body_data))
+	{
+		cur = body_data;
+	}
+	else if (!(iter = PyObject_GetIter(body_data)))
+	{
+		log_expt(LOG_ERR);
+		repr = PyObject_ASCII(body_data);
+		snprintf(err, 128, 
+			"libpyfcgi.write_body() expect argument to be a str a bytes or an iterator, but %s given",
+			PyUnicode_AsUTF8(repr));
+		Py_DECREF(repr);
+		PyErr_SetString(PyExc_ValueError, err);
+		Py_RETURN_NONE;
+	}
+	else
+	{
+		Py_INCREF(iter);
+		cur = PyIter_Next(iter);
+pyfcgi_log(LOG_DEBUG, "Got iter for writing body...");
+	}
+
+	if(!cur)
+	{
+		/**@todo trigger pyhon warning : empty body ? **/
+		Py_RETURN_NONE;
+	}
+
+	// if headers not sent yet, send them....
+	if(!libpyfcgi.headers_sent)
+	{
+pyfcgi_log(LOG_DEBUG, "Headers not sent... sending them...");
+		libpyfcgi_send_headers();
+	}
+
+	while(cur)
+	{
+		Py_INCREF(cur);
+		bytes = NULL;
+		if(PyUnicode_Check(cur))
+		{
+			dat = PyUnicode_AsUTF8AndSize(cur, &sz);
+			if(!dat)
+			{
+				repr = PyObject_ASCII(cur);
+				snprintf(err, 128,
+					"libpyfcgi.__write_body unable to encode string as UTF-8 : %s",
+					PyUnicode_AsUTF8(repr));
+				Py_DECREF(repr);
+				PyErr_SetString(PyExc_ValueError, err);
+				Py_RETURN_NONE;
+			}
+		}
+		else if(PyBytes_Check(cur))
+		{
+			dat = PyBytes_AsString(cur);
+			if(!dat)
+			{
+				/**@todo if no expt set, set error str */
+				Py_RETURN_NONE;
+			}
+			sz = PyBytes_GET_SIZE(cur);
+		}
+		else
+		{
+			bytes = PyObject_Bytes(cur);
+			if(!bytes)
+			{
+				repr = PyObject_ASCII(cur);
+				snprintf(err, 128,
+					"libpyfcgi.__write_body expected str or bytes but %s given",
+					PyUnicode_AsUTF8(repr));
+				Py_DECREF(repr);
+				PyErr_SetString(PyExc_ValueError, err);
+				Py_RETURN_NONE;
+			}
+			dat = PyBytes_AsString(cur);
+			if(!dat)
+			{
+				/**@todo if no expt set, set error str */
+				Py_RETURN_NONE;
+			}
+			sz = PyBytes_GET_SIZE(cur);
+		}
+		
+pyfcgi_log(LOG_DEBUG, "Sending '%s'", dat);
+		FCGX_PutStr(dat, sz, libpyfcgi.out);
 
-	response_status = argv[0];
-	response_headers = argv[1];
+		if(bytes) { Py_DECREF(bytes); }
+		Py_DECREF(cur);
+		cur = iter?PyIter_Next(iter):NULL;
+	}
+	if(iter)
+	{
+		Py_DECREF(iter);
+	}
 	Py_RETURN_NONE;
 }

src/pyutils.c

@@ -57,7 +57,9 @@ void update_python_path()
 	}
 
 	// Fetch, dup & update the python path
+pyfcgi_log(LOG_DEBUG, "DEBUG 0");
 	ppath = Py_GetPath();
+pyfcgi_log(LOG_DEBUG, "DEBUG 1");
 	if(!ppath)
 	{
 		if(PyErr_Occurred())
@@ -386,27 +388,20 @@ PyObject* import_entrypoint()
 	return entry_fun;
 }
 
-static PyObject* libpyfcgi_self = NULL;
 PyObject* get_start_response()
 {
 	PyObject *module;
-	response_status = NULL;
-	response_headers = NULL;
-	if(!libpyfcgi_self)
+	if(!libpyfcgi.self)
 	{
-		module = PyModule_Create(&pyfcgimodule);
+		module = PyInit_libpyfcgi();
 		if(module == NULL)
 		{
 			pyfcgi_log(LOG_ERR, "Unable to create libpyfcgi python module");
 			return NULL;
 		}
-		libpyfcgi_self = module;
+		libpyfcgi.self = module;
 	}
-	else
-	{
-		module = libpyfcgi_self;
-	}
-	return PyObject_GetAttrString(libpyfcgi_self, "start_response");
+	return PyObject_GetAttrString(libpyfcgi.self, "start_response");
 }
 
 void log_expt(int priority)
@@ -417,7 +412,7 @@ void log_expt(int priority)
 		return;
 	}
 
-	PyObject *expt, *expt_str, *expt_bytes, *expt_cls,
+	PyObject *expt, *expt_bytes, *expt_cls,
 		*expt_val, *expt_type, *traceback;
 	char *msg, *type, *val;
 	int msg_sz;
@@ -426,12 +421,7 @@ void log_expt(int priority)
 	PyErr_Fetch(&expt_cls, &expt, &traceback);
 
 	// Fetching exception message using __str__()
-	expt_str = PyObject_GetAttrString(expt, "__str__");
-	if(!expt_str)
-	{
-		pyfcgi_log(LOG_ERR, "Unable to fetch __str__ from exception");
-	}
-	expt_val = PyObject_CallObject(expt_str, NULL);
+	expt_val = PyObject_ASCII(expt);
 	expt_bytes = PyUnicode_AsUTF8String(expt_val);
 
 	msg = PyBytes_AsString(expt_bytes);

src/pyworker.c

@@ -27,6 +27,13 @@ static inline void worker_set_idle(int);
  * @param int semid */
 static inline void worker_set_busy(int);
 
+/**@brief Process results from a pep333 worker
+ * @param FCGX_Stream* out stream from libFCGI
+ * @param PyObject* application function returned value
+ */
+static inline int work333_send_result(FCGX_Stream*, PyObject* ret);
+
+
 static int worker_piper_sigrcv = 0;
 
 int work333(int wrk_id, int semid)
@@ -47,11 +54,10 @@ int work333(int wrk_id, int semid)
 
 	pyfcgi_log(LOG_INFO, "Worker started with PEP333 App");
 
-	update_python_path(); // add cwd to python path
-	Py_Initialize();
+	pyinit();
+	pyfcgi_log(LOG_DEBUG, "Python started");
 	update_python_fd(pipe_out, pipe_err);
 	fetch_pyflush(&(pyflush[0]), &(pyflush[1]));
-	pyfcgi_log(LOG_INFO, "Python started");
 
 	//importing os
 	py_osmod = python_osmod();
@@ -79,28 +85,63 @@ int work333(int wrk_id, int semid)
 	{
 		gettimeofday(&start, NULL);
 		worker_set_busy(semid);
+pyfcgi_log(LOG_DEBUG, "Working !!");
 		count++;
 		environ = update_pyenv(py_osmod, envp);
 
 		libpyfcgi_clean_response();
+		libpyfcgi.out = out_stream;
 		args = Py_BuildValue("OO", environ, start_response);
+pyfcgi_log(LOG_DEBUG, "Calling entrypoint :D");
 		entry_ret = PyObject_CallObject(entry_fun, args);
+		Py_INCREF(entry_ret);
+
 		if(PyErr_Occurred())
 		{
 			log_expt(LOG_ERR);
 		}
 		// able to process returned value
+		// Simulate python call of libpyfcgi.write_body()
+pyfcgi_log(LOG_DEBUG, "Writing body !");
+		_pyfcgi_write_body(entry_ret);
+		if(PyErr_Occurred())
+		{
+			log_expt(LOG_ERR);
+		}
+pyfcgi_log(LOG_DEBUG, "Cleaning...");
 
 		// clean stuffs
 		Py_DECREF(args);
 		Py_DECREF(environ);
+		Py_DECREF(entry_ret);
 		// flush & logs pystdout & pystderr
 		PyObject_CallObject(pyflush[0], NULL);
 		PyObject_CallObject(pyflush[1], NULL);
+
+		FCGX_FClose(out_stream);
+		FCGX_FClose(in_stream);
+		FCGX_FClose(err_stream);
+		FCGI_Finish();
+		worker_set_idle(semid);
+		gettimeofday(&stop, NULL);
+		stop.tv_sec = stop.tv_sec - start.tv_sec;
+		stop.tv_usec = stop.tv_usec - start.tv_usec;
+		if(stop.tv_usec < 0)
+		{
+			stop.tv_usec += 1000000;
+			stop.tv_sec -= 1;
+		}
+		pyfcgi_log(LOG_DEBUG, "Worker[%d] request %d END [OK] in %ld.%06lds",
+			wrk_id, count, stop.tv_sec, stop.tv_usec);
 	}
 	return 0;
 }
 
+static inline int work333_send_result(FCGX_Stream *out, PyObject* ret)
+{
+	return 0;
+}
+
 int work(int wrk_id, int semid)
 {
 	PyObject *entry_fun, *pystdout_flush, *pystderr_flush, *py_osmod,
@@ -117,6 +158,10 @@ int work(int wrk_id, int semid)
 	piper_args_t piper_args;
 	char *piper_stack;
 
+	char ident[128];
+	snprintf(ident, 128, "Worker[%d]", wrk_id);
+	pyfcgi_logger_set_ident(ident);
+
 	max_reqs = PyFCGI_conf.max_reqs;
 	piper_args.wrk_id = wrk_id;
 	piper_args.act = &act;
@@ -144,8 +189,7 @@ int work(int wrk_id, int semid)
 		exit(err);
 	}
 
-	pyfcgi_log(	LOG_INFO,
-		"Worker %d started", wrk_id);
+	pyfcgi_log(LOG_INFO, "Worker %d started", wrk_id);
 
 	update_python_path(); // add cwd to python path
 	Py_Initialize(); // "start" python

src/responder.c

@@ -112,6 +112,21 @@ int responder_loop()
 			}
 			if(status)
 			{
+				if(WIFSIGNALED(status))
+				{
+					if(WTERMSIG(status) == 11)
+					{
+						pyfcgi_log(LOG_ALERT,
+							"Worker[%d] segfault !",
+							n);
+					}
+					else
+					{
+						pyfcgi_log(LOG_ALERT,
+							"Worker[%d] terminated by signal %d",
+							n, WTERMSIG(status));
+					}
+				}
 				if(WEXITSTATUS(status) & PYFCGI_FATAL)
 				{
 					pyfcgi_log(LOG_ALERT,
@@ -213,7 +228,14 @@ pid_t spawn(int wrk_id, int semid)
 	else if(!res)
 	{
 		// Child process
-		exit(work(wrk_id, semid));
+		if(PyFCGI_conf.pep333)
+		{
+			exit(work333(wrk_id, semid));
+		}
+		else
+		{
+			exit(work(wrk_id, semid));
+		}
 	}
 	// Sleep to avoid spawning like hell thinking all workers are
 	// busy. Let some time to this one to go up...