Using secure boot status to determin its awailability for installation.

Cargo.lock

@@ -1804,6 +1804,8 @@ dependencies = [
  "log",
  "rand 0.10.1",
  "rust-i18n",
+ "serde",
+ "serde_json",
  "time-format",
  "toml 1.1.2+spec-1.1.0",
 ]

Cargo.toml

@@ -12,6 +12,8 @@ iced = { version = "0.14", default-features = false, features = ["crisp", "linux
 iced_moving_picture = "0"
 log = "0.4"
 rust-i18n = "3"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
 time-format = "1.2"
 toml = "1"
 

src/kira_sysinfo.rs

@@ -95,3 +95,37 @@ pub fn get_gpus_list() -> Vec<GpuInfo> {
 
     res
 }
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct SecureBootStatus {
+    pub installed: bool,
+    pub guid: String,
+    pub setup_mode: bool,
+    pub secure_boot: bool,
+    pub vendors: Vec<String>,
+    pub firmware_quirks: Vec<String>,
+}
+
+pub fn get_secure_boot_status() -> Result<SecureBootStatus, String> {
+    use std::process::Command;
+
+    //sbctl --json status
+    match Command::new("sbctl").args(["--json", "status"]).output() {
+        Ok(cmd_output) => {
+            if cmd_output.status.success() {
+                match serde_json::from_slice(&cmd_output.stdout) {
+                    Ok(res) => Ok(res),
+                    Err(ex) => Err(ex.to_string()),
+                }
+            } else {
+                Err(format!(
+                    "Error getting disk devices list: {}",
+                    String::from_utf8(cmd_output.stderr).unwrap_or("UNKNOWN".into())
+                ))
+            }
+        }
+        Err(ex) => Err(ex.to_string()),
+    }
+}

src/stage.rs

@@ -72,6 +72,10 @@ impl StageResult {
         self.add_val(val_name, ConfigValue::Bool(v))
     }
 
+    pub fn add_val_u64(self, val_name: &str, v: u64) -> Self {
+        self.add_val(val_name, ConfigValue::U64(v))
+    }
+
     pub fn get_val(&self, val_name: &str) -> Option<ConfigValue> {
         let v = self
             .config

src/stages/partition/mod.rs

@@ -82,6 +82,7 @@ pub struct PartitionStage {
     swap_mode: Option<SwapMode>,
     use_zram: bool,
     secure_boot: bool,
+    secure_boot_in_setup_mode: bool,
     custom_swap_size_mb: u32,
     custom_swap_size_str: String,
     selected_disk_parts: Option<Vec<(String, u16, Color)>>,
@@ -116,6 +117,14 @@ impl PartitionStage {
 
         let min_disk_size: KiraSize = KiraSize::new_mb(min_disk_size_mb.try_into().unwrap_or(8192));
 
+
+        let sec_boot_setup = match kira_sysinfo::get_secure_boot_status() {
+            Ok(sb_status) => sb_status.setup_mode,
+            Err(ex) => {
+                log::error!("Unable to get secure boot status! {}", ex);
+                false
+            }
+        };
         match maybe_dev_list {
             Ok(dev_list) => {
                 let acepted_dev: Vec<BlkDev> = dev_list
@@ -143,6 +152,7 @@ impl PartitionStage {
                     swap_mode: Some(SwapMode::SwapNoHibernate),
                     use_zram: true,
                     secure_boot: false,
+                    secure_boot_in_setup_mode: sec_boot_setup,
                     custom_swap_size_mb: 1024,
                     custom_swap_size_str: "1024MB".into(),
                     selected_disk_parts: None,
@@ -205,14 +215,14 @@ impl PartitionStage {
     }
 
     fn gen_result(&self) -> StageResult {
+        let swap_size: KiraSize = self.get_swap_size();
+        let dev_name = self
+            .device
+            .clone()
+            .expect("Device should be selected!")
+            .name;
         StageResult::new("partition")
-            .add_val_string(
+            .add_val_string("device", dev_name)
-                "device",
-                self.device
-                    .as_ref()
-                    .and_then(|v| Some(v.name.clone()))
-                    .unwrap_or_else(|| "NONE".to_string()),
-            )
             .add_val_string(
                 "swap_mode",
                 self.swap_mode
@@ -220,7 +230,8 @@ impl PartitionStage {
                     .unwrap_or(SwapMode::NoSwap)
                     .to_string(),
             )
-            .add_val_bool("zram", self.use_zram)
+            .add_val_u64("swap_size_mb", swap_size.mb())
+            .add_val_bool("use_zram", self.use_zram)
             .add_val_bool("secure_boot", self.secure_boot)
     }
 
@@ -320,7 +331,11 @@ impl PartitionStage {
         let dev_parts_content = widget::column![dev_parts_text, dev_parts_content];
 
         let back_button = widget::button(widget::text(t!("button.back"))).on_press(Message::Back);
-        let next_button = widget::button(widget::text(t!("button.next"))).on_press(Message::Next);
+        let next_button = if self.device.is_some() {
+            widget::button(widget::text(t!("button.next"))).on_press(Message::Next)
+        } else {
+            widget::button(widget::text(t!("button.next")))
+        };
 
         let selected_dev_text = match self.selected_disk_parts {
             Some(_) => widget::text(t!("partition.current_dev_layout")),
@@ -329,6 +344,12 @@ impl PartitionStage {
         let selected_dev_content = kira_color_bar::color_bar(self.selected_disk_parts.clone(), 64);
         let selected_dev_content = widget::column![selected_dev_text, selected_dev_content];
 
+        let use_sec_boot_checkbox = if self.secure_boot_in_setup_mode {
+            widget::checkbox(self.secure_boot).label(t!("partition.use_secure_boot"))
+                        .on_toggle(Message::ToggleSecureBoot)
+        }
+        else {widget::checkbox(self.secure_boot).label(t!("partition.use_secure_boot"))};
+
         widget::column![
             widget::container(
                 widget::column![
@@ -354,9 +375,7 @@ impl PartitionStage {
                         .label(t!("partition.use_zram"))
                         .on_toggle(Message::ToggleZram),
                     widget::rule::horizontal(2),
-                    widget::checkbox(self.secure_boot)
+                    use_sec_boot_checkbox,
-                        .label(t!("partition.use_secure_boot"))
-                        .on_toggle(Message::ToggleSecureBoot),
                     widget::rule::horizontal(2),
                     selected_dev_content,
                     dev_parts_content,