head: head_backwards for non-seekable files like /proc/* or fifos (named pipes)

src/uu/head/src/head.rs

@@ -243,63 +243,82 @@
     Ok(())
 }
 
-fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: usize) -> std::io::Result<()> {
+fn checked_convert_to_usize_or_print_error(n: u64) -> Option<usize> {
+    match usize::try_from(n) {
+        Ok(value) => Some(value),
+        Err(e) => {
+            show!(USimpleError::new(
+                1,
+                format!("{e}: number of bytes is too large")
+            ));
+            None
+        }
+    }
+}
+
+fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: u64) -> std::io::Result<()> {
     if n == 0 {
         //prints everything
         return read_n_bytes(input, std::u64::MAX);
     }
 
-    let stdout = std::io::stdout();
-    let mut stdout = stdout.lock();
+    if let Some(n) = checked_convert_to_usize_or_print_error(n) {
+        let stdout = std::io::stdout();
+        let mut stdout = stdout.lock();
 
-    let mut ring_buffer = vec![0u8; n];
+        let mut ring_buffer = vec![0u8; n];
 
-    // first we fill the ring buffer
-    if let Err(e) = input.read_exact(&mut ring_buffer) {
-        if e.kind() == ErrorKind::UnexpectedEof {
-            return Ok(());
-        } else {
-            return Err(e);
-        }
-    }
-    let mut buffer = [0u8; BUF_SIZE];
-    loop {
-        let read = loop {
-            match input.read(&mut buffer) {
-                Ok(n) => break n,
-                Err(e) => match e.kind() {
-                    ErrorKind::Interrupted => {}
-                    _ => return Err(e),
-                },
-            }
-        };
-        if read == 0 {
-            return Ok(());
-        } else if read >= n {
-            stdout.write_all(&ring_buffer)?;
-            stdout.write_all(&buffer[..read - n])?;
-            for i in 0..n {
-                ring_buffer[i] = buffer[read - n + i];
+        // first we fill the ring buffer
+        if let Err(e) = input.read_exact(&mut ring_buffer) {
+            if e.kind() == ErrorKind::UnexpectedEof {
+                return Ok(());
+            } else {
+                return Err(e);
             }
-        } else {
-            stdout.write_all(&ring_buffer[..read])?;
-            for i in 0..n - read {
-                ring_buffer[i] = ring_buffer[read + i];
+        }
+        let mut buffer = [0u8; BUF_SIZE];
+        loop {
+            let read = loop {
+                match input.read(&mut buffer) {
+                    Ok(n) => break n,
+                    Err(e) => match e.kind() {
+                        ErrorKind::Interrupted => {}
+                        _ => return Err(e),
+                    },
+                }
+            };
+            if read == 0 {
+                return Ok(());
+            } else if read >= n {
+                stdout.write_all(&ring_buffer)?;
+                stdout.write_all(&buffer[..read - n])?;
+                for i in 0..n {
+                    ring_buffer[i] = buffer[read - n + i];
+                }
+            } else {
+                stdout.write_all(&ring_buffer[..read])?;
+                for i in 0..n - read {
+                    ring_buffer[i] = ring_buffer[read + i];
+                }
+                ring_buffer[n - read..].copy_from_slice(&buffer[..read]);
             }
-            ring_buffer[n - read..].copy_from_slice(&buffer[..read]);
         }
     }
+
+    Ok(())
 }
 
 fn read_but_last_n_lines(
     input: impl std::io::BufRead,
-    n: usize,
+    n: u64,
     separator: u8,
 ) -> std::io::Result<()> {
-    let stdout = std::io::stdout();
-    let mut stdout = stdout.lock();
-    for bytes in take_all_but(lines(input, separator), n) {
-        stdout.write_all(&bytes?)?;
+    if let Some(n) = checked_convert_to_usize_or_print_error(n) {
+        let stdout = std::io::stdout();
+        let mut stdout = stdout.lock();
+        for bytes in take_all_but(lines(input, separator), n) {
+            stdout.write_all(&bytes?)?;
+        }
     }
     Ok(())
 }
@@ -380,7 +399,41 @@
     }
 }
 
+fn is_seekable(input: &mut std::fs::File) -> bool {
+    let current_pos = input.stream_position();
+    current_pos.is_ok()
+        && input.seek(SeekFrom::End(0)).is_ok()
+        && input.seek(SeekFrom::Start(current_pos.unwrap())).is_ok()
+}
+
 fn head_backwards_file(input: &mut std::fs::File, options: &HeadOptions) -> std::io::Result<()> {
+    let seekable = is_seekable(input);
+    if seekable {
+        return head_backwards_on_seekable_file(input, options);
+    }
+
+    head_backwards_on_non_seekable_file(input, options)
+}
+
+fn head_backwards_on_non_seekable_file(
+    input: &mut std::fs::File,
+    options: &HeadOptions,
+) -> std::io::Result<()> {
+    let reader = &mut std::io::BufReader::with_capacity(BUF_SIZE, &*input);
+
+    match options.mode {
+        Mode::AllButLastBytes(n) => read_but_last_n_bytes(reader, n)?,
+        Mode::AllButLastLines(n) => read_but_last_n_lines(reader, n, options.line_ending.into())?,
+        _ => unreachable!(),
+    }
+
+    Ok(())
+}
+
+fn head_backwards_on_seekable_file(
+    input: &mut std::fs::File,
+    options: &HeadOptions,
+) -> std::io::Result<()> {
     match options.mode {
         Mode::AllButLastBytes(n) => {
             let size = input.metadata()?.len();
@@ -434,32 +487,13 @@
                 let stdin = std::io::stdin();
                 let mut stdin = stdin.lock();
 
-                // Outputting "all-but-last" requires us to use a ring buffer with size n, so n
-                // must be converted from u64 to usize to fit in memory. If such conversion fails,
-                // it means the platform doesn't have enough memory to hold the buffer, so we fail.
-                if let Mode::AllButLastLines(n) | Mode::AllButLastBytes(n) = options.mode {
-                    if let Err(e) = usize::try_from(n) {
-                        show!(USimpleError::new(
-                            1,
-                            format!("{e}: number of bytes is too large")
-                        ));
-                        continue;
-                    };
-                };
-
                 match options.mode {
                     Mode::FirstBytes(n) => read_n_bytes(&mut stdin, n),
-                    // unwrap is guaranteed to succeed because we checked the value of n above
-                    Mode::AllButLastBytes(n) => {
-                        read_but_last_n_bytes(&mut stdin, n.try_into().unwrap())
-                    }
+                    Mode::AllButLastBytes(n) => read_but_last_n_bytes(&mut stdin, n),
                     Mode::FirstLines(n) => read_n_lines(&mut stdin, n, options.line_ending.into()),
-                    // unwrap is guaranteed to succeed because we checked the value of n above
-                    Mode::AllButLastLines(n) => read_but_last_n_lines(
-                        &mut stdin,
-                        n.try_into().unwrap(),
-                        options.line_ending.into(),
-                    ),
+                    Mode::AllButLastLines(n) => {
+                        read_but_last_n_lines(&mut stdin, n, options.line_ending.into())
+                    }
                 }
             }
             (name, false) => {

tests/by-util/test_head.rs

@@ -378,3 +378,45 @@ fn test_presume_input_pipe_5_chars() {
         .run()
         .stdout_is_fixture("lorem_ipsum_5_chars.expected");
 }
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_version() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/proc/version"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(result.stdout().len() > 0);
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_bytes_proc_fs_modules() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["-c", "-1", "/proc/modules"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(result.stdout().len() > 0);
+}
+
+#[cfg(all(
+    not(target_os = "windows"),
+    not(target_os = "macos"),
+    not(target_os = "freebsd")
+))]
+#[test]
+fn test_read_backwards_lines_proc_fs_modules() {
+    let ts = TestScenario::new(util_name!());
+
+    let args = ["--lines", "-1", "/proc/modules"];
+    let result = ts.ucmd().args(&args).succeeds();
+    assert!(result.stdout().len() > 0);
+}