mbrkit 1.0.1

A CLI for building, inspecting, extracting, and verifying MBR-backed disk images
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Implementation of `mbrkit pack`.

use std::fs::{File, OpenOptions};
use std::io::{Seek, SeekFrom, Write};

use crate::cli::PackArgs;
use crate::error::{MbrkitError, Result};
use crate::layout::DiskLayout;
use crate::mbr::MbrHeader;

/// Execute the `pack` command.
pub fn run(args: PackArgs) -> Result<()> {
    let layout = DiskLayout::from_pack_args(&args)?;

    if args.dry_run {
        print_layout(&layout);
        return Ok(());
    }

    if layout.output.exists() && !args.force {
        return Err(MbrkitError::InvalidArgument(format!(
            "output image `{}` already exists; use --force to overwrite it",
            layout.output.display()
        )));
    }

    let mut options = OpenOptions::new();
    options.write(true).create(true).truncate(true);
    let mut output = options.open(&layout.output).map_err(|source| {
        MbrkitError::io(
            Some(layout.output.clone()),
            "failed to create output disk image",
            source,
        )
    })?;
    output.set_len(layout.disk_size).map_err(|source| {
        MbrkitError::io(
            Some(layout.output.clone()),
            "failed to size output disk image",
            source,
        )
    })?;

    let mut header = MbrHeader::new(layout.bootstrap_code, layout.disk_signature);
    header.reserved = layout.reserved;

    for partition in &layout.partitions {
        header.set_partition(partition.slot - 1, partition)?;
    }

    output.seek(SeekFrom::Start(0)).map_err(|source| {
        MbrkitError::io(
            Some(layout.output.clone()),
            "failed to seek to the MBR sector",
            source,
        )
    })?;
    output.write_all(&header.to_sector()).map_err(|source| {
        MbrkitError::io(
            Some(layout.output.clone()),
            "failed to write the MBR sector",
            source,
        )
    })?;

    for partition in &layout.partitions {
        let mut input = File::open(&partition.file).map_err(|source| {
            MbrkitError::io(
                Some(partition.file.clone()),
                "failed to open partition payload",
                source,
            )
        })?;

        output
            .seek(SeekFrom::Start(partition.start_offset()))
            .map_err(|source| {
                MbrkitError::io(
                    Some(layout.output.clone()),
                    "failed to seek to partition offset",
                    source,
                )
            })?;
        copy_exact_with_padding(&mut input, &mut output, partition.byte_len())?;
    }

    output.flush().map_err(|source| {
        MbrkitError::io(
            Some(layout.output.clone()),
            "failed to flush output disk image",
            source,
        )
    })?;

    println!("Created {}", layout.output.display());
    Ok(())
}

/// Print the resolved disk layout for a dry run.
fn print_layout(layout: &DiskLayout) {
    println!("Output: {}", layout.output.display());
    println!("Disk size: {} bytes", layout.disk_size);
    println!("Disk signature: 0x{:08x}", layout.disk_signature);
    println!("Alignment: {} sectors", layout.align_sectors);
    println!();
    println!("Slot  Boot  Type   Start    Sectors    File");
    println!("----  ----  -----  -------  ---------  ----");

    for partition in &layout.partitions {
        println!(
            "{:<4}  {:<4}  0x{:02x}  {:<7}  {:<9}  {}",
            partition.slot,
            if partition.bootable { "*" } else { "-" },
            partition.partition_type.0,
            partition.start_lba,
            partition.sector_count,
            partition.file.display()
        );
    }
}

/// Copy a partition payload into the disk image and zero-pad the remaining space.
fn copy_exact_with_padding(input: &mut File, output: &mut File, target_len: u64) -> Result<()> {
    let copied = io_copy(input, output)?;

    if copied > target_len {
        return Err(MbrkitError::InvalidArgument(
            "copied payload exceeded the reserved partition size".into(),
        ));
    }

    let mut remaining = target_len - copied;
    let padding = [0_u8; 4096];

    while remaining > 0 {
        let chunk = remaining.min(padding.len() as u64) as usize;
        output
            .write_all(&padding[..chunk])
            .map_err(|source| MbrkitError::io(None, "failed to write partition padding", source))?;
        remaining -= chunk as u64;
    }

    Ok(())
}

/// Wrap `std::io::copy` so the command module keeps consistent error mapping.
fn io_copy(input: &mut File, output: &mut File) -> Result<u64> {
    std::io::copy(input, output)
        .map_err(|source| MbrkitError::io(None, "failed to copy partition payload", source))
}