isobemak 0.3.4

Create bootable ISO images with FAT32 and UEFI (El Torito) support in Rust.
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

use std::io::{self, Seek, Write};
use std::mem;
use uuid::Uuid;

pub const EFI_SYSTEM_PARTITION_GUID: &str = "C12A7328-F81F-11D2-BA4B-00A0C93EC93B";

// GPT Partition Entry structure
#[repr(C, packed)]
#[derive(Debug, Clone, Copy)]
pub struct GptPartitionEntry {
    pub partition_type_guid: [u8; 16],
    pub unique_partition_guid: [u8; 16],
    pub starting_lba: u64,
    pub ending_lba: u64,
    pub attributes: u64,
    pub partition_name: [u16; 36], // UTF-16LE
}

impl GptPartitionEntry {
    pub fn new(
        partition_type_guid: &str,
        unique_partition_guid: &str,
        starting_lba: u64,
        ending_lba: u64,
        partition_name: &str,
        attributes: u64,
    ) -> Self {
        let partition_type_guid_bytes = uuid_to_gpt_mixed_endian(
            &Uuid::parse_str(partition_type_guid).expect("Failed to parse partition type GUID"),
        );
        let unique_partition_guid_bytes = uuid_to_gpt_mixed_endian(
            &Uuid::parse_str(unique_partition_guid).expect("Failed to parse unique partition GUID"),
        );

        let mut name_bytes = [0u16; 36];
        for (i, c) in partition_name.encode_utf16().take(36).enumerate() {
            name_bytes[i] = c;
        }

        GptPartitionEntry {
            partition_type_guid: partition_type_guid_bytes,
            unique_partition_guid: unique_partition_guid_bytes,
            starting_lba,
            ending_lba,
            attributes,
            partition_name: name_bytes,
        }
    }

    pub fn to_bytes(&self) -> [u8; mem::size_of::<GptPartitionEntry>()] {
        let mut bytes = [0u8; mem::size_of::<GptPartitionEntry>()];
        let mut offset = 0;

        bytes[offset..offset + 16].copy_from_slice(&self.partition_type_guid);
        offset += 16;
        bytes[offset..offset + 16].copy_from_slice(&self.unique_partition_guid);
        offset += 16;
        bytes[offset..offset + 8].copy_from_slice(&self.starting_lba.to_le_bytes());
        offset += 8;
        bytes[offset..offset + 8].copy_from_slice(&self.ending_lba.to_le_bytes());
        offset += 8;
        bytes[offset..offset + 8].copy_from_slice(&self.attributes.to_le_bytes());
        offset += 8;
        for i in 0..36 {
            bytes[offset..offset + 2].copy_from_slice(&self.partition_name[i].to_le_bytes());
            offset += 2;
        }

        bytes
    }

    pub fn write_to<W: Write + Seek>(&self, writer: &mut W) -> io::Result<()> {
        let partition_bytes = self.to_bytes();
        writer.write_all(&partition_bytes)?;
        Ok(())
    }
}

/// Convert a UUID to the mixed-endian byte order required by GPT/UEFI spec.
///
/// GPT stores GUIDs in a mixed-endian format:
///   - time_low (u32): little-endian
///   - time_mid (u16): little-endian
///   - time_high_and_version (u16): little-endian
///   - clock_seq_and_variant + node: big-endian
///
/// The `uuid` crate's `into_bytes()` returns RFC 4122 big-endian format,
/// which is incorrect for GPT. This function corrects the endianness.
pub(crate) fn uuid_to_gpt_mixed_endian(uuid: &Uuid) -> [u8; 16] {
    let (time_low, time_mid, time_high, rest) = uuid.as_fields();
    let mut bytes = [0u8; 16];
    bytes[0..4].copy_from_slice(&time_low.to_le_bytes());
    bytes[4..6].copy_from_slice(&time_mid.to_le_bytes());
    bytes[6..8].copy_from_slice(&time_high.to_le_bytes());
    bytes[8..16].copy_from_slice(rest);
    bytes
}