fix: use OwnedFd in parse_fd for I/O safety

Author: funcpp

librdb/src/parser.rs

@@ -1,4 +1,10 @@
-use std::{ffi::CString, marker::PhantomData, os::fd::RawFd, path::Path, ptr};
+use std::{
+    ffi::CString,
+    marker::PhantomData,
+    os::fd::{IntoRawFd, OwnedFd},
+    path::Path,
+    ptr,
+};
 
 use librdb_sys::{
     self, RdbHandlersDataCallbacks, RdbStatus_RDB_STATUS_ERROR, RdbStatus_RDB_STATUS_OK,
@@ -116,27 +122,26 @@ impl<H: RdbHandlers> Parser<H> {
         self.run_parse()
     }
 
-    /// Attach a file-descriptor reader and parse the RDB data.
+    /// Parse RDB data from a file descriptor.
     ///
-    /// If `close_when_done` is true, librdb will close the fd after parsing.
-    /// The fd must be in blocking mode.
+    /// Takes ownership of the fd. The fd must be in blocking mode.
     ///
     /// # Errors
     /// Returns an error if the reader cannot be created, the RDB data is
     /// malformed, or a handler callback returns `Err`.
-    pub fn parse_fd(&mut self, fd: RawFd, close_when_done: bool) -> Result<()> {
+    pub fn parse_fd(&mut self, fd: OwnedFd) -> Result<()> {
         if self.parsed {
             return Err(RdbError::Parser {
                 code: 0,
                 message: "parser already used; create a new Parser instance".into(),
             });
         }
 
-        // SAFETY: self.raw is a valid parser in CONFIGURING state. The caller
-        // is responsible for providing a valid, blocking fd.
-        let reader = unsafe {
-            librdb_sys::RDBX_createReaderFileDesc(self.raw, fd, i32::from(close_when_done))
-        };
+        // SAFETY: self.raw is a valid parser in CONFIGURING state.
+        // OwnedFd guarantees a valid fd; into_raw_fd transfers ownership to
+        // librdb which will close it (fdCloseWhenDone = 1).
+        let raw_fd = fd.into_raw_fd();
+        let reader = unsafe { librdb_sys::RDBX_createReaderFileDesc(self.raw, raw_fd, 1) };
         if reader.is_null() {
             return Err(self.extract_c_error("RDBX_createReaderFileDesc returned null"));
         }

librdb/tests/level2.rs

@@ -647,13 +647,11 @@ fn empty_rdb() {
 #[test]
 fn parse_fd_single_key() {
     use std::fs::File;
-    use std::os::fd::IntoRawFd;
 
     let file = File::open(fixture("single_key.rdb")).expect("open fixture");
-    let fd = file.into_raw_fd(); // transfer ownership to librdb
 
     let mut parser = Parser::new(Collector::default()).expect("create parser");
-    parser.parse_fd(fd, true).expect("parse");
+    parser.parse_fd(file.into()).expect("parse");
     let events = parser.into_handler().events;
 
     let keys = keys_of(&events);