#include "Python.h"

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

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION()

#include "pycore_object.h"

#include "pycore_pyatomic_ft_wrappers.h"

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

#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()

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

#ifdef Py_GIL_DISABLED

int buf_shared;

} 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 (FT_ATOMIC_LOAD_SSIZE_RELAXED(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; \

}

#ifdef Py_GIL_DISABLED

#define SHARED_BUF(self) ((self)->buf_shared || !_PyObject_IsUniquelyReferenced((self)->buf))

#define SHARED_BUF(self) (!_PyObject_IsUniquelyReferenced((self)->buf))

static inline void

set_shared_buf(bytesio *self)

{

#ifdef Py_GIL_DISABLED

self->buf_shared = 1;

}

static inline void

clear_shared_buf(bytesio *self)

{

#ifdef Py_GIL_DISABLED

self->buf_shared = 0;

}

static int

resize_unshared_buffer_lock_held(bytesio *self, Py_ssize_t size)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

#ifdef Py_GIL_DISABLED

/* If the internal bytes object escaped via a zero-copy getvalue(), read(),

assert(!self->buf_shared);

int ret = _PyBytes_ResizeKeepOnError(&self->buf, size);

if (ret == 0) {

clear_shared_buf(self);

}

return ret;

}

static Py_ssize_t

scan_eol_lock_held(bytesio *self, Py_ssize_t len)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

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_lock_held(bytesio *self, size_t size)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

PyObject *new_buf;

assert(SHARED_BUF(self));

assert(FT_ATOMIC_LOAD_SSIZE_RELAXED(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);

clear_shared_buf(self);

return 0;

}

static int

resize_buffer_lock_held(bytesio *self, size_t size)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

assert(self->buf != NULL);

assert(FT_ATOMIC_LOAD_SSIZE_RELAXED(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_lock_held(self, alloc) < 0)

return -1;

}

else {

if (resize_unshared_buffer_lock_held(self, 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_lock_held(bytesio *self, PyObject *b)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

Py_buffer buf;

Py_ssize_t len;

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

return -1;

}

if (check_closed(self) || check_exports(self)) {

len = -1;

goto done;

}

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_lock_held(self, endpos) < 0) {

len = -1;

goto done;

}

}

else if (SHARED_BUF(self)) {

if (unshare_buffer_lock_held(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))

{

PyObject *ret;

bytesio *self = bytesio_CAST(op);

Py_BEGIN_CRITICAL_SECTION(self);

if (self->buf == NULL) {

ret = Py_True;

}

else {

ret = Py_False;

}

Py_END_CRITICAL_SECTION();

return ret;

}

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 || FT_ATOMIC_LOAD_SSIZE_RELAXED(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_lock_held(self, self->string_size) < 0)

return NULL;

}

else {

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

return NULL;

}

}

set_shared_buf(self);

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 *

peek_bytes_lock_held(bytesio *self, Py_ssize_t size)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

const char *output;

assert(self->buf != NULL);

assert(size <= self->string_size);

if (size > 1 &&

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

FT_ATOMIC_LOAD_SSIZE_RELAXED(self->exports) == 0) {

set_shared_buf(self);

return Py_NewRef(self->buf);

}

/* gh-141311: Avoid undefined behavior when self->pos (limit PY_SSIZE_T_MAX)

if (size == 0) {

return PyBytes_FromStringAndSize(NULL, 0);

}

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

return PyBytes_FromStringAndSize(output, size);

}

static PyObject *

read_bytes_lock_held(bytesio *self, Py_ssize_t size)

{

PyObject *bytes = peek_bytes_lock_held(self, size);

if (bytes != NULL) {

assert(PyBytes_GET_SIZE(bytes) == size);

self->pos += size;

}

return bytes;

}

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_lock_held(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_peek_impl(bytesio *self, Py_ssize_t size)

{

CHECK_CLOSED(self);

if (size < 1) {

size = DEFAULT_BUFFER_SIZE;

}

/* adjust invalid sizes */

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

if (size > n) {

size = n;

/* n can be negative after truncate() or seek() */

if (size < 0) {

size = 0;

}

}

return peek_bytes_lock_held(self, size);

}

static PyObject *

_io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size)

{

Py_ssize_t n;

CHECK_CLOSED(self);

n = scan_eol_lock_held(self, size);

return read_bytes_lock_held(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_lock_held(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) {

/* gh-141311: Avoid undefined behavior when self->pos (limit

return PyLong_FromSsize_t(0);

}

}

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

assert(len >= 0);

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

self->pos += len;

return PyLong_FromSsize_t(len);

}

static PyObject *

_io_BytesIO_truncate_impl(bytesio *self, PyObject *size)

{

CHECK_CLOSED(self);

CHECK_EXPORTS(self);

Py_ssize_t new_size;

if (size == Py_None) {

new_size = self->pos;

}

else {

new_size = PyLong_AsLong(size);

if (new_size == -1 && PyErr_Occurred()) {

return NULL;

}

if (new_size < 0) {

PyErr_Format(PyExc_ValueError,

"negative size value %zd", new_size);

return NULL;

}

}

if (new_size < self->string_size) {

Py_ssize_t old_string_size = self->string_size;

self->string_size = new_size;

if (resize_buffer_lock_held(self, new_size) < 0) {

self->string_size = old_string_size;

return NULL;

}

}

return PyLong_FromSsize_t(new_size);

}

static PyObject *

bytesio_iternext_lock_held(PyObject *op)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

Py_ssize_t n;

bytesio *self = bytesio_CAST(op);

CHECK_CLOSED(self);

n = scan_eol_lock_held(self, -1);

if (n == 0)

return NULL;

return read_bytes_lock_held(self, n);

}

static PyObject *

bytesio_iternext(PyObject *op)

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytesio_iternext_lock_held(op);

Py_END_CRITICAL_SECTION();

return ret;

}

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

{

/* The exported buffers keep the internal buffer alive. */

Py_CLEAR(self->buf);

Py_RETURN_NONE;

}

static PyObject *

bytesio_getstate_lock_held(PyObject *op)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

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_getstate(PyObject *op, PyObject *Py_UNUSED(dummy))

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytesio_getstate_lock_held(op);

Py_END_CRITICAL_SECTION();

return ret;

}

static PyObject *

bytesio_setstate_lock_held(PyObject *op, PyObject *state)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyObject *result;

PyObject *position_obj;

PyObject *dict;

Py_ssize_t pos;

bytesio *self = bytesio_CAST(op);