From 45120f19b89a3ab9c4ceb832495b513b42f22ae7 Mon Sep 17 00:00:00 2001 From: Cody Maloney Date: Sat, 21 Nov 2026 03:11:40 -0800 Subject: [PATCH] gh-162246: Fix leak when re-initializing `BufferedRWPair` Calling `BufferedRWPair.__init__()` on an already initialized object overwrote the reader and writer pointers without releasing the previous objects. Build the new reader and writer first, then swap them in, releasing the old writer before the old reader as in `bufferedrwpair_clear()`. Make the Python implementation release the old writer before the old reader too, so pending writes are not lost when both share a raw stream. Co-Authored-By: Claude Opus 5.5 --- Lib/_pyio.py | 8 ++++++-- Lib/test/test_io/test_bufferedio.py | 15 +++++++++++++++ ...2026-11-21-11-11-34.gh-issue-162246.jN-ORE.rst | 2 ++ Modules/_io/bufferedio.c | 15 ++++++++++----- 4 files changed, 33 insertions(+), 7 deletions(-) create mode 100644 Misc/NEWS.d/next/Library/2026-11-21-11-11-34.gh-issue-162246.jN-ORE.rst diff --git a/Lib/_pyio.py b/Lib/_pyio.py index ec1b20d0426768..034d81a9bc1885 100644 --- a/Lib/_pyio.py +++ b/Lib/_pyio.py @@ -1394,8 +1394,12 @@ def __init__(self, reader, writer, buffer_size=DEFAULT_BUFFER_SIZE): if not writer.writable(): raise OSError('"writer" argument must be writable.') - self.reader = BufferedReader(reader, buffer_size) - self.writer = BufferedWriter(writer, buffer_size) + new_reader = BufferedReader(reader, buffer_size) + new_writer = BufferedWriter(writer, buffer_size) + # Release a previous writer before a previous reader so it flushes + # before the reader closes a shared raw stream. + self.writer = new_writer + self.reader = new_reader def read(self, size=-1): if size is None: diff --git a/Lib/test/test_io/test_bufferedio.py b/Lib/test/test_io/test_bufferedio.py index 997e335591b483..b114a927c7cb1e 100644 --- a/Lib/test/test_io/test_bufferedio.py +++ b/Lib/test/test_io/test_bufferedio.py @@ -1032,6 +1032,21 @@ def test_uninitialized(self): self.assertEqual(pair.read(0), b'') self.assertEqual(pair.write(b''), 0) + def test_reinit(self): + # gh-162246: Calling __init__() again must release the previous + # reader and writer, the writer first so it flushes before the + # reader closes a shared raw stream. + raw = self.MockRawIO() + pair = self.tp(raw, raw) + pair.write(b"abc") + ref = weakref.ref(raw) + pair.__init__(self.MockRawIO(), self.MockRawIO()) + support.gc_collect() + self.assertEqual(raw._write_stack, [b"abc"]) + del raw + support.gc_collect() + self.assertIsNone(ref()) + def test_detach(self): pair = self.tp(self.MockRawIO(), self.MockRawIO()) self.assertRaises(self.UnsupportedOperation, pair.detach) diff --git a/Misc/NEWS.d/next/Library/2026-11-21-11-11-34.gh-issue-162246.jN-ORE.rst b/Misc/NEWS.d/next/Library/2026-11-21-11-11-34.gh-issue-162246.jN-ORE.rst new file mode 100644 index 00000000000000..d596bd87ad31e9 --- /dev/null +++ b/Misc/NEWS.d/next/Library/2026-11-21-11-11-34.gh-issue-162246.jN-ORE.rst @@ -0,0 +1,2 @@ +Fix a reference leak in :class:`io.BufferedRWPair` when :meth:`~object.__init__` +is called more than once: the previous reader and writer are now released. diff --git a/Modules/_io/bufferedio.c b/Modules/_io/bufferedio.c index f585bd8483370f..9e5a7216ee013b 100644 --- a/Modules/_io/bufferedio.c +++ b/Modules/_io/bufferedio.c @@ -2287,20 +2287,25 @@ _io_BufferedRWPair___init___impl(rwpair *self, PyObject *reader, return -1; } - self->reader = (buffered *) PyObject_CallFunction( + buffered *new_reader = (buffered *) PyObject_CallFunction( (PyObject *)state->PyBufferedReader_Type, "On", reader, buffer_size); - if (self->reader == NULL) + if (new_reader == NULL) { return -1; + } - self->writer = (buffered *) PyObject_CallFunction( + buffered *new_writer = (buffered *) PyObject_CallFunction( (PyObject *)state->PyBufferedWriter_Type, "On", writer, buffer_size); - if (self->writer == NULL) { - Py_CLEAR(self->reader); + if (new_writer == NULL) { + Py_DECREF(new_reader); return -1; } + /* Release a previous writer before a previous reader, see + bufferedrwpair_clear(). */ + Py_XSETREF(self->writer, new_writer); + Py_XSETREF(self->reader, new_reader); return 0; }