/* Author: Daniel Stutzbach */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stddef.h> /* For offsetof */

/*

 * Known likely problems:

 *

 * - Files larger then 2**32-1

 * - Files with unicode filenames

 * - Passing numbers greater than 2**32-1 when an integer is expected

 * - Making it work on Windows and other oddball platforms

 *

 * To Do:

 *

 * - autoconfify header file inclusion

 */

#ifdef MS_WINDOWS

/* can simulate truncate with Win32 API functions; see file_truncate */

#define HAVE_FTRUNCATE

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#endif

typedef struct {

	PyObject_HEAD

	int fd;

	unsigned readable : 1;

	unsigned writable : 1;

	int seekable : 2; /* -1 means unknown */

	int closefd : 1;

	PyObject *weakreflist;

} PyFileIOObject;

PyTypeObject PyFileIO_Type;

#define PyFileIO_Check(op) (PyObject_TypeCheck((op), &PyFileIO_Type))

/* Returns 0 on success, errno (which is < 0) on failure. */

static int

internal_close(PyFileIOObject *self)

{

	int save_errno = 0;

	if (self->fd >= 0) {

		int fd = self->fd;

		self->fd = -1;

		Py_BEGIN_ALLOW_THREADS

		if (close(fd) < 0)

			save_errno = errno;

		Py_END_ALLOW_THREADS

	}

	return save_errno;

}

static PyObject *

fileio_close(PyFileIOObject *self)

{

	if (!self->closefd) {

		if (PyErr_WarnEx(PyExc_RuntimeWarning,

				 "Trying to close unclosable fd!", 3) < 0) {

			return NULL;

		}

		Py_RETURN_NONE;

	}

	errno = internal_close(self);

	if (errno < 0) {

		PyErr_SetFromErrno(PyExc_IOError);

		return NULL;

	}

	Py_RETURN_NONE;

}

static PyObject *

fileio_new(PyTypeObject *type, PyObject *args, PyObject *kews)

{

	PyFileIOObject *self;

	assert(type != NULL && type->tp_alloc != NULL);

	self = (PyFileIOObject *) type->tp_alloc(type, 0);

	if (self != NULL) {

		self->fd = -1;

		self->readable = 0;

		self->writable = 0;

		self->seekable = -1;

		self->closefd = 1;

		self->weakreflist = NULL;

	}

	return (PyObject *) self;

}

/* On Unix, open will succeed for directories.

   In Python, there should be no file objects referring to

   directories, so we need a check.  */

static int

dircheck(PyFileIOObject* self)

{

#if defined(HAVE_FSTAT) && defined(S_IFDIR) && defined(EISDIR)

	struct stat buf;

	if (self->fd < 0)

		return 0;

	if (fstat(self->fd, &buf) == 0 && S_ISDIR(buf.st_mode)) {

		char *msg = strerror(EISDIR);

		PyObject *exc;

		internal_close(self);

		exc = PyObject_CallFunction(PyExc_IOError, "(is)",

					    EISDIR, msg);

		PyErr_SetObject(PyExc_IOError, exc);

		Py_XDECREF(exc);

		return -1;

	}

#endif

	return 0;

}

static int

fileio_init(PyObject *oself, PyObject *args, PyObject *kwds)

{

	PyFileIOObject *self = (PyFileIOObject *) oself;

	static char *kwlist[] = {"file", "mode", "closefd", NULL};

	char *name = NULL;

	char *mode = "r";

	char *s;

#ifdef MS_WINDOWS

	Py_UNICODE *widename = NULL;

#endif

	int ret = 0;

	int rwa = 0, plus = 0, append = 0;

	int flags = 0;

	int fd = -1;

	int closefd = 1;

	assert(PyFileIO_Check(oself));

	if (self->fd >= 0) {

		/* Have to close the existing file first. */

		if (internal_close(self) < 0)

			return -1;

	}

	if (PyArg_ParseTupleAndKeywords(args, kwds, "i|si:fileio",

					kwlist, &fd, &mode, &closefd)) {

		if (fd < 0) {

			PyErr_SetString(PyExc_ValueError,

					"Negative filedescriptor");

			return -1;

		}

	}

	else {

		PyErr_Clear();

#ifdef Py_WIN_WIDE_FILENAMES

	    if (GetVersion() < 0x80000000) {

		/* On NT, so wide API available */

		PyObject *po;

		if (PyArg_ParseTupleAndKeywords(args, kwds, "U|si:fileio",

						kwlist, &po, &mode, &closefd)

						) {

			widename = PyUnicode_AS_UNICODE(po);

		} else {

			/* Drop the argument parsing error as narrow

			   strings are also valid. */

			PyErr_Clear();

		}

	    }

	    if (widename == NULL)

#endif

	    {

		if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|si:fileio",

						 kwlist,

						 Py_FileSystemDefaultEncoding,

						 &name, &mode, &closefd))

			return -1;

	    }

	}

	s = mode;

	while (*s) {

		switch (*s++) {

		case 'r':

			if (rwa) {

			bad_mode:

				PyErr_SetString(PyExc_ValueError,

						"Must have exactly one of read/write/append mode");

				goto error;

			}

			rwa = 1;

			self->readable = 1;

			break;

		case 'w':

			if (rwa)

				goto bad_mode;

			rwa = 1;

			self->writable = 1;

			flags |= O_CREAT | O_TRUNC;

			break;

		case 'a':

			if (rwa)

				goto bad_mode;

			rwa = 1;

			self->writable = 1;

			flags |= O_CREAT;

			append = 1;

			break;

		case '+':

			if (plus)

				goto bad_mode;

			self->readable = self->writable = 1;

			plus = 1;

			break;

		default:

			PyErr_Format(PyExc_ValueError,

				     "invalid mode: %.200s", mode);

			goto error;

		}

	}

	if (!rwa)

		goto bad_mode;

	if (self->readable && self->writable)

		flags |= O_RDWR;

	else if (self->readable)

		flags |= O_RDONLY;

	else

		flags |= O_WRONLY;

#ifdef O_BINARY

	flags |= O_BINARY;

#endif

#ifdef O_APPEND

	if (append)

		flags |= O_APPEND;

#endif

	if (fd >= 0) {

		self->fd = fd;

		self->closefd = closefd;

	}

	else {

		self->closefd = 1;

		if (!closefd) {

			PyErr_SetString(PyExc_ValueError,

                            "Cannot use closefd=False with file name");

			goto error;

		}

		Py_BEGIN_ALLOW_THREADS

		errno = 0;

#ifdef MS_WINDOWS

		if (widename != NULL)

			self->fd = _wopen(widename, flags, 0666);

		else

#endif

			self->fd = open(name, flags, 0666);

		Py_END_ALLOW_THREADS

		if (self->fd < 0) {

#ifdef MS_WINDOWS

			PyErr_SetFromErrnoWithUnicodeFilename(PyExc_IOError, widename);

#else

			PyErr_SetFromErrnoWithFilename(PyExc_IOError, name);

#endif

			goto error;

		}

		if(dircheck(self) < 0)

			goto error;

	}

	goto done;

 error:

	ret = -1;

 done:

	PyMem_Free(name);

	return ret;

}

static void

fileio_dealloc(PyFileIOObject *self)

{

	if (self->weakreflist != NULL)

		PyObject_ClearWeakRefs((PyObject *) self);

	if (self->fd >= 0 && self->closefd) {

		errno = internal_close(self);

		if (errno < 0) {

			PySys_WriteStderr("close failed: [Errno %d] %s\n",

                                          errno, strerror(errno));

		}

	}

	Py_TYPE(self)->tp_free((PyObject *)self);

}

static PyObject *

err_closed(void)

{

	PyErr_SetString(PyExc_ValueError, "I/O operation on closed file");

	return NULL;

}

static PyObject *

err_mode(char *action)

{

	PyErr_Format(PyExc_ValueError, "File not open for %s", action);

	return NULL;

}

static PyObject *

fileio_fileno(PyFileIOObject *self)

{

	if (self->fd < 0)

		return err_closed();

	return PyInt_FromLong((long) self->fd);

}

static PyObject *

fileio_readable(PyFileIOObject *self)

{

	if (self->fd < 0)

		return err_closed();

	return PyBool_FromLong((long) self->readable);

}

static PyObject *

fileio_writable(PyFileIOObject *self)

{

	if (self->fd < 0)

		return err_closed();

	return PyBool_FromLong((long) self->writable);

}

static PyObject *

fileio_seekable(PyFileIOObject *self)

{

	if (self->fd < 0)

		return err_closed();

	if (self->seekable < 0) {

		int ret;

		Py_BEGIN_ALLOW_THREADS

		ret = lseek(self->fd, 0, SEEK_CUR);

		Py_END_ALLOW_THREADS

		if (ret < 0)

			self->seekable = 0;

		else

			self->seekable = 1;

	}

	return PyBool_FromLong((long) self->seekable);

}

static PyObject *

fileio_readinto(PyFileIOObject *self, PyObject *args)

{

	Py_buffer pbuf;

	Py_ssize_t n;

	if (self->fd < 0)

		return err_closed();

	if (!self->readable)

		return err_mode("reading");

	if (!PyArg_ParseTuple(args, "w*", &pbuf))

		return NULL;

	Py_BEGIN_ALLOW_THREADS

	errno = 0;

	n = read(self->fd, pbuf.buf, pbuf.len);

	Py_END_ALLOW_THREADS

	PyBuffer_Release(&pbuf);

	if (n < 0) {

		if (errno == EAGAIN)

			Py_RETURN_NONE;

		PyErr_SetFromErrno(PyExc_IOError);

		return NULL;

	}

	return PyLong_FromSsize_t(n);

}

#define DEFAULT_BUFFER_SIZE (8*1024)

static PyObject *

fileio_readall(PyFileIOObject *self)

{

	PyObject *result;

	Py_ssize_t total = 0;

	int n;

	result = PyString_FromStringAndSize(NULL, DEFAULT_BUFFER_SIZE);

	if (result == NULL)

		return NULL;

	while (1) {

		Py_ssize_t newsize = total + DEFAULT_BUFFER_SIZE;

		if (PyString_GET_SIZE(result) < newsize) {

			if (_PyString_Resize(&result, newsize) < 0) {

				if (total == 0) {

					Py_DECREF(result);

					return NULL;

				}

				PyErr_Clear();

				break;

			}

		}

		Py_BEGIN_ALLOW_THREADS

		errno = 0;

		n = read(self->fd,

			 PyString_AS_STRING(result) + total,

			 newsize - total);

		Py_END_ALLOW_THREADS

		if (n == 0)

			break;

		if (n < 0) {

			if (total > 0)

				break;

			if (errno == EAGAIN) {

				Py_DECREF(result);

				Py_RETURN_NONE;

			}

			Py_DECREF(result);

			PyErr_SetFromErrno(PyExc_IOError);

			return NULL;

		}

		total += n;

	}

	if (PyString_GET_SIZE(result) > total) {

		if (_PyString_Resize(&result, total) < 0) {

			/* This should never happen, but just in case */

			Py_DECREF(result);

			return NULL;

		}

	}

	return result;

}

static PyObject *

fileio_read(PyFileIOObject *self, PyObject *args)

{

	char *ptr;

	Py_ssize_t n;

	Py_ssize_t size = -1;

	PyObject *bytes;

	if (self->fd < 0)

		return err_closed();

	if (!self->readable)

		return err_mode("reading");

	if (!PyArg_ParseTuple(args, "|n", &size))

		return NULL;

        if (size < 0) {

		return fileio_readall(self);

	}

	bytes = PyString_FromStringAndSize(NULL, size);

	if (bytes == NULL)

		return NULL;

	ptr = PyString_AS_STRING(bytes);

	Py_BEGIN_ALLOW_THREADS

	errno = 0;

	n = read(self->fd, ptr, size);

	Py_END_ALLOW_THREADS

	if (n < 0) {

		if (errno == EAGAIN)

			Py_RETURN_NONE;

		PyErr_SetFromErrno(PyExc_IOError);

		return NULL;

	}

	if (n != size) {

		if (_PyString_Resize(&bytes, n) < 0) {

			Py_DECREF(bytes);

			return NULL;

		}

	}

	return (PyObject *) bytes;

}

static PyObject *

fileio_write(PyFileIOObject *self, PyObject *args)

{

	Py_buffer pbuf;

	Py_ssize_t n;

	if (self->fd < 0)

		return err_closed();

	if (!self->writable)

		return err_mode("writing");

	if (!PyArg_ParseTuple(args, "s*", &pbuf))

		return NULL;

	Py_BEGIN_ALLOW_THREADS

	errno = 0;

	n = write(self->fd, pbuf.buf, pbuf.len);

	Py_END_ALLOW_THREADS

	PyBuffer_Release(&pbuf);

	if (n < 0) {

		if (errno == EAGAIN)

			Py_RETURN_NONE;

		PyErr_SetFromErrno(PyExc_IOError);

		return NULL;

	}

	return PyLong_FromSsize_t(n);

}

/* XXX Windows support below is likely incomplete */

#if defined(MS_WIN64) || defined(MS_WINDOWS)