fix(crashtracking): repair macOS sidecar connector

Author: morrisonlevi

components-rs/lib.rs

@@ -324,7 +324,7 @@ fn reuse_sidecar_fd_connector(_unix_socket_path: &str) -> std::os::fd::RawFd {
     }
 
     // Best-effort, signal context: read the transport pointer and get its current fd via
-    // SidecarTransport::signal_fd (which uses get_mut, never locking). Going through the raw
+    // SidecarTransport::as_raw_fd (which uses get_mut, never locking). Going through the raw
     // pointer knowingly bypasses aliasing checks — the crashing thread is the only realistic
     // accessor.
     let transport = unsafe { datadog_sidecar_for_signal }
@@ -333,8 +333,104 @@ fn reuse_sidecar_fd_connector(_unix_socket_path: &str) -> std::os::fd::RawFd {
         return -1;
     }
     let fd = unsafe { (*transport).as_raw_fd() };
+    prepare_crashtracker_sidecar_fd(fd)
+}
+
+#[cfg(target_os = "macos")]
+fn prepare_crashtracker_sidecar_fd(fd: std::os::fd::RawFd) -> std::os::fd::RawFd {
+    // Crashtracker takes ownership of and closes the connector fd. Duplicate the sidecar
+    // transport fd so reporting an exception cannot leave the transport holding a closed fd.
+    let crashtracker_fd = unsafe { libc::dup(fd) };
+    if crashtracker_fd < 0 {
+        return -1;
+    }
+
     let bytes = crashtracker_receiver_request_bytes();
-    let sent = unsafe { libc::send(dup, bytes.as_ptr() as *const libc::c_void, bytes.len(), 0) };
+    let sent = unsafe {
+        libc::send(
+            crashtracker_fd,
+            bytes.as_ptr().cast::<libc::c_void>(),
+            bytes.len(),
+            0,
+        )
+    };
+    if sent != bytes.len() as isize {
+        // Preserve the send error for Receiver::from_connector's last_os_error().
+        let errno = if sent < 0 {
+            unsafe { *libc::__error() }
+        } else {
+            libc::EIO
+        };
+        unsafe {
+            libc::close(crashtracker_fd);
+            *libc::__error() = errno;
+        }
+        return -1;
+    }
+
+    crashtracker_fd
+}
+
+#[cfg(all(test, target_os = "macos"))]
+mod crashtracker_connector_tests {
+    use super::*;
+    use std::os::fd::{AsRawFd, FromRawFd, OwnedFd};
+
+    fn dgram_pair() -> (OwnedFd, OwnedFd) {
+        let mut fds = [-1; 2];
+        let result =
+            unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_DGRAM, 0, fds.as_mut_ptr()) };
+        assert_eq!(result, 0, "socketpair: {}", std::io::Error::last_os_error());
+        unsafe {
+            (
+                OwnedFd::from_raw_fd(fds[0]),
+                OwnedFd::from_raw_fd(fds[1]),
+            )
+        }
+    }
+
+    fn recv(fd: &OwnedFd, buffer: &mut [u8]) -> usize {
+        let received = unsafe {
+            libc::recv(
+                fd.as_raw_fd(),
+                buffer.as_mut_ptr().cast::<libc::c_void>(),
+                buffer.len(),
+                0,
+            )
+        };
+        assert!(received >= 0, "recv: {}", std::io::Error::last_os_error());
+        received as usize
+    }
+
+    #[test]
+    fn connector_sends_upgrade_request_without_consuming_transport_fd() {
+        let (transport, peer) = dgram_pair();
+
+        let crashtracker_fd = prepare_crashtracker_sidecar_fd(transport.as_raw_fd());
+        assert!(crashtracker_fd >= 0);
+        let crashtracker_fd = unsafe { OwnedFd::from_raw_fd(crashtracker_fd) };
+
+        let expected = crashtracker_receiver_request_bytes();
+        let mut received = vec![0; expected.len()];
+        let len = recv(&peer, &mut received);
+        assert_eq!(&received[..len], expected);
+
+        drop(crashtracker_fd);
+        let message = b"transport-still-open";
+        let sent = unsafe {
+            libc::send(
+                transport.as_raw_fd(),
+                message.as_ptr().cast::<libc::c_void>(),
+                message.len(),
+                0,
+            )
+        };
+        assert_eq!(sent, message.len() as isize);
+
+        let mut received = [0; 32];
+        let len = recv(&peer, &mut received);
+        assert_eq!(&received[..len], message);
+    }
 }
 
 // Hack: Without this, the PECL build of the tracer does not contain the ddog_library_* functions