#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

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

#ifdef MS_WINDOWS

#define HAVE_FTRUNCATE

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

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))

static PyObject *

portable_lseek(int fd, PyObject *posobj, int whence);

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) {

self->fd = -1;

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;

}

static int

dircheck(PyFileIOObject* self, char *name)

{

#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, "(iss)",

EISDIR, msg, name);

PyErr_SetObject(PyExc_IOError, exc);

Py_XDECREF(exc);

return -1;

}

return 0;

}

static int

check_fd(int fd)

{

#if defined(HAVE_FSTAT)

struct stat buf;

if (fstat(fd, &buf) < 0 && errno == EBADF) {

PyObject *exc;

char *msg = strerror(EBADF);

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

EBADF, msg);

PyErr_SetObject(PyExc_OSError, exc);

Py_XDECREF(exc);

return -1;

}

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;

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;

}

if (check_fd(fd))

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

PyErr_Clear();

}

}

if (widename == NULL)

{

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 'b':

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;

#ifdef O_APPEND

if (append)

flags |= O_APPEND;

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

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

Py_END_ALLOW_THREADS

if (self->fd < 0) {

#ifdef MS_WINDOWS

if (widename != NULL)

PyErr_SetFromErrnoWithUnicodeFilename(PyExc_IOError, widename);

else

PyErr_SetFromErrnoWithFilename(PyExc_IOError, name);

goto error;

}

if(dircheck(self, name) < 0)

goto error;

}

if (append) {

/* For consistent behaviour, we explicitly seek to the

PyObject *pos = portable_lseek(self->fd, NULL, 2);

if (pos == NULL)

goto error;

Py_DECREF(pos);

}

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);

}

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

typedef PY_LONG_LONG Py_off_t;

typedef off_t Py_off_t;

static PyObject *

portable_lseek(int fd, PyObject *posobj, int whence)

{

Py_off_t pos, res;

#ifdef SEEK_SET

/* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */

switch (whence) {

#if SEEK_SET != 0

case 0: whence = SEEK_SET; break;

#if SEEK_CUR != 1

case 1: whence = SEEK_CUR; break;

#if SEEK_END != 2

case 2: whence = SEEK_END; break;

}

#endif /* SEEK_SET */

if (posobj == NULL)

pos = 0;

else {

if(PyFloat_Check(posobj)) {

PyErr_SetString(PyExc_TypeError, "an integer is required");

return NULL;

}

#if defined(HAVE_LARGEFILE_SUPPORT)

pos = PyLong_AsLongLong(posobj);

pos = PyLong_AsLong(posobj);

if (PyErr_Occurred())

return NULL;

}

Py_BEGIN_ALLOW_THREADS

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

res = _lseeki64(fd, pos, whence);

res = lseek(fd, pos, whence);

Py_END_ALLOW_THREADS

if (res < 0)

return PyErr_SetFromErrno(PyExc_IOError);

#if defined(HAVE_LARGEFILE_SUPPORT)

return PyLong_FromLongLong(res);

return PyLong_FromLong(res);

}

static PyObject *

fileio_seek(PyFileIOObject *self, PyObject *args)

{

PyObject *posobj;

int whence = 0;

if (self->fd < 0)

return err_closed();

if (!PyArg_ParseTuple(args, "O|i", &posobj, &whence))

return NULL;

return portable_lseek(self->fd, posobj, whence);

}

static PyObject *

fileio_tell(PyFileIOObject *self, PyObject *args)

{

if (self->fd < 0)

return err_closed();

return portable_lseek(self->fd, NULL, 1);

}

#ifdef HAVE_FTRUNCATE

static PyObject *

fileio_truncate(PyFileIOObject *self, PyObject *args)

{

PyObject *posobj = NULL;

Py_off_t pos;

int ret;

int fd;

fd = self->fd;

if (fd < 0)

return err_closed();

if (!self->writable)

return err_mode("writing");

if (!PyArg_ParseTuple(args, "|O", &posobj))

return NULL;

if (posobj == Py_None || posobj == NULL) {

/* Get the current position. */

posobj = portable_lseek(fd, NULL, 1);

if (posobj == NULL)

return NULL;

}

else {

/* Move to the position to be truncated. */

posobj = portable_lseek(fd, posobj, 0);

}

#if defined(HAVE_LARGEFILE_SUPPORT)

pos = PyLong_AsLongLong(posobj);

pos = PyLong_AsLong(posobj);

if (PyErr_Occurred())

return NULL;

#ifdef MS_WINDOWS

/* MS _chsize doesn't work if newsize doesn't fit in 32 bits,

{

HANDLE hFile;

/* Truncate. Note that this may grow the file! */

Py_BEGIN_ALLOW_THREADS

errno = 0;

hFile = (HANDLE)_get_osfhandle(fd);

ret = hFile == (HANDLE)-1;

if (ret == 0) {

ret = SetEndOfFile(hFile) == 0;

if (ret)

errno = EACCES;

}

Py_END_ALLOW_THREADS

}

Py_BEGIN_ALLOW_THREADS

errno = 0;

ret = ftruncate(fd, pos);

Py_END_ALLOW_THREADS

#endif /* !MS_WINDOWS */

if (ret != 0) {

PyErr_SetFromErrno(PyExc_IOError);

return NULL;

}

return posobj;

}

static char *

mode_string(PyFileIOObject *self)

{

if (self->readable) {

if (self->writable)

return "rb+";

else

return "rb";

}

else

return "wb";

}

static PyObject *

fileio_repr(PyFileIOObject *self)

{

if (self->fd < 0)

return PyString_FromFormat("_fileio._FileIO(-1)");

return PyString_FromFormat("_fileio._FileIO(%d, '%s')",

self->fd, mode_string(self));

}

static PyObject *

fileio_isatty(PyFileIOObject *self)

{

long res;

if (self->fd < 0)

return err_closed();

Py_BEGIN_ALLOW_THREADS

res = isatty(self->fd);

Py_END_ALLOW_THREADS

return PyBool_FromLong(res);

}

PyDoc_STRVAR(fileio_doc,

"reading and writing.");

PyDoc_STRVAR(read_doc,

"On end-of-file, returns ''.");

PyDoc_STRVAR(readall_doc,

"or None if no data is available. On end-of-file, returns ''.");

PyDoc_STRVAR(write_doc,

"The number of bytes actually written is returned.");

PyDoc_STRVAR(fileno_doc,

"This is needed for lower-level file interfaces, such the fcntl module.");

PyDoc_STRVAR(seek_doc,

"Note that not all file objects are seekable.");

#ifdef HAVE_FTRUNCATE

PyDoc_STRVAR(truncate_doc,

"The current file position is changed to the value of size.");

PyDoc_STRVAR(tell_doc,

"tell() -> int. Current file position");

PyDoc_STRVAR(readinto_doc,

"readinto() -> Undocumented. Don't use this; it may go away.");

PyDoc_STRVAR(close_doc,

"called more than once without error. Changes the fileno to -1.");

PyDoc_STRVAR(isatty_doc,

"isatty() -> bool. True if the file is connected to a tty device.");

PyDoc_STRVAR(seekable_doc,

"seekable() -> bool. True if file supports random-access.");

PyDoc_STRVAR(readable_doc,

"readable() -> bool. True if file was opened in a read mode.");

PyDoc_STRVAR(writable_doc,

"writable() -> bool. True if file was opened in a write mode.");

static PyMethodDef fileio_methods[] = {

{"read", (PyCFunction)fileio_read, METH_VARARGS, read_doc},

{"readall", (PyCFunction)fileio_readall, METH_NOARGS, readall_doc},

{"readinto", (PyCFunction)fileio_readinto, METH_VARARGS, readinto_doc},

{"write", (PyCFunction)fileio_write, METH_VARARGS, write_doc},

{"seek", (PyCFunction)fileio_seek, METH_VARARGS, seek_doc},

{"tell", (PyCFunction)fileio_tell, METH_VARARGS, tell_doc},

#ifdef HAVE_FTRUNCATE

{"truncate", (PyCFunction)fileio_truncate, METH_VARARGS, truncate_doc},

{"close", (PyCFunction)fileio_close, METH_NOARGS, close_doc},

{"seekable", (PyCFunction)fileio_seekable, METH_NOARGS, seekable_doc},

{"readable", (PyCFunction)fileio_readable, METH_NOARGS, readable_doc},

{"writable", (PyCFunction)fileio_writable, METH_NOARGS, writable_doc},

{"fileno", (PyCFunction)fileio_fileno, METH_NOARGS, fileno_doc},

{"isatty", (PyCFunction)fileio_isatty, METH_NOARGS, isatty_doc},

{NULL, NULL} /* sentinel */

};

static PyObject *

get_closed(PyFileIOObject *self, void *closure)

{

return PyBool_FromLong((long)(self->fd < 0));

}

static PyObject *

get_closefd(PyFileIOObject *self, void *closure)

{

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

}

static PyObject *

get_mode(PyFileIOObject *self, void *closure)

{

return PyString_FromString(mode_string(self));

}

static PyGetSetDef fileio_getsetlist[] = {

{"closed", (getter)get_closed, NULL, "True if the file is closed"},

{"closefd", (getter)get_closefd, NULL,

"True if the file descriptor will be closed"},

{"mode", (getter)get_mode, NULL, "String giving the file mode"},

{0},

};

PyTypeObject PyFileIO_Type = {

PyVarObject_HEAD_INIT(NULL, 0)

"_FileIO",

sizeof(PyFileIOObject),

0,

(destructor)fileio_dealloc, /* tp_dealloc */

0, /* tp_print */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_compare */

(reprfunc)fileio_repr, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */

fileio_doc, /* tp_doc */

0, /* tp_traverse */

0, /* tp_clear */

0, /* tp_richcompare */

offsetof(PyFileIOObject, weakreflist), /* tp_weaklistoffset */

0, /* tp_iter */

0, /* tp_iternext */

fileio_methods, /* tp_methods */

0, /* tp_members */

fileio_getsetlist, /* tp_getset */

0, /* tp_base */

0, /* tp_dict */

0, /* tp_descr_get */

0, /* tp_descr_set */

0, /* tp_dictoffset */

fileio_init, /* tp_init */

PyType_GenericAlloc, /* tp_alloc */

fileio_new, /* tp_new */

PyObject_Del, /* tp_free */

};

static PyMethodDef module_methods[] = {

{NULL, NULL}

};

init_fileio(void)

{

PyObject *m; /* a module object */

m = Py_InitModule3("_fileio", module_methods,

"Fast implementation of io.FileIO.");

if (m == NULL)

return;

if (PyType_Ready(&PyFileIO_Type) < 0)

return;

Py_INCREF(&PyFileIO_Type);

PyModule_AddObject(m, "_FileIO", (PyObject *) &PyFileIO_Type);

}