introduce rust

src/bootstrap.rs

@@ -0,0 +1 @@
+pub mod config;

src/bootstrap/config.rs

@@ -0,0 +1,158 @@
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct Config {
+    pub anti_phishing_code: String,
+
+    pub keymap: Option<String>,
+    pub modules: Option<String>,
+
+    pub auths: Vec<Auth>,
+
+    pub networks: Vec<Network>,
+
+    #[serde(default)]
+    pub ssh: SSHServer,
+
+    #[serde(default)]
+    pub pre_lvm_crypt: Vec<CryptDev>,
+    #[serde(default)]
+    pub lvm: Vec<LvmVG>,
+    #[serde(default)]
+    pub crypt: Vec<CryptDev>,
+
+    pub bootstrap: Bootstrap,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct Auth {
+    pub name: String,
+    #[serde(rename = "sshKey")]
+    pub ssh_key: String,
+    pub password: String,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct Network {
+    pub name: String,
+    pub interfaces: Vec<NetworkInterface>,
+    pub script: String,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct NetworkInterface {
+    pub var: String,
+    pub n: usize,
+    pub regexps: Vec<String>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct SSHServer {
+    pub listen: String,
+    pub keys: SSHKeys,
+}
+impl Default for SSHServer {
+    fn default() -> Self {
+        Self {
+            listen: "[::]:22".to_string(),
+            keys: SSHKeys::default(),
+        }
+    }
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct SSHKeys {
+    dsa: Option<String>,
+    rsa: Option<String>,
+    ecdsa: Option<String>,
+    ed25519: Option<String>,
+}
+impl SSHKeys {
+    pub fn iter(&self) -> impl Iterator<Item = &str> {
+        [
+            self.dsa.iter(),
+            self.rsa.iter(),
+            self.ecdsa.iter(),
+            self.ed25519.iter(),
+        ]
+        .into_iter()
+        .flatten()
+        .map(String::as_str)
+    }
+}
+impl Default for SSHKeys {
+    fn default() -> Self {
+        Self {
+            dsa: Some("id_dsa".to_string()),
+            rsa: Some("id_rsa".to_string()),
+            ecdsa: Some("id_ecdsa".to_string()),
+            ed25519: Some("id_ed25519".to_string()),
+        }
+    }
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct LvmVG {
+    vg: String,
+    pvs: LvmPV,
+
+    #[serde(default)]
+    defaults: LvmLVDefaults,
+
+    lvs: Vec<LvmLV>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct LvmLVDefaults {
+    #[serde(default = "default_fs")]
+    fs: String,
+    raid: Option<Raid>,
+}
+impl Default for LvmLVDefaults {
+    fn default() -> Self {
+        Self {
+            fs: default_fs(),
+            raid: None,
+        }
+    }
+}
+
+fn default_fs() -> String {
+    "ext4".to_string()
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct LvmLV {
+    name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fs: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    raid: Option<Raid>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    size: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    extents: Option<String>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct LvmPV {
+    n: i16,
+    regexps: Vec<String>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct CryptDev {
+    name: String,
+    dev: Option<String>,
+    prefix: Option<String>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct Raid {
+    mirrors: Option<u8>,
+    stripes: Option<u8>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct Bootstrap {
+    dev: String,
+    seed: String,
+}

src/cmd.rs

@@ -0,0 +1,5 @@
+pub mod bootstrap;
+pub mod connect_boot;
+pub mod init;
+pub mod init_input;
+pub mod version;

src/cmd/init.rs

@@ -0,0 +1,233 @@
+use eyre::{format_err, Result};
+use log::{error, info, warn};
+use std::os::unix::fs::symlink;
+use tokio::{fs, process::Command};
+
+use crate::{bootstrap::config::Config, cmd::version::version_string};
+
+mod dmcrypt;
+mod networks;
+mod sshd;
+
+pub async fn run() {
+    if std::process::id() != 1 {
+        error!("init must run as PID 1, not {}", std::process::id());
+        std::process::exit(1);
+    }
+
+    unsafe {
+        use std::env;
+        env::set_var("PATH", "/bin:/sbin:/usr/bin:/usr/sbin");
+        env::set_var("HOME", "/root");
+    }
+
+    info!("Welcome to {}", version_string());
+
+    let uname = nix::sys::utsname::uname().expect("uname should work");
+    let kernel_version = uname.release().to_string_lossy();
+    info!("Linux version {kernel_version}");
+
+    let cfg: Config = retry(async || {
+        let cfg = (fs::read("config.yaml").await)
+            .map_err(|e| format_err!("failed to read config: {e}"))?;
+        serde_yaml::from_slice(cfg.as_slice())
+            .map_err(|e| format_err!("failed to parse config: {e}"))
+    })
+    .await;
+
+    info!("config loaded");
+    info!("anti-phishing-code: {}", cfg.anti_phishing_code);
+
+    // mount basic filesystems
+    mount("none", "/proc", "proc", None).await;
+    mount("none", "/sys", "sysfs", None).await;
+    mount("none", "/dev", "devtmpfs", None).await;
+    mount("none", "/dev/pts", "devpts", Some("gid=5,mode=620")).await;
+
+    // mount modules
+    if let Some(ref modules) = cfg.modules {
+        retry_or_ignore(async || {
+            info!("mounting modules");
+            mount(modules, "/modules", "squashfs", None).await;
+
+            fs::create_dir_all("/lib/modules").await?;
+            let modules_path = &format!("/modules/lib/modules/{kernel_version}");
+
+            if !std::fs::exists(modules_path)? {
+                return Err(format_err!(
+                    "invalid modules package: {modules_path} should exist"
+                ));
+            }
+
+            symlink(modules_path, format!("/lib/modules/{kernel_version}"))?;
+            Ok(())
+        })
+        .await;
+    } else {
+        warn!("modules NOT mounted (not configured)");
+    }
+
+    // open input channels
+    tokio::spawn(crate::input::answer_requests_from_stdin());
+    tokio::spawn(crate::input::answer_requests_from_socket());
+
+    // init devices
+    info!("initializing devices");
+    start_daemon("udevd", &[]).await;
+
+    exec("udevadm", &["trigger", "-c", "add", "-t", "devices"]).await;
+    exec("udevadm", &["trigger", "-c", "add", "-t", "subsystems"]).await;
+    exec("udevadm", &["settle"]).await;
+
+    // networks
+    networks::setup(&cfg).await;
+
+    // Wireguard VPN
+    // TODO startVPN()
+
+    // SSH service
+    sshd::start(&cfg).await;
+
+    // dmcrypt blockdevs
+    dmcrypt::setup(&cfg).await;
+    // TODO setupCrypt(cfg.PreLVMCrypt, map[string]string{});
+
+    // LVM
+    // TODO setupLVM(cfg);
+
+    // bootstrap the system
+    // TODO bootstrap(cfg);
+
+    // finalize
+    // TODO finalizeBoot();
+
+    exec_shell().await;
+}
+
+async fn mount(src: &str, dst: &str, fstype: &str, opts: Option<&str>) {
+    if let Err(e) = fs::create_dir_all(dst).await {
+        error!("failed to create dir {dst}: {e}");
+    }
+
+    let mut args = vec![src, dst, "-t", fstype];
+    if let Some(opts) = opts {
+        args.extend(["-o", opts]);
+    }
+    exec("mount", &args).await;
+}
+
+async fn start_daemon(prog: &str, args: &[&str]) {
+    let (cmd_str, mut cmd) = cmd_str(prog, args);
+    retry_or_ignore(async || {
+        info!("starting as daemon: {cmd_str}");
+        cmd.spawn()?;
+        Ok(())
+    })
+    .await;
+}
+
+async fn exec(prog: &str, args: &[&str]) {
+    let (cmd_str, mut cmd) = cmd_str(prog, args);
+    retry_or_ignore(async || {
+        info!("# {cmd_str}");
+        let s = cmd.status().await?;
+        if s.success() {
+            Ok(())
+        } else {
+            Err(format_err!("command failed: {s}"))
+        }
+    })
+    .await;
+}
+
+async fn input_line() -> String {
+    use tokio::io::{stdin, AsyncBufReadExt, BufReader};
+    let mut stdin = BufReader::new(stdin()).lines();
+    let Ok(line) = stdin.next_line().await else {
+        panic!("unable to read a line");
+    };
+    line.expect("stdin should not the closed")
+}
+
+async fn retry_or_ignore(mut action: impl AsyncFnMut() -> Result<()>) {
+    loop {
+        match action().await {
+            Ok(_) => return,
+            Err(e) => {
+                error!("{e}");
+
+                loop {
+                    eprint!("[r]etry, [i]gnore, or [s]hell? ");
+
+                    match input_line().await.trim() {
+                        "r" => break,
+                        "i" => return,
+                        "s" => {
+                            exec_shell().await;
+                            break;
+                        }
+                        v => {
+                            eprintln!("invalid choice: {v:?}");
+                        }
+                    };
+                }
+            }
+        }
+    }
+}
+
+async fn retry<T>(mut action: impl AsyncFnMut() -> Result<T>) -> T {
+    loop {
+        match action().await {
+            Ok(v) => return v,
+            Err(e) => {
+                error!("{e}");
+
+                loop {
+                    eprint!("[r]etry, or [s]hell? ");
+
+                    match input_line().await.trim() {
+                        "r" => break,
+                        "s" => {
+                            exec_shell().await;
+                            break;
+                        }
+                        v => {
+                            eprintln!("invalid choice: {v:?}");
+                        }
+                    };
+                }
+            }
+        }
+    }
+}
+
+async fn exec_shell() {
+    let mut child = match Command::new("ash").spawn() {
+        Ok(c) => c,
+        Err(e) => {
+            error!("failed to exec shell: {e}");
+            return;
+        }
+    };
+
+    let _ = child.wait().await;
+}
+
+fn cmd_str(prog: &str, args: &[&str]) -> (String, Command) {
+    use std::borrow::Cow;
+
+    let mut buf = String::new();
+
+    buf.push_str(&shell_escape::escape(Cow::Borrowed(prog)));
+
+    for &arg in args {
+        buf.push(' ');
+        buf.push_str(&shell_escape::escape(Cow::Borrowed(arg)));
+    }
+
+    let mut cmd = Command::new(prog);
+    cmd.args(args);
+
+    (buf, cmd)
+}

src/cmd/init/dmcrypt.rs

@@ -0,0 +1,10 @@
+use super::{retry_or_ignore, Config};
+use crate::input;
+
+pub async fn setup(cfg: &Config) {
+    let resp = input::read_line("input something: ").await;
+    println!("user response: {resp}");
+    let resp = input::read_password("input password: ").await;
+    println!("user response: {resp}");
+    // TODO
+}

src/cmd/init/networks.rs

@@ -0,0 +1,94 @@
+use itertools::Itertools;
+use log::{info, warn};
+use std::collections::BTreeSet as Set;
+use tokio::process::Command;
+
+use super::{format_err, retry_or_ignore, Config, Result};
+use crate::{
+    bootstrap::config,
+    udev,
+    utils::{select_n_by_regex, NameAliases},
+};
+
+pub async fn setup(cfg: &Config) {
+    if cfg.networks.is_empty() {
+        warn!("no networks configured");
+        return;
+    }
+
+    let mut assigned = Set::new();
+
+    for net in &cfg.networks {
+        retry_or_ignore(async || setup_network(net, &mut assigned).await).await;
+    }
+}
+
+async fn setup_network(net: &config::Network, assigned: &mut Set<String>) -> Result<()> {
+    info!("setting up network {}", net.name);
+
+    let netdevs = get_interfaces()?
+        .filter(|dev| !assigned.contains(dev.name()))
+        .collect::<Vec<_>>();
+
+    for dev in &netdevs {
+        info!(
+            "- available network device: {}, aliases [{}]",
+            dev.name(),
+            dev.aliases().join(", ")
+        );
+    }
+
+    let mut cmd = Command::new("ash");
+    cmd.arg("-c");
+    cmd.arg(&net.script);
+
+    let mut selected = Vec::new();
+
+    for iface in &net.interfaces {
+        let var = &iface.var;
+
+        let netdevs = netdevs.iter().filter(|na| !assigned.contains(na.name()));
+        let if_names = select_n_by_regex(iface.n, &iface.regexps, netdevs);
+
+        if if_names.is_empty() {
+            return Err(format_err!("- no interface match for {var:?}"));
+        }
+
+        let value = if_names.join(" ");
+        info!("- {var}={value}");
+        cmd.env(var, value);
+
+        selected.extend(if_names);
+    }
+
+    info!("- running script");
+    let status = cmd.status().await?;
+    if !status.success() {
+        return Err(format_err!("setup script failed: {status}"));
+    }
+
+    assigned.extend(selected);
+    Ok(())
+}
+
+fn get_interfaces() -> Result<impl Iterator<Item = NameAliases>> {
+    Ok(udev::get_devices("net")?.into_iter().map(|dev| {
+        let mut na = NameAliases::new(dev.sysname().to_string());
+
+        for (property, value) in dev.properties() {
+            if [
+                "INTERFACE",
+                "ID_NET_NAME",
+                "ID_NET_NAME_PATH",
+                "ID_NET_NAME_MAC",
+                "ID_NET_NAME_SLOT",
+            ]
+            .contains(&property)
+            {
+                na.push(value.to_string());
+            }
+        }
+
+        na
+    }))
+}

src/cmd/init/sshd.rs

@@ -0,0 +1,86 @@
+use log::{info, warn};
+use std::fs;
+use std::io::Write;
+use std::os::unix::fs::PermissionsExt;
+use std::process::Stdio;
+use tokio::net;
+use tokio::process::Command;
+
+use super::{retry_or_ignore, Config};
+
+pub async fn start(cfg: &Config) {
+    retry_or_ignore(async || {
+        info!("ssh: writing authorized keys");
+
+        let ssh_dir = "/root/.ssh";
+        let authorized_keys = format!("{ssh_dir}/authorized_keys");
+
+        fs::create_dir_all(ssh_dir)?;
+        fs::set_permissions(ssh_dir, fs::Permissions::from_mode(0o700))?;
+
+        let mut ak = Vec::new();
+
+        for auth in &cfg.auths {
+            writeln!(ak, "{} {}", auth.ssh_key, auth.name)?;
+        }
+
+        fs::write(authorized_keys, ak)?;
+        Ok(())
+    })
+    .await;
+
+    retry_or_ignore(async || {
+        let mut sshd_args = Vec::new();
+
+        sshd_args.extend(["-i", "-E", "/var/log/sshd.log"]);
+
+        for key_path in cfg.ssh.keys.iter() {
+            if !fs::exists(key_path).is_ok_and(|b| b) {
+                info!("ssh: host key not found (ignored): {key_path}");
+                continue;
+            }
+            sshd_args.extend(["-h", key_path]);
+        }
+
+        let sshd_args = sshd_args.into_iter().map(String::from).collect();
+
+        // don't pre-start sshd as it should rarely be useful at this stage, use inetd-style.
+        let listen_addr = cfg.ssh.listen.clone();
+        info!("ssh: starting listener on {listen_addr}");
+
+        let listener = net::TcpListener::bind(listen_addr).await?;
+
+        tokio::spawn(handle_ssh_connections(listener, sshd_args));
+
+        Ok(())
+    })
+    .await;
+}
+
+async fn handle_ssh_connections(listener: net::TcpListener, sshd_args: Vec<String>) {
+    loop {
+        let (stream, remote) = match listener.accept().await {
+            Ok(v) => v,
+            Err(e) => {
+                warn!("ssh: listener stopped: {e}");
+                return;
+            }
+        };
+
+        info!("ssh: new connection from {remote}");
+
+        use std::os::unix::io::{AsRawFd, FromRawFd};
+        let fd = stream.as_raw_fd();
+
+        let mut cmd = Command::new("/usr/sbin/sshd");
+        cmd.args(&sshd_args);
+
+        cmd.stdin(unsafe { Stdio::from_raw_fd(fd) });
+        cmd.stdout(unsafe { Stdio::from_raw_fd(fd) });
+        cmd.stderr(Stdio::null());
+
+        if let Err(e) = cmd.spawn() {
+            warn!("ssh: failed to start server: {e}");
+        }
+    }
+}

src/cmd/init_input.rs

@@ -0,0 +1,11 @@
+use crate::input;
+
+pub async fn run() {
+    tokio::spawn(async {
+        if let Err(e) = input::forward_requests_from_socket().await {
+            eprintln!("failed to forwards requests from socket: {e}");
+            std::process::exit(1);
+        }
+    });
+    input::answer_requests_from_stdin().await;
+}

src/cmd/version.rs

@@ -0,0 +1,12 @@
+pub fn run() {
+    println!("{}", version_string());
+}
+
+pub fn version_string() -> String {
+    format!(
+        "Direktil {} v{} (git commit {})",
+        env!("CARGO_PKG_NAME"),
+        env!("CARGO_PKG_VERSION"),
+        env!("GIT_COMMIT")
+    )
+}

src/input.rs

@@ -0,0 +1,227 @@
+use log::warn;
+use std::fmt::Display;
+use std::sync::{Arc, LazyLock};
+use tokio::io::{self, AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::net;
+use tokio::sync::{oneshot, watch, Mutex};
+
+pub async fn read_line(prompt: impl Display) -> String {
+    read(prompt, false).await
+}
+
+pub async fn read_password(prompt: impl Display) -> String {
+    read(prompt, true).await
+}
+
+#[derive(Clone, serde::Deserialize, serde::Serialize)]
+pub struct InputRequest {
+    prompt: String,
+    hide: bool,
+}
+
+pub type Reply = Arc<Mutex<Option<oneshot::Sender<String>>>>;
+
+static REQ: LazyLock<Mutex<watch::Sender<Option<(InputRequest, Reply)>>>> = LazyLock::new(|| {
+    let (tx, _) = watch::channel(None);
+    Mutex::new(tx)
+});
+static READ_MUTEX: Mutex<()> = Mutex::const_new(());
+
+async fn read(prompt: impl Display, hide_input: bool) -> String {
+    let _read_lock = READ_MUTEX.lock();
+
+    let req = InputRequest {
+        prompt: prompt.to_string(),
+        hide: hide_input,
+    };
+
+    let (tx, rx) = oneshot::channel();
+    let reply = Arc::new(Mutex::new(Some(tx)));
+
+    REQ.lock().await.send_replace(Some((req, reply)));
+
+    let input = rx.await.expect("reply sender should not be closed");
+
+    REQ.lock().await.send_replace(None);
+
+    input
+}
+
+pub async fn answer_requests_from_stdin() {
+    let mut stdin = BufReader::new(io::stdin()).lines();
+    let mut stdout = io::stdout();
+
+    let mut current_req = REQ.lock().await.subscribe();
+    current_req.mark_changed();
+
+    loop {
+        // TODO check is stdin has been closed (using C-c is enough for now)
+        (current_req.changed().await).expect("input request should not close");
+
+        let Some((req, reply)) = current_req.borrow_and_update().clone() else {
+            continue;
+        };
+
+        // handle hide
+        let mut saved_termios = None;
+        if req.hide {
+            match termios::Termios::from_fd(0) {
+                Ok(mut tio) => {
+                    saved_termios = Some(tio.clone());
+                    tio.c_lflag &= !termios::ECHO;
+                    if let Err(e) = termios::tcsetattr(0, termios::TCSAFLUSH, &tio) {
+                        warn!("password will be echoed! Failed to set pty attrs: {e}");
+                    }
+                }
+                Err(e) => {
+                    warn!("password will be echoed! Failed to get pty attrs: {e}");
+                }
+            }
+        }
+
+        // print the prompt and wait for user input
+        stdout.write_all(req.prompt.as_bytes()).await.unwrap();
+        stdout.flush().await.unwrap();
+
+        tokio::select!(
+            r = stdin.next_line() => {
+                let Ok(Some(line)) = r else {
+                    warn!("stdin closed");
+                    return;
+                };
+
+                if let Some(tx) = reply.lock().await.take() {
+                    let _ = tx.send(line);
+                }
+
+                if saved_termios.is_some() {
+                    // final '\n' is hidden too so fix it
+                    stdout.write_all(b"\n").await.unwrap();
+                    stdout.flush().await.unwrap();
+                }
+            }
+            _ = current_req.changed() => {
+                // reply came from somewhere else
+                stdout.write_all(b"<answered>\n").await.unwrap();
+                stdout.flush().await.unwrap();
+
+                current_req.mark_changed();
+            }
+        );
+
+        // restore term if input was hidden
+        if let Some(tio) = saved_termios {
+            if let Err(e) = termios::tcsetattr(0, termios::TCSAFLUSH, &tio) {
+                warn!("failed to restore pty attrs: {e}");
+            }
+        }
+    }
+}
+
+const SOCKET_PATH: &str = "/run/init.sock";
+
+pub async fn answer_requests_from_socket() {
+    let Ok(listener) = net::UnixListener::bind(SOCKET_PATH)
+        .inspect_err(|e| warn!("failed start input socket listener: {e}"))
+    else {
+        return;
+    };
+
+    loop {
+        let Ok((conn, _)) = (listener.accept())
+            .await
+            .inspect_err(|e| warn!("input socket listener failed: {e}"))
+        else {
+            return;
+        };
+
+        tokio::spawn(handle_connection(conn));
+    }
+}
+
+async fn handle_connection(conn: net::UnixStream) {
+    let mut current_req = REQ.lock().await.subscribe();
+    current_req.mark_changed();
+
+    let (rd, mut wr) = io::split(conn);
+    let mut rd = BufReader::new(rd).lines();
+
+    loop {
+        (current_req.changed().await).expect("input request should not close");
+        let Some((req, reply)) = current_req.borrow_and_update().clone() else {
+            if wr.write_all(b"null\n").await.is_err() {
+                return;
+            }
+            if wr.flush().await.is_err() {
+                return;
+            }
+
+            continue;
+        };
+
+        {
+            let mut buf = serde_json::to_vec(&req).unwrap();
+            buf.push(b'\n');
+
+            if (wr.write_all(&buf).await).is_err() {
+                return;
+            }
+            if wr.flush().await.is_err() {
+                return;
+            }
+        }
+
+        tokio::select!(
+            r = rd.next_line() => {
+                let Ok(Some(line)) = r else {
+                    return; // closed
+                };
+
+                if let Some(tx) = reply.lock().await.take() {
+                    let _ = tx.send(line);
+                }
+            }
+            _ = current_req.changed() => {
+                // reply came from somewhere else
+                current_req.mark_changed();
+            }
+        );
+    }
+}
+
+pub async fn forward_requests_from_socket() -> eyre::Result<()> {
+    let stream = net::UnixStream::connect(SOCKET_PATH).await?;
+
+    let (rd, mut wr) = io::split(stream);
+    let mut rd = BufReader::new(rd).lines();
+
+    let mut line = rd.next_line().await?;
+
+    loop {
+        let Some(req) = line else {
+            return Ok(());
+        };
+
+        let req: Option<InputRequest> = serde_json::from_str(&req)?;
+
+        let Some(req) = req else {
+            // request answered from somewhere else
+            REQ.lock().await.send_replace(None);
+            line = rd.next_line().await?;
+            continue;
+        };
+
+        tokio::select!(
+            mut r = read(req.prompt, req.hide) => {
+                r.push('\n');
+                wr.write_all(r.as_bytes()).await?;
+                wr.flush().await?;
+
+                line = rd.next_line().await?;
+            }
+            l = rd.next_line() => {
+                line = l?;
+            }
+        );
+    }
+}

src/lib.rs

@@ -0,0 +1,7 @@
+pub mod bootstrap;
+pub mod cmd;
+pub mod lsblk;
+pub mod lvm;
+pub mod udev;
+pub mod utils;
+pub mod input;

src/lsblk.rs

@@ -0,0 +1,27 @@
+use std::io;
+use std::process::Command;
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct Report {
+    pub blockdevices: Vec<BlockDev>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+pub struct BlockDev {
+    pub name: String,
+    #[serde(rename = "maj:min")]
+    pub maj_min: String,
+    pub rm: bool,
+    pub size: String,
+    pub ro: bool,
+    #[serde(rename = "type")]
+    pub dev_type: String,
+    pub mountpoints: Vec<Option<String>>,
+    #[serde(default)]
+    pub children: Vec<BlockDev>,
+}
+
+pub fn report() -> io::Result<Report> {
+    let output = Command::new("lsblk").arg("--json").output()?;
+    Ok(serde_json::from_slice(output.stdout.as_slice()).unwrap())
+}

src/lvm.rs

@@ -0,0 +1,84 @@
+use std::io;
+use std::process::Command;
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+struct Report {
+    report: Vec<ReportObj>,
+}
+
+#[derive(Debug, serde::Deserialize, serde::Serialize)]
+#[serde(untagged)]
+enum ReportObj {
+    PV { pv: Vec<PV> },
+    VG { vg: Vec<VG> },
+    LV { lv: Vec<LV> },
+}
+
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+pub struct PV {
+    pub pv_name: String,
+    pub vg_name: String,
+    pub pv_fmt: String,
+    pub pv_attr: String,
+    pub pv_size: String,
+    pub pv_free: String,
+}
+
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+pub struct VG {
+    pub vg_name: String,
+    pub pv_count: String,
+    pub lv_count: String,
+    pub snap_count: String,
+    pub vg_attr: String,
+    pub vg_size: String,
+    pub vg_free: String,
+}
+
+#[derive(Debug, Clone, serde::Deserialize, serde::Serialize)]
+pub struct LV {
+    lv_name: String,
+    vg_name: String,
+    lv_attr: String,
+    lv_size: String,
+    pool_lv: String,
+    origin: String,
+    data_percent: String,
+    metadata_percent: String,
+    move_pv: String,
+    mirror_log: String,
+    copy_percent: String,
+    convert_lv: String,
+}
+
+pub fn pvs() -> io::Result<Vec<PV>> {
+    report_cmd("pvs", |o| match o {
+        ReportObj::PV { pv } => Some(pv),
+        _ => None,
+    })
+}
+
+pub fn vgs() -> io::Result<Vec<VG>> {
+    report_cmd("vgs", |o| match o {
+        ReportObj::VG { vg } => Some(vg),
+        _ => None,
+    })
+}
+
+pub fn lvs() -> io::Result<Vec<LV>> {
+    report_cmd("lvs", |o| match o {
+        ReportObj::LV { lv } => Some(lv),
+        _ => None,
+    })
+}
+
+fn report_cmd<T>(cmd: &str, find: fn(ReportObj) -> Option<Vec<T>>) -> io::Result<Vec<T>> {
+    let output = Command::new(cmd).arg("--reportformat=json").output()?;
+    let report: Report = serde_json::from_slice(output.stdout.as_slice()).unwrap();
+    Ok(report
+        .report
+        .into_iter()
+        .filter_map(find)
+        .flatten()
+        .collect())
+}

src/main.rs

@@ -0,0 +1,75 @@
+use eyre::Result;
+use log::error;
+use std::env;
+use std::io::Write;
+use std::process::exit;
+
+use init::cmd;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> Result<()> {
+    let mut log_builder = env_logger::builder();
+
+    let call_name = env::args().next().unwrap_or("init".into());
+    let call_name = (call_name.rsplit_once('/').map(|(_, n)| n)).unwrap_or(call_name.as_str());
+
+    if call_name == "init" {
+        let mut lw = LogWriter::new();
+        lw.push(std::io::stderr());
+        lw.push(std::fs::File::create("/var/log/init.log")?);
+
+        log_builder.target(env_logger::Target::Pipe(Box::new(lw)));
+    }
+
+    log_builder
+        .format_timestamp_millis()
+        .format_target(false)
+        .filter_level(log::LevelFilter::Info)
+        .write_style(env_logger::WriteStyle::Always)
+        .init();
+
+    match call_name {
+        "init" => cmd::init::run().await,
+        "init-version" => cmd::version::run(),
+        "init-input" => cmd::init_input::run().await,
+
+        _ => {
+            error!("invalid call name: {call_name:?}");
+            exit(1);
+        }
+    };
+
+    Ok(())
+}
+
+struct LogWriter {
+    targets: Vec<Box<dyn Write + Send + 'static>>,
+}
+
+impl LogWriter {
+    pub fn new() -> Self {
+        Self {
+            targets: Vec::new(),
+        }
+    }
+
+    pub fn push<W: Write + Send + 'static>(&mut self, w: W) {
+        self.targets.push(Box::new(w));
+    }
+}
+
+impl Write for LogWriter {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        for target in self.targets.iter_mut() {
+            target.write_all(buf)?;
+        }
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        for target in self.targets.iter_mut() {
+            target.flush()?;
+        }
+        Ok(())
+    }
+}

src/udev.rs

@@ -0,0 +1,65 @@
+use eyre::Result;
+use log::error;
+
+pub struct Device {
+    sysname: String,
+    output: String,
+}
+
+impl Device {
+    pub fn sysname(&self) -> &str {
+        self.sysname.as_str()
+    }
+
+    pub fn properties(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.output
+            .lines()
+            .filter_map(|line| line.strip_prefix("E: ")?.split_once('='))
+    }
+}
+
+pub fn get_devices(class: &str) -> Result<Vec<Device>> {
+    let mut devices = Vec::new();
+
+    // none of libudev and udev crates were able to list network devices.
+    // falling back to manual sysfs scanning :(
+    //
+    // Even when given a syspath,
+    // - udev crate failed to see all properties;
+    // - libudev crate segfaulted on the second property (SYSNUM ok, then segfault).
+    // falling back to parsing udevadm output :(
+    //
+    // The best fix would be to check what's wrong with udev crate.
+
+    let entries = std::fs::read_dir(format!("/sys/class/{class}"))?;
+    for entry in entries {
+        let Ok(entry) = entry else {
+            continue;
+        };
+
+        let path = entry.path();
+        let path = path.to_string_lossy();
+
+        let output = std::process::Command::new("udevadm")
+            .args(&["info", &format!("--path={path}")])
+            .stderr(std::process::Stdio::piped())
+            .output()?;
+
+        if !output.status.success() {
+            error!("udevadm fail for {path}");
+            continue;
+        }
+
+        let output = String::from_utf8_lossy(&output.stdout);
+
+        let name = entry.file_name();
+        let dev = Device {
+            sysname: name.to_string_lossy().to_string(),
+            output: output.into_owned(),
+        };
+
+        devices.push(dev);
+    }
+
+    Ok(devices)
+}

src/utils.rs

@@ -0,0 +1,61 @@
+use log::error;
+use std::collections::BTreeSet as Set;
+
+pub struct NameAliases {
+    name: String,
+    aliases: Set<String>,
+}
+
+impl NameAliases {
+    pub fn new(name: String) -> Self {
+        Self {
+            name,
+            aliases: Set::new(),
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+    pub fn aliases(&self) -> impl Iterator<Item = &str> {
+        self.aliases.iter().map(|s| s.as_str())
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &str> {
+        std::iter::once(self.name()).chain(self.aliases())
+    }
+
+    pub fn push(&mut self, alias: String) {
+        if self.name == alias {
+            return;
+        }
+        self.aliases.insert(alias);
+    }
+}
+
+pub fn select_n_by_regex<'t>(
+    n: usize,
+    regexs: &Vec<String>,
+    nas: impl Iterator<Item = &'t NameAliases>,
+) -> Vec<String> {
+    // compile regexs
+    let regexs: Vec<_> = (regexs.iter())
+        .filter_map(|re| {
+            regex::Regex::new(re)
+                .inspect_err(|e| error!("invalid regex ignored: {re:?}: {e}"))
+                .ok()
+        })
+        .collect();
+
+    let matching = |name| regexs.iter().any(|re| re.is_match(name));
+
+    let nas = nas
+        .filter(|na| na.iter().any(matching))
+        .map(|na| na.name().to_string());
+
+    if n <= 0 {
+        nas.collect()
+    } else {
+        nas.take(n).collect()
+    }
+}