/* File object implementation */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */

#ifdef MS_WINDOWS

#define fileno _fileno

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

#define HAVE_FTRUNCATE

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#endif

#ifdef _MSC_VER

/* Need GetVersion to see if on NT so safe to use _wfopen */

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#endif /* _MSC_VER */

#if defined(PYOS_OS2) && defined(PYCC_GCC)

#include <io.h>

#endif

#define BUF(v) PyString_AS_STRING((PyStringObject *)v)

#ifndef DONT_HAVE_ERRNO_H

#include <errno.h>

#endif

#ifdef HAVE_GETC_UNLOCKED

#define GETC(f) getc_unlocked(f)

#define FLOCKFILE(f) flockfile(f)

#define FUNLOCKFILE(f) funlockfile(f)

#else

#define GETC(f) getc(f)

#define FLOCKFILE(f)

#define FUNLOCKFILE(f)

#endif

/* Bits in f_newlinetypes */

#define NEWLINE_UNKNOWN	0	/* No newline seen, yet */

#define NEWLINE_CR 1		/* \r newline seen */

#define NEWLINE_LF 2		/* \n newline seen */

#define NEWLINE_CRLF 4		/* \r\n newline seen */

/*

 * These macros release the GIL while preventing the f_close() function being

 * called in the interval between them.  For that purpose, a running total of

 * the number of currently running unlocked code sections is kept in

 * the unlocked_count field of the PyFileObject. The close() method raises

 * an IOError if that field is non-zero.  See issue #815646, #595601.

 */

#define FILE_BEGIN_ALLOW_THREADS(fobj) \

{ \

	fobj->unlocked_count++; \

	Py_BEGIN_ALLOW_THREADS

#define FILE_END_ALLOW_THREADS(fobj) \

	Py_END_ALLOW_THREADS \

	fobj->unlocked_count--; \

	assert(fobj->unlocked_count >= 0); \

}

#define FILE_ABORT_ALLOW_THREADS(fobj) \

	Py_BLOCK_THREADS \

	fobj->unlocked_count--; \

	assert(fobj->unlocked_count >= 0);

#ifdef __cplusplus

extern "C" {

#endif

FILE *

PyFile_AsFile(PyObject *f)

{

	if (f == NULL || !PyFile_Check(f))

		return NULL;

	else

		return ((PyFileObject *)f)->f_fp;

}

void PyFile_IncUseCount(PyFileObject *fobj)

{

	fobj->unlocked_count++;

}

void PyFile_DecUseCount(PyFileObject *fobj)

{

	fobj->unlocked_count--;

	assert(fobj->unlocked_count >= 0);

}

PyObject *

PyFile_Name(PyObject *f)

{

	if (f == NULL || !PyFile_Check(f))

		return NULL;

	else

		return ((PyFileObject *)f)->f_name;

}

/* This is a safe wrapper around PyObject_Print to print to the FILE

   of a PyFileObject. PyObject_Print releases the GIL but knows nothing

   about PyFileObject. */

static int

file_PyObject_Print(PyObject *op, PyFileObject *f, int flags)

{

	int result;

	PyFile_IncUseCount(f);

	result = PyObject_Print(op, f->f_fp, flags);

	PyFile_DecUseCount(f);

	return result;

}

/* On Unix, fopen will succeed for directories.

   In Python, there should be no file objects referring to

   directories, so we need a check.  */

static PyFileObject*

dircheck(PyFileObject* f)

{

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

	struct stat buf;

	if (f->f_fp == NULL)

		return f;

	if (fstat(fileno(f->f_fp), &buf) == 0 &&

	    S_ISDIR(buf.st_mode)) {

		char *msg = strerror(EISDIR);

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

						      EISDIR, msg);

		PyErr_SetObject(PyExc_IOError, exc);

		Py_XDECREF(exc);

		return NULL;

	}

#endif

	return f;

}

static PyObject *

fill_file_fields(PyFileObject *f, FILE *fp, PyObject *name, char *mode,

		 int (*close)(FILE *))

{

	assert(name != NULL);

	assert(f != NULL);

	assert(PyFile_Check(f));

	assert(f->f_fp == NULL);

	Py_DECREF(f->f_name);

	Py_DECREF(f->f_mode);

	Py_DECREF(f->f_encoding);

	Py_DECREF(f->f_errors);

        Py_INCREF(name);

        f->f_name = name;

	f->f_mode = PyString_FromString(mode);

	f->f_close = close;

	f->f_softspace = 0;

	f->f_binary = strchr(mode,'b') != NULL;

	f->f_buf = NULL;

	f->f_univ_newline = (strchr(mode, 'U') != NULL);

	f->f_newlinetypes = NEWLINE_UNKNOWN;

	f->f_skipnextlf = 0;

	Py_INCREF(Py_None);

	f->f_encoding = Py_None;

	Py_INCREF(Py_None);

	f->f_errors = Py_None;

	if (f->f_mode == NULL)

		return NULL;

	f->f_fp = fp;

        f = dircheck(f);

	return (PyObject *) f;

}

/* check for known incorrect mode strings - problem is, platforms are

   free to accept any mode characters they like and are supposed to

   ignore stuff they don't understand... write or append mode with

   universal newline support is expressly forbidden by PEP 278.

   Additionally, remove the 'U' from the mode string as platforms

   won't know what it is. Non-zero return signals an exception */

int

_PyFile_SanitizeMode(char *mode)

{

	char *upos;

	size_t len = strlen(mode);

	if (!len) {

		PyErr_SetString(PyExc_ValueError, "empty mode string");

		return -1;

	}

	upos = strchr(mode, 'U');

	if (upos) {

		memmove(upos, upos+1, len-(upos-mode)); /* incl null char */

		if (mode[0] == 'w' || mode[0] == 'a') {

			PyErr_Format(PyExc_ValueError, "universal newline "

			             "mode can only be used with modes "

				     "starting with 'r'");

			return -1;

		}

		if (mode[0] != 'r') {

			memmove(mode+1, mode, strlen(mode)+1);

			mode[0] = 'r';

		}

		if (!strchr(mode, 'b')) {

			memmove(mode+2, mode+1, strlen(mode));

			mode[1] = 'b';

		}

	} else if (mode[0] != 'r' && mode[0] != 'w' && mode[0] != 'a') {

		PyErr_Format(PyExc_ValueError, "mode string must begin with "

	        	    "one of 'r', 'w', 'a' or 'U', not '%.200s'", mode);

		return -1;

	}

	return 0;

}

static PyObject *

open_the_file(PyFileObject *f, char *name, char *mode)

{

	char *newmode;

	assert(f != NULL);

	assert(PyFile_Check(f));

#ifdef MS_WINDOWS

	/* windows ignores the passed name in order to support Unicode */

	assert(f->f_name != NULL);

#else

	assert(name != NULL);

#endif

	assert(mode != NULL);

	assert(f->f_fp == NULL);

	/* probably need to replace 'U' by 'rb' */

	newmode = PyMem_MALLOC(strlen(mode) + 3);

	if (!newmode) {

		PyErr_NoMemory();

		return NULL;

	}

	strcpy(newmode, mode);

	if (_PyFile_SanitizeMode(newmode)) {

		f = NULL;

		goto cleanup;

	}

	/* rexec.py can't stop a user from getting the file() constructor --

	   all they have to do is get *any* file object f, and then do

	   type(f).  Here we prevent them from doing damage with it. */

	if (PyEval_GetRestricted()) {

		PyErr_SetString(PyExc_IOError,

		"file() constructor not accessible in restricted mode");

		f = NULL;

		goto cleanup;

	}

	errno = 0;

#ifdef MS_WINDOWS

	if (PyUnicode_Check(f->f_name)) {

		PyObject *wmode;

		wmode = PyUnicode_DecodeASCII(newmode, strlen(newmode), NULL);

		if (f->f_name && wmode) {

			FILE_BEGIN_ALLOW_THREADS(f)

			/* PyUnicode_AS_UNICODE OK without thread

			   lock as it is a simple dereference. */

			f->f_fp = _wfopen(PyUnicode_AS_UNICODE(f->f_name),

					  PyUnicode_AS_UNICODE(wmode));

			FILE_END_ALLOW_THREADS(f)

		}

		Py_XDECREF(wmode);

	}

#endif

	if (NULL == f->f_fp && NULL != name) {

		FILE_BEGIN_ALLOW_THREADS(f)

		f->f_fp = fopen(name, newmode);

		FILE_END_ALLOW_THREADS(f)

	}

	if (f->f_fp == NULL) {

#if defined  _MSC_VER && (_MSC_VER < 1400 || !defined(__STDC_SECURE_LIB__))

		/* MSVC 6 (Microsoft) leaves errno at 0 for bad mode strings,

		 * across all Windows flavors.  When it sets EINVAL varies

		 * across Windows flavors, the exact conditions aren't

		 * documented, and the answer lies in the OS's implementation

		 * of Win32's CreateFile function (whose source is secret).

		 * Seems the best we can do is map EINVAL to ENOENT.

		 * Starting with Visual Studio .NET 2005, EINVAL is correctly

		 * set by our CRT error handler (set in exceptions.c.)

		 */

		if (errno == 0)	/* bad mode string */

			errno = EINVAL;

		else if (errno == EINVAL) /* unknown, but not a mode string */

			errno = ENOENT;

#endif

                /* EINVAL is returned when an invalid filename or

                 * an invalid mode is supplied. */

		if (errno == EINVAL) {

			PyObject *v;

			char message[100];

			PyOS_snprintf(message, 100, 

			    "invalid mode ('%.50s') or filename", mode);

			v = Py_BuildValue("(isO)", errno, message, f->f_name);

			if (v != NULL) {

				PyErr_SetObject(PyExc_IOError, v);

				Py_DECREF(v);

			}

		}

		else

			PyErr_SetFromErrnoWithFilenameObject(PyExc_IOError, f->f_name);

		f = NULL;

	}

	if (f != NULL)

		f = dircheck(f);

cleanup:

	PyMem_FREE(newmode);

	return (PyObject *)f;

}

static PyObject *

close_the_file(PyFileObject *f)

{

	int sts = 0;

	int (*local_close)(FILE *);

	FILE *local_fp = f->f_fp;

	if (local_fp != NULL) {

		local_close = f->f_close;

		if (local_close != NULL && f->unlocked_count > 0) {

			if (f->ob_refcnt > 0) {

				PyErr_SetString(PyExc_IOError,

					"close() called during concurrent "

					"operation on the same file object.");

			} else {

				/* This should not happen unless someone is

				 * carelessly playing with the PyFileObject

				 * struct fields and/or its associated FILE

				 * pointer. */

				PyErr_SetString(PyExc_SystemError,

					"PyFileObject locking error in "

					"destructor (refcnt <= 0 at close).");

			}

			return NULL;

		}

		/* NULL out the FILE pointer before releasing the GIL, because

		 * it will not be valid anymore after the close() function is

		 * called. */

		f->f_fp = NULL;

		if (local_close != NULL) {

			Py_BEGIN_ALLOW_THREADS

			errno = 0;

			sts = (*local_close)(local_fp);

			Py_END_ALLOW_THREADS

			if (sts == EOF)

				return PyErr_SetFromErrno(PyExc_IOError);

			if (sts != 0)

				return PyInt_FromLong((long)sts);

		}

	}

	Py_RETURN_NONE;

}

PyObject *

PyFile_FromFile(FILE *fp, char *name, char *mode, int (*close)(FILE *))

{

	PyFileObject *f = (PyFileObject *)PyFile_Type.tp_new(&PyFile_Type,

							     NULL, NULL);

	if (f != NULL) {

		PyObject *o_name = PyString_FromString(name);

		if (o_name == NULL)

			return NULL;

		if (fill_file_fields(f, fp, o_name, mode, close) == NULL) {

			Py_DECREF(f);

			f = NULL;

		}

                Py_DECREF(o_name);

	}

	return (PyObject *) f;

}

PyObject *

PyFile_FromString(char *name, char *mode)

{

	extern int fclose(FILE *);

	PyFileObject *f;

	f = (PyFileObject *)PyFile_FromFile((FILE *)NULL, name, mode, fclose);

	if (f != NULL) {

		if (open_the_file(f, name, mode) == NULL) {

			Py_DECREF(f);

			f = NULL;

		}

	}

	return (PyObject *)f;

}

void

PyFile_SetBufSize(PyObject *f, int bufsize)

{

	PyFileObject *file = (PyFileObject *)f;

	if (bufsize >= 0) {

		int type;

		switch (bufsize) {

		case 0:

			type = _IONBF;

			break;

#ifdef HAVE_SETVBUF

		case 1:

			type = _IOLBF;

			bufsize = BUFSIZ;

			break;

#endif

		default:

			type = _IOFBF;

#ifndef HAVE_SETVBUF

			bufsize = BUFSIZ;

#endif

			break;

		}

		fflush(file->f_fp);

		if (type == _IONBF) {

			PyMem_Free(file->f_setbuf);

			file->f_setbuf = NULL;

		} else {

			file->f_setbuf = (char *)PyMem_Realloc(file->f_setbuf, 

                                                                bufsize);

		}

#ifdef HAVE_SETVBUF

		setvbuf(file->f_fp, file->f_setbuf, type, bufsize);

#else /* !HAVE_SETVBUF */

		setbuf(file->f_fp, file->f_setbuf);

#endif /* !HAVE_SETVBUF */

	}

}

/* Set the encoding used to output Unicode strings.

   Return 1 on success, 0 on failure. */

int

PyFile_SetEncoding(PyObject *f, const char *enc)

{

	return PyFile_SetEncodingAndErrors(f, enc, NULL);

}

int

PyFile_SetEncodingAndErrors(PyObject *f, const char *enc, char* errors)

{

	PyFileObject *file = (PyFileObject*)f;

	PyObject *str, *oerrors;

	assert(PyFile_Check(f));

	str = PyString_FromString(enc);

	if (!str)

		return 0;

	if (errors) {

		oerrors = PyString_FromString(errors);

		if (!oerrors) {

			Py_DECREF(str);

			return 0;

		}

	} else {

		oerrors = Py_None;

		Py_INCREF(Py_None);

	}

	Py_DECREF(file->f_encoding);

	file->f_encoding = str;

	Py_DECREF(file->f_errors);

	file->f_errors = oerrors;

	return 1;

}

static PyObject *

err_closed(void)

{

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

	return NULL;

}

/* Refuse regular file I/O if there's data in the iteration-buffer.

 * Mixing them would cause data to arrive out of order, as the read*

 * methods don't use the iteration buffer. */

static PyObject *

err_iterbuffered(void)

{

	PyErr_SetString(PyExc_ValueError,

		"Mixing iteration and read methods would lose data");

	return NULL;

}

static void drop_readahead(PyFileObject *);

/* Methods */

static void

file_dealloc(PyFileObject *f)

{

	PyObject *ret;

	if (f->weakreflist != NULL)

		PyObject_ClearWeakRefs((PyObject *) f);

	ret = close_the_file(f);

	if (!ret) {

		PySys_WriteStderr("close failed in file object destructor:\n");

		PyErr_Print();

	}

	else {

		Py_DECREF(ret);

	}

	PyMem_Free(f->f_setbuf);

	Py_XDECREF(f->f_name);

	Py_XDECREF(f->f_mode);

	Py_XDECREF(f->f_encoding);

	Py_XDECREF(f->f_errors);

	drop_readahead(f);

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

}

static PyObject *