     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88

    use crate::io::{self, ErrorKind, Read, Write};
    use crate::mem::MaybeUninit;

    /// Copies the entire contents of a reader into a writer.
    ///
    /// This function will continuously read data from `reader` and then
    /// write it into `writer` in a streaming fashion until `reader`
    /// returns EOF.
    ///
    /// On success, the total number of bytes that were copied from
    /// `reader` to `writer` is returned.
    ///
    /// If you’re wanting to copy the contents of one file to another and you’re
    /// working with filesystem paths, see the [`fs::copy`] function.
    ///
    /// [`fs::copy`]: crate::fs::copy
    ///
    /// # Errors
    ///
    /// This function will return an error immediately if any call to [`read`] or
    /// [`write`] returns an error. All instances of [`ErrorKind::Interrupted`] are
    /// handled by this function and the underlying operation is retried.
    ///
    /// [`read`]: Read::read
    /// [`write`]: Write::write
    ///
    /// # Examples
    ///
    /// ```
    /// use std::io;
    ///
    /// fn main() -> io::Result<()> {
    ///     let mut reader: &[u8] = b"hello";
    ///     let mut writer: Vec<u8> = vec![];
    ///
    ///     io::copy(&mut reader, &mut writer)?;
    ///
    ///     assert_eq!(&b"hello"[..], &writer[..]);
    ///     Ok(())
    /// }
    /// ```
    #[stable(feature = "rust1", since = "1.0.0")]
    pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
    where
        R: Read,
        W: Write,
    {
        cfg_if::cfg_if! {
            if #[cfg(any(target_os = "linux", target_os = "android"))] {
                crate::sys::kernel_copy::copy_spec(reader, writer)
            } else {
                generic_copy(reader, writer)
            }
        }
    }

    /// The general read-write-loop implementation of
    /// `io::copy` that is used when specializations are not available or not applicable.
    pub(crate) fn generic_copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
    where
        R: Read,
        W: Write,
    {
        let mut buf = MaybeUninit::<[u8; super::DEFAULT_BUF_SIZE]>::uninit();
        // FIXME: #42788
        //
        //   - This creates a (mut) reference to a slice of
        //     _uninitialized_ integers, which is **undefined behavior**
        //
        //   - Only the standard library gets to soundly "ignore" this,
        //     based on its privileged knowledge of unstable rustc
        //     internals;
        unsafe {
            reader.initializer().initialize(buf.assume_init_mut());
        }

        let mut written = 0;
        loop {
            let len = match reader.read(unsafe { buf.assume_init_mut() }) {
                Ok(0) => return Ok(written),
                Ok(len) => len,
                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
                Err(e) => return Err(e),
            };
            writer.write_all(unsafe { &buf.assume_init_ref()[..len] })?;
            written += len as u64;
        }
    }