use crate::vfs::{VfsError, VfsResult, VirtualFileSystem};use std::collections::BTreeMap; const COMMAND_STUB: &[u8] = b"#!/bin/sh\n# kernel command stub\n"; #[derive(Debug, Clone, PartialEq, Eq)]pub struct CommandDriver {    name: String,    commands: Vec<String>,} impl CommandDriver {    pub fn new<N, I, C>(name: N, commands: I) -> Self    where        N: Into<String>,        I: IntoIterator<Item = C>,        C: Into<String>,    {        Self {            name: name.into(),            commands: commands.into_iter().map(Into::into).collect(),        }    }     pub fn name(&self) -> &str {        &self.name    }     pub fn commands(&self) -> &[String] {        &self.commands    }     fn validate_commands(&self) -> VfsResult<()> {        for command in &self.commands {            validate_command_name(command)?;        }         Ok(())    }} #[derive(Debug, Default, Clone)]pub struct CommandRegistry {    commands: BTreeMap<String, CommandDriver>,    warnings: Vec<String>,} impl CommandRegistry {    pub fn new() -> Self {        Self::default()    }     pub fn register(&mut self, driver: CommandDriver) -> VfsResult<()> {        driver.validate_commands()?;         for command in &driver.commands {            if let Some(existing) = self.commands.get(command) {                self.warnings.push(format!(                    "command \"{command}\" overridden: {} -> {}",                    existing.name(),                    driver.name()                ));            }             self.commands.insert(command.clone(), driver.clone());        }         Ok(())    }     pub fn warnings(&self) -> &[String] {        &self.warnings    }     pub fn resolve(&self, command: &str) -> Option<&CommandDriver> {        self.commands.get(command)    }     pub fn list(&self) -> BTreeMap<String, String> {        self.commands            .iter()            .map(|(command, driver)| (command.clone(), driver.name().to_owned()))            .collect()    }     pub fn populate_bin<F>(&self, vfs: &mut F) -> VfsResult<()>    where        F: VirtualFileSystem,    {        self.populate_commands(vfs, self.commands.keys())    }     pub fn populate_driver_bin<F>(&self, vfs: &mut F, driver: &CommandDriver) -> VfsResult<()>    where        F: VirtualFileSystem,    {        self.populate_commands(vfs, driver.commands())    }     fn populate_commands<F, I, S>(&self, vfs: &mut F, commands: I) -> VfsResult<()>    where        F: VirtualFileSystem,        I: IntoIterator<Item = S>,        S: AsRef<str>,    {        let commands = commands            .into_iter()            .map(|command| {                validate_command_name(command.as_ref())?;                Ok(command.as_ref().to_owned())            })            .collect::<VfsResult<Vec<_>>>()?;         if !vfs.exists("/bin") {            vfs.mkdir("/bin", true)?;        }         for command in commands {            let path = format!("/bin/{command}");            if !vfs.exists(&path) {                vfs.write_file(&path, COMMAND_STUB.to_vec())?;                let _ = vfs.chmod(&path, 0o755);            }        }         Ok(())    }} fn validate_command_name(command: &str) -> VfsResult<()> {    if command.is_empty()        || command == "."        || command == ".."        || command.contains('/')        || command.contains('\0')    {        return Err(VfsError::new(            "EINVAL",            format!("invalid command name {command:?}"),        ));    }     Ok(())}