#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

#define HAVE_FTRUNCATE

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#ifdef _MSC_VER

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#endif /* _MSC_VER */

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

#include <io.h>

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

#ifndef DONT_HAVE_ERRNO_H

#include <errno.h>

#ifdef HAVE_GETC_UNLOCKED

#define GETC(f) getc_unlocked(f)

#define FLOCKFILE(f) flockfile(f)

#define FUNLOCKFILE(f) funlockfile(f)

#define GETC(f) getc(f)

#define FLOCKFILE(f)

#define FUNLOCKFILE(f)

#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 */

#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" {

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;

}

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;

}

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

EISDIR, msg, f->f_name);

PyErr_SetObject(PyExc_IOError, exc);

Py_XDECREF(exc);

return NULL;

}

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;

}

#if defined _MSC_VER && _MSC_VER >= 1400 && defined(__STDC_SECURE_LIB__)

#define Py_VERIFY_WINNT

static int _PyVerify_Mode_WINNT(const char *mode)

{

/* See if mode string is valid on Windows to avoid hard assertions */

/* remove leading spacese */

int singles = 0;

int pairs = 0;

int encoding = 0;

const char *s, *c;

while(*mode == ' ') /* strip initial spaces */

++mode;

if (!strchr("rwa", *mode)) /* must start with one of these */

return 0;

while (*++mode) {

if (*mode == ' ' || *mode == 'N') /* ignore spaces and N */

continue;

s = "+TD"; /* each of this can appear only once */

c = strchr(s, *mode);

if (c) {

ptrdiff_t idx = s-c;

if (singles & (1<<idx))

return 0;

singles |= (1<<idx);

continue;

}

s = "btcnSR"; /* only one of each letter in the pairs allowed */

c = strchr(s, *mode);

if (c) {

ptrdiff_t idx = (s-c)/2;

if (pairs & (1<<idx))

return 0;

pairs |= (1<<idx);

continue;

}

if (*mode == ',') {

encoding = 1;

break;

}

return 0; /* found an invalid char */

}

if (encoding) {

char *e[] = {"UTF-8", "UTF-16LE", "UNICODE"};

while (*mode == ' ')

++mode;

/* find 'ccs =' */

if (strncmp(mode, "ccs", 3))

return 0;

mode += 3;

while (*mode == ' ')

++mode;

if (*mode != '=')

return 0;

while (*mode == ' ')

++mode;

for(encoding = 0; encoding<_countof(e); ++encoding) {

size_t l = strlen(e[encoding]);

if (!strncmp(mode, e[encoding], l)) {

mode += l; /* found a valid encoding */

break;

}

}

if (encoding == _countof(e))

return 0;

}

/* skip trailing spaces */

while (*mode == ' ')

++mode;

return *mode == '\0'; /* must be at the end of the string */

}

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

}

#ifdef Py_VERIFY_WINNT

/* additional checks on NT with visual studio 2005 and higher */

if (!_PyVerify_Mode_WINNT(mode)) {

PyErr_Format(PyExc_ValueError, "Invalid mode ('%.50s')", 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);

assert(name != NULL);

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

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

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

PyUnicode_AS_UNICODE(wmode));

FILE_END_ALLOW_THREADS(f)

}

Py_XDECREF(wmode);

}

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,

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

errno = EINVAL;

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

errno = ENOENT;

/* EINVAL is returned when an invalid filename or

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

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

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;

}

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;

default:

type = _IOFBF;

#ifndef HAVE_SETVBUF

bufsize = BUFSIZ;

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 */

}

}

PyFile_SetEncoding(PyObject *f, const char *enc)

{

return PyFile_SetEncodingAndErrors(f, enc, NULL);

}

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;

}

static PyObject *

err_iterbuffered(void)

{

PyErr_SetString(PyExc_ValueError,

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

return NULL;

}

static void drop_readahead(PyFileObject *);

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 *

file_repr(PyFileObject *f)

{

if (PyUnicode_Check(f->f_name)) {

#ifdef Py_USING_UNICODE

PyObject *ret = NULL;

PyObject *name = PyUnicode_AsUnicodeEscapeString(f->f_name);

const char *name_str = name ? PyString_AsString(name) : "?";

ret = PyString_FromFormat("<%s file u'%s', mode '%s' at %p>",

f->f_fp == NULL ? "closed" : "open",

name_str,

PyString_AsString(f->f_mode),

f);

Py_XDECREF(name);

return ret;

} else {

return PyString_FromFormat("<%s file '%s', mode '%s' at %p>",

f->f_fp == NULL ? "closed" : "open",

PyString_AsString(f->f_name),

PyString_AsString(f->f_mode),

f);

}

}

static PyObject *

file_close(PyFileObject *f)

{

PyObject *sts = close_the_file(f);

PyMem_Free(f->f_setbuf);

f->f_setbuf = NULL;

return sts;

}

#if !defined(HAVE_LARGEFILE_SUPPORT)

typedef off_t Py_off_t;

#elif SIZEOF_OFF_T >= 8

typedef off_t Py_off_t;

#elif SIZEOF_FPOS_T >= 8

typedef fpos_t Py_off_t;

#error "Large file support, but neither off_t nor fpos_t is large enough."

static int

_portable_fseek(FILE *fp, Py_off_t offset, int whence)

{

#if !defined(HAVE_LARGEFILE_SUPPORT)

return fseek(fp, offset, whence);

#elif defined(HAVE_FSEEKO) && SIZEOF_OFF_T >= 8

return fseeko(fp, offset, whence);

#elif defined(HAVE_FSEEK64)

return fseek64(fp, offset, whence);

#elif defined(__BEOS__)

return _fseek(fp, offset, whence);

#elif SIZEOF_FPOS_T >= 8

/* lacking a 64-bit capable fseek(), use a 64-bit capable fsetpos()

fpos_t pos;

switch (whence) {

case SEEK_END:

#ifdef MS_WINDOWS

fflush(fp);

if (_lseeki64(fileno(fp), 0, 2) == -1)

return -1;

if (fseek(fp, 0, SEEK_END) != 0)

return -1;

/* fall through */

case SEEK_CUR:

if (fgetpos(fp, &pos) != 0)

return -1;

offset += pos;

break;

/* case SEEK_SET: break; */

}

return fsetpos(fp, &offset);

#error "Large file support, but no way to fseek."

}

static Py_off_t

_portable_ftell(FILE* fp)

{

#if !defined(HAVE_LARGEFILE_SUPPORT)

return ftell(fp);

#elif defined(HAVE_FTELLO) && SIZEOF_OFF_T >= 8

return ftello(fp);

#elif defined(HAVE_FTELL64)

return ftell64(fp);

#elif SIZEOF_FPOS_T >= 8

fpos_t pos;

if (fgetpos(fp, &pos) != 0)

return -1;

return pos;

#error "Large file support, but no way to ftell."

}

static PyObject *

file_seek(PyFileObject *f, PyObject *args)

{

int whence;

int ret;

Py_off_t offset;

PyObject *offobj, *off_index;

if (f->f_fp == NULL)

return err_closed();

drop_readahead(f);

whence = 0;

if (!PyArg_ParseTuple(args, "O|i:seek", &offobj, &whence))

return NULL;

off_index = PyNumber_Index(offobj);

if (!off_index) {

if (!PyFloat_Check(offobj))

return NULL;

/* Deprecated in 2.6 */

PyErr_Clear();

if (PyErr_WarnEx(PyExc_DeprecationWarning,

"integer argument expected, got float",

1) < 0)

return NULL;

off_index = offobj;

Py_INCREF(offobj);

}

#if !defined(HAVE_LARGEFILE_SUPPORT)

offset = PyInt_AsLong(off_index);

offset = PyLong_Check(off_index) ?

PyLong_AsLongLong(off_index) : PyInt_AsLong(off_index);

Py_DECREF(off_index);

if (PyErr_Occurred())

return NULL;

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

ret = _portable_fseek(f->f_fp, offset, whence);

FILE_END_ALLOW_THREADS(f)

if (ret != 0) {

PyErr_SetFromErrno(PyExc_IOError);

clearerr(f->f_fp);

return NULL;

}

f->f_skipnextlf = 0;

Py_INCREF(Py_None);

return Py_None;

}

#ifdef HAVE_FTRUNCATE

static PyObject *

file_truncate(PyFileObject *f, PyObject *args)

{

Py_off_t newsize;

PyObject *newsizeobj = NULL;

Py_off_t initialpos;

int ret;

if (f->f_fp == NULL)

return err_closed();

if (!PyArg_UnpackTuple(args, "truncate", 0, 1, &newsizeobj))

return NULL;

/* Get current file position. If the file happens to be open for

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

initialpos = _portable_ftell(f->f_fp);

FILE_END_ALLOW_THREADS(f)

if (initialpos == -1)

goto onioerror;

/* Set newsize to current postion if newsizeobj NULL, else to the

if (newsizeobj != NULL) {

#if !defined(HAVE_LARGEFILE_SUPPORT)

newsize = PyInt_AsLong(newsizeobj);

newsize = PyLong_Check(newsizeobj) ?

PyLong_AsLongLong(newsizeobj) :

PyInt_AsLong(newsizeobj);

if (PyErr_Occurred())

return NULL;

}

else /* default to current position */

newsize = initialpos;

/* Flush the stream. We're mixing stream-level I/O with lower-level

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

ret = fflush(f->f_fp);

FILE_END_ALLOW_THREADS(f)

if (ret != 0)

goto onioerror;

#ifdef MS_WINDOWS

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

{

HANDLE hFile;

/* Have to move current pos to desired endpoint on Windows. */

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

ret = _portable_fseek(f->f_fp, newsize, SEEK_SET) != 0;

FILE_END_ALLOW_THREADS(f)

if (ret)

goto onioerror;

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

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

hFile = (HANDLE)_get_osfhandle(fileno(f->f_fp));

ret = hFile == (HANDLE)-1;

if (ret == 0) {

ret = SetEndOfFile(hFile) == 0;

if (ret)

errno = EACCES;

}

FILE_END_ALLOW_THREADS(f)

if (ret)

goto onioerror;

}

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

ret = ftruncate(fileno(f->f_fp), newsize);

FILE_END_ALLOW_THREADS(f)

if (ret != 0)

goto onioerror;

#endif /* !MS_WINDOWS */

/* Restore original file position. */

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

ret = _portable_fseek(f->f_fp, initialpos, SEEK_SET) != 0;

FILE_END_ALLOW_THREADS(f)

if (ret)

goto onioerror;

Py_INCREF(Py_None);

return Py_None;

onioerror:

PyErr_SetFromErrno(PyExc_IOError);

clearerr(f->f_fp);

return NULL;

}

#endif /* HAVE_FTRUNCATE */

static PyObject *

file_tell(PyFileObject *f)

{

Py_off_t pos;

if (f->f_fp == NULL)

return err_closed();

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

pos = _portable_ftell(f->f_fp);

FILE_END_ALLOW_THREADS(f)

if (pos == -1) {

PyErr_SetFromErrno(PyExc_IOError);

clearerr(f->f_fp);

return NULL;

}

if (f->f_skipnextlf) {

int c;

c = GETC(f->f_fp);

if (c == '\n') {

f->f_newlinetypes |= NEWLINE_CRLF;

pos++;

f->f_skipnextlf = 0;

} else if (c != EOF) ungetc(c, f->f_fp);

}

#if !defined(HAVE_LARGEFILE_SUPPORT)

return PyInt_FromLong(pos);

return PyLong_FromLongLong(pos);

}

static PyObject *

file_fileno(PyFileObject *f)

{

if (f->f_fp == NULL)

return err_closed();

return PyInt_FromLong((long) fileno(f->f_fp));

}

static PyObject *

file_flush(PyFileObject *f)

{

int res;

if (f->f_fp == NULL)

return err_closed();

FILE_BEGIN_ALLOW_THREADS(f)

errno = 0;

res = fflush(f->f_fp);

FILE_END_ALLOW_THREADS(f)

if (res != 0) {

PyErr_SetFromErrno(PyExc_IOError);

clearerr(f->f_fp);

return NULL;

}

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

file_isatty(PyFileObject *f)

{

long res;

if (f->f_fp == NULL)

return err_closed();

FILE_BEGIN_ALLOW_THREADS(f)

res = isatty((int)fileno(f->f_fp));

FILE_END_ALLOW_THREADS(f)

return PyBool_FromLong(res);

}

#if BUFSIZ < 8192

#define SMALLCHUNK 8192

#define SMALLCHUNK BUFSIZ

#if SIZEOF_INT < 4

#define BIGCHUNK (512 * 32)

#define BIGCHUNK (512 * 1024)

static size_t

new_buffersize(PyFileObject *f, size_t currentsize)

{

#ifdef HAVE_FSTAT

off_t pos, end;

struct stat st;

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

end = st.st_size;

/* The following is not a bug: we really need to call lseek()

pos = lseek(fileno(f->f_fp), 0L, SEEK_CUR);

if (pos >= 0) {

pos = ftell(f->f_fp);

}

if (pos < 0)

clearerr(f->f_fp);

if (end > pos && pos >= 0)