shun 0.6.0

Flow-driven payload delivery runtime — installers, flashers, and portable modes
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

//! Flash target: write an image to a block device, verify, done — the
//! evernight image flasher rides on this surface. Block-device writing
//! (volume unmount, elevation, post-write verification) lands in a later
//! iteration; v0 ships the trait surface plus a demo-grade Windows
//! enumeration backend for the flasher UI.

use std::path::Path;

use crate::error::ShunError;
use crate::flow::FlowEvent;

/// A block device eligible as a flash target.
#[derive(Debug, Clone, PartialEq)]
pub struct FlashDevice {
    /// OS-specific identifier (`\\.\PhysicalDrive2`, `/dev/rdisk4`, ...).
    pub id: String,

    /// Human-readable label (vendor / model).
    pub label: String,

    /// Device size in bytes.
    pub size: u64,

    /// Removable media (USB sticks); non-removable devices require an
    /// explicit override in [`FlashConfig`](crate::config::FlashConfig).
    pub removable: bool,
}

/// Block-device write backend.
pub trait FlashTarget {
    /// Enumerate candidate devices.
    fn list_devices(&self) -> Result<Vec<FlashDevice>, ShunError>;

    /// Write `image` onto `device` and verify the written bytes, emitting
    /// progress events.
    fn write(
        &self,
        device: &FlashDevice,
        image: &Path,
        on_event: &mut dyn FnMut(FlowEvent),
    ) -> Result<(), ShunError>;
}

/// Windows backend enumerating removable logical drives — demo-grade (the
/// evernight flasher replaces this with physical-drive enumeration and raw
/// writes), but enough to drive a flasher UI end to end.
#[derive(Debug, Clone, Copy, Default)]
pub struct LogicalDrives;

#[cfg(windows)]
const DRIVE_REMOVABLE: u32 = 2;

#[cfg(windows)]
impl FlashTarget for LogicalDrives {
    fn list_devices(&self) -> Result<Vec<FlashDevice>, ShunError> {
        use windows_sys::Win32::Storage::FileSystem::{
            GetDiskFreeSpaceExW, GetDriveTypeW, GetLogicalDrives,
        };

        fn wide(root: &str) -> [u16; 4] {
            let mut out = [0u16; 4];
            for (slot, ch) in out.iter_mut().zip(root.encode_utf16()) {
                *slot = ch;
            }
            out
        }

        let masks = unsafe { GetLogicalDrives() };
        if masks == 0 {
            return Err(ShunError::Io(std::io::Error::last_os_error()));
        }

        let mut devices = Vec::new();
        for i in 0..26u32 {
            if masks & (1 << i) == 0 {
                continue;
            }
            let letter = (b'A' + i as u8) as char;
            let root = format!("{letter}:\\");
            let root_w = wide(&root);
            if unsafe { GetDriveTypeW(root_w.as_ptr()) } != DRIVE_REMOVABLE {
                continue;
            }
            let mut total: u64 = 0;
            let size = unsafe {
                GetDiskFreeSpaceExW(
                    root_w.as_ptr(),
                    std::ptr::null_mut(),
                    &mut total,
                    std::ptr::null_mut(),
                )
            };
            devices.push(FlashDevice {
                id: root,
                label: format!("Removable drive ({letter}:)"),
                size: if size != 0 { total } else { 0 },
                removable: true,
            });
        }
        Ok(devices)
    }

    fn write(
        &self,
        _device: &FlashDevice,
        _image: &Path,
        _on_event: &mut dyn FnMut(FlowEvent),
    ) -> Result<(), ShunError> {
        Err(ShunError::Unsupported(
            "block-device write (lands with the evernight flasher)",
        ))
    }
}

#[cfg(not(windows))]
impl FlashTarget for LogicalDrives {
    fn list_devices(&self) -> Result<Vec<FlashDevice>, ShunError> {
        Err(ShunError::Unsupported(
            "logical drive enumeration (windows only)",
        ))
    }

    fn write(
        &self,
        _device: &FlashDevice,
        _image: &Path,
        _on_event: &mut dyn FnMut(FlowEvent),
    ) -> Result<(), ShunError> {
        Err(ShunError::Unsupported(
            "block-device write (lands with the evernight flasher)",
        ))
    }
}