Merge branch 'main' into tstrings

Author: lysnikolaou

Include/internal/pycore_ceval.h

@@ -373,6 +373,10 @@ PyAPI_FUNC(_PyStackRef) _PyFloat_FromDouble_ConsumeInputs(_PyStackRef left, _PyS
     #endif
 #endif
 
+#if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG)
+extern int _PyRunRemoteDebugger(PyThreadState *tstate);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

Lib/test/test_sys.py

@@ -2125,6 +2125,19 @@ def test_remote_exec_with_exception(self):
         self.assertIn(b"Remote script exception", stderr)
         self.assertEqual(stdout.strip(), b"Target process running...")
 
+    def test_new_namespace_for_each_remote_exec(self):
+        """Test that each remote_exec call gets its own namespace."""
+        script = textwrap.dedent(
+            """
+            assert globals() is not __import__("__main__").__dict__
+            print("Remote script executed successfully!")
+            """
+        )
+        returncode, stdout, stderr = self._run_remote_exec_test(script)
+        self.assertEqual(returncode, 0)
+        self.assertEqual(stderr, b"")
+        self.assertIn(b"Remote script executed successfully", stdout)
+
     def test_remote_exec_disabled_by_env(self):
         """Test remote exec is disabled when PYTHON_DISABLE_REMOTE_DEBUG is set"""
         env = os.environ.copy()

Modules/signalmodule.c

@@ -1777,6 +1777,10 @@ PyErr_CheckSignals(void)
         _Py_RunGC(tstate);
     }
 
+#if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG)
+    _PyRunRemoteDebugger(tstate);
+#endif
+
     if (!_Py_ThreadCanHandleSignals(tstate->interp)) {
         return 0;
     }

Python/ceval_gil.c

@@ -1193,6 +1193,29 @@ _PyEval_DisableGIL(PyThreadState *tstate)
 #endif
 
 #if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG)
+// Note that this function is inline to avoid creating a PLT entry
+// that would be an easy target for a ROP gadget.
+static inline int run_remote_debugger_source(PyObject *source)
+{
+    const char *str = PyBytes_AsString(source);
+    if (!str) {
+        return -1;
+    }
+
+    PyObject *ns = PyDict_New();
+    if (!ns) {
+        return -1;
+    }
+
+    PyObject *res = PyRun_String(str, Py_file_input, ns, ns);
+    Py_DECREF(ns);
+    if (!res) {
+        return -1;
+    }
+    Py_DECREF(res);
+    return 0;
+}
+
 // Note that this function is inline to avoid creating a PLT entry
 // that would be an easy target for a ROP gadget.
 static inline void run_remote_debugger_script(const char *path)
@@ -1225,23 +1248,44 @@ static inline void run_remote_debugger_script(const char *path)
     Py_DECREF(fileobj);
 
     if (source) {
-        const char *str = PyBytes_AsString(source);
-        if (str) {
-            // PyRun_SimpleString() automatically raises an unraisable
-            // exception if it fails so we don't need to check the return value.
-            PyRun_SimpleString(str);
-        } else {
-            PyErr_FormatUnraisable("Error reading debugger script %s", path);
+        if (0 != run_remote_debugger_source(source)) {
+            PyErr_FormatUnraisable("Error executing debugger script %s", path);
         }
         Py_DECREF(source);
     }
+}
 
-    // Just in case something went wrong, don't leave this function
-    // with an unhandled exception.
-    if (PyErr_Occurred()) {
-        PyErr_FormatUnraisable("Error executing debugger script %s", path);
+int _PyRunRemoteDebugger(PyThreadState *tstate)
+{
+    const PyConfig *config = _PyInterpreterState_GetConfig(tstate->interp);
+    if (config->remote_debug == 1
+         && tstate->remote_debugger_support.debugger_pending_call == 1)
+    {
+        tstate->remote_debugger_support.debugger_pending_call = 0;
+
+        // Immediately make a copy in case of a race with another debugger
+        // process that's trying to write to the buffer. At least this way
+        // we'll be internally consistent: what we audit is what we run.
+        const size_t pathsz
+            = sizeof(tstate->remote_debugger_support.debugger_script_path);
+
+        char *path = PyMem_Malloc(pathsz);
+        if (path) {
+            // And don't assume the debugger correctly null terminated it.
+            memcpy(
+                path,
+                tstate->remote_debugger_support.debugger_script_path,
+                pathsz);
+            path[pathsz - 1] = '\0';
+            if (*path) {
+                run_remote_debugger_script(path);
+            }
+            PyMem_Free(path);
+        }
     }
+    return 0;
 }
+
 #endif
 
 /* Do periodic things, like check for signals and async I/0.
@@ -1372,32 +1416,7 @@ _Py_HandlePending(PyThreadState *tstate)
     }
 
 #if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG)
-    const PyConfig *config = _PyInterpreterState_GetConfig(tstate->interp);
-    if (config->remote_debug == 1
-         && tstate->remote_debugger_support.debugger_pending_call == 1)
-    {
-        tstate->remote_debugger_support.debugger_pending_call = 0;
-
-        // Immediately make a copy in case of a race with another debugger
-        // process that's trying to write to the buffer. At least this way
-        // we'll be internally consistent: what we audit is what we run.
-        const size_t pathsz
-            = sizeof(tstate->remote_debugger_support.debugger_script_path);
-
-        char *path = PyMem_Malloc(pathsz);
-        if (path) {
-            // And don't assume the debugger correctly null terminated it.
-            memcpy(
-                path,
-                tstate->remote_debugger_support.debugger_script_path,
-                pathsz);
-            path[pathsz - 1] = '\0';
-            if (*path) {
-                run_remote_debugger_script(path);
-            }
-            PyMem_Free(path);
-        }
-    }
+    _PyRunRemoteDebugger(tstate);
 #endif
 
     return 0;

Python/traceback.c

@@ -842,11 +842,11 @@ _Py_DumpDecimal(int fd, size_t value)
 
 /* Format an integer as hexadecimal with width digits into fd file descriptor.
    The function is signal safe. */
-void
-_Py_DumpHexadecimal(int fd, uintptr_t value, Py_ssize_t width)
+static void
+dump_hexadecimal(int fd, uintptr_t value, Py_ssize_t width, int strip_zeros)
 {
     char buffer[sizeof(uintptr_t) * 2 + 1], *ptr, *end;
-    const Py_ssize_t size = Py_ARRAY_LENGTH(buffer) - 1;
+    Py_ssize_t size = Py_ARRAY_LENGTH(buffer) - 1;
 
     if (width > size)
         width = size;
@@ -862,7 +862,35 @@ _Py_DumpHexadecimal(int fd, uintptr_t value, Py_ssize_t width)
         value >>= 4;
     } while ((end - ptr) < width || value);
 
-    (void)_Py_write_noraise(fd, ptr, end - ptr);
+    size = end - ptr;
+    if (strip_zeros) {
+        while (*ptr == '0' && size >= 2) {
+            ptr++;
+            size--;
+        }
+    }
+
+    (void)_Py_write_noraise(fd, ptr, size);
+}
+
+void
+_Py_DumpHexadecimal(int fd, uintptr_t value, Py_ssize_t width)
+{
+    dump_hexadecimal(fd, value, width, 0);
+}
+
+static void
+dump_pointer(int fd, void *ptr)
+{
+    PUTS(fd, "0x");
+    dump_hexadecimal(fd, (uintptr_t)ptr, sizeof(void*), 1);
+}
+
+static void
+dump_char(int fd, char ch)
+{
+    char buf[1] = {ch};
+    (void)_Py_write_noraise(fd, buf, 1);
 }
 
 void
@@ -924,8 +952,7 @@ _Py_DumpASCII(int fd, PyObject *text)
         ch = PyUnicode_READ(kind, data, i);
         if (' ' <= ch && ch <= 126) {
             /* printable ASCII character */
-            char c = (char)ch;
-            (void)_Py_write_noraise(fd, &c, 1);
+            dump_char(fd, (char)ch);
         }
         else if (ch <= 0xff) {
             PUTS(fd, "\\x");
@@ -1227,7 +1254,9 @@ _Py_backtrace_symbols_fd(int fd, void *const *array, Py_ssize_t size)
             || info[i].dli_fname == NULL
             || info[i].dli_fname[0] == '\0'
         ) {
-            dprintf(fd, "  Binary file '<unknown>' [%p]\n", array[i]);
+            PUTS(fd, "  Binary file '<unknown>' [");
+            dump_pointer(fd, array[i]);
+            PUTS(fd, "]\n");
             continue;
         }
 
@@ -1237,11 +1266,12 @@ _Py_backtrace_symbols_fd(int fd, void *const *array, Py_ssize_t size)
             info[i].dli_saddr = info[i].dli_fbase;
         }
 
-        if (info[i].dli_sname == NULL
-            && info[i].dli_saddr == 0) {
-            dprintf(fd, "  Binary file \"%s\" [%p]\n",
-                    info[i].dli_fname,
-                    array[i]);
+        if (info[i].dli_sname == NULL && info[i].dli_saddr == 0) {
+            PUTS(fd, "  Binary file \"");
+            PUTS(fd, info[i].dli_fname);
+            PUTS(fd, "\" [");
+            dump_pointer(fd, array[i]);
+            PUTS(fd, "]\n");
         }
         else {
             char sign;
@@ -1255,10 +1285,16 @@ _Py_backtrace_symbols_fd(int fd, void *const *array, Py_ssize_t size)
                 offset = info[i].dli_saddr - array[i];
             }
             const char *symbol_name = info[i].dli_sname != NULL ? info[i].dli_sname : "";
-            dprintf(fd, "  Binary file \"%s\", at %s%c%#tx [%p]\n",
-                    info[i].dli_fname,
-                    symbol_name,
-                    sign, offset, array[i]);
+            PUTS(fd, "  Binary file \"");
+            PUTS(fd, info[i].dli_fname);
+            PUTS(fd, "\", at ");
+            PUTS(fd, symbol_name);
+            dump_char(fd, sign);
+            PUTS(fd, "0x");
+            dump_hexadecimal(fd, offset, sizeof(offset), 1);
+            PUTS(fd, " [");
+            dump_pointer(fd, array[i]);
+            PUTS(fd, "]\n");
         }
     }
 }