python · erlend-aasland · Oct 25, 2023 · Oct 23, 2023 · Oct 24, 2023 · Oct 25, 2023
diff --git a/Misc/NEWS.d/next/Library/2023-10-23-23-14-54.gh-issue-111233.sCdCC0.rst b/Misc/NEWS.d/next/Library/2023-10-23-23-14-54.gh-issue-111233.sCdCC0.rst
@@ -0,0 +1 @@
+Fix :mod:`select` not checking for errors when initializing.
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
@@ -2444,12 +2444,19 @@ _select_exec(PyObject *m)
         return -1;
     }
 
+#define ADD_INT(VAL) \
+    do { \
+        if (PyModule_AddIntConstant((m), #V
10000
AL, (VAL)) < 0) { \
+            return -1; \
+        } \
+    } while (0)
+
 #ifdef PIPE_BUF
 #ifdef HAVE_BROKEN_PIPE_BUF
 #undef PIPE_BUF
 #define PIPE_BUF 512
 #endif
-    PyModule_AddIntMacro(m, PIPE_BUF);
+    ADD_INT(PIPE_BUF);
 #endif
 
 #if defined(HAVE_POLL) && !defined(HAVE_BROKEN_POLL)
@@ -2468,31 +2475,31 @@ _select_exec(PyObject *m)
             return -1;
         }
 
-        PyModule_AddIntMacro(m, POLLIN);
-        PyModule_AddIntMacro(m, POLLPRI);
-        PyModule_AddIntMacro(m, POLLOUT);
-        PyModule_AddIntMacro(m, POLLERR);
-        PyModule_AddIntMacro(m, POLLHUP);
-        PyModule_AddIntMacro(m, POLLNVAL);
+        ADD_INT(POLLIN);
+        ADD_INT(POLLPRI);
+        ADD_INT(POLLOUT);
+        ADD_INT(POLLERR);
+        ADD_INT(POLLHUP);
+        ADD_INT(POLLNVAL);
 
 #ifdef POLLRDNORM
-        PyModule_AddIntMacro(m, POLLRDNORM);
+        ADD_INT(POLLRDNORM);
 #endif
 #ifdef POLLRDBAND
-        PyModule_AddIntMacro(m, POLLRDBAND);
+        ADD_INT(POLLRDBAND);
 #endif
 #ifdef POLLWRNORM
-        PyModule_AddIntMacro(m, POLLWRNORM);
+        ADD_INT(POLLWRNORM);
 #endif
 #ifdef POLLWRBAND
-        PyModule_AddIntMacro(m, POLLWRBAND);
+        ADD_INT(POLLWRBAND);
 #endif
 #ifdef POLLMSG
-        PyModule_AddIntMacro(m, POLLMSG);
+        ADD_INT(POLLMSG);
 #endif
 #ifdef POLLRDHUP
         /* Kernel 2.6.17+ */
-        PyModule_AddIntMacro(m, POLLRDHUP);
+        ADD_INT(POLLRDHUP);
 #endif
     }
 #endif /* HAVE_POLL */
@@ -2515,45 +2522,54 @@ _select_exec(PyObject *m)
         return -1;
     }
 
-    PyModule_AddIntMacro(m, EPOLLIN);
-    PyModule_AddIntMacro(m, EPOLLOUT);
-    PyModule_AddIntMacro(m, EPOLLPRI);
-    PyModule_AddIntMacro(m, EPOLLERR);
-    PyModule_AddIntMacro(m, EPOLLHUP);
+    ADD_INT(EPOLLIN);
+    ADD_INT(EPOLLOUT);
+    ADD_INT(EPOLLPRI);
+    ADD_INT(EPOLLERR);
+    ADD_INT(EPOLLHUP);
 #ifdef EPOLLRDHUP
     /* Kernel 2.6.17 */
-    PyModule_AddIntMacro(m, EPOLLRDHUP);
+    ADD_INT(EPOLLRDHUP);
 #endif
-    PyModule_AddIntMacro(m, EPOLLET);
+    ADD_INT(EPOLLET);
 #ifdef EPOLLONESHOT
     /* Kernel 2.6.2+ */
-    PyModule_AddIntMacro(m, EPOLLONESHOT);
+    ADD_INT(EPOLLONESHOT);
 #endif
 #ifdef EPOLLEXCLUSIVE
-    PyModule_AddIntMacro(m, EPOLLEXCLUSIVE);
+    ADD_INT(EPOLLEXCLUSIVE);
 #endif
 
 #ifdef EPOLLRDNORM
-    PyModule_AddIntMacro(m, EPOLLRDNORM);
+    ADD_INT(EPOLLRDNORM);
 #endif
 #ifdef EPOLLRDBAND
-    PyModule_AddIntMacro(m, EPOLLRDBAND);
+    ADD_INT(EPOLLRDBAND);
 #endif
 #ifdef EPOLLWRNORM
-    PyModule_AddIntMacro(m, EPOLLWRNORM);
+    ADD_INT(EPOLLWRNORM);
 #endif
 #ifdef EPOLLWRBAND
-    PyModule_AddIntMacro(m, EPOLLWRBAND);
+    ADD_INT(EPOLLWRBAND);
 #endif
 #ifdef EPOLLMSG
-    PyModule_AddIntMacro(m, EPOLLMSG);
+    ADD_INT(EPOLLMSG);
 #endif
 
 #ifdef EPOLL_CLOEXEC
-    PyModule_AddIntMacro(m, EPOLL_CLOEXEC);
+    ADD_INT(EPOLL_CLOEXEC);
 #endif
 #endif /* HAVE_EPOLL */
 
+#undef ADD_INT
+
+#define ADD_INT_CONST(NAME, VAL) \
+    do { \
+        if (PyModule_AddIntConstant(m, NAME, VAL) < 0) { \
+            return -1; \
+        } \
+    } while (0)
+
 #ifdef HAVE_KQUEUE
     state->kqueue_event_Type = (PyTypeObject *)PyType_FromModuleAndSpec(
         m, &kqueue_event_Type_spec, NULL);
@@ -2574,80 +2590,83 @@ _select_exec(PyObject *m)
     }
 
     /* event filters */
-    PyModule_AddIntConstant(m, "KQ_FILTER_READ", EVFILT_READ);
-    PyModule_AddIntConstant(m, "KQ_FILTER_WRITE", EVFILT_WRITE);
+    ADD_INT_CONST("KQ_FILTER_READ", EVFILT_READ);
+    ADD_INT_CONST("KQ_FILTER_WRITE", EVFILT_WRITE);
 #ifdef EVFILT_AIO
-    PyModule_AddIntConstant(m, "KQ_FILTER_AIO", EVFILT_AIO);
+    ADD_INT_CONST("KQ_FILTER_AIO", EVFILT_AIO);
 #endif
 #ifdef EVFILT_VNODE
-    PyModule_AddIntConstant(m, "KQ_FILTER_VNODE", EVFILT_VNODE);
+    ADD_INT_CONST("KQ_FILTER_VNODE", EVFILT_VNODE);
 #endif
 #ifdef EVFILT_PROC
-    PyModule_AddIntConstant(m, "KQ_FILTER_PROC", EVFILT_PROC);
+    ADD_INT_CONST("KQ_FILTER_PROC", EVFILT_PROC);
 #endif
 #ifdef EVFILT_NETDEV
-    PyModule_AddIntConstant(m, "KQ_FILTER_NETDEV", EVFILT_NETDEV);
+    ADD_INT_CONST("KQ_FILTER_NETDEV", EVFILT_NETDEV);
 #endif
 #ifdef EVFILT_SIGNAL
-    PyModule_AddIntConstant(m, "KQ_FILTER_SIGNAL", EVFILT_SIGNAL);
+    ADD_INT_CONST("KQ_FILTER_SIGNAL", EVFILT_SIGNAL);
 #endif
-    PyModule_AddIntConstant(m, "KQ_FILTER_TIMER", EVFILT_TIMER);
+    ADD_INT_CONST("KQ_FILTER_TIMER", EVFILT_TIMER);
 
     /* event flags */
-    PyModule_AddIntConstant(m, "KQ_EV_ADD", EV_ADD);
-    PyModule_AddIntConstant(m, "KQ_EV_DELETE", EV_DELETE);
-    PyModule_AddIntConstant(m, "KQ_EV_ENABLE", EV_ENABLE);
-    PyModule_AddIntConstant(m, "KQ_EV_DISABLE", EV_DISABLE);
-    PyModule_AddIntConstant(m, "KQ_EV_ONESHOT", EV_ONESHOT);
-    PyModule_AddIntConstant(m, "KQ_EV_CLEAR", EV_CLEAR);
+    ADD_INT_CONST("KQ_EV_ADD", EV_ADD);
+    ADD_INT_CONST("KQ_EV_DELETE", EV_DELETE);
+    ADD_INT_CONST("KQ_EV_ENABLE", EV_ENABLE);
+    ADD_INT_CONST("KQ_EV_DISABLE", EV_DISABLE);
+    ADD_INT_CONST("KQ_EV_ONESHOT", EV_ONESHOT);
+    ADD_INT_CONST("KQ_EV_CLEAR", EV_CLEAR);
 
 #ifdef EV_SYSFLAGS
-    PyModule_AddIntConstant(m, "KQ_EV_SYSFLAGS", EV_SYSFLAGS);
+    ADD_INT_CONST("KQ_EV_SYSFLAGS", EV_SYSFLAGS);
 #endif
 #ifdef EV_FLAG1
-    PyModule_AddIntConstant(m, "KQ_EV_FLAG1", EV_FLAG1);
+    ADD_INT_CONST("KQ_EV_FLAG1", EV_FLAG1);
 #endif
 
-    PyModule_AddIntConstant(m, "KQ_EV_EOF", EV_EOF);
-    PyModule_AddIntConstant(m, "KQ_EV_ERROR", EV_ERROR);
+    ADD_INT_CONST("KQ_EV_EOF", EV_EOF);
+    ADD_INT_CONST("KQ_EV_ERROR", EV_ERROR);
 
     /* READ WRITE filter flag */
 #ifdef NOTE_LOWAT
-    PyModule_AddIntConstant(m, "KQ_NOTE_LOWAT", NOTE_LOWAT);
+    ADD_INT_CONST("KQ_NOTE_LOWAT", NOTE_LOWAT);
 #endif
 
     /* VNODE filter flags  */
 #ifdef EVFILT_VNODE
-    PyModule_AddIntConstant(m, "KQ_NOTE_DELETE", NOTE_DELETE);
-    PyModule_AddIntConstant(m, "KQ_NOTE_WRITE", NOTE_WRITE);
-    PyModule_AddIntConstant(m, "KQ_NOTE_EXTEND", NOTE_EXTEND);
-    PyModule_AddIntConstant(m, "KQ_NOTE_ATTRIB", NOTE_ATTRIB);
-    PyModule_AddIntConstant(m, "KQ_NOTE_LINK", NOTE_LINK);
-    PyModule_AddIntConstant(m, "KQ_NOTE_RENAME", NOTE_RENAME);
-    PyModule_AddIntConstant(m, "KQ_NOTE_REVOKE", NOTE_REVOKE);
+    ADD_INT_CONST("KQ_NOTE_DELETE", NOTE_DELETE);
+    ADD_INT_CONST("KQ_NOTE_WRITE", NOTE_WRITE);
+    ADD_INT_CONST("KQ_NOTE_EXTEND", NOTE_EXTEND);
+    ADD_INT_CONST("KQ_NOTE_ATTRIB", NOTE_ATTRIB);
+    ADD_INT_CONST("KQ_NOTE_LINK", NOTE_LINK);
+    ADD_INT_CONST("KQ_NOTE_RENAME", NOTE_RENAME);
+    ADD_INT_CONST("KQ_NOTE_REVOKE", NOTE_REVOKE);
 #endif
 
     /* PROC filter flags  */
 #ifdef EVFILT_PROC
-    PyModule_AddIntConstant(m, "KQ_NOTE_EXIT", NOTE_EXIT);
-    PyModule_AddIntConstant(m, "KQ_NOTE_FORK", NOTE_FORK);
-    PyModule_AddIntConstant(m, "KQ_NOTE_EXEC", NOTE_EXEC);
-    PyModule_AddIntConstant(m, "KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK);
-    PyModule_AddIntConstant(m, "KQ_NOTE_PDATAMASK", NOTE_PDATAMASK);
-
-    PyModule_AddIntConstant(m, "KQ_NOTE_TRACK", NOTE_TRACK);
-    PyModule_AddIntConstant(m, "KQ_NOTE_CHILD", NOTE_CHILD);
-    PyModule_AddIntConstant(m, "KQ_NOTE_TRACKERR", NOTE_TRACKERR);
+    ADD_INT_CONST("KQ_NOTE_EXIT", NOTE_EXIT);
+    ADD_INT_CONST("KQ_NOTE_FORK", NOTE_FORK);
+    ADD_INT_CONST("KQ_NOTE_EXEC", NOTE_EXEC);
+    ADD_INT_CONST("KQ_NOTE_PCTRLMASK", NOTE_PCTRLMASK);
+    ADD_INT_CONST("KQ_NOTE_PDATAMASK", NOTE_PDATAMASK);
+
+    ADD_INT_CONST("KQ_NOTE_TRACK", NOTE_TRACK);
+    ADD_INT_CONST("KQ_NOTE_CHILD", NOTE_CHILD);
+    ADD_INT_CONST("KQ_NOTE_TRACKERR", NOTE_TRACKERR);
 #endif
 
     /* NETDEV filter flags */
 #ifdef EVFILT_NETDEV
-    PyModule_AddIntConstant(m, "KQ_NOTE_LINKUP", NOTE_LINKUP);
-    PyModule_AddIntConstant(m, "KQ_NOTE_LINKDOWN", NOTE_LINKDOWN);
-    PyModule_AddIntConstant(m, "KQ_NOTE_LINKINV", NOTE_LINKINV);
+    ADD_INT_CONST("KQ_NOTE_LINKUP", NOTE_LINKUP);
+    ADD_INT_CONST("KQ_NOTE_LINKDOWN", NOTE_LINKDOWN);
+    ADD_INT_CONST("KQ_NOTE_LINKINV", NOTE_LINKINV);
 #endif
 
 #endif /* HAVE_KQUEUE */
+
+#undef ADD_INT_CONST
+
     return 0;
 }