#include "Python.h"

#include "pycore_object.h"

#include "pycore_sysmodule.h" // _PySys_GetSizeOf()

#include <stddef.h> // offsetof()

#include "_iomodule.h"

typedef struct {

PyObject_HEAD

PyObject *buf;

Py_ssize_t pos;

Py_ssize_t string_size;

PyObject *dict;

PyObject *weakreflist;

Py_ssize_t exports;

} bytesio;

#define bytesio_CAST(op) ((bytesio *)(op))

typedef struct {

PyObject_HEAD

bytesio *source;

} bytesiobuf;

#define bytesiobuf_CAST(op) ((bytesiobuf *)(op))

static int

check_closed(bytesio *self)

{

if (self->buf == NULL) {

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

return 1;

}

return 0;

}

static int

check_exports(bytesio *self)

{

if (self->exports > 0) {

PyErr_SetString(PyExc_BufferError,

"Existing exports of data: object cannot be re-sized");

return 1;

}

return 0;

}

#define CHECK_CLOSED(self) \

if (check_closed(self)) { \

return NULL; \

}

#define CHECK_EXPORTS(self) \

if (check_exports(self)) { \

return NULL; \

}

#define SHARED_BUF(self) (Py_REFCNT((self)->buf) > 1)

static Py_ssize_t

scan_eol(bytesio *self, Py_ssize_t len)

{

const char *start, *n;

Py_ssize_t maxlen;

assert(self->buf != NULL);

assert(self->pos >= 0);

if (self->pos >= self->string_size)

return 0;

/* Move to the end of the line, up to the end of the string, s. */

maxlen = self->string_size - self->pos;

if (len < 0 || len > maxlen)

len = maxlen;

if (len) {

start = PyBytes_AS_STRING(self->buf) + self->pos;

n = memchr(start, '\n', len);

if (n)

/* Get the length from the current position to the end of

len = n - start + 1;

}

assert(len >= 0);

assert(self->pos < PY_SSIZE_T_MAX - len);

return len;

}

static int

unshare_buffer(bytesio *self, size_t size)

{

PyObject *new_buf;

assert(SHARED_BUF(self));

assert(self->exports == 0);

assert(size >= (size_t)self->string_size);

new_buf = PyBytes_FromStringAndSize(NULL, size);

if (new_buf == NULL)

return -1;

memcpy(PyBytes_AS_STRING(new_buf), PyBytes_AS_STRING(self->buf),

self->string_size);

Py_SETREF(self->buf, new_buf);

return 0;

}

static int

resize_buffer(bytesio *self, size_t size)

{

assert(self->buf != NULL);

assert(self->exports == 0);

/* Here, unsigned types are used to avoid dealing with signed integer

size_t alloc = PyBytes_GET_SIZE(self->buf);

/* For simplicity, stay in the range of the signed type. Anyway, Python

if (size > PY_SSIZE_T_MAX)

goto overflow;

if (size < alloc / 2) {

/* Major downsize; resize down to exact size. */

alloc = size + 1;

}

else if (size < alloc) {

/* Within allocated size; quick exit */

return 0;

}

else if (size <= alloc * 1.125) {

/* Moderate upsize; overallocate similar to list_resize() */

alloc = size + (size >> 3) + (size < 9 ? 3 : 6);

}

else {

/* Major upsize; resize up to exact size */

alloc = size + 1;

}

if (SHARED_BUF(self)) {

if (unshare_buffer(self, alloc) < 0)

return -1;

}

else {

if (_PyBytes_Resize(&self->buf, alloc) < 0)

return -1;

}

return 0;

overflow:

PyErr_SetString(PyExc_OverflowError,

"new buffer size too large");

return -1;

}

Py_NO_INLINE static Py_ssize_t

write_bytes(bytesio *self, PyObject *b)

{

if (check_closed(self)) {

return -1;

}

if (check_exports(self)) {

return -1;

}

Py_buffer buf;

if (PyObject_GetBuffer(b, &buf, PyBUF_CONTIG_RO) < 0) {

return -1;

}

Py_ssize_t len = buf.len;

if (len == 0) {

goto done;

}

assert(self->pos >= 0);

size_t endpos = (size_t)self->pos + len;

if (endpos > (size_t)PyBytes_GET_SIZE(self->buf)) {

if (resize_buffer(self, endpos) < 0) {

len = -1;

goto done;

}

}

else if (SHARED_BUF(self)) {

if (unshare_buffer(self, Py_MAX(endpos, (size_t)self->string_size)) < 0) {

len = -1;

goto done;

}

}

if (self->pos > self->string_size) {

/* In case of overseek, pad with null bytes the buffer region between

memset(PyBytes_AS_STRING(self->buf) + self->string_size, '\0',

(self->pos - self->string_size) * sizeof(char));

}

/* Copy the data to the internal buffer, overwriting some of the existing

memcpy(PyBytes_AS_STRING(self->buf) + self->pos, buf.buf, len);

self->pos = endpos;

/* Set the new length of the internal string if it has changed. */

if ((size_t)self->string_size < endpos) {

self->string_size = endpos;

}

done:

PyBuffer_Release(&buf);

return len;

}

static PyObject *

bytesio_get_closed(PyObject *op, void *Py_UNUSED(closure))

{

bytesio *self = bytesio_CAST(op);

if (self->buf == NULL) {

Py_RETURN_TRUE;

}

else {

Py_RETURN_FALSE;

}

}

static PyObject *

_io_BytesIO_readable_impl(bytesio *self)

{

CHECK_CLOSED(self);

Py_RETURN_TRUE;

}

static PyObject *

_io_BytesIO_writable_impl(bytesio *self)

{

CHECK_CLOSED(self);

Py_RETURN_TRUE;

}

static PyObject *

_io_BytesIO_seekable_impl(bytesio *self)

{

CHECK_CLOSED(self);

Py_RETURN_TRUE;

}

static PyObject *

_io_BytesIO_flush_impl(bytesio *self)

{

CHECK_CLOSED(self);

Py_RETURN_NONE;

}

static PyObject *

_io_BytesIO_getbuffer_impl(bytesio *self, PyTypeObject *cls)

{

_PyIO_State *state = get_io_state_by_cls(cls);

PyTypeObject *type = state->PyBytesIOBuffer_Type;

bytesiobuf *buf;

PyObject *view;

CHECK_CLOSED(self);

buf = (bytesiobuf *) type->tp_alloc(type, 0);

if (buf == NULL)

return NULL;

buf->source = (bytesio*)Py_NewRef(self);

view = PyMemoryView_FromObject((PyObject *) buf);

Py_DECREF(buf);

return view;

}

static PyObject *

_io_BytesIO_getvalue_impl(bytesio *self)

{

CHECK_CLOSED(self);

if (self->string_size <= 1 || self->exports > 0)

return PyBytes_FromStringAndSize(PyBytes_AS_STRING(self->buf),

self->string_size);

if (self->string_size != PyBytes_GET_SIZE(self->buf)) {

if (SHARED_BUF(self)) {

if (unshare_buffer(self, self->string_size) < 0)

return NULL;

}

else {

if (_PyBytes_Resize(&self->buf, self->string_size) < 0)

return NULL;

}

}

return Py_NewRef(self->buf);

}

static PyObject *

_io_BytesIO_isatty_impl(bytesio *self)

{

CHECK_CLOSED(self);

Py_RETURN_FALSE;

}

static PyObject *

_io_BytesIO_tell_impl(bytesio *self)

{

CHECK_CLOSED(self);

return PyLong_FromSsize_t(self->pos);

}

static PyObject *

read_bytes(bytesio *self, Py_ssize_t size)

{

const char *output;

assert(self->buf != NULL);

assert(size <= self->string_size);

if (size > 1 &&

self->pos == 0 && size == PyBytes_GET_SIZE(self->buf) &&

self->exports == 0) {

self->pos += size;

return Py_NewRef(self->buf);

}

output = PyBytes_AS_STRING(self->buf) + self->pos;

self->pos += size;

return PyBytes_FromStringAndSize(output, size);

}

static PyObject *

_io_BytesIO_read_impl(bytesio *self, Py_ssize_t size)

{

Py_ssize_t n;

CHECK_CLOSED(self);

/* adjust invalid sizes */

n = self->string_size - self->pos;

if (size < 0 || size > n) {

size = n;

if (size < 0)

size = 0;

}

return read_bytes(self, size);

}

static PyObject *

_io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size)

{

return _io_BytesIO_read_impl(self, size);

}

static PyObject *

_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size)

{

Py_ssize_t n;

CHECK_CLOSED(self);

n = scan_eol(self, size);

return read_bytes(self, n);

}

static PyObject *

_io_BytesIO_readlines_impl(bytesio *self, PyObject *arg)

{

Py_ssize_t maxsize, size, n;

PyObject *result, *line;

const char *output;

CHECK_CLOSED(self);

if (PyLong_Check(arg)) {

maxsize = PyLong_AsSsize_t(arg);

if (maxsize == -1 && PyErr_Occurred())

return NULL;

}

else if (arg == Py_None) {

/* No size limit, by default. */

maxsize = -1;

}

else {

PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",

Py_TYPE(arg)->tp_name);

return NULL;

}

size = 0;

result = PyList_New(0);

if (!result)

return NULL;

output = PyBytes_AS_STRING(self->buf) + self->pos;

while ((n = scan_eol(self, -1)) != 0) {

self->pos += n;

line = PyBytes_FromStringAndSize(output, n);

if (!line)

goto on_error;

if (PyList_Append(result, line) == -1) {

Py_DECREF(line);

goto on_error;

}

Py_DECREF(line);

size += n;

if (maxsize > 0 && size >= maxsize)

break;

output += n;

}

return result;

on_error:

Py_DECREF(result);

return NULL;

}

static PyObject *

_io_BytesIO_readinto_impl(bytesio *self, Py_buffer *buffer)

{

Py_ssize_t len, n;

CHECK_CLOSED(self);

/* adjust invalid sizes */

len = buffer->len;

n = self->string_size - self->pos;

if (len > n) {

len = n;

if (len < 0)

len = 0;

}

memcpy(buffer->buf, PyBytes_AS_STRING(self->buf) + self->pos, len);

assert(self->pos + len < PY_SSIZE_T_MAX);

assert(len >= 0);

self->pos += len;

return PyLong_FromSsize_t(len);

}

static PyObject *

_io_BytesIO_truncate_impl(bytesio *self, Py_ssize_t size)

{

CHECK_CLOSED(self);

CHECK_EXPORTS(self);

if (size < 0) {

PyErr_Format(PyExc_ValueError,

"negative size value %zd", size);

return NULL;

}

if (size < self->string_size) {

self->string_size = size;

if (resize_buffer(self, size) < 0)

return NULL;

}

return PyLong_FromSsize_t(size);

}

static PyObject *

bytesio_iternext(PyObject *op)

{

Py_ssize_t n;

bytesio *self = bytesio_CAST(op);

CHECK_CLOSED(self);

n = scan_eol(self, -1);

if (n == 0)

return NULL;

return read_bytes(self, n);

}

static PyObject *

_io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence)

{

CHECK_CLOSED(self);

if (pos < 0 && whence == 0) {

PyErr_Format(PyExc_ValueError,

"negative seek value %zd", pos);

return NULL;

}

/* whence = 0: offset relative to beginning of the string.

if (whence == 1) {

if (pos > PY_SSIZE_T_MAX - self->pos) {

PyErr_SetString(PyExc_OverflowError,

"new position too large");

return NULL;

}

pos += self->pos;

}

else if (whence == 2) {

if (pos > PY_SSIZE_T_MAX - self->string_size) {

PyErr_SetString(PyExc_OverflowError,

"new position too large");

return NULL;

}

pos += self->string_size;

}

else if (whence != 0) {

PyErr_Format(PyExc_ValueError,

"invalid whence (%i, should be 0, 1 or 2)", whence);

return NULL;

}

if (pos < 0)

pos = 0;

self->pos = pos;

return PyLong_FromSsize_t(self->pos);

}

static PyObject *

_io_BytesIO_write_impl(bytesio *self, PyObject *b)

{

Py_ssize_t n = write_bytes(self, b);

return n >= 0 ? PyLong_FromSsize_t(n) : NULL;

}

static PyObject *

_io_BytesIO_writelines_impl(bytesio *self, PyObject *lines)

{

PyObject *it, *item;

CHECK_CLOSED(self);

it = PyObject_GetIter(lines);

if (it == NULL)

return NULL;

while ((item = PyIter_Next(it)) != NULL) {

Py_ssize_t ret = write_bytes(self, item);

Py_DECREF(item);

if (ret < 0) {

Py_DECREF(it);

return NULL;

}

}

Py_DECREF(it);

/* See if PyIter_Next failed */

if (PyErr_Occurred())

return NULL;

Py_RETURN_NONE;

}

static PyObject *

_io_BytesIO_close_impl(bytesio *self)

{

CHECK_EXPORTS(self);

Py_CLEAR(self->buf);

Py_RETURN_NONE;

}

static PyObject *

bytesio_getstate(PyObject *op, PyObject *Py_UNUSED(dummy))

{

bytesio *self = bytesio_CAST(op);

PyObject *initvalue = _io_BytesIO_getvalue_impl(self);

PyObject *dict;

PyObject *state;

if (initvalue == NULL)

return NULL;

if (self->dict == NULL) {

dict = Py_NewRef(Py_None);

}

else {

dict = PyDict_Copy(self->dict);

if (dict == NULL) {

Py_DECREF(initvalue);

return NULL;

}

}

state = Py_BuildValue("(OnN)", initvalue, self->pos, dict);

Py_DECREF(initvalue);

return state;

}

static PyObject *

bytesio_setstate(PyObject *op, PyObject *state)

{

PyObject *result;

PyObject *position_obj;

PyObject *dict;

Py_ssize_t pos;

bytesio *self = bytesio_CAST(op);

assert(state != NULL);

/* We allow the state tuple to be longer than 3, because we may need

if (!PyTuple_Check(state) || PyTuple_GET_SIZE(state) < 3) {

PyErr_Format(PyExc_TypeError,

"%.200s.__setstate__ argument should be 3-tuple, got %.200s",

Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);

return NULL;

}

CHECK_EXPORTS(self);

/* Reset the object to its default state. This is only needed to handle

self->string_size = 0;

self->pos = 0;

/* Set the value of the internal buffer. If state[0] does not support the

result = _io_BytesIO_write_impl(self, PyTuple_GET_ITEM(state, 0));

if (result == NULL)

return NULL;

Py_DECREF(result);

/* Set carefully the position value. Alternatively, we could use the seek

position_obj = PyTuple_GET_ITEM(state, 1);

if (!PyLong_Check(position_obj)) {

PyErr_Format(PyExc_TypeError,

"second item of state must be an integer, not %.200s",

Py_TYPE(position_obj)->tp_name);

return NULL;

}

pos = PyLong_AsSsize_t(position_obj);

if (pos == -1 && PyErr_Occurred())

return NULL;

if (pos < 0) {

PyErr_SetString(PyExc_ValueError,

"position value cannot be negative");

return NULL;

}

self->pos = pos;

/* Set the dictionary of the instance variables. */

dict = PyTuple_GET_ITEM(state, 2);

if (dict != Py_None) {

if (!PyDict_Check(dict)) {

PyErr_Format(PyExc_TypeError,

"third item of state should be a dict, got a %.200s",

Py_TYPE(dict)->tp_name);

return NULL;

}

if (self->dict) {

/* Alternatively, we could replace the internal dictionary

if (PyDict_Update(self->dict, dict) < 0)

return NULL;

}

else {

self->dict = Py_NewRef(dict);

}

}

Py_RETURN_NONE;

}

static void

bytesio_dealloc(PyObject *op)

{

bytesio *self = bytesio_CAST(op);

PyTypeObject *tp = Py_TYPE(self);

_PyObject_GC_UNTRACK(self);

if (self->exports > 0) {

PyErr_SetString(PyExc_SystemError,

"deallocated BytesIO object has exported buffers");

PyErr_Print();

}

Py_CLEAR(self->buf);

Py_CLEAR(self->dict);

if (self->weakreflist != NULL)

PyObject_ClearWeakRefs(op);

tp->tp_free(self);

Py_DECREF(tp);

}

static PyObject *

bytesio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

bytesio *self;

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

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

if (self == NULL)

return NULL;

/* tp_alloc initializes all the fields to zero. So we don't have to

self->buf = PyBytes_FromStringAndSize(NULL, 0);

if (self->buf == NULL) {

Py_DECREF(self);

return PyErr_NoMemory();

}

return (PyObject *)self;

}

static int

_io_BytesIO___init___impl(bytesio *self, PyObject *initvalue)

{

/* In case, __init__ is called multiple times. */

self->string_size = 0;

self->pos = 0;

if (self->exports > 0) {

PyErr_SetString(PyExc_BufferError,

"Existing exports of data: object cannot be re-sized");

return -1;

}

if (initvalue && initvalue != Py_None) {

if (PyBytes_CheckExact(initvalue)) {

Py_XSETREF(self->buf, Py_NewRef(initvalue));

self->string_size = PyBytes_GET_SIZE(initvalue);

}

else {

PyObject *res;

res = _io_BytesIO_write_impl(self, initvalue);

if (res == NULL)

return -1;

Py_DECREF(res);

self->pos = 0;

}

}

return 0;

}

static PyObject *

bytesio_sizeof(PyObject *op, PyObject *Py_UNUSED(dummy))

{

bytesio *self = bytesio_CAST(op);

size_t res = _PyObject_SIZE(Py_TYPE(self));

if (self->buf && !SHARED_BUF(self)) {

size_t s = _PySys_GetSizeOf(self->buf);

if (s == (size_t)-1) {

return NULL;

}

res += s;

}

return PyLong_FromSize_t(res);

}

static int

bytesio_traverse(PyObject *op, visitproc visit, void *arg)

{

bytesio *self = bytesio_CAST(op);

Py_VISIT(Py_TYPE(self));

Py_VISIT(self->dict);

Py_VISIT(self->buf);

return 0;

}

static int

bytesio_clear(PyObject *op)

{

bytesio *self = bytesio_CAST(op);