Implement partial support for wsgi.* environ

The url_scheme is static to "http" for the moment...

include/conf.h

@@ -125,8 +125,13 @@ struct pyfcgi_context_s {
 	/**@brief workers count */
 	unsigned int n_wrk;
 
+	/**@brief Stores python_path (not dupped by python) */
 	wchar_t python_path[PATH_MAX];
+	/**@brief Stores venv_path for python home (not dupped by python) */
 	wchar_t venv_path[PATH_MAX];
+
+	/**@brief Stores a part of the environ (containing wsgi.* keys) */
+	PyObject *wsgi_dict;
 };
 
 /**@brief Structure containing configuration

include/python_ioin.h

@@ -0,0 +1,93 @@
+/*
+ * 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 lib_ioin Defines libpyfcgi.IoIn class
+ * @brief The IoIn class implement base IO interface allowing python to read
+ * HTTP request from FCGI
+ * @ingroup libpyfcgo
+ */
+/**@file python_ioin.h
+ * @ingroup lib_ioin
+ */
+
+#ifndef _PYTHON_IOIN__H__
+#define _PYTHON_IOIN__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 <limits.h>
+#include <stdlib.h>
+
+#define IoIn__FromString(self, str) \
+(((IoIn*)self)->bin?PyBytes_FromString:PyUnicode_FromString)(str)
+
+#define IoIn__FromBuff(self) IoIn__FromString(self, ((IoIn*)self)->buff)
+
+extern PyMethodDef IoIn_methods[];
+extern PyMemberDef IoIn_members[];
+extern PyTypeObject IoInType;
+
+typedef struct
+{
+	PyObject_VAR_HEAD;
+	PyObject *closed;
+	FCGX_Stream **in_stream;
+	char *buff;
+	/**@brief buffer size */
+	int buff_sz;
+	/**@brief 1 if binary stream (sending PyBytes) 0 if sending PyUnicode */
+	short bin;
+	/**@brief 1 if EOF encountered, else 0 */
+	short eof;
+} IoIn;
+
+int pyfcgi_ioin_init(PyObject *self, PyObject *args, PyObject *kwds);
+void pyfcgi_ioin_del(IoIn *self);
+
+PyObject* pyfcgi_ioin_close(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_fileno(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_flush(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_isatty(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_readable(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_readline(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_readlines(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_read(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_readall(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_readinto(PyObject *self, PyObject **argv, Py_ssize_t argc);
+
+PyObject* pyfcgi_ioin_WriteError(PyObject *self, PyObject **argv, Py_ssize_t argc);
+#define pyfcgi_ioin_writelines pyfcgi_ioin_WriteError
+#define pyfcgi_ioin_write pyfcgi_ioin_WriteError
+
+PyObject* pyfcgi_ioin_SeekError(PyObject *self, PyObject **argv, Py_ssize_t argc);
+#define pyfcgi_ioin_seek pyfcgi_ioin_SeekError
+#define pyfcgi_ioin_tell pyfcgi_ioin_SeekError
+
+PyObject* pyfcgi_ioin_truncate(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_seekable(PyObject *self, PyObject **argv, Py_ssize_t argc);
+PyObject* pyfcgi_ioin_writable(PyObject *self, PyObject **argv, Py_ssize_t argc);
+
+#endif

include/python_pyfcgi.h

@@ -43,6 +43,7 @@
 #include "structmember.h"
 
 #include "logger.h"
+#include "python_ioin.h"
 
 #define LIBPYFCGI_DEFAULT_HEADERS "Content-Type: text/html\r\nStatus: %s\r\n\r\n"
 #define LIBPYFCGI_DEFAULT_STATUS "200 OK"
@@ -60,12 +61,17 @@ struct libpyfcgi_context_s
 	/**@brief PEP333 headers ref
 	 * @ingroup libpyfcgi */
 	PyObject *headers;
+	/**@brief libpyfcgi.IoIn instance */
+	IoIn *ioin;
 	/**@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 Stores the libFCGI stream from wich HTTP request can be read
+	 * @ingroup libpyfcgi */
+	FCGX_Stream *in;
 	/**@brief Persistent buffer (avoid malloc) for PEP333 headers */
 	char *heads_buf;
 	/**@brief Buffer size */
@@ -93,6 +99,8 @@ inline void libpyfcgi_clean_response()
 	libpyfcgi.headers = NULL;
 	libpyfcgi.headers_sent = 0;
 	libpyfcgi.rep_sz = 0;
+	libpyfcgi.ioin->eof=0;
+	libpyfcgi.ioin->closed=Py_False;
 }
 
 /**@brief Send headers stored in @ref libpyfcgi context

src/Makefile.am

@@ -6,13 +6,13 @@ pyfcgi_LDADD = $(PYTHON_LDFLAGS)
 
 # libpyfcgi python module
 lib_LTLIBRARIES = libpyfcgi.la
-libpyfcgi_la_SOURCES = python_pyfcgi.c
+libpyfcgi_la_SOURCES = python_pyfcgi.c python_ioin.c
 libpyfcgi_la_CFLAGS = $(PYTHON_SO_CFLAGS)
 libpyfcgi_la_LDFLAGS = $(PYTHON_SO_LDFLAGS)
 
 # static librarie for check
 noinst_LIBRARIES = libpyfcgi.a
-libpyfcgi_a_SOURCES = logger.c pyworker.c responder.c conf.c pyutils.c python_pyfcgi.c
+libpyfcgi_a_SOURCES = logger.c pyworker.c responder.c conf.c pyutils.c python_pyfcgi.c python_ioin.c
 libpyfcgi_a_CFLAGS = $(PYTHON_CFLAGS)
 
 

src/python_ioin.c

@@ -0,0 +1,512 @@
+#include "python_ioin.h"
+/**@file python_ioin.c
+ * @ingroup lib_ioin
+ */
+
+/**@brief If given object in_stream is NULL set error indicator
+ * @return 0 if no error else -1 or -2
+ */
+static int _check_nullin(PyObject *self);
+
+/**@brief Request a new buffer size.
+ * 
+ * @param PyObject* self The IoIn instance
+ * @param int nreq number of bytes required in buffer
+ * @return 0 on error else buffer size
+ */
+static int pyfcgi_ioin__reqbuf(PyObject *self, int nreq);
+
+/**@brief Concat two bytes/unicode given IoIn configuration flag
+ */
+static PyObject* IoIn__Concat(PyObject *self, PyObject *left, PyObject *right);
+
+PyMethodDef IoIn_methods[] = {
+	{"close", (PyCFunction)pyfcgi_ioin_close, METH_FASTCALL, NULL},
+	{"fileno", (PyCFunction)pyfcgi_ioin_fileno, METH_FASTCALL, NULL},
+	{"flush", (PyCFunction)pyfcgi_ioin_flush, METH_FASTCALL, NULL},
+	{"isatty", (PyCFunction)pyfcgi_ioin_isatty, METH_FASTCALL, NULL},
+	{"readable", (PyCFunction)pyfcgi_ioin_readable, METH_FASTCALL, NULL},
+	{"readline", (PyCFunction)pyfcgi_ioin_readline, METH_FASTCALL, NULL},
+	{"readlines", (PyCFunction)pyfcgi_ioin_readlines, METH_FASTCALL, NULL},
+	{"seek", (PyCFunction)pyfcgi_ioin_seek, METH_FASTCALL, NULL},
+	{"seekable", (PyCFunction)pyfcgi_ioin_seekable, METH_FASTCALL, NULL},
+	{"tell", (PyCFunction)pyfcgi_ioin_tell, METH_FASTCALL, NULL},
+	{"truncate", (PyCFunction)pyfcgi_ioin_truncate, METH_FASTCALL, NULL},
+	{"writable", (PyCFunction)pyfcgi_ioin_writable, METH_FASTCALL, NULL},
+	{"writelines", (PyCFunction)pyfcgi_ioin_writelines, METH_FASTCALL, NULL},
+	{"read", (PyCFunction)pyfcgi_ioin_read, METH_FASTCALL, NULL},
+	{"readall", (PyCFunction)pyfcgi_ioin_readall, METH_FASTCALL, NULL},
+	{"readinto", (PyCFunction)pyfcgi_ioin_readinto, METH_FASTCALL, NULL},
+	{"write", (PyCFunction)pyfcgi_ioin_write, METH_FASTCALL, NULL},
+	{NULL} //Sentinel
+};
+
+PyMemberDef IoIn_members[] = {
+	{"closed", T_OBJECT, offsetof(IoIn, closed), READONLY, "True if the stream is closed"},
+	{NULL}
+};
+
+PyTypeObject IoInType = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"libpyfcgi.IoIn",                     /* tp_name */
+	sizeof(IoIn),                        /* tp_basicsize */
+	0,                                               /* tp_itemsize */
+	(destructor)pyfcgi_ioin_del, /* tp_dealloc */
+	0,                                               /* tp_print */
+	0,                                               /* tp_getattr */
+	0,                                               /* tp_setattr */
+	0,                                               /* tp_reserved */
+	0,                                               /* tp_repr */
+	0,                                               /* tp_as_number */
+	0,                                               /* tp_as_sequence */
+	0,                              /* tp_as_mapping */
+	0,                                               /* tp_hash  */
+	0,                                               /* tp_call */
+	0,                                               /* tp_str */
+	0,                                               /* tp_getattro */
+	0,                                               /* tp_setattro */
+	0,                                               /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT |
+	Py_TPFLAGS_BASETYPE,   /* tp_flags */
+	"RawIo interface to FCGI input stream",                /* tp_doc */
+	0,                                               /* tp_traverse */
+	0,                                               /* tp_clear */
+	0,                                               /* tp_richcompare */
+	0,                                               /* tp_weaklistoffset */
+	0,                                               /* tp_iter */
+	0,                                               /* tp_iternext */
+	IoIn_methods,                        /* tp_methods */
+	IoIn_members,                        /* tp_members */
+	0,                                               /* tp_getset */
+	0,                                               /* tp_base */
+	0,                                               /* tp_dict */
+	0,                                               /* tp_descr_get */
+	0,                                               /* tp_descr_set */
+	0,                                               /* tp_dictoffset */
+	pyfcgi_ioin_init,          /* tp_init */
+	0,                                               /* tp_alloc */
+	0,                            /* tp_new */
+};
+
+
+int pyfcgi_ioin_init(PyObject *self, PyObject *args, PyObject *kwds)
+{
+	IoIn *ioin = (void*)self;
+	ioin->in_stream = NULL;
+	ioin->buff = NULL;
+	ioin->buff_sz = 0;
+	ioin->eof=0;
+	ioin->bin=1;
+	return 0;
+}
+
+void pyfcgi_ioin_del(IoIn *self)
+{
+	IoIn *ioin = self;
+	if(ioin->buff) { free(ioin->buff); }
+	Py_TYPE(self)->tp_free((PyObject*)self);
+}
+
+PyObject* pyfcgi_ioin_close(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.close() not expecting any argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+	if(FCGX_FClose(*((IoIn*)self)->in_stream) < 0)
+	{
+		PyErr_Format(PyExc_OSError,
+			"%A unable to close", self);
+	}
+	((IoIn*)self)->closed = Py_True;
+	Py_RETURN_NONE;
+}
+
+PyObject* pyfcgi_ioin_fileno(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	PyErr_SetString(PyExc_OSError, "libpyfcgi.IoIn has no fileno");
+	Py_RETURN_NONE;
+}
+
+PyObject* pyfcgi_ioin_flush(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.close() not expecting any argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+	if(FCGX_FFlush(*((IoIn*)self)->in_stream) < 0)
+	{
+		PyErr_Format(PyExc_OSError,
+			"%A unable to flush", self);
+	}
+	Py_RETURN_NONE;
+}
+
+PyObject* pyfcgi_ioin_isatty(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	return Py_False;
+}
+
+PyObject* pyfcgi_ioin_readable(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	return Py_True;
+}
+
+PyObject* pyfcgi_ioin_readline(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	int read_n;
+	long arg;
+	char *ret;
+
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc > 1)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.close() expecting 0 or 1 argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+	if(!argc || !argv[0])
+	{
+		read_n = pyfcgi_ioin__reqbuf(self, 0);
+	}
+	else
+	{
+		arg = PyLong_AsLong(argv[0]);
+		if(PyErr_Occurred())
+		{
+			Py_RETURN_NONE;
+		}
+		read_n = pyfcgi_ioin__reqbuf(self, (arg>INT_MAX)?INT_MAX:arg);
+	}
+
+	ret = ((IoIn*)self)->buff;
+	if(!FCGX_GetLine(ret, read_n, *((IoIn*)self)->in_stream))
+	{
+		((IoIn*)self)->eof = 1;
+		ret = "";
+	}
+	return IoIn__FromString(self, ret);
+}
+
+PyObject* pyfcgi_ioin_readlines(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	size_t hint, left;
+	int read_n, toread;
+	size_t sz;
+	PyObject *res, *cur_str, *read_str, *tmp;
+	char *buff;
+
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc > 1)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.close() expecting 0 or 1 argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+	if(!argc || !argv[0])
+	{
+		hint = 0;
+		left = 0;
+	}
+	else
+	{
+		hint = PyLong_AsSize_t(argv[0]);
+		if(PyErr_Occurred())
+		{
+			Py_RETURN_NONE;
+		}
+		left = hint;
+	}
+
+	res = PyList_New(0);
+	if(!res)
+	{
+		Py_RETURN_NONE;
+	}
+	Py_INCREF(res);
+
+	read_n = pyfcgi_ioin__reqbuf(self, 0);
+	buff = ((IoIn*)self)->buff;
+	cur_str = NULL;
+
+	while((hint && left) || !hint)
+	{
+		toread = (hint&&((size_t)read_n > left))?(int)left:read_n;
+		if(!FCGX_GetLine(buff, toread,
+			*((IoIn*)self)->in_stream))
+		{
+			((IoIn*)self)->eof = 1;
+			break;
+		}
+		sz = strlen(buff);
+		left -= sz;
+		read_str = IoIn__FromBuff(self);
+		if(!read_str)
+		{
+			Py_RETURN_NONE;
+		}
+		Py_INCREF(read_str);
+		if(cur_str)
+		{
+			tmp = IoIn__Concat(self, cur_str, read_str);
+			Py_INCREF(tmp);
+			cur_str = tmp;
+		}
+		else
+		{
+			cur_str = read_str;
+		}
+
+		if(buff[sz-1] == '\n')
+		{
+			if(PyList_Append(res, cur_str))
+			{
+				Py_DECREF(cur_str);
+				Py_RETURN_NONE;
+			}
+			Py_DECREF(cur_str);
+			cur_str = NULL;
+		}
+	}
+	if(cur_str)
+	{
+		if(PyList_Append(res, cur_str))
+		{
+			Py_DECREF(cur_str);
+			Py_RETURN_NONE;
+		}
+		Py_DECREF(cur_str);
+	}
+	Py_DECREF(res);
+	return res;
+}
+
+PyObject* pyfcgi_ioin_read(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	size_t left, sz, max;
+	long l;
+	int read_n, toread;
+	PyObject *res, *read_str;
+	char *buff;
+
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc > 1)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.read() expecting at most 1 argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+
+	if(((IoIn*)self)->eof)
+	{
+		return IoIn__FromString(self, "");
+	}
+	max = 0;
+	if(argc)
+	{
+		l = PyLong_AsLong(argv[0]);
+		if(PyErr_Occurred() || l > 0)
+		{
+			PyErr_Clear();
+			max = PyLong_AsSize_t(argv[0]);
+			if(PyErr_Occurred())
+			{
+				Py_RETURN_NONE;
+			}
+		}
+	}
+	left = max;
+	read_n = pyfcgi_ioin__reqbuf(self, 0);
+	buff = ((IoIn*)self)->buff;
+	if(!(res = IoIn__FromString(self, "")))
+	{
+		Py_RETURN_NONE;
+	}
+	while((max && left) || !max)
+	{
+		toread = (max&&((size_t)read_n > left))?(int)left:read_n;
+		if(FCGX_GetStr(buff, toread, *((IoIn*)self)->in_stream) < toread)
+		{
+			((IoIn*)self)->eof = 1;
+			break;
+		}
+		sz = strlen(buff);
+		left -= sz;
+		if(!(read_str = IoIn__FromBuff(self)))
+		{
+			Py_RETURN_NONE;
+		}
+		Py_INCREF(read_str);
+		if(!(res = IoIn__Concat(self, res, read_str)))
+		{
+			Py_RETURN_NONE;
+		}
+		Py_INCREF(res);
+	}
+	Py_DECREF(res);
+	return res;
+}
+
+PyObject* pyfcgi_ioin_readall(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.readall() not expecting any argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+	return pyfcgi_ioin_read(self, NULL, 0);
+}
+
+PyObject* pyfcgi_ioin_readinto(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	PyObject *b;
+	Py_ssize_t max, left, read_n;
+	char *buff, *buff_ptr;
+	int toread, ret;
+
+	if(_check_nullin(self)) { Py_RETURN_NONE; }
+	if(argc != 1)
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.readinto() expecting 1 argument but %zd given",
+			argc);
+		Py_RETURN_NONE;
+	}
+	b = argv[0];
+	if(!PyByteArray_Check(b))
+	{
+		PyErr_Format(PyExc_ValueError,
+			"libpyfcgi.IoIn.readinto() expected bytearray as argument but %A given",
+			b);
+		Py_RETURN_NONE;
+	}
+	left = max = PyByteArray_Size(b);
+	buff = PyByteArray_AsString(b);
+	buff_ptr = buff;
+	read_n = pyfcgi_ioin__reqbuf(self, 0);
+	while(left)
+	{
+		toread = left>read_n?read_n:left;
+		if((ret = FCGX_GetStr(buff_ptr, toread,
+			*((IoIn*)self)->in_stream)) < toread)
+		{
+			((IoIn*)self)->eof = 1;
+			break;
+		}
+		buff_ptr += ret;
+		left -= ret;
+
+	}
+	return b;
+}	
+
+
+PyObject* pyfcgi_ioin_truncate(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	PyErr_SetString(PyExc_OSError, "libpyfcgi.IoIn cannot be truncated");
+	Py_RETURN_NONE;
+}
+
+PyObject* pyfcgi_ioin_SeekError(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	PyErr_SetString(PyExc_OSError, "libpyfcgi.IoIn is not seekable");
+	Py_RETURN_NONE;
+}
+
+PyObject* pyfcgi_ioin_WriteError(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	PyErr_SetString(PyExc_OSError, "libpyfcgi.IoIn is not writable");
+	Py_RETURN_NONE;
+}
+
+PyObject* pyfcgi_ioin_seekable(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	return Py_False;
+}
+
+PyObject* pyfcgi_ioin_writable(PyObject *self, PyObject **argv, Py_ssize_t argc)
+{
+	return Py_False;
+}
+
+
+static int _check_nullin(PyObject *self)
+{
+	if(!((IoIn*)self)->in_stream)
+	{
+		PyErr_SetString(PyExc_RuntimeError,
+			"pyfcgi.IoIn called in wrong context : FGCI input not set");
+		return -1;
+	}
+	else if(!(*(((IoIn*)self)->in_stream)))
+	{
+		PyErr_SetString(PyExc_RuntimeError,
+			"pyfcgi.IoIn called in wrong context : FGCI input is NULL");
+		return -2;
+	}
+	return 0;
+}
+
+static int pyfcgi_ioin__reqbuf(PyObject *self, int nreq)
+{
+	IoIn *ioin;
+	void *tmp;
+	int err;
+
+	ioin = (IoIn*)self;
+
+	if(ioin->buff_sz > nreq && ioin->buff)
+	{
+		return ioin->buff_sz;
+	}
+	
+	ioin->buff_sz = ((nreq>>12)+1)<<12;
+	if(ioin->buff_sz < nreq) { ioin->buff_sz = nreq; }
+
+	if(!(tmp = realloc(ioin->buff, ioin->buff_sz)))
+	{
+		err = errno;
+		PyErr_Format(PyExc_OSError,
+			"%A error reallocating internal buffer : %s",
+			self, strerror(err));
+		errno = err;
+		return 0;
+	}
+	ioin->buff = tmp;
+	return ioin->buff_sz;
+}
+
+/**@brief Concat two bytes/unicode given IoIn configuration flag
+ * @warn Py_DECREF both arguments
+ */
+static PyObject* IoIn__Concat(PyObject *self, PyObject *left, PyObject *right)
+{
+	if(((IoIn*)self)->bin)
+	{
+		PyBytes_Concat(&left, right);
+		Py_DECREF(right);
+		return left;
+	}
+	PyObject *res;
+	res = PyUnicode_Concat(left, right);
+	Py_DECREF(left);
+	Py_DECREF(right);
+	return res;
+}
+
+
+

src/python_pyfcgi.c

@@ -21,8 +21,9 @@
 
 /* Globals definitions */
 /* libpyfcgi context */
-libpyfcgi_context_t libpyfcgi = { NULL, NULL, NULL, 0, NULL, NULL, 0 };
+libpyfcgi_context_t libpyfcgi = { NULL, NULL, NULL, NULL, 0, NULL, NULL, 0 };
 /* Python module methods specs */
+/**@todo Add doc in last field */
 PyMethodDef pyfcgimodule_methods[] = {
 	{"start_response", (PyCFunction)pyfcgi_start_response, METH_FASTCALL, NULL},
 	{"write_body", (PyCFunction)pyfcgi_write_body, METH_FASTCALL, NULL},
@@ -300,12 +301,41 @@ PyInit_libpyfcgi(void)
 	{
 		return libpyfcgi.self;
 	}
+
+	// init IoIn type
+	IoInType.tp_new = PyType_GenericNew;
+	if(PyType_Ready(&IoInType) < 0)
+	{
+		return NULL;
+	}
+
 	// init module & globals
 	libpyfcgi.status = NULL;
 	libpyfcgi.headers = NULL;
 	libpyfcgi.rep_sz = 0;
 	libpyfcgi.self = PyModule_Create(&pyfcgimodule);
 	if(libpyfcgi.self == NULL) { return NULL; }
+
+	// Add type to module (optionnal)
+	PyModule_AddObject(libpyfcgi.self, "IoIn", (PyObject*)&IoInType);
+
+	// Create a new instance of IoIn
+	libpyfcgi.ioin = (IoIn*)PyObject_CallObject((PyObject*)&IoInType, NULL);
+	Py_INCREF(libpyfcgi.ioin);
+	if(!libpyfcgi.ioin)
+	{
+		return NULL;
+	}
+	libpyfcgi.ioin->in_stream = &libpyfcgi.in; // point on stream pointer
+	libpyfcgi.ioin->bin = 1; // binary stream (bytes for python)
+
+	// Add it to wsgi dict
+	if(PyDict_SetItemString(PyFCGI_conf.context.wsgi_dict, "wsgi.input",
+		(PyObject*)libpyfcgi.ioin))
+	{
+		return NULL;
+	}
+
 	return libpyfcgi.self;
 }
 

src/pyutils.c

@@ -3,7 +3,8 @@
 void pyinit()
 {
 	char *venv_path;
-	PyObject *sitemod, *mainfun;
+	PyObject *sitemod, *mainfun, *wsgi;
+
 
 	if( (venv_path = getenv("VIRTUAL_ENV")) )
 	{
@@ -27,6 +28,14 @@ void pyinit()
 	//Append "." to sys.path
 	sitemod = PySys_GetObject("path");
 	PyList_Append(sitemod, PyUnicode_FromString("."));
+
+	//Initialize the wsgi PEP333 dict
+	wsgi = PyFCGI_conf.context.wsgi_dict = PyDict_New();
+	PyDict_SetItemString(wsgi, "wsgi.version", Py_BuildValue("ii", 1,0));
+
+	PyDict_SetItemString(wsgi, "wsgi.multithread", Py_False);
+	PyDict_SetItemString(wsgi, "wsgi.multiprocess", Py_True);
+	PyDict_SetItemString(wsgi, "wsgi.run_once", Py_False);
 }
 
 void update_python_path()
@@ -270,6 +279,9 @@ void update_python_fd(int pipe_out[2], int pipe_err[2])
 		goto update_python_fd_err_args;
 	}
 	Py_DECREF(args);
+
+	PyDict_SetItemString(PyFCGI_conf.context.wsgi_dict, "wsgi.errors", new_fd);
+
 	if(PySys_SetObject("stderr", new_fd))
 	{
 		pyfcgi_log(LOG_ERR, "Unable to set sys.stderr");
@@ -367,6 +379,11 @@ PyObject* update_pyenv(PyObject *py_osmod, char **environ)
 		Py_DECREF(pykey);
 		cur++;
 	}
+	/**@todo set given headers */
+	PyDict_SetItemString(PyFCGI_conf.context.wsgi_dict, "wsgi.url_scheme",
+		Py_BuildValue("U", "http"));
+
+	PyDict_Update(pyenv, PyFCGI_conf.context.wsgi_dict);
 	PyObject_SetAttrString(py_osmod, "environ", pyenv);
 	return pyenv;
 }

src/pyworker.c

@@ -90,6 +90,7 @@ int work333(int wrk_id, int semid)
 
 		libpyfcgi_clean_response();
 		libpyfcgi.out = out_stream;
+		libpyfcgi.in = in_stream;
 		args = Py_BuildValue("OO", environ, start_response);
 		entry_ret = PyObject_CallObject(entry_fun, args);
 		if(entry_ret && entry_ret != Py_None )