gh-78724: raise RuntimeError's when calling methods on non-ready Struct()'s

Calling the ``Struct.__new__()`` dunder without required argument now is
deprecated.  Calling the ``Struct.__init__()`` dunder method on
initialized object now also is deprecated.

Author: skirpichev

Lib/test/test_struct.py

@@ -7,6 +7,7 @@
 import unittest
 import struct
 import sys
+import warnings
 import weakref
 
 from test import support
@@ -575,7 +576,11 @@ def test_Struct_reinitialization(self):
         # Struct instance.  This test can be used to detect the leak
         # when running with regrtest -L.
         s = struct.Struct('i')
-        s.__init__('ii')
+        with self.assertWarns(DeprecationWarning):
+            s.__init__('ii')
+        with warnings.catch_warnings():
+            warnings.simplefilter("error", DeprecationWarning)
+            self.assertRaises(DeprecationWarning, s.__init__, 'ii')
 
     def check_sizeof(self, format_str, number_of_codes):
         # The size of 'PyStructObject'
@@ -783,7 +788,8 @@ class MyStruct(struct.Struct):
             def __init__(self):
                 super().__init__('>h')
 
-        my_struct = MyStruct()
+        with self.assertWarns(DeprecationWarning):
+            my_struct = MyStruct()
         self.assertEqual(my_struct.pack(12345), b'\x30\x39')
 
     def test_repr(self):
@@ -826,8 +832,19 @@ def __bool__(self):
                 S.__init__('I')
                 return True
 
-        self.assertRaises(RuntimeError, S.pack, Evil(), 1)
-        self.assertRaises(RuntimeError, S.pack_into, buf, 0, Evil(), 1)
+        with self.assertWarns(DeprecationWarning):
+            self.assertRaises(RuntimeError, S.pack, Evil(), 1)
+            self.assertRaises(RuntimeError, S.pack_into, buf, 0, Evil(), 1)
+
+    def test_operations_on_half_initialized_Struct(self):
+        with self.assertWarns(DeprecationWarning):
+            S = struct.Struct.__new__(struct.Struct)
+
+        spam = array.array('b', b' ')
+        for attr in ['iter_unpack', 'pack', 'pack_into',
+                     'unpack', 'unpack_from']:
+            meth = getattr(S, attr)
+            self.assertRaises(RuntimeError, meth, spam)
 
 
 class UnpackIteratorTest(unittest.TestCase):

Misc/NEWS.d/next/Library/2026-01-10-10-04-08.gh-issue-78724.xkXfxX.rst

@@ -0,0 +1,6 @@
+Prevent crashes due to using half-initialized :class:`~struct.Struct`
+objects. For example, created by ``Struct.__new__(Struct)``.  Calling the
+``Struct.__new__()`` dunder without required argument now is deprecated.
+Calling :meth:`~object.__init__` dunder method of :class:`~struct.Struct`
+object on initialized object now also is deprecated.  Patch by Sergey B
+Kirpichev.

Modules/_struct.c

@@ -71,6 +71,7 @@ typedef struct {
     PyObject *s_format;
     PyObject *weakreflist; /* List of weak references */
     PyMutex mutex; /* to prevent mutation during packing */
+    bool ready;
 } PyStructObject;
 
 #define PyStructObject_CAST(op)     ((PyStructObject *)(op))
@@ -1763,6 +1764,12 @@ s_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     PyObject *self;
 
+    if (PyTuple_GET_SIZE(args) != 1
+        && PyErr_WarnEx(PyExc_DeprecationWarning,
+                        "Struct().__new__() has one required argument", 1))
+    {
+        return NULL;
+    }
     assert(type != NULL);
     allocfunc alloc_func = PyType_GetSlot(type, Py_tp_alloc);
     assert(alloc_func != NULL);
@@ -1775,6 +1782,7 @@ s_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         s->s_size = -1;
         s->s_len = -1;
         s->mutex = (PyMutex){0};
+        s->ready = false;
     }
     return self;
 }
@@ -1796,8 +1804,13 @@ static int
 Struct___init___impl(PyStructObject *self, PyObject *format)
 /*[clinic end generated code: output=b8e80862444e92d0 input=192a4575a3dde802]*/
 {
-    int ret = 0;
-
+    if (self->ready
+        && PyErr_WarnEx(PyExc_DeprecationWarning,
+                        ("Explicit call of __init__() on "
+                         "initialized Struct()"), 1))
+    {
+        return -1;
+    }
     if (PyUnicode_Check(format)) {
         format = PyUnicode_AsASCIIString(format);
         if (format == NULL)
@@ -1823,8 +1836,11 @@ Struct___init___impl(PyStructObject *self, PyObject *format)
                         "Call Struct.__init__() in struct.pack()");
         return -1;
     }
-    ret = prepare_s(self);
-    return ret;
+    if (prepare_s(self)) {
+        return -1;
+    }
+    self->ready = true;
+    return 0;
 }
 
 static int
@@ -1924,6 +1940,10 @@ Struct_unpack_impl(PyStructObject *self, Py_buffer *buffer)
 /*[clinic end generated code: output=873a24faf02e848a input=3113f8e7038b2f6c]*/
 {
     _structmodulestate *state = get_struct_state_structinst(self);
+    if (!self->ready) {
+        PyErr_SetString(PyExc_RuntimeError, "Call unpack on non-initialized Struct()");
+        return NULL;
+    }
     assert(self->s_codes != NULL);
     if (buffer->len != self->s_size) {
         PyErr_Format(state->StructError,
@@ -1956,6 +1976,10 @@ Struct_unpack_from_impl(PyStructObject *self, Py_buffer *buffer,
 /*[clinic end generated code: output=57fac875e0977316 input=cafd4851d473c894]*/
 {
     _structmodulestate *state = get_struct_state_structinst(self);
+    if (!self->ready) {
+        PyErr_SetString(PyExc_RuntimeError, "Call unpack_from on non-initialized Struct()");
+        return NULL;
+    }
     assert(self->s_codes != NULL);
 
     if (offset < 0) {
@@ -2108,6 +2132,10 @@ Struct_iter_unpack_impl(PyStructObject *self, PyObject *buffer)
 {
     _structmodulestate *state = get_struct_state_structinst(self);
     unpackiterobject *iter;
+    if (!self->ready) {
+        PyErr_SetString(PyExc_RuntimeError, "Call iter_unpack on non-initialized Struct()");
+        return NULL;
+    }
 
     assert(self->s_codes != NULL);
 
@@ -2249,6 +2277,10 @@ s_pack(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
 
     /* Validate arguments. */
     soself = PyStructObject_CAST(self);
+    if (!soself->ready) {
+        PyErr_SetString(PyExc_RuntimeError, "Call pack on non-initialized Struct()");
+        return NULL;
+    }
     assert(PyStruct_Check(self, state));
     assert(soself->s_codes != NULL);
     if (nargs != soself->s_len)
@@ -2295,6 +2327,10 @@ s_pack_into(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
 
     /* Validate arguments.  +1 is for the first arg as buffer. */
     soself = PyStructObject_CAST(self);
+    if (!soself->ready) {
+        PyErr_SetString(PyExc_RuntimeError, "Call pack_into on non-initialized Struct()");
+        return NULL;
+    }
     assert(PyStruct_Check(self, state));
     assert(soself->s_codes != NULL);
     if (nargs != (soself->s_len + 2))