#include "Python.h"

#include "pycore_bytesobject.h" // _PyBytes_Join()

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_pyerrors.h" // _Py_FatalErrorFormat()

#include "pycore_pylifecycle.h" // _Py_IsInterpreterFinalizing()

#include "_iomodule.h"

PyDoc_STRVAR(bufferediobase_doc,

"Base class for buffered IO objects.\n"

"\n"

"The main difference with RawIOBase is that the read() method\n"

"supports omitting the size argument, and does not have a default\n"

"implementation that defers to readinto().\n"

"\n"

"In addition, read(), readinto() and write() may raise\n"

"BlockingIOError if the underlying raw stream is in non-blocking\n"

"mode and not ready; unlike their raw counterparts, they will never\n"

"return None.\n"

"\n"

"A typical implementation should not inherit from a RawIOBase\n"

"implementation, but wrap one.\n"

);

static PyObject *

_bufferediobase_readinto_generic(PyObject *self, Py_buffer *buffer, char readinto1)

{

Py_ssize_t len;

PyObject *data;

PyObject *attr = readinto1

? &_Py_ID(read1)

: &_Py_ID(read);

data = _PyObject_CallMethod(self, attr, "n", buffer->len);

if (data == NULL)

return NULL;

if (!PyBytes_Check(data)) {

Py_DECREF(data);

PyErr_SetString(PyExc_TypeError, "read() should return bytes");

return NULL;

}

len = PyBytes_GET_SIZE(data);

if (len > buffer->len) {

PyErr_Format(PyExc_ValueError,

"read() returned too much data: "

"%zd bytes requested, %zd returned",

buffer->len, len);

Py_DECREF(data);

return NULL;

}

memcpy(buffer->buf, PyBytes_AS_STRING(data), len);

Py_DECREF(data);

return PyLong_FromSsize_t(len);

}

static PyObject *

_io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer)

{

return _bufferediobase_readinto_generic(self, buffer, 0);

}

static PyObject *

_io__BufferedIOBase_readinto1_impl(PyObject *self, Py_buffer *buffer)

{

return _bufferediobase_readinto_generic(self, buffer, 1);

}

static PyObject *

bufferediobase_unsupported(_PyIO_State *state, const char *message)

{

PyErr_SetString(state->unsupported_operation, message);

return NULL;

}

static PyObject *

_io__BufferedIOBase_detach_impl(PyObject *self, PyTypeObject *cls)

{

_PyIO_State *state = get_io_state_by_cls(cls);

return bufferediobase_unsupported(state, "detach");

}

static PyObject *

_io__BufferedIOBase_read_impl(PyObject *self, PyTypeObject *cls,

int Py_UNUSED(size))

{

_PyIO_State *state = get_io_state_by_cls(cls);

return bufferediobase_unsupported(state, "read");

}

static PyObject *

_io__BufferedIOBase_read1_impl(PyObject *self, PyTypeObject *cls,

int Py_UNUSED(size))

{

_PyIO_State *state = get_io_state_by_cls(cls);

return bufferediobase_unsupported(state, "read1");

}

static PyObject *

_io__BufferedIOBase_write_impl(PyObject *self, PyTypeObject *cls,

PyObject *Py_UNUSED(b))

{

_PyIO_State *state = get_io_state_by_cls(cls);

return bufferediobase_unsupported(state, "write");

}

typedef struct {

PyObject_HEAD

PyObject *raw;

int ok; /* Initialized? */

int detached;

int readable;

int writable;

char finalizing;

/* True if this is a vanilla Buffered object (rather than a user derived

int fast_closed_checks;

/* Absolute position inside the raw stream (-1 if unknown). */

Py_off_t abs_pos;

/* A static buffer of size `buffer_size` */

char *buffer;

/* Current logical position in the buffer. */

Py_off_t pos;

/* Position of the raw stream in the buffer. */

Py_off_t raw_pos;

/* Just after the last buffered byte in the buffer, or -1 if the buffer

Py_off_t read_end;

/* Just after the last byte actually written */

Py_off_t write_pos;

/* Just after the last byte waiting to be written, or -1 if the buffer

Py_off_t write_end;

PyThread_type_lock lock;

volatile unsigned long owner;

Py_ssize_t buffer_size;

Py_ssize_t buffer_mask;

PyObject *dict;

PyObject *weakreflist;

} buffered;

static int

_enter_buffered_busy(buffered *self)

{

int relax_locking;

PyLockStatus st;

if (self->owner == PyThread_get_thread_ident()) {

PyErr_Format(PyExc_RuntimeError,

"reentrant call inside %R", self);

return 0;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

relax_locking = _Py_IsInterpreterFinalizing(interp);

Py_BEGIN_ALLOW_THREADS

if (!relax_locking)

st = PyThread_acquire_lock(self->lock, 1);

else {

/* When finalizing, we don't want a deadlock to happen with daemon

st = PyThread_acquire_lock_timed(self->lock, (PY_TIMEOUT_T)1e6, 0);

}

Py_END_ALLOW_THREADS

if (relax_locking && st != PY_LOCK_ACQUIRED) {

PyObject *ascii = PyObject_ASCII((PyObject*)self);

_Py_FatalErrorFormat(__func__,

"could not acquire lock for %s at interpreter "

"shutdown, possibly due to daemon threads",

ascii ? PyUnicode_AsUTF8(ascii) : "<ascii(self) failed>");

}

return 1;

}

#define ENTER_BUFFERED(self) \

( (PyThread_acquire_lock(self->lock, 0) ? \

1 : _enter_buffered_busy(self)) \

&& (self->owner = PyThread_get_thread_ident(), 1) )

#define LEAVE_BUFFERED(self) \

do { \

self->owner = 0; \

PyThread_release_lock(self->lock); \

} while(0);

#define CHECK_INITIALIZED(self) \

if (self->ok <= 0) { \

if (self->detached) { \

PyErr_SetString(PyExc_ValueError, \

"raw stream has been detached"); \

} else { \

PyErr_SetString(PyExc_ValueError, \

"I/O operation on uninitialized object"); \

} \

return NULL; \

}

#define CHECK_INITIALIZED_INT(self) \

if (self->ok <= 0) { \

if (self->detached) { \

PyErr_SetString(PyExc_ValueError, \

"raw stream has been detached"); \

} else { \

PyErr_SetString(PyExc_ValueError, \

"I/O operation on uninitialized object"); \

} \

return -1; \

}

#define IS_CLOSED(self) \

(!self->buffer || \

(self->fast_closed_checks \

? _PyFileIO_closed(self->raw) \

: buffered_closed(self)))

#define CHECK_CLOSED(self, error_msg) \

if (IS_CLOSED(self) && (Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t) == 0)) { \

PyErr_SetString(PyExc_ValueError, error_msg); \

return NULL; \

} \

#define VALID_READ_BUFFER(self) \

(self->readable && self->read_end != -1)

#define VALID_WRITE_BUFFER(self) \

(self->writable && self->write_end != -1)

#define ADJUST_POSITION(self, _new_pos) \

do { \

self->pos = _new_pos; \

if (VALID_READ_BUFFER(self) && self->read_end < self->pos) \

self->read_end = self->pos; \

} while(0)

#define READAHEAD(self) \

((self->readable && VALID_READ_BUFFER(self)) \

? (self->read_end - self->pos) : 0)

#define RAW_OFFSET(self) \

(((VALID_READ_BUFFER(self) || VALID_WRITE_BUFFER(self)) \

&& self->raw_pos >= 0) ? self->raw_pos - self->pos : 0)

#define RAW_TELL(self) \

(self->abs_pos != -1 ? self->abs_pos : _buffered_raw_tell(self))

#define MINUS_LAST_BLOCK(self, size) \

(self->buffer_mask ? \

(size & ~self->buffer_mask) : \

(self->buffer_size * (size / self->buffer_size)))

static int

buffered_clear(buffered *self)

{

self->ok = 0;

Py_CLEAR(self->raw);

Py_CLEAR(self->dict);

return 0;

}

static void

buffered_dealloc(buffered *self)

{

PyTypeObject *tp = Py_TYPE(self);

self->finalizing = 1;

if (_PyIOBase_finalize((PyObject *) self) < 0)

return;

_PyObject_GC_UNTRACK(self);

self->ok = 0;

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs((PyObject *)self);

if (self->buffer) {

PyMem_Free(self->buffer);

self->buffer = NULL;

}

if (self->lock) {

PyThread_free_lock(self->lock);

self->lock = NULL;

}

(void)buffered_clear(self);

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

Py_DECREF(tp);

}

static PyObject *

_io__Buffered___sizeof___impl(buffered *self)

{

size_t res = _PyObject_SIZE(Py_TYPE(self));

if (self->buffer) {

res += (size_t)self->buffer_size;

}

return PyLong_FromSize_t(res);

}

static int

buffered_traverse(buffered *self, visitproc visit, void *arg)

{

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->raw);

Py_VISIT(self->dict);

return 0;

}

static PyObject *

_io__Buffered__dealloc_warn(buffered *self, PyObject *source)

{

if (self->ok && self->raw) {

PyObject *r;

r = PyObject_CallMethodOneArg(self->raw, &_Py_ID(_dealloc_warn), source);

if (r)

Py_DECREF(r);

else

PyErr_Clear();

}

Py_RETURN_NONE;

}

static PyObject *

_io__Buffered_simple_flush_impl(buffered *self)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(flush));

}

static int

buffered_closed(buffered *self)

{

int closed;

PyObject *res;

CHECK_INITIALIZED_INT(self)

res = PyObject_GetAttr(self->raw, &_Py_ID(closed));

if (res == NULL)

return -1;

closed = PyObject_IsTrue(res);

Py_DECREF(res);

return closed;

}

static PyObject *

buffered_closed_get(buffered *self, void *context)

{

CHECK_INITIALIZED(self)

return PyObject_GetAttr(self->raw, &_Py_ID(closed));

}

static PyObject *

_io__Buffered_close_impl(buffered *self)

{

PyObject *res = NULL;

int r;

CHECK_INITIALIZED(self)

if (!ENTER_BUFFERED(self)) {

return NULL;

}

r = buffered_closed(self);

if (r < 0)

goto end;

if (r > 0) {

res = Py_NewRef(Py_None);

goto end;

}

if (self->finalizing) {

PyObject *r = _io__Buffered__dealloc_warn(self, (PyObject *) self);

if (r)

Py_DECREF(r);

else

PyErr_Clear();

}

/* flush() will most probably re-take the lock, so drop it first */

LEAVE_BUFFERED(self)

r = _PyFile_Flush((PyObject *)self);

if (!ENTER_BUFFERED(self)) {

return NULL;

}

PyObject *exc = NULL;

if (r < 0) {

exc = PyErr_GetRaisedException();

}

res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(close));

if (self->buffer) {

PyMem_Free(self->buffer);

self->buffer = NULL;

}

if (exc != NULL) {

_PyErr_ChainExceptions1(exc);

Py_CLEAR(res);

}

self->read_end = 0;

self->pos = 0;

end:

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

_io__Buffered_detach_impl(buffered *self)

{

PyObject *raw;

CHECK_INITIALIZED(self)

if (_PyFile_Flush((PyObject *)self) < 0) {

return NULL;

}

raw = self->raw;

self->raw = NULL;

self->detached = 1;

self->ok = 0;

return raw;

}

static PyObject *

_io__Buffered_seekable_impl(buffered *self)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(seekable));

}

static PyObject *

_io__Buffered_readable_impl(buffered *self)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(readable));

}

static PyObject *

_io__Buffered_writable_impl(buffered *self)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(writable));

}

static PyObject *

buffered_name_get(buffered *self, void *context)

{

CHECK_INITIALIZED(self)

return PyObject_GetAttr(self->raw, &_Py_ID(name));

}

static PyObject *

buffered_mode_get(buffered *self, void *context)

{

CHECK_INITIALIZED(self)

return PyObject_GetAttr(self->raw, &_Py_ID(mode));

}

static PyObject *

_io__Buffered_fileno_impl(buffered *self)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(fileno));

}

static PyObject *

_io__Buffered_isatty_impl(buffered *self)

{

CHECK_INITIALIZED(self)

return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(isatty));

}

static PyObject *

_bufferedwriter_flush_unlocked(buffered *);

static Py_ssize_t

_bufferedreader_fill_buffer(buffered *self);

static void

_bufferedreader_reset_buf(buffered *self);

static void

_bufferedwriter_reset_buf(buffered *self);

static PyObject *

_bufferedreader_peek_unlocked(buffered *self);

static PyObject *

_bufferedreader_read_all(buffered *self);

static PyObject *

_bufferedreader_read_fast(buffered *self, Py_ssize_t);

static PyObject *

_bufferedreader_read_generic(buffered *self, Py_ssize_t);

static Py_ssize_t

_bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len);

static void

_set_BlockingIOError(const char *msg, Py_ssize_t written)

{

PyObject *err;

PyErr_Clear();

err = PyObject_CallFunction(PyExc_BlockingIOError, "isn",

errno, msg, written);

if (err)

PyErr_SetObject(PyExc_BlockingIOError, err);

Py_XDECREF(err);

}

static Py_ssize_t *

_buffered_check_blocking_error(void)

{

PyObject *exc = PyErr_GetRaisedException();

if (exc == NULL || !PyErr_GivenExceptionMatches(exc, PyExc_BlockingIOError)) {

PyErr_SetRaisedException(exc);

return NULL;

}

PyOSErrorObject *err = (PyOSErrorObject *)exc;

/* TODO: sanity check (err->written >= 0) */

PyErr_SetRaisedException(exc);

return &err->written;

}

static Py_off_t

_buffered_raw_tell(buffered *self)

{

Py_off_t n;

PyObject *res;

res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(tell));

if (res == NULL)

return -1;

n = PyNumber_AsOff_t(res, PyExc_ValueError);

Py_DECREF(res);

if (n < 0) {

if (!PyErr_Occurred())

PyErr_Format(PyExc_OSError,

"Raw stream returned invalid position %" PY_PRIdOFF,

(PY_OFF_T_COMPAT)n);

return -1;

}

self->abs_pos = n;

return n;

}

static Py_off_t

_buffered_raw_seek(buffered *self, Py_off_t target, int whence)

{

PyObject *res, *posobj, *whenceobj;

Py_off_t n;

posobj = PyLong_FromOff_t(target);

if (posobj == NULL)

return -1;

whenceobj = PyLong_FromLong(whence);

if (whenceobj == NULL) {

Py_DECREF(posobj);

return -1;

}

res = PyObject_CallMethodObjArgs(self->raw, &_Py_ID(seek),

posobj, whenceobj, NULL);

Py_DECREF(posobj);

Py_DECREF(whenceobj);

if (res == NULL)

return -1;

n = PyNumber_AsOff_t(res, PyExc_ValueError);

Py_DECREF(res);

if (n < 0) {

if (!PyErr_Occurred())

PyErr_Format(PyExc_OSError,

"Raw stream returned invalid position %" PY_PRIdOFF,

(PY_OFF_T_COMPAT)n);

return -1;

}

self->abs_pos = n;

return n;

}

static int

_buffered_init(buffered *self)

{

Py_ssize_t n;

if (self->buffer_size <= 0) {

PyErr_SetString(PyExc_ValueError,

"buffer size must be strictly positive");

return -1;

}

if (self->buffer)

PyMem_Free(self->buffer);

self->buffer = PyMem_Malloc(self->buffer_size);

if (self->buffer == NULL) {

PyErr_NoMemory();

return -1;

}

if (self->lock)

PyThread_free_lock(self->lock);

self->lock = PyThread_allocate_lock();

if (self->lock == NULL) {

PyErr_SetString(PyExc_RuntimeError, "can't allocate read lock");

return -1;

}

self->owner = 0;

/* Find out whether buffer_size is a power of 2 */

/* XXX is this optimization useful? */

for (n = self->buffer_size - 1; n & 1; n >>= 1)

;

if (n == 0)

self->buffer_mask = self->buffer_size - 1;

else

self->buffer_mask = 0;

if (_buffered_raw_tell(self) == -1)

PyErr_Clear();

return 0;

}

_PyIO_trap_eintr(void)

{

if (!PyErr_ExceptionMatches(PyExc_OSError)) {

return 0;

}

PyObject *exc = PyErr_GetRaisedException();

PyOSErrorObject *env_err = (PyOSErrorObject *)exc;

assert(env_err != NULL);

if (env_err->myerrno != NULL) {

assert(EINTR > 0 && EINTR < INT_MAX);

assert(PyLong_CheckExact(env_err->myerrno));

int overflow;

int myerrno = PyLong_AsLongAndOverflow(env_err->myerrno, &overflow);

PyErr_Clear();

if (myerrno == EINTR) {

Py_DECREF(exc);

return 1;

}

}

/* This silences any error set by PyObject_RichCompareBool() */

PyErr_SetRaisedException(exc);

return 0;

}

static PyObject *

buffered_flush_and_rewind_unlocked(buffered *self)

{

PyObject *res;

res = _bufferedwriter_flush_unlocked(self);

if (res == NULL)

return NULL;

Py_DECREF(res);

if (self->readable) {

/* Rewind the raw stream so that its position corresponds to

Py_off_t n;

n = _buffered_raw_seek(self, -RAW_OFFSET(self), 1);

_bufferedreader_reset_buf(self);

if (n == -1)

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

_io__Buffered_flush_impl(buffered *self)

{

PyObject *res;

CHECK_INITIALIZED(self)

CHECK_CLOSED(self, "flush of closed file")

if (!ENTER_BUFFERED(self))

return NULL;

res = buffered_flush_and_rewind_unlocked(self);

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

_io__Buffered_peek_impl(buffered *self, Py_ssize_t size)

{

PyObject *res = NULL;

CHECK_INITIALIZED(self)

CHECK_CLOSED(self, "peek of closed file")

if (!ENTER_BUFFERED(self))

return NULL;

if (self->writable) {

res = buffered_flush_and_rewind_unlocked(self);

if (res == NULL)

goto end;

Py_CLEAR(res);

}

res = _bufferedreader_peek_unlocked(self);

end:

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

_io__Buffered_read_impl(buffered *self, Py_ssize_t n)

{

PyObject *res;

CHECK_INITIALIZED(self)

if (n < -1) {

PyErr_SetString(PyExc_ValueError,

"read length must be non-negative or -1");

return NULL;

}

CHECK_CLOSED(self, "read of closed file")

if (n == -1) {

/* The number of bytes is unspecified, read until the end of stream */

if (!ENTER_BUFFERED(self))

return NULL;

res = _bufferedreader_read_all(self);

}

else {

res = _bufferedreader_read_fast(self, n);

if (res != Py_None)

return res;

Py_DECREF(res);

if (!ENTER_BUFFERED(self))

return NULL;

res = _bufferedreader_read_generic(self, n);

}

LEAVE_BUFFERED(self)

return res;

}

static PyObject *

_io__Buffered_read1_impl(buffered *self, Py_ssize_t n)

{

Py_ssize_t have, r;

PyObject *res = NULL;

CHECK_INITIALIZED(self)

if (n < 0) {

n = self->buffer_size;

}

CHECK_CLOSED(self, "read of closed file")

if (n == 0)

return PyBytes_FromStringAndSize(NULL, 0);

/* Return up to n bytes. If at least one byte is buffered, we