Address review round 2: checkpoint reject, thread-safe pid/ports, drop dead binding

- checkpoint(): a popen() Process owns the handle, so checkpoint (SIGSTOP +
  ptrace freeze) now rejects with _reject_if_popen() instead of reaching
  past the Process for a handle that is None on the sandbox — consistent
  with wait/pause/resume/kill.

- Sandbox.pid / Sandbox.ports: delegate to the Process (Process.pid is
  lock-guarded + cached; new Process.ports() reads the handle under the
  lock and reports {} while a wait() holds it). Previously both did a raw
  FFI read of the Process's handle via _live_handle(), racing a concurrent
  wait() free. Extracted _read_port_mappings() shared by both.

- Removed the now-unused sandlock_handle_kill ctypes binding: Process.kill
  signals the group by pid (killpg), so the FFI kill has no caller.

Tests: checkpoint() rejects a popen Process; Sandbox.pid/ports delegate to
the live Process and return None/{} after it is reaped.

Author: dzerik

python/src/sandlock/_sdk.py

@@ -333,11 +333,6 @@ def confine(policy: "PolicyDataclass") -> None:
     ctypes.POINTER(ctypes.c_int),  # out_stderr_fd
 ]
 
-# SIGKILL the handle's process group without freeing it (so wait can still
-# collect the exit status). 0 on success, -1 on error.
-_lib.sandlock_handle_kill.restype = ctypes.c_int
-_lib.sandlock_handle_kill.argtypes = [_c_handle_p]
-
 # Result
 _lib.sandlock_result_exit_code.restype = ctypes.c_int
 _lib.sandlock_result_exit_code.argtypes = [_c_result_p]

python/src/sandlock/sandbox.py

@@ -560,11 +560,15 @@ def __exit__(self, exc_type, exc_val, exc_tb):
     def pid(self) -> int | None:
         """Child PID while running, None otherwise. Reflects a running child from
         either the sandbox lifecycle or a live :meth:`popen` :class:`Process`."""
-        handle = self._live_handle()
-        if handle is None:
+        proc = self._popen_process()
+        if proc is not None:
+            # The Process owns the handle; its pid is lock-guarded and cached, so
+            # reading it can't race a concurrent wait() freeing the handle.
+            return proc.pid
+        if self._handle is None:
             return None
         from ._sdk import _lib
-        return _lib.sandlock_handle_pid(handle) or None
+        return _lib.sandlock_handle_pid(self._handle) or None
 
     @property
     def is_running(self) -> bool:
@@ -1207,19 +1211,14 @@ def ports(self) -> dict[int, int]:
         or no ports have been remapped. Works for a running child from either
         the lifecycle or a live :meth:`popen` :class:`Process`.
         """
-        handle = self._live_handle()
-        if handle is None:
-            return {}
-        from ._sdk import _lib
-        c_str = _lib.sandlock_handle_port_mappings(handle)
-        if not c_str:
+        proc = self._popen_process()
+        if proc is not None:
+            # The Process owns the handle; its ports() reads it under the lock so
+            # this can't race a concurrent wait() freeing it.
+            return proc.ports()
+        if self._handle is None:
             return {}
-        try:
-            import json
-            raw = json.loads(c_str.decode())
-            return {int(k): v for k, v in raw.items()}
-        finally:
-            _lib.sandlock_string_free(c_str)
+        return _read_port_mappings(self._handle)
 
     def checkpoint(
         self,
@@ -1244,6 +1243,10 @@ def checkpoint(
         """
         from ._sdk import _lib, Checkpoint
 
+        # A popen() Process owns its handle; checkpoint (SIGSTOP + ptrace freeze)
+        # would fight the streaming Process for it, so reject rather than reach
+        # past it — consistent with wait/pause/resume/kill.
+        self._reject_if_popen()
         if self._handle is None:
             raise RuntimeError("sandbox is not running (use start() or run() first)")
         ptr = _lib.sandlock_handle_checkpoint(self._handle)
@@ -1255,6 +1258,22 @@ def checkpoint(
         return cp
 
 
+def _read_port_mappings(handle) -> dict[int, int]:
+    """Decode {virtual: real} port mappings for a live handle. Shared by
+    ``Sandbox.ports`` and ``Process.ports``; the caller must hold whatever lock
+    guards ``handle`` while invoking this."""
+    from ._sdk import _lib
+    c_str = _lib.sandlock_handle_port_mappings(handle)
+    if not c_str:
+        return {}
+    try:
+        import json
+        raw = json.loads(c_str.decode())
+        return {int(k): v for k, v in raw.items()}
+    finally:
+        _lib.sandlock_string_free(c_str)
+
+
 def _encode(s: str) -> bytes:
     """Encode a string to UTF-8 bytes, rejecting NUL bytes."""
     if isinstance(s, str):
@@ -1394,6 +1413,15 @@ def pid(self) -> int | None:
         with self._lock:
             return self._pid if self._handle is not None and self._pid > 0 else None
 
+    def ports(self) -> dict[int, int]:
+        """Current virtual→real port mappings while running, else ``{}`` (needs
+        ``port_remap``). Reads the handle under the lock, and reports ``{}``
+        while a :meth:`wait` holds it, so it can't race the wait's free."""
+        with self._lock:
+            if self._handle is None or self._waiting:
+                return {}
+            return _read_port_mappings(self._handle)
+
     def kill(self) -> None:
         """SIGKILL the child's entire process group by pid (like the sandbox and
         the Go binding), so a kill from another thread is safe while :meth:`wait`

python/tests/test_popen.py

@@ -277,7 +277,8 @@ def test_sandbox_lifecycle_methods_reject_popen_process():
     sandbox = _policy()
     proc = sandbox.popen(["sleep", "100"])
     try:
-        for op in (sandbox.wait, sandbox.kill, sandbox.pause, sandbox.resume):
+        for op in (sandbox.wait, sandbox.kill, sandbox.pause, sandbox.resume,
+                   sandbox.checkpoint):
             with pytest.raises(RuntimeError):
                 op()
         # The Process still works after the rejected sandbox-level calls.
@@ -287,6 +288,23 @@ def test_sandbox_lifecycle_methods_reject_popen_process():
         proc.wait()
 
 
+def test_sandbox_pid_and_ports_delegate_to_popen_process():
+    # Sandbox.pid/ports must read the popen child through the Process (whose
+    # accessors are lock-guarded), not touch the Process's handle directly —
+    # otherwise a concurrent wait() free would race the raw FFI read.
+    sandbox = _policy()
+    proc = sandbox.popen(["sleep", "100"])
+    try:
+        assert proc.pid is not None
+        assert sandbox.pid == proc.pid
+        assert sandbox.ports() == proc.ports()  # both {} without port_remap
+    finally:
+        proc.kill()
+        proc.wait()
+    assert sandbox.pid is None
+    assert sandbox.ports() == {}
+
+
 def test_wait_timeout_zero_does_not_wait_forever():
     # timeout=0 (and sub-millisecond values) must not collapse to "wait forever";
     # they return promptly with a non-success (killed) result. Watchdog so a