extract, list: auto-detect and decompress gzip archives

Previously, extract and list passed the raw file bytes directly to the
tar parser without decompression. When given a .tar.gz file, the
compressed gzip stream was interpreted as tar headers, producing errors
like "numeric field did not have utf-8 text" on the checksum field.

Detect gzip compression by reading the two-byte magic number (0x1f
0x8b) at the start of the file, and wrap the reader in a GzDecoder
when present. Plain .tar files continue to work as before.

Confirmed this patch allows extraction of Go source code from
https://go.dev/dl/ (previously we would get an error).

Fixes #158.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: kevinburke

Cargo.lock

@@ -67,6 +67,7 @@ tar = { optional = true, version = "0.0.1", package = "uu_tar", path = "src/uu/t
 
 [dev-dependencies]
 chrono = { workspace = true }
+flate2 = "1"
 libc = { workspace = true }
 pretty_assertions = "1"
 rand = { workspace = true }

Cargo.toml

@@ -19,6 +19,7 @@ regex = { workspace = true }
 tar = { workspace = true }
 chrono = { workspace = true }
 thiserror = { workspace = true }
+flate2 = "1"
 
 [lib]
 path = "src/tar.rs"

src/uu/tar/Cargo.toml

@@ -0,0 +1,19 @@
+// This file is part of the uutils tar package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use std::fs::File;
+use std::io::{Read, Seek};
+
+/// Check whether a file is gzip-compressed.
+///
+/// Gzip files always start with the two-byte signature 0x1f 0x8b.
+/// This peeks at the first two bytes and then seeks back to the
+/// beginning so the caller can read the file from the start.
+pub fn is_gzip(file: &mut File) -> bool {
+    let mut magic = [0u8; 2];
+    let n = file.read(&mut magic).unwrap_or(0);
+    file.seek(std::io::SeekFrom::Start(0)).ok();
+    n == 2 && magic == [0x1f, 0x8b]
+}

src/uu/tar/src/compression.rs

@@ -3,8 +3,11 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::compression;
 use crate::errors::TarError;
+use flate2::read::GzDecoder;
 use std::fs::File;
+use std::io::{BufReader, Read};
 use std::path::Path;
 use tar::Archive;
 use uucore::error::UResult;
@@ -23,11 +26,19 @@ use uucore::error::UResult;
 /// - The archive format is invalid
 /// - Files cannot be extracted due to I/O or permission errors
 pub fn extract_archive(archive_path: &Path, verbose: bool) -> UResult<()> {
-    // Open the archive file
-    let file = File::open(archive_path).map_err(|e| TarError::from_io_error(e, archive_path))?;
+    let mut file =
+        File::open(archive_path).map_err(|e| TarError::from_io_error(e, archive_path))?;
 
-    // Create Archive instance
-    let mut archive = Archive::new(file);
+    if compression::is_gzip(&mut file) {
+        let reader = BufReader::new(GzDecoder::new(file));
+        return extract_from_reader(reader, archive_path, verbose);
+    }
+
+    extract_from_reader(file, archive_path, verbose)
+}
+
+fn extract_from_reader<R: Read>(reader: R, archive_path: &Path, verbose: bool) -> UResult<()> {
+    let mut archive = Archive::new(reader);
 
     // Extract to current directory
     if verbose {

src/uu/tar/src/operations/extract.rs

@@ -3,19 +3,32 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use crate::compression;
 use crate::errors::TarError;
 use chrono::{TimeZone, Utc};
+use flate2::read::GzDecoder;
 use std::fs::File;
+use std::io::{BufReader, Read};
 use std::path::Path;
 use tar::Archive;
 use uucore::error::UResult;
 use uucore::fs::display_permissions_unix;
 
 /// List the contents of a tar archive, printing one entry per line.
 pub fn list_archive(archive_path: &Path, verbose: bool) -> UResult<()> {
-    let file: File =
+    let mut file: File =
         File::open(archive_path).map_err(|e| TarError::from_io_error(e, archive_path))?;
-    let mut archive = Archive::new(file);
+
+    if compression::is_gzip(&mut file) {
+        let reader = BufReader::new(GzDecoder::new(file));
+        return list_from_reader(reader, verbose);
+    }
+
+    list_from_reader(file, verbose)
+}
+
+fn list_from_reader<R: Read>(reader: R, verbose: bool) -> UResult<()> {
+    let mut archive = Archive::new(reader);
 
     for entry_result in archive.entries().map_err(TarError::CannotReadEntries)? {
         let entry = entry_result.map_err(TarError::CannotReadEntry)?;

src/uu/tar/src/operations/list.rs

@@ -3,6 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+pub mod compression;
 pub mod errors;
 mod operations;
 

src/uu/tar/src/tar.rs

@@ -3,6 +3,7 @@
 // For the full copyright and license information, please view the LICENSE
 // file that was distributed with this source code.
 
+use std::io::Write;
 use std::path::{self, PathBuf};
 
 use uutests::{at_and_ucmd, new_ucmd};
@@ -752,3 +753,79 @@ fn test_list_conflicts_with_extract() {
         .code_is(2)
         .stderr_contains("cannot be used with");
 }
+
+// Gzip-compressed archive tests
+
+#[test]
+fn test_extract_gzip_archive() {
+    let (at, _ucmd) = at_and_ucmd!();
+
+    // Build a .tar.gz in memory: tar containing one file, then gzip-compress it
+    let mut tar_bytes = Vec::new();
+    {
+        let mut builder = tar_rs_crate::Builder::new(&mut tar_bytes);
+        let content = b"hello from gzip";
+        let mut header = tar_rs_crate::Header::new_gnu();
+        header.set_path("gzfile.txt").unwrap();
+        header.set_size(content.len() as u64);
+        header.set_mode(0o644);
+        header.set_cksum();
+        builder.append(&header, &content[..]).unwrap();
+        builder.finish().unwrap();
+    }
+
+    // Gzip-compress the tar bytes
+    let mut gz_bytes = Vec::new();
+    {
+        let mut encoder =
+            flate2::write::GzEncoder::new(&mut gz_bytes, flate2::Compression::default());
+        encoder.write_all(&tar_bytes).unwrap();
+        encoder.finish().unwrap();
+    }
+
+    at.write_bytes("archive.tar.gz", &gz_bytes);
+
+    // Extract using our tar implementation
+    new_ucmd!()
+        .arg("-xf")
+        .arg(at.plus("archive.tar.gz"))
+        .current_dir(at.as_string())
+        .succeeds();
+
+    assert!(at.file_exists("gzfile.txt"));
+    assert_eq!(at.read("gzfile.txt"), "hello from gzip");
+}
+
+#[test]
+fn test_list_gzip_archive() {
+    let (at, _ucmd) = at_and_ucmd!();
+
+    // Build a .tar.gz in memory
+    let mut tar_bytes = Vec::new();
+    {
+        let mut builder = tar_rs_crate::Builder::new(&mut tar_bytes);
+        let content = b"list test content";
+        let mut header = tar_rs_crate::Header::new_gnu();
+        header.set_path("listed.txt").unwrap();
+        header.set_size(content.len() as u64);
+        header.set_mode(0o644);
+        header.set_cksum();
+        builder.append(&header, &content[..]).unwrap();
+        builder.finish().unwrap();
+    }
+
+    let mut gz_bytes = Vec::new();
+    {
+        let mut encoder =
+            flate2::write::GzEncoder::new(&mut gz_bytes, flate2::Compression::default());
+        encoder.write_all(&tar_bytes).unwrap();
+        encoder.finish().unwrap();
+    }
+
+    at.write_bytes("archive.tar.gz", &gz_bytes);
+
+    new_ucmd!()
+        .args(&["-tf", &at.plus_as_string("archive.tar.gz")])
+        .succeeds()
+        .stdout_contains("listed.txt");
+}