dd: refactor stdin handling to use StdinRaw struct

Author: xtqqczze

src/uu/dd/src/dd.rs

@@ -35,6 +35,9 @@ use std::ffi::OsString;
 use std::fs::Metadata;
 use std::fs::{File, OpenOptions};
 use std::io::{self, Read, Seek, SeekFrom, Write};
+use std::mem::ManuallyDrop;
+use std::ops::Deref;
+use std::ops::DerefMut;
 #[cfg(any(target_os = "linux", target_os = "android"))]
 use std::os::fd::AsFd;
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -205,6 +208,34 @@ fn read_and_discard<R: Read>(reader: &mut R, n: u64, buf_size: usize) -> io::Res
     Ok(total)
 }
 
+#[cfg(unix)]
+struct StdinRaw(ManuallyDrop<File>);
+
+#[cfg(unix)]
+impl StdinRaw {
+    fn new() -> Self {
+        let fd = io::stdin().as_raw_fd();
+        let f = unsafe { File::from_raw_fd(fd) };
+        Self(ManuallyDrop::new(f))
+    }
+}
+
+#[cfg(unix)]
+impl Deref for StdinRaw {
+    type Target = File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(unix)]
+impl DerefMut for StdinRaw {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 /// Data sources.
 ///
 /// Use [`Source::stdin_as_file`] if available to enable more
@@ -219,7 +250,7 @@ enum Source {
 
     /// Input from stdin, opened from its file descriptor.
     #[cfg(unix)]
-    StdinFile(File),
+    StdinRaw(StdinRaw),
 
     /// Input from a named pipe, also known as a FIFO.
     #[cfg(unix)]
@@ -229,16 +260,14 @@ enum Source {
 impl Source {
     /// Create a source from stdin using its raw file descriptor.
     ///
-    /// This returns an instance of the `Source::StdinFile` variant,
+    /// This returns an instance of the `Source::StdinRaw` variant,
     /// using the raw file descriptor of [`io::Stdin`] to create
     /// the [`File`] parameter. You can use this instead of
     /// `Source::Stdin` to allow reading from stdin without consuming
     /// the entire contents of stdin when this process terminates.
     #[cfg(unix)]
-    fn stdin_as_file() -> Self {
-        let fd = io::stdin().as_raw_fd();
-        let f = unsafe { File::from_raw_fd(fd) };
-        Self::StdinFile(f)
+    fn stdin_raw() -> Self {
+        Self::StdinRaw(StdinRaw::new())
     }
 
     fn skip(&mut self, n: u64, ibs: usize) -> io::Result<u64> {
@@ -255,7 +284,7 @@ impl Source {
                 Ok(m)
             }
             #[cfg(unix)]
-            Self::StdinFile(f) => {
+            Self::StdinRaw(f) => {
                 if let Ok(Some(len)) = try_get_len_of_block_device(f)
                     && len < n
                 {
@@ -284,7 +313,7 @@ impl Source {
                     // ESPIPE means the file descriptor is not seekable (e.g., a pipe),
                     // so fall back to reading and discarding bytes using ibs-sized buffer
                     Some(Err(e)) if e.raw_os_error() == Some(libc::ESPIPE) => {
-                        let m = read_and_discard(f, n, ibs)?;
+                        let m = read_and_discard::<File>(f, n, ibs)?;
                         if m < n {
                             show_error!(
                                 "{}",
@@ -335,7 +364,7 @@ impl Read for Source {
             Self::Stdin(stdin) => stdin.read(buf),
             Self::File(f) => f.read(buf),
             #[cfg(unix)]
-            Self::StdinFile(f) => f.read(buf),
+            Self::StdinRaw(f) => f.read(buf),
             #[cfg(unix)]
             Self::Fifo(f) => f.read(buf),
         }
@@ -379,9 +408,9 @@ impl<'a> Input<'a> {
             }
         };
         #[cfg(unix)]
-        let mut src = Source::stdin_as_file();
+        let mut src = Source::stdin_raw();
         #[cfg(unix)]
-        if let Source::StdinFile(f) = &src
+        if let Source::StdinRaw(f) = &src
             && settings.iflags.directory
             && !f.metadata()?.is_dir()
         {