✨ Add mtree CRLF/content compatibility normalization

Normalize mtree input before parsing with mtree2 to handle
bsdtar-style manifests that use CRLF line endings or the
non-standard `content=` keyword shorthand.

Author: ChanTsune

cli/src/command/core/mtree.rs

@@ -30,8 +30,9 @@ pub(crate) fn transform_mtree_entries<R: Read>(
     filter: &PathFilter<'_>,
     time_filters: &TimeFilters,
 ) -> io::Result<Vec<io::Result<Option<NormalEntry>>>> {
+    let normalized = normalize_mtree_input(reader)?;
     // Use empty cwd to avoid mtree2 joining paths with current working directory
-    let mtree = MTree::from_reader_with_cwd(reader, PathBuf::new());
+    let mtree = MTree::from_reader_with_cwd(io::Cursor::new(normalized), PathBuf::new());
     let mut results = Vec::new();
 
     for entry_result in mtree {
@@ -85,6 +86,108 @@ pub(crate) fn transform_mtree_entries<R: Read>(
     Ok(results)
 }
 
+/// Normalizes mtree input so bsdtar-style manifests can be parsed by mtree2.
+///
+/// - Converts CRLF/CR line endings to LF
+/// - Rewrites `content=` to `contents=` (`content=` is a non-standard shorthand
+///   accepted by bsdtar but not recognized by mtree2)
+fn normalize_mtree_input(mut reader: impl Read) -> io::Result<Vec<u8>> {
+    let mut raw = Vec::new();
+    reader.read_to_end(&mut raw)?;
+    let normalized_line_endings = normalize_line_endings(&raw);
+    Ok(rewrite_content_keyword_alias(&normalized_line_endings))
+}
+
+fn normalize_line_endings(input: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(input.len());
+    let mut idx = 0;
+    while idx < input.len() {
+        if input[idx] == b'\r' {
+            if idx + 1 < input.len() && input[idx + 1] == b'\n' {
+                idx += 1;
+            }
+            out.push(b'\n');
+        } else {
+            out.push(input[idx]);
+        }
+        idx += 1;
+    }
+    out
+}
+
+fn rewrite_content_keyword_alias(input: &[u8]) -> Vec<u8> {
+    let mut out = Vec::with_capacity(input.len());
+    let mut line_start = 0;
+    while line_start < input.len() {
+        let mut line_end = line_start;
+        while line_end < input.len() && input[line_end] != b'\n' {
+            line_end += 1;
+        }
+
+        rewrite_content_keyword_line(&input[line_start..line_end], &mut out);
+        if line_end < input.len() {
+            out.push(b'\n');
+            line_end += 1;
+        }
+        line_start = line_end;
+    }
+    out
+}
+
+/// Rewrites `content=` tokens to `contents=` within a single physical line.
+///
+/// Skips comment lines and preserves the first token (entry name or directive like `/set`).
+/// `/set` directives are intentionally processed because they carry keyword defaults.
+///
+/// Limitation: operates on physical lines, so `content=` as the first token on a
+/// backslash-continuation line will not be rewritten. This is acceptable because such
+/// formatting is uncommon, and the case was already broken before normalization (mtree2
+/// does not recognize `content=`).
+fn rewrite_content_keyword_line(line: &[u8], out: &mut Vec<u8>) {
+    if line.is_empty() || line[0] == b'#' {
+        out.extend_from_slice(line);
+        return;
+    }
+
+    let mut idx = 0;
+    while idx < line.len() && is_mtree_whitespace(line[idx]) {
+        idx += 1;
+    }
+    while idx < line.len() && !is_mtree_whitespace(line[idx]) {
+        idx += 1;
+    }
+    out.extend_from_slice(&line[..idx]);
+
+    while idx < line.len() {
+        let ws_start = idx;
+        while idx < line.len() && is_mtree_whitespace(line[idx]) {
+            idx += 1;
+        }
+        out.extend_from_slice(&line[ws_start..idx]);
+
+        let token_start = idx;
+        while idx < line.len() && !is_mtree_whitespace(line[idx]) {
+            idx += 1;
+        }
+        if token_start == idx {
+            break;
+        }
+
+        let token = &line[token_start..idx];
+        if token.starts_with(b"content=") {
+            out.extend_from_slice(b"contents=");
+            out.extend_from_slice(&token[b"content=".len()..]);
+        } else {
+            out.extend_from_slice(token);
+        }
+    }
+}
+
+#[inline]
+fn is_mtree_whitespace(byte: u8) -> bool {
+    matches!(byte, b' ' | b'\t')
+}
+
 /// Creates a single archive entry from an mtree entry.
 fn create_entry_from_mtree(
     mtree_entry: &MtreeEntry,
@@ -434,4 +537,53 @@ mod tests {
         assert_eq!(entry2.path().to_str(), Some("file2.txt"));
         assert!(entry2.optional(), "file2.txt should be marked as optional");
     }
+
+    #[test]
+    fn normalize_mtree_input_converts_crlf_and_content_alias() {
+        let input = b"#mtree\r\nf type=file content=bar/foo\r\n";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, b"#mtree\nf type=file contents=bar/foo\n");
+    }
+
+    #[test]
+    fn normalize_mtree_input_keeps_existing_contents_keyword() {
+        let input = b"#mtree\nf type=file contents=bar/foo\n";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, input);
+    }
+
+    #[test]
+    fn normalize_mtree_input_preserves_first_token() {
+        let input = b"#mtree\ncontent=file type=file contents=bar/foo\n";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, input);
+    }
+
+    #[test]
+    fn normalize_mtree_input_handles_wrapped_crlf_line() {
+        let input = b"#mtree\r\nf uname=\\\r\nroot content=bar/foo\r\n";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, b"#mtree\nf uname=\\\nroot contents=bar/foo\n");
+    }
+
+    #[test]
+    fn normalize_line_endings_converts_standalone_cr() {
+        let input = b"#mtree\rf type=file content=bar/foo\r";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, b"#mtree\nf type=file contents=bar/foo\n");
+    }
+
+    #[test]
+    fn normalize_mtree_input_rewrites_tab_separated_content() {
+        let input = b"#mtree\nf\ttype=file\tcontent=bar/foo\n";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, b"#mtree\nf\ttype=file\tcontents=bar/foo\n");
+    }
+
+    #[test]
+    fn normalize_mtree_input_handles_no_trailing_newline() {
+        let input = b"#mtree\nf type=file content=bar/foo";
+        let normalized = normalize_mtree_input(&input[..]).unwrap();
+        assert_eq!(normalized, b"#mtree\nf type=file contents=bar/foo");
+    }
 }

cli/tests/cli/stdio/mtree.rs

@@ -157,6 +157,71 @@ fn stdio_mtree_contents_keyword() {
     assert_eq!(entry_names.len(), 1);
 }
 
+/// Precondition: An mtree manifest uses CRLF line endings, wrapped lines, and `content=` alias.
+/// Action: Create and extract archive from the mtree manifest.
+/// Expectation: Parsing succeeds and entries are created with expected payloads.
+#[test]
+fn stdio_mtree_crlf_wrapped_and_content_alias() {
+    setup();
+
+    let base = PathBuf::from("stdio_mtree_crlf_wrapped_and_content_alias");
+    fs::create_dir_all(base.join("bar")).unwrap();
+    fs::write(base.join("bar/foo"), "abc").unwrap();
+    fs::write(base.join("bar/goo"), "xyz").unwrap();
+
+    fs::write(
+        base.join("manifest.mtree"),
+        "#mtree\r\nf type=file uname=\\\r\nroot gname=root mode=0755 content=bar/foo\r\ng type=file uname=root gname=root mode=0755 content=bar/goo\r\n",
+    )
+    .unwrap();
+
+    let output_archive = base.join("output.pna");
+    cargo_bin_cmd!("pna")
+        .args([
+            "--quiet",
+            "experimental",
+            "stdio",
+            "--create",
+            "--unstable",
+            "--overwrite",
+            "-f",
+            output_archive.to_str().unwrap(),
+            "-C",
+            base.to_str().unwrap(),
+            "@manifest.mtree",
+        ])
+        .assert()
+        .success();
+
+    let entry_names: HashSet<String> = get_archive_entry_names(&output_archive)
+        .into_iter()
+        .collect();
+    assert!(entry_names.contains("f"), "Missing f");
+    assert!(entry_names.contains("g"), "Missing g");
+    assert_eq!(entry_names.len(), 2);
+
+    let out_dir = base.join("out");
+    fs::create_dir_all(&out_dir).unwrap();
+    cargo_bin_cmd!("pna")
+        .args([
+            "--quiet",
+            "experimental",
+            "stdio",
+            "--extract",
+            "--unstable",
+            "--overwrite",
+            "-f",
+            output_archive.to_str().unwrap(),
+            "--out-dir",
+            out_dir.to_str().unwrap(),
+        ])
+        .assert()
+        .success();
+
+    assert_eq!(fs::read(out_dir.join("f")).unwrap(), b"abc");
+    assert_eq!(fs::read(out_dir.join("g")).unwrap(), b"xyz");
+}
+
 /// Precondition: An mtree manifest specifies directory and file entries.
 /// Action: Create archive from the mtree manifest.
 /// Expectation: The archive contains both directory and file entries.