IGNIETFERRO-1816 Update Python 3 from 3.9.12 to 3.10.4

ref:9f96be6d02ee8044fdd6f124b799b270c20ce641

1 files changed, 149 insertions, 119 deletions

diff --git a/contrib/tools/python3/src/Modules/sha256module.c b/contrib/tools/python3/src/Modules/sha256module.c
index 9b885c72553..fac7073d951 100644
--- a/contrib/tools/python3/src/Modules/sha256module.c
+++ b/contrib/tools/python3/src/Modules/sha256module.c
@@ -17,7 +17,7 @@
 /* SHA objects */
 
 #include "Python.h"
-#include "pycore_byteswap.h"      // _Py_bswap32()
+#include "pycore_bitutils.h"      // _Py_bswap32()
 #include "structmember.h"         // PyMemberDef
 #include "hashlib.h"
 #include "pystrhex.h"
@@ -51,6 +51,19 @@ typedef struct {
 
 #include "clinic/sha256module.c.h"
 
+typedef struct {
+    PyTypeObject* sha224_type;
+    PyTypeObject* sha256_type;
+} _sha256_state;
+
+static inline _sha256_state*
+_sha256_get_state(PyObject *module)
+{
+    void *state = PyModule_GetState(module);
+    assert(state != NULL);
+    return (_sha256_state *)state;
+}
+
 /* When run on a little-endian CPU we need to perform byte reversal on an
    array of longwords. */
 
@@ -365,28 +378,40 @@ sha_final(unsigned char digest[SHA_DIGESTSIZE], SHAobject *sha_info)
  * ------------------------------------------------------------------------
  */
 
-static PyTypeObject SHA224type;
-static PyTypeObject SHA256type;
-
 
 static SHAobject *
-newSHA224object(void)
+newSHA224object(_sha256_state *state)
 {
-    return (SHAobject *)PyObject_New(SHAobject, &SHA224type);
+    SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject,
+                                                  state->sha224_type);
+    PyObject_GC_Track(sha);
+    return sha;
 }
 
 static SHAobject *
-newSHA256object(void)
+newSHA256object(_sha256_state *state)
 {
-    return (SHAobject *)PyObject_New(SHAobject, &SHA256type);
+    SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject,
+                                                  state->sha256_type);
+    PyObject_GC_Track(sha);
+    return sha;
 }
 
 /* Internal methods for a hash object */
+static int
+SHA_traverse(PyObject *ptr, visitproc visit, void *arg)
+{
+    Py_VISIT(Py_TYPE(ptr));
+    return 0;
+}
 
 static void
 SHA_dealloc(PyObject *ptr)
 {
-    PyObject_Del(ptr);
+    PyTypeObject *tp = Py_TYPE(ptr);
+    PyObject_GC_UnTrack(ptr);
+    PyObject_GC_Del(ptr);
+    Py_DECREF(tp);
 }
 
 
@@ -395,21 +420,25 @@ SHA_dealloc(PyObject *ptr)
 /*[clinic input]
 SHA256Type.copy
 
+    cls:defining_class
+
 Return a copy of the hash object.
 [clinic start generated code]*/
 
 static PyObject *
-SHA256Type_copy_impl(SHAobject *self)
-/*[clinic end generated code: output=1a8bbd66a0c9c168 input=f58840a618d4f2a7]*/
+SHA256Type_copy_impl(SHAobject *self, PyTypeObject *cls)
+/*[clinic end generated code: output=9273f92c382be12f input=3137146fcb88e212]*/
 {
     SHAobject *newobj;
-
-    if (Py_IS_TYPE(self, &SHA256type)) {
-        if ( (newobj = newSHA256object())==NULL)
+    _sha256_state *state = PyType_GetModuleState(cls);
+    if (Py_IS_TYPE(self, state->sha256_type)) {
+        if ( (newobj = newSHA256object(state)) == NULL) {
             return NULL;
+        }
     } else {
-        if ( (newobj = newSHA224object())==NULL)
+        if ( (newobj = newSHA224object(state))==NULL) {
             return NULL;
+        }
     }
 
     SHAcopy(self, newobj);
@@ -517,74 +546,30 @@ static PyMemberDef SHA_members[] = {
     {NULL}  /* Sentinel */
 };
 
-static PyTypeObject SHA224type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_sha256.sha224",   /*tp_name*/
-    sizeof(SHAobject),  /*tp_basicsize*/
-    0,                  /*tp_itemsize*/
-    /* methods */
-    SHA_dealloc,        /*tp_dealloc*/
-    0,                  /*tp_vectorcall_offset*/
-    0,                  /*tp_getattr*/
-    0,                  /*tp_setattr*/
-    0,                  /*tp_as_async*/
-    0,                  /*tp_repr*/
-    0,                  /*tp_as_number*/
-    0,                  /*tp_as_sequence*/
-    0,                  /*tp_as_mapping*/
-    0,                  /*tp_hash*/
-    0,                  /*tp_call*/
-    0,                  /*tp_str*/
-    0,                  /*tp_getattro*/
-    0,                  /*tp_setattro*/
-    0,                  /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT, /*tp_flags*/
-    0,                  /*tp_doc*/
-    0,                  /*tp_traverse*/
-    0,                  /*tp_clear*/
-    0,                  /*tp_richcompare*/
-    0,                  /*tp_weaklistoffset*/
-    0,                  /*tp_iter*/
-    0,                  /*tp_iternext*/
-    SHA_methods,        /* tp_methods */
-    SHA_members,        /* tp_members */
-    SHA_getseters,      /* tp_getset */
+static PyType_Slot sha256_types_slots[] = {
+    {Py_tp_dealloc, SHA_dealloc},
+    {Py_tp_methods, SHA_methods},
+    {Py_tp_members, SHA_members},
+    {Py_tp_getset, SHA_getseters},
+    {Py_tp_traverse, SHA_traverse},
+    {0,0}
 };
 
-static PyTypeObject SHA256type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    "_sha256.sha256",   /*tp_name*/
-    sizeof(SHAobject),  /*tp_basicsize*/
-    0,                  /*tp_itemsize*/
-    /* methods */
-    SHA_dealloc,        /*tp_dealloc*/
-    0,                  /*tp_vectorcall_offset*/
-    0,                  /*tp_getattr*/
-    0,                  /*tp_setattr*/
-    0,                  /*tp_as_async*/
-    0,                  /*tp_repr*/
-    0,                  /*tp_as_number*/
-    0,                  /*tp_as_sequence*/
-    0,                  /*tp_as_mapping*/
-    0,                  /*tp_hash*/
-    0,                  /*tp_call*/
-    0,                  /*tp_str*/
-    0,                  /*tp_getattro*/
-    0,                  /*tp_setattro*/
-    0,                  /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT, /*tp_flags*/
-    0,                  /*tp_doc*/
-    0,                  /*tp_traverse*/
-    0,                  /*tp_clear*/
-    0,                  /*tp_richcompare*/
-    0,                  /*tp_weaklistoffset*/
-    0,                  /*tp_iter*/
-    0,                  /*tp_iternext*/
-    SHA_methods,        /* tp_methods */
-    SHA_members,        /* tp_members */
-    SHA_getseters,      /* tp_getset */
+static PyType_Spec sha224_type_spec = {
+    .name = "_sha256.sha224",
+    .basicsize = sizeof(SHAobject),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
+    .slots = sha256_types_slots
 };
 
+static PyType_Spec sha256_type_spec = {
+    .name = "_sha256.sha256",
+    .basicsize = sizeof(SHAobject),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
+    .slots = sha256_types_slots
+};
 
 /* The single module-level function: new() */
 
@@ -602,15 +587,19 @@ static PyObject *
 _sha256_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity)
 /*[clinic end generated code: output=a1de327e8e1185cf input=9be86301aeb14ea5]*/
 {
-    SHAobject *new;
     Py_buffer buf;
 
-    if (string)
+    if (string) {
         GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
+    }
 
-    if ((new = newSHA256object()) == NULL) {
-        if (string)
+    _sha256_state *state = PyModule_GetState(module);
+
+    SHAobject *new;
+    if ((new = newSHA256object(state)) == NULL) {
+        if (string) {
             PyBuffer_Release(&buf);
+        }
         return NULL;
     }
 
@@ -618,8 +607,9 @@ _sha256_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity)
 
     if (PyErr_Occurred()) {
         Py_DECREF(new);
-        if (string)
+        if (string) {
             PyBuffer_Release(&buf);
+        }
         return NULL;
     }
     if (string) {
@@ -644,15 +634,17 @@ static PyObject *
 _sha256_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity)
 /*[clinic end generated code: output=08be6b36569bc69c input=9fcfb46e460860ac]*/
 {
-    SHAobject *new;
     Py_buffer buf;
-
-    if (string)
+    if (string) {
         GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
+    }
 
-    if ((new = newSHA224object()) == NULL) {
-        if (string)
+    _sha256_state *state = PyModule_GetState(module);
+    SHAobject *new;
+    if ((new = newSHA224object(state)) == NULL) {
+        if (string) {
             PyBuffer_Release(&buf);
+        }
         return NULL;
     }
 
@@ -660,8 +652,9 @@ _sha256_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity)
 
     if (PyErr_Occurred()) {
         Py_DECREF(new);
-        if (string)
+        if (string) {
             PyBuffer_Release(&buf);
+        }
         return NULL;
     }
     if (string) {
@@ -681,43 +674,80 @@ static struct PyMethodDef SHA_functions[] = {
     {NULL,      NULL}            /* Sentinel */
 };
 
+static int
+_sha256_traverse(PyObject *module, visitproc visit, void *arg)
+{
+    _sha256_state *state = _sha256_get_state(module);
+    Py_VISIT(state->sha224_type);
+    Py_VISIT(state->sha256_type);
+    return 0;
+}
 
-/* Initialize this module. */
+static int
+_sha256_clear(PyObject *module)
+{
+    _sha256_state *state = _sha256_get_state(module);
+    Py_CLEAR(state->sha224_type);
+    Py_CLEAR(state->sha256_type);
+    return 0;
+}
 
-static struct PyModuleDef _sha256module = {
-        PyModuleDef_HEAD_INIT,
-        "_sha256",
-        NULL,
-        -1,
-        SHA_functions,
-        NULL,
-        NULL,
-        NULL,
-        NULL
-};
+static void
+_sha256_free(void *module)
+{
+    _sha256_clear((PyObject *)module);
+}
 
-PyMODINIT_FUNC
-PyInit__sha256(void)
+static int sha256_exec(PyObject *module)
 {
-    PyObject *m;
+    _sha256_state *state = _sha256_get_state(module);
 
-    Py_SET_TYPE(&SHA224type, &PyType_Type);
-    if (PyType_Ready(&SHA224type) < 0) {
-        return NULL;
+    state->sha224_type = (PyTypeObject *)PyType_FromModuleAndSpec(
+        module, &sha224_type_spec, NULL);
+
+    if (state->sha224_type == NULL) {
+        return -1;
     }
-    Py_SET_TYPE(&SHA256type, &PyType_Type);
-    if (PyType_Ready(&SHA256type) < 0) {
-        return NULL;
+
+    state->sha256_type = (PyTypeObject *)PyType_FromModuleAndSpec(
+        module, &sha256_type_spec, NULL);
+
+    if (state->sha256_type == NULL) {
+        return -1;
     }
 
-    m = PyModule_Create(&_sha256module);
-    if (m == NULL)
-        return NULL;
+    Py_INCREF((PyObject *)state->sha224_type);
+    if (PyModule_AddObject(module, "SHA224Type", (PyObject *)state->sha224_type) < 0) {
+        Py_DECREF((PyObject *)state->sha224_type);
+        return -1;
+    }
+    Py_INCREF((PyObject *)state->sha256_type);
+    if (PyModule_AddObject(module, "SHA256Type", (PyObject *)state->sha256_type) < 0) {
+        Py_DECREF((PyObject *)state->sha256_type);
+        return -1;
+    }
+    return 0;
+}
+
+static PyModuleDef_Slot _sha256_slots[] = {
+    {Py_mod_exec, sha256_exec},
+    {0, NULL}
+};
 
-    Py_INCREF((PyObject *)&SHA224type);
-    PyModule_AddObject(m, "SHA224Type", (PyObject *)&SHA224type);
-    Py_INCREF((PyObject *)&SHA256type);
-    PyModule_AddObject(m, "SHA256Type", (PyObject *)&SHA256type);
-    return m;
+static struct PyModuleDef _sha256module = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "_sha256",
+    .m_size = sizeof(_sha256_state),
+    .m_methods = SHA_functions,
+    .m_slots = _sha256_slots,
+    .m_traverse = _sha256_traverse,
+    .m_clear = _sha256_clear,
+    .m_free = _sha256_free
+};
 
+/* Initialize this module. */
+PyMODINIT_FUNC
+PyInit__sha256(void)
+{
+    return PyModuleDef_Init(&_sha256module);
 }