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

src/uu/head/src/head.rs

@@ -243,12 +243,23 @@
     Ok(())
 }
 
-fn read_but_last_n_bytes(input: &mut impl std::io::BufRead, n: usize) -> std::io::Result<()> {
+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 n = match usize::try_from(n) {
+        Ok(value) => value,
+        Err(e) => {
+            show!(USimpleError::new(
+                1,
+                format!("{e}: number of bytes is too large")
+            ));
+            return Ok(());
+        }
+    };
+
     let stdout = std::io::stdout();
     let mut stdout = stdout.lock();
 
@@ -293,9 +304,20 @@
 
 fn read_but_last_n_lines(
     input: impl std::io::BufRead,
-    n: usize,
+    n: u64,
     separator: u8,
 ) -> std::io::Result<()> {
+    let n = match usize::try_from(n) {
+        Ok(value) => value,
+        Err(e) => {
+            show!(USimpleError::new(
+                1,
+                format!("{e}: number of bytes is too large")
+            ));
+            return Ok(());
+        }
+    };
+
     let stdout = std::io::stdout();
     let mut stdout = stdout.lock();
     for bytes in take_all_but(lines(input, separator), n) {
@@ -380,7 +402,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 +490,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);
+}