gh-126554: ctypes: Correctly handle NULL dlsym values

Lib/test/test_ctypes/test_dlerror.py

@@ -0,0 +1,69 @@
+import os.path
+import sys
+import unittest
+from ctypes import CDLL
+
+FOO_C = r"""
+#include <stdio.h>
+
+/* This is a 'GNU indirect function' (IFUNC) that will be called by
+   dlsym() to resolve the symbol "foo" to an address. Typically, such
+   a function would return the address of an actual function, but it
+   can also just return NULL.  For some background on IFUNCs, see
+   https://willnewton.name/uncategorized/using-gnu-indirect-functions/
+
+   Adapted from Michael Kerrisk's answer: https://stackoverflow.com/a/53590014
+*/
+
+asm (".type foo, @gnu_indirect_function");
+
+void *foo(void)
+{
+    fprintf(stderr, "foo IFUNC called\n");
+    return NULL;
+}
+"""
+
+
+@unittest.skipUnless(sys.platform.startswith('linux'),
+                     'Test only valid for Linux')
+class TestNullDlsym(unittest.TestCase):
+    def test_null_dlsym(self):
+        import subprocess
+        import tempfile
+
+        try:
+            p = subprocess.Popen(['gcc', '--version'], stdout=subprocess.PIPE,
+                                 stderr=subprocess.DEVNULL)
+            out, _ = p.communicate()
+        except OSError:
+            raise unittest.SkipTest('gcc, needed for test, not available')
+        with tempfile.TemporaryDirectory() as d:
+            # Create a source file foo.c, that uses
+            # a GNU Indirect Function. See FOO_C.
+            srcname = os.path.join(d, 'foo.c')
+            libname = 'py_ctypes_test_null_dlsym'
+            dstname = os.path.join(d, 'lib%s.so' % libname)
+            with open(srcname, 'w') as f:
+                f.write(FOO_C)
+            self.assertTrue(os.path.exists(srcname))
+            # Compile the file to a shared library
+            cmd = ['gcc', '-fPIC', '-shared', '-o', dstname, srcname]
+            out = subprocess.check_output(cmd)
+            self.assertTrue(os.path.exists(dstname))
+            # Load the shared library
+            L = CDLL(dstname)
+
+            with self.assertRaises(AttributeError) as cm:
+                # Try accessing the 'foo' symbol.
+                # It should resolve via dlsym() to NULL,
+                # and since we subjectively treat NULL
+                # addresses as errors, we should get
+                # an error.
+                L.foo
+
+            self.assertEqual(str(cm.exception),
+                             "function 'foo' not found")
+
+if __name__ == "__main__":
+    unittest.main()

Misc/NEWS.d/next/C_API/2024-11-07-20-24-58.gh-issue-126554.ri12eb.rst

@@ -0,0 +1 @@
+Fix rare crash upon system failure in :class:`ctypes.CDLL`.

Modules/_ctypes/_ctypes.c

@@ -967,18 +967,34 @@ CDataType_in_dll_impl(PyObject *type, PyTypeObject *cls, PyObject *dll,
         return NULL;
     }
 #else
+	/* dlerror() always returns the latest error.
+	 *
+	 * Clear the previous value before calling dlsym(),
+	 * to ensure we can tell if our call resulted in an error.
+	 */
+    dlerror();
     address = (void *)dlsym(handle, name);
-    if (!address) {
 #ifdef __CYGWIN__
-/* dlerror() isn't very helpful on cygwin */
+    if (!address) {
+        /* dlerror() isn't very helpful on cygwin */
         PyErr_Format(PyExc_ValueError,
                      "symbol '%s' not found",
                      name);
+        return NULL;
+    }
 #else
-        PyErr_SetString(PyExc_ValueError, dlerror());
-#endif
+    char *dlerr = dlerror();
+    if (dlerr) {
+        PyErr_SetString(PyExc_ValueError, dlerr);
+        return NULL;
+    }
+    else if (!address) {
+        PyErr_Format(PyExc_ValueError,
+                     "symbol '%s' not found",
+                     name);
         return NULL;
     }
+#endif
 #endif
     ctypes_state *st = get_module_state_by_def(Py_TYPE(type));
     return PyCData_AtAddress(st, type, address);
@@ -3774,19 +3790,37 @@ PyCFuncPtr_FromDll(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     }
 #else
+	/* dlerror() always returns the latest error.
+	 *
+	 * Clear the previous value before calling dlsym(),
+	 * to ensure we can tell if our call resulted in an error.
+	 */
+    dlerror();
     address = (PPROC)dlsym(handle, name);
-    if (!address) {
 #ifdef __CYGWIN__
-/* dlerror() isn't very helpful on cygwin */
+    if (!address) {
+        /* dlerror() isn't very helpful on cygwin */
         PyErr_Format(PyExc_AttributeError,
                      "function '%s' not found",
                      name);
+        Py_DECREF(ftuple);
+        return NULL;
+    }
 #else
-        PyErr_SetString(PyExc_AttributeError, dlerror());
-#endif
+    char *dlerr = dlerror();
+    if (dlerr) {
+        PyErr_SetString(PyExc_AttributeError, dlerr);
+        Py_DECREF(ftuple);
+        return NULL;
+    }
+    else if (!address) {
+        PyErr_Format(PyExc_AttributeError,
+                     "function '%s' not found",
+                     name);
         Py_DECREF(ftuple);
         return NULL;
     }
+#endif
 #endif
     ctypes_state *st = get_module_state_by_def(Py_TYPE(type));
     if (!_validate_paramflags(st, type, paramflags)) {

Modules/_ctypes/callproc.c

@@ -1623,10 +1623,23 @@ static PyObject *py_dl_sym(PyObject *self, PyObject *args)
     if (PySys_Audit("ctypes.dlsym/handle", "O", args) < 0) {
         return NULL;
     }
+
+	/* dlerror() always returns the latest error.
+	 *
+	 * Clear the previous value before calling dlsym(),
+	 * to ensure we can tell if our call resulted in an error.
+	 */
+	dlerror();
     ptr = dlsym((void*)handle, name);
-    if (!ptr) {
-        PyErr_SetString(PyExc_OSError,
-                               dlerror());
+	char *dlerr = dlerror();
+    if (dlerr) {
+        PyErr_SetString(PyExc_OSError, dlerr);
+        return NULL;
+    }
+    else if (!ptr) {
+        PyErr_Format(PyExc_OSError,
+                     "symbol '%s' not found",
+                     name);
         return NULL;
     }
     return PyLong_FromVoidPtr(ptr);