bootmgr-rs-core 0.16.5

A framework for easily creating boot managers 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
98
99
100
101
102
103
104
105
106
107
108
109
110
111

// SPDX-FileCopyrightText: 2025 some100 <ootinnyoo@outlook.com>
// SPDX-License-Identifier: MIT

//! Parses configuration files of various formats into [`Config`].
//!
//! The currently supported formats are as follows:
//! - BLS Config files (also known as BLS Type 1)
//! - UKI Executable files (also known as BLS Type 2)
//! - Windows BCD
//!
//! This also supports auto detection for:
//! - BOOTx64.efi, BOOTia32.efi, BOOTaa32.efi, BOOTaa64.efi.
//! - shellx64.efi
//! - boot.efi (macOS)
//!
//! These parsers are all feature gated. This is to avoid too much code size and bloat if the user doesn't have
//! macOS or UKIs on their system, for example, or didn't have Windows. It will also avoid having to scan filesystems
//! In that case, one can simply build this workspace with `--no-default-features`, then specify the parsers that are
//! applicable to their system. The features are as follows:
//! - bls
//! - fallback
//! - osx
//! - shell
//! - uki
//! - windows
//!
//! You can enable or disable these features in accordance with your requirements.

use alloc::vec::Vec;
use uefi::Handle;

use crate::{config::Config, features, system::fs::UefiFileSystem};

/// The BLS (BLS type 1) parser.
pub mod bls;

/// The fallback boot EFI detector.
pub mod fallback;

/// The macOS boot EFI detector.
pub mod osx;

/// The UEFI shell boot EFI detector.
pub mod shell;

/// The UKI (BLS type 2) EFI parser.
pub mod uki;

/// The Windows BCD parser.
pub mod windows;

/// The parsers that exist.
#[derive(Clone, Copy, Debug)]
pub enum Parsers {
    /// The BLS Type #1 parser.
    Bls,

    /// The fallback bootloader autodetection.
    Fallback,

    /// The `boot.efi` macOS autodetection.
    Osx,

    /// The UEFI shell autodetection.
    Shell,

    /// The BLS Type #2 (UKI) parser.
    Uki,

    /// The Windows BCD parser.
    Windows,

    /// A special boot option (such as reboot, shutdown).
    Special,
}

impl Parsers {
    /// Convert a [`Parsers`] type into an [`&str`].
    #[must_use = "Has no effect if the result is unused"]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Bls => "bls",
            Self::Fallback => "fallback",
            Self::Osx => "osx",
            Self::Shell => "shell",
            Self::Uki => "uki",
            Self::Windows => "windows",
            Self::Special => "special",
        }
    }
}

/// Parses configs.
pub trait ConfigParser {
    /// Pushes configs into a mutable reference to a vector, given a filesystem and handle to that filesystem.
    fn parse_configs(fs: &mut UefiFileSystem, handle: Handle, configs: &mut Vec<Config>);
}

/// Parses every config file that has an implementation in parsers.
pub(super) fn parse_all_configs(
    fs: &mut UefiFileSystem,
    handle: Handle,
    configs: &mut Vec<Config>,
) {
    features::bls::BlsConfig::parse_configs(fs, handle, configs);
    features::fallback::FallbackConfig::parse_configs(fs, handle, configs);
    features::osx::OsxConfig::parse_configs(fs, handle, configs);
    features::shell::ShellConfig::parse_configs(fs, handle, configs);
    features::uki::UkiConfig::parse_configs(fs, handle, configs);
    features::windows::WinConfig::parse_configs(fs, handle, configs);
}