rdpal 0.3.5

A tool to manipulate Linux initrd files
Documentation 
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

use anyhow::Result;

use crate::compression;
use crate::cpio;
use crate::segment::RawSegment;

/// Print information about all segments in a ramdisk file.
pub fn print_info(
    file_path: &str,
    file_size: usize,
    segments: &[RawSegment],
    verbose: bool,
) -> Result<()> {
    println!(
        "Ramdisk: {file_path} ({} bytes, {} archive{})",
        file_size,
        segments.len(),
        if segments.len() == 1 { "" } else { "s" }
    );
    println!();
    println!(
        "  {:>3}  {:>12}  {:>12}  {:>11}  {:>12}  {:>7}  First Entry",
        "#", "Offset", "Comp Size", "Compression", "Decomp Size", "Entries"
    );
    println!("  {}", "-".repeat(80));

    for (i, seg) in segments.iter().enumerate() {
        let decompressed = compression::decompress(&seg.data, seg.compression)?;
        let (archive, _) = cpio::parse_archive(&decompressed)?;

        let first_entry = archive
            .entries
            .first()
            .map(|e| e.name.as_str())
            .unwrap_or("");

        println!(
            "  {:>3}  {:>12}  {:>12}  {:>11}  {:>12}  {:>7}  {}",
            i,
            seg.offset,
            seg.data.len(),
            seg.compression.to_string(),
            decompressed.len(),
            archive.entries.len(),
            first_entry,
        );

        if verbose {
            println!(
                "         {:<6} {:>10}  {}",
                "Type", "Size", "Path"
            );
            println!("         {}", "-".repeat(60));
            for entry in &archive.entries {
                let kind = if entry.is_dir() {
                    "dir"
                } else if entry.is_symlink() {
                    "link"
                } else {
                    "file"
                };
                let name = if entry.is_symlink() {
                    let target = String::from_utf8_lossy(&entry.data);
                    format!("{} -> {}", entry.name, target)
                } else {
                    entry.name.clone()
                };
                println!(
                    "         {:<6} {:>10}  {}",
                    kind,
                    entry.data.len(),
                    name,
                );
            }
            println!();
        }
    }

    Ok(())
}