dd: refactor stdout handling to use StdoutRaw struct

Author: xtqqczze

src/uu/dd/src/dd.rs

@@ -25,7 +25,6 @@ use progress::ProgUpdateType;
 use progress::{ProgUpdate, ReadStat, StatusLevel, WriteStat, gen_prog_updater};
 #[cfg(target_os = "linux")]
 use progress::{check_and_reset_sigusr1, install_sigusr1_handler};
-use uucore::io::OwnedFileDescriptorOrHandle;
 use uucore::translate;
 
 use std::cmp;
@@ -625,7 +624,7 @@ enum Density {
 /// Data destinations.
 enum Dest {
     /// Output to stdout.
-    Stdout(File),
+    StdoutRaw(StdoutRaw),
 
     /// Output to a file.
     ///
@@ -645,7 +644,7 @@ enum Dest {
 impl Dest {
     fn fsync(&mut self) -> io::Result<()> {
         match self {
-            Self::Stdout(stdout) => stdout.flush(),
+            Self::StdoutRaw(stdout) => stdout.flush(),
             Self::File(f, _) => {
                 f.flush()?;
                 f.sync_all()
@@ -662,7 +661,7 @@ impl Dest {
 
     fn fdatasync(&mut self) -> io::Result<()> {
         match self {
-            Self::Stdout(stdout) => stdout.flush(),
+            Self::StdoutRaw(stdout) => stdout.flush(),
             Self::File(f, _) => {
                 f.flush()?;
                 f.sync_data()
@@ -680,7 +679,7 @@ impl Dest {
     #[cfg_attr(not(unix), allow(unused_variables))]
     fn seek(&mut self, n: u64, obs: usize) -> io::Result<u64> {
         match self {
-            Self::Stdout(stdout) => io::copy(&mut io::repeat(0).take(n), stdout),
+            Self::StdoutRaw(stdout) => io::copy(&mut io::repeat(0).take(n), &mut **stdout),
             Self::File(f, _) => {
                 #[cfg(unix)]
                 if let Ok(Some(len)) = try_get_len_of_block_device(f)
@@ -790,6 +789,38 @@ fn handle_o_direct_write(
     Err(original_error)
 }
 
+struct StdoutRaw(core::mem::ManuallyDrop<File>);
+
+impl StdoutRaw {
+    #[cfg(not(windows))]
+    fn new() -> Self {
+        let fd = io::stdout().as_raw_fd();
+        let f = unsafe { File::from_raw_fd(fd) };
+        Self(core::mem::ManuallyDrop::new(f))
+    }
+
+    #[cfg(windows)]
+    fn new() -> Self {
+        let handle = std::os::windows::io::AsRawHandle::as_raw_handle(&io::stdout());
+        let f = unsafe { std::os::windows::io::FromRawHandle::from_raw_handle(handle) };
+        Self(core::mem::ManuallyDrop::new(f))
+    }
+}
+
+impl core::ops::Deref for StdoutRaw {
+    type Target = File;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl core::ops::DerefMut for StdoutRaw {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 impl Write for Dest {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match self {
@@ -816,7 +847,7 @@ impl Write for Dest {
                     Err(e) => Err(e),
                 }
             }
-            Self::Stdout(stdout) => stdout.write(buf),
+            Self::StdoutRaw(stdout) => stdout.write(buf),
             #[cfg(unix)]
             Self::Fifo(f) => f.write(buf),
             #[cfg(unix)]
@@ -826,7 +857,7 @@ impl Write for Dest {
 
     fn flush(&mut self) -> io::Result<()> {
         match self {
-            Self::Stdout(stdout) => stdout.flush(),
+            Self::StdoutRaw(stdout) => stdout.flush(),
             Self::File(f, _) => f.flush(),
             #[cfg(unix)]
             Self::Fifo(f) => f.flush(),
@@ -853,8 +884,8 @@ struct Output<'a> {
 impl<'a> Output<'a> {
     /// Instantiate this struct with stdout as a destination.
     fn new_stdout(settings: &'a Settings) -> UResult<Self> {
-        let fx = OwnedFileDescriptorOrHandle::from(io::stdout())?;
-        let mut dst = Dest::Stdout(fx.into_file());
+        let stdout = StdoutRaw::new();
+        let mut dst = Dest::StdoutRaw(stdout);
         dst.seek(settings.seek, settings.obs)
             .map_err_context(|| translate!("dd-error-write-error"))?;
         Ok(Self { dst, settings })
@@ -914,16 +945,17 @@ impl<'a> Output<'a> {
     /// already opened by the system (stdout) and has a state
     /// (current position) that shall be used.
     fn new_file_from_stdout(settings: &'a Settings) -> UResult<Self> {
-        let fx = OwnedFileDescriptorOrHandle::from(io::stdout())?;
+        let stdout = StdoutRaw::new();
         #[cfg(any(target_os = "linux", target_os = "android"))]
         if let Some(libc_flags) = make_linux_oflags(&settings.oflags) {
             nix::fcntl::fcntl(
-                fx.as_raw().as_fd(),
+                stdout.as_fd(),
                 FcntlArg::F_SETFL(OFlag::from_bits_retain(libc_flags)),
             )?;
         }
 
-        Self::prepare_file(fx.into_file(), settings)
+        // TODO: avoid cloning the underlying file descriptor here
+        Self::prepare_file(stdout.try_clone()?, settings)
     }
 
     /// Instantiate this struct with the given named pipe as a destination.