install: implement copying from streams

src/uu/cat/Cargo.toml

@@ -24,6 +24,9 @@ uucore = { workspace = true, features = ["fs", "pipes"] }
 [target.'cfg(unix)'.dependencies]
 nix = { workspace = true }
 
+[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
+uucore = { workspace = true, features = ["splice"] }
+
 [[bin]]
 name = "cat"
 path = "src/main.rs"

src/uu/cat/src/cat.rs

@@ -12,12 +12,12 @@ use uucore::display::Quotable;
 use uucore::error::UResult;
 use uucore::fs::FileInformation;
 
-#[cfg(unix)]
-use std::os::fd::{AsFd, AsRawFd};
-
 /// Linux splice support
 #[cfg(any(target_os = "linux", target_os = "android"))]
-mod splice;
+use uucore::splice::write_fast_using_splice;
+
+#[cfg(unix)]
+use std::os::fd::{AsFd, AsRawFd};
 
 /// Unix domain socket support
 #[cfg(unix)]
@@ -26,6 +26,7 @@ use std::net::Shutdown;
 use std::os::unix::fs::FileTypeExt;
 #[cfg(unix)]
 use std::os::unix::net::UnixStream;
+
 use uucore::{format_usage, help_about, help_usage};
 
 const USAGE: &str = help_usage!("cat.md");
@@ -454,7 +455,7 @@ fn write_fast<R: FdReadable>(handle: &mut InputHandle<R>) -> CatResult<()> {
     {
         // If we're on Linux or Android, try to use the splice() system call
         // for faster writing. If it works, we're done.
-        if !splice::write_fast_using_splice(handle, &stdout_lock)? {
+        if !write_fast_using_splice(&handle.reader, &stdout_lock)?.1 {
             return Ok(());
         }
     }

src/uu/cp/Cargo.toml

@@ -41,6 +41,9 @@ indicatif = { workspace = true }
 xattr = { workspace = true }
 exacl = { workspace = true, optional = true }
 
+[target.'cfg(any(target_os = "linux", target_os = "android"))'.dependencies]
+uucore = { workspace = true, features = ["splice"] }
+
 [[bin]]
 name = "cp"
 path = "src/main.rs"

src/uu/cp/src/cp.rs

@@ -10,7 +10,7 @@ use std::collections::{HashMap, HashSet};
 #[cfg(not(windows))]
 use std::ffi::CString;
 use std::ffi::OsString;
-use std::fs::{self, File, Metadata, OpenOptions, Permissions};
+use std::fs::{self, Metadata, OpenOptions, Permissions};
 use std::io;
 #[cfg(unix)]
 use std::os::unix::ffi::OsStrExt;
@@ -1933,10 +1933,12 @@ fn handle_copy_mode(
 
     let source_is_symlink = source_file_type.is_symlink();
 
+    #[cfg(unix)]
+    let source_is_stream = source_file_type.is_fifo()
+        || source_file_type.is_block_device()
+        || source_file_type.is_char_device();
     #[cfg(unix)]
     let source_is_fifo = source_file_type.is_fifo();
-    #[cfg(not(unix))]
-    let source_is_fifo = false;
 
     match options.copy_mode {
         CopyMode::Link => {
@@ -1971,7 +1973,10 @@ fn handle_copy_mode(
                 options,
                 context,
                 source_is_symlink,
+                #[cfg(unix)]
                 source_is_fifo,
+                #[cfg(unix)]
+                source_is_stream,
                 symlinked_files,
             )?;
         }
@@ -1991,7 +1996,10 @@ fn handle_copy_mode(
                             options,
                             context,
                             source_is_symlink,
+                            #[cfg(unix)]
                             source_is_fifo,
+                            #[cfg(unix)]
+                            source_is_stream,
                             symlinked_files,
                         )?;
                     }
@@ -2021,7 +2029,10 @@ fn handle_copy_mode(
                                 options,
                                 context,
                                 source_is_symlink,
+                                #[cfg(unix)]
                                 source_is_fifo,
+                                #[cfg(unix)]
+                                source_is_stream,
                                 symlinked_files,
                             )?;
                         }
@@ -2034,7 +2045,10 @@ fn handle_copy_mode(
                     options,
                     context,
                     source_is_symlink,
+                    #[cfg(unix)]
                     source_is_fifo,
+                    #[cfg(unix)]
+                    source_is_stream,
                     symlinked_files,
                 )?;
             }
@@ -2284,6 +2298,19 @@ fn copy_file(
     }
 
     if options.dereference(source_in_command_line) {
+        // HACK: when `cp` reads from inter-process pipe, its original pipe would've been
+        // inaccessible once we reach this part of the code as it has been closed. That means we
+        // can't dereference it to get its attribute.
+        // find a more reliable way to distinguish between named pipes and anonymous pipes.
+        #[cfg(unix)]
+        if source_metadata.file_type().is_fifo() {
+            copy_attributes(source, dest, &options.attributes)?;
+        } else if let Ok(src) = canonicalize(source, MissingHandling::Normal, ResolveMode::Physical)
+        {
+            copy_attributes(&src, dest, &options.attributes)?;
+        }
+
+        #[cfg(not(unix))]
         if let Ok(src) = canonicalize(source, MissingHandling::Normal, ResolveMode::Physical) {
             copy_attributes(&src, dest, &options.attributes)?;
         }
@@ -2350,13 +2377,15 @@ fn handle_no_preserve_mode(options: &Options, org_mode: u32) -> u32 {
 
 /// Copy the file from `source` to `dest` either using the normal `fs::copy` or a
 /// copy-on-write scheme if --reflink is specified and the filesystem supports it.
+#[allow(clippy::too_many_arguments)]
 fn copy_helper(
     source: &Path,
     dest: &Path,
     options: &Options,
     context: &str,
     source_is_symlink: bool,
-    source_is_fifo: bool,
+    #[cfg(unix)] source_is_fifo: bool,
+    #[cfg(unix)] source_is_stream: bool,
     symlinked_files: &mut HashSet<FileInformation>,
 ) -> CopyResult<()> {
     if options.parents {
@@ -2368,15 +2397,13 @@ fn copy_helper(
         return Err(Error::NotADirectory(dest.to_path_buf()));
     }
 
-    if source.as_os_str() == "/dev/null" {
-        /* workaround a limitation of fs::copy
-         * https://github.com/rust-lang/rust/issues/79390
-         */
-        File::create(dest).context(dest.display().to_string())?;
-    } else if source_is_fifo && options.recursive && !options.copy_contents {
+    #[cfg(unix)]
+    if source_is_fifo && options.recursive && !options.copy_contents {
         #[cfg(unix)]
         copy_fifo(dest, options.overwrite, options.debug)?;
-    } else if source_is_symlink {
+        return Ok(());
+    }
+    if source_is_symlink {
         copy_link(source, dest, symlinked_files)?;
     } else {
         let copy_debug = copy_on_write(
@@ -2385,7 +2412,9 @@ fn copy_helper(
             options.reflink_mode,
             options.sparse_mode,
             context,
-            #[cfg(any(target_os = "linux", target_os = "android", target_os = "macos"))]
+            #[cfg(unix)]
+            source_is_stream,
+            #[cfg(unix)]
             source_is_fifo,
         )?;
 

src/uu/cp/src/platform/linux.rs

@@ -6,13 +6,16 @@
 
 use libc::{SEEK_DATA, SEEK_HOLE};
 use std::fs::{File, OpenOptions};
-use std::io::Read;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
 use std::os::unix::fs::FileExt;
 use std::os::unix::fs::MetadataExt;
 use std::os::unix::fs::{FileTypeExt, OpenOptionsExt};
 use std::os::unix::io::AsRawFd;
 use std::path::Path;
 
+use uucore::splice::write_fast_using_splice;
+
 use quick_error::ResultExt;
 
 use uucore::mode::get_umask;
@@ -220,8 +223,8 @@ fn check_dest_is_fifo(dest: &Path) -> bool {
     }
 }
 
-/// Copy the contents of the given source FIFO to the given file.
-fn copy_fifo_contents<P>(source: P, dest: P) -> std::io::Result<u64>
+/// Copy the contents of the given source stream to a given file.
+fn copy_stream_contents<P>(is_pipe: bool, source: P, dest: P) -> std::io::Result<u64>
 where
     P: AsRef<Path>,
 {
@@ -250,23 +253,50 @@ where
         .write(true)
         .mode(mode)
         .open(&dest)?;
-    let num_bytes_copied = std::io::copy(&mut src_file, &mut dst_file)?;
-    dst_file.set_permissions(src_file.metadata()?.permissions())?;
-    Ok(num_bytes_copied)
+
+    let num_bytes_copied;
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    {
+        // If we're on Linux or Android, try to use the splice() system call
+        // for faster writing. If it works, we're done.
+        let res = write_fast_using_splice(&src_file, &dst_file.as_fd())?;
+        if !res.1 {
+            num_bytes_copied = res.0;
+        } else {
+            num_bytes_copied = std::io::copy(&mut src_file, &mut dst_file)?
+                .try_into()
+                .unwrap();
+            dst_file.flush()?;
+        }
+    }
+
+    #[cfg(not(any(target_os = "linux", target_os = "android")))]
+    {
+        num_bytes_copied = std::io::copy(&mut src_file, &mut dst_file)?
+            .try_into()
+            .unwrap();
+    }
+
+    // If stream is a character or block device, we don't need to take care of its permissions for
+    // now. See: https://github.com/uutils/coreutils/pull/4211
+    if is_pipe {
+        dst_file.set_permissions(src_file.metadata()?.permissions())?;
+    }
+
+    Ok(num_bytes_copied.try_into().unwrap())
 }
 
 /// Copies `source` to `dest` using copy-on-write if possible.
 ///
-/// The `source_is_fifo` flag must be set to `true` if and only if
-/// `source` is a FIFO (also known as a named pipe). In this case,
-/// copy-on-write is not possible, so we copy the contents using
-/// [`std::io::copy`].
+/// The `source_is_stream` flag must be set to `true` if and only if
+/// `source` is a stream (i.e FIFOs, block/character devices).
 pub(crate) fn copy_on_write(
     source: &Path,
     dest: &Path,
     reflink_mode: ReflinkMode,
     sparse_mode: SparseMode,
     context: &str,
+    source_is_stream: bool,
     source_is_fifo: bool,
 ) -> CopyResult<CopyDebug> {
     let mut copy_debug = CopyDebug {
@@ -279,10 +309,10 @@ pub(crate) fn copy_on_write(
             copy_debug.sparse_detection = SparseDebug::Zeros;
             // Default SparseDebug val for SparseMode::Always
             copy_debug.reflink = OffloadReflinkDebug::No;
-            if source_is_fifo {
+            if source_is_stream {
                 copy_debug.offload = OffloadReflinkDebug::Avoided;
 
-                copy_fifo_contents(source, dest).map(|_| ())
+                copy_stream_contents(source_is_fifo, source, dest).map(|_| ())
             } else {
                 let mut copy_method = CopyMethod::Default;
                 let result = handle_reflink_never_sparse_always(source, dest);
@@ -300,10 +330,10 @@ pub(crate) fn copy_on_write(
         (ReflinkMode::Never, SparseMode::Never) => {
             copy_debug.reflink = OffloadReflinkDebug::No;
 
-            if source_is_fifo {
+            if source_is_stream {
                 copy_debug.offload = OffloadReflinkDebug::Avoided;
 
-                copy_fifo_contents(source, dest).map(|_| ())
+                copy_stream_contents(source_is_fifo, source, dest).map(|_| ())
             } else {
                 let result = handle_reflink_never_sparse_never(source);
                 if let Ok(debug) = result {
@@ -315,9 +345,9 @@ pub(crate) fn copy_on_write(
         (ReflinkMode::Never, SparseMode::Auto) => {
             copy_debug.reflink = OffloadReflinkDebug::No;
 
-            if source_is_fifo {
+            if source_is_stream {
                 copy_debug.offload = OffloadReflinkDebug::Avoided;
-                copy_fifo_contents(source, dest).map(|_| ())
+                copy_stream_contents(source_is_fifo, source, dest).map(|_| ())
             } else {
                 let mut copy_method = CopyMethod::Default;
                 let result = handle_reflink_never_sparse_auto(source, dest);
@@ -335,10 +365,10 @@ pub(crate) fn copy_on_write(
         (ReflinkMode::Auto, SparseMode::Always) => {
             copy_debug.sparse_detection = SparseDebug::Zeros; // Default SparseDebug val for
                                                               // SparseMode::Always
-            if source_is_fifo {
+            if source_is_stream {
                 copy_debug.offload = OffloadReflinkDebug::Avoided;
 
-                copy_fifo_contents(source, dest).map(|_| ())
+                copy_stream_contents(source_is_fifo, source, dest).map(|_| ())
             } else {
                 let mut copy_method = CopyMethod::Default;
                 let result = handle_reflink_auto_sparse_always(source, dest);
@@ -356,9 +386,9 @@ pub(crate) fn copy_on_write(
 
         (ReflinkMode::Auto, SparseMode::Never) => {
             copy_debug.reflink = OffloadReflinkDebug::No;
-            if source_is_fifo {
+            if source_is_stream {
                 copy_debug.offload = OffloadReflinkDebug::Avoided;
-                copy_fifo_contents(source, dest).map(|_| ())
+                copy_stream_contents(source_is_fifo, source, dest).map(|_| ())
             } else {
                 let result = handle_reflink_auto_sparse_never(source);
                 if let Ok(debug) = result {
@@ -369,9 +399,9 @@ pub(crate) fn copy_on_write(
             }
         }
         (ReflinkMode::Auto, SparseMode::Auto) => {
-            if source_is_fifo {
+            if source_is_stream {
                 copy_debug.offload = OffloadReflinkDebug::Unsupported;
-                copy_fifo_contents(source, dest).map(|_| ())
+                copy_stream_contents(source_is_fifo, source, dest).map(|_| ())
             } else {
                 let mut copy_method = CopyMethod::Default;
                 let result = handle_reflink_auto_sparse_auto(source, dest);

src/uu/cp/src/platform/macos.rs

@@ -15,15 +15,16 @@ use crate::{CopyDebug, CopyResult, OffloadReflinkDebug, ReflinkMode, SparseDebug
 
 /// Copies `source` to `dest` using copy-on-write if possible.
 ///
-/// The `source_is_fifo` flag must be set to `true` if and only if
-/// `source` is a FIFO (also known as a named pipe).
+/// The `source_is_stream` flag must be set to `true` if and only if
+/// `source` is a stream (i.e FIFOs, block/character devices)
 pub(crate) fn copy_on_write(
     source: &Path,
     dest: &Path,
     reflink_mode: ReflinkMode,
     sparse_mode: SparseMode,
     context: &str,
-    source_is_fifo: bool,
+    source_is_stream: bool,
+    #[allow(unused_variables)] source_is_fifo: bool,
 ) -> CopyResult<CopyDebug> {
     if sparse_mode != SparseMode::Auto {
         return Err("--sparse is only supported on linux".to_string().into());
@@ -85,7 +86,9 @@ pub(crate) fn copy_on_write(
             }
             _ => {
                 copy_debug.reflink = OffloadReflinkDebug::Yes;
-                if source_is_fifo {
+                if source_is_stream {
+                    // `fs::copy` does not support copying special files (including streams).
+                    // Instead, `cp` would have to make the files then use io::copy.
                     let mut src_file = File::open(source)?;
                     let mut dst_file = File::create(dest)?;
                     io::copy(&mut src_file, &mut dst_file).context(context)?