PyFCGI/src/python_ioin.c

#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 = "";
	}
//dprintf(2, "readline : '%s'\n", 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')
		{
//dprintf(2, "readlines : '%s'\n", PyUnicode_AsUTF8(cur_str));
			if(PyList_Append(res, cur_str))
			{
				Py_DECREF(cur_str);
				Py_RETURN_NONE;
			}
			Py_DECREF(cur_str);
			cur_str = NULL;
		}
	}
	if(cur_str)
	{
//dprintf(2, "readlines(post) : '%s'\n", PyUnicode_AsUTF8(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, max;
	long l;
	int read_n, toread, sz;
	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;
	}
	Py_INCREF(res);
	while((max && left) || !max)
	{
		toread = (max&&((size_t)read_n > left))?(int)left:read_n;
		sz = FCGX_GetStr(buff, toread, *((IoIn*)self)->in_stream);
		if(sz)
		{
			if(sz == toread) { buff[sz] = '\0'; }
			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);
		}

		if( sz < toread)
		{
			((IoIn*)self)->eof = 1;
			break;
		}
	}
//dprintf(2, "read : %s\n", PyBytes_AsString(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;
	}
dprintf(2, "readall calling read : ");
	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;

	}
//dprintf(2, "readinto chr buff : '%s'\n", buff);
//dprintf(2, "readinto bytes repr : '%s'\n", PyByteArray_AsString(b));
	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;
}