//! Target system services: hostname, keymap, timezone, locale and systemd //! unit enablement. use std::path::Path; use phoebus_core::system as sysgen; use phoebus_core::InstallConfig; use crate::error::{ExecError, Result}; use crate::exec::Exec; use crate::portage; pub fn configure(exec: &Exec, config: &InstallConfig) -> Result<()> { write_network(exec, config)?; let target = exec.target(); target.write( "etc/vconsole.conf", format!("KEYMAP={}\n", config.system.keymap), )?; target.write( "etc/locale.conf", format!("LANG={}\n", config.system.locale), )?; set_timezone(exec, &config.system.timezone)?; portage::write_locale_gen(exec, config)?; let root = Path::new(&exec.root); portage::chroot(exec, root, "locale-gen", &[]).map_err(|e| { ExecError::operation("services", "generate locales (locale-gen)", e.to_string()) })?; let network_essentials = sysgen::network_target_services(); for svc in sysgen::target_services(config) { let is_essential = network_essentials.iter().any(|&e| e == svc); match portage::chroot(exec, root, "systemctl", &["enable", &svc]) { Ok(()) => exec.logger.info(format!("enabled system service {svc}")), Err(e) if is_essential => { return Err(ExecError::operation( "services", &format!("enable essential service {svc}"), e.to_string(), )); } Err(e) => { exec.logger .warn(format!("could not enable non-essential service {svc}: {e}")); } } } // OpenSSH is installed (client + server) but sshd stays disabled and // inactive by default and no firewall port is opened. A user enables it // explicitly later (see `SSH_ENABLE_DOC`). ensure_sshd_disabled(exec, root)?; Ok(()) } /// sshd stays disabled/inactive after installation and reboot. Best-effort: /// a missing unit in a minimal target must not fail the install. fn ensure_sshd_disabled(exec: &Exec, root: &Path) -> Result<()> { for args in [&["disable", "sshd"][..], &["stop", "sshd"][..]] { match portage::chroot(exec, root, "systemctl", args) { Ok(()) => exec.logger.info(format!("sshd {} (default off)", args[0])), Err(e) => exec.logger.warn(format!("could not sshd {}: {e}", args[0])), } } // No firewall port is opened by the installer; record the explicit // opt-in so `sys` and the docs agree. exec.logger.info(format!( "sshd is installed but disabled; enable later with: {}", sysgen::SSH_ENABLE_DOC )); Ok(()) } /// Verify on the installed system: OpenSSH client works, the server package /// is present, and sshd remains disabled and inactive. pub fn verify_ssh_state(exec: &Exec) -> Result<()> { let root = Path::new(&exec.root); portage::chroot(exec, root, "ssh", &["-V"]) .map_err(|e| ExecError::operation("services", "verify ssh client", e.to_string()))?; // `systemctl is-enabled` exits 0 only when enabled; nonzero means // disabled/static/missing — all acceptable for the default-off server. if portage::chroot(exec, root, "systemctl", &["is-enabled", "sshd"]).is_ok() { return Err(ExecError::operation( "services", "verify sshd disabled", "sshd is enabled; it must stay disabled by default", )); } exec.logger.info("ssh client works; sshd remains disabled"); Ok(()) } pub fn write_network(exec: &Exec, config: &InstallConfig) -> Result<()> { let target = exec.target(); target.write("etc/hostname", format!("{}\n", config.system.hostname))?; let hosts = format!( "127.0.0.1\tlocalhost\n::1\t\tlocalhost\n127.0.1.1\t{}\n", config.system.hostname ); target.write("etc/hosts", hosts)?; Ok(()) } pub fn set_timezone(exec: &Exec, timezone: &str) -> Result<()> { let target = exec.target(); target.ensure_dir("etc")?; let link = target.etc("localtime")?; let _ = std::fs::remove_file(&link); let dest = format!("/usr/share/zoneinfo/{timezone}"); std::os::unix::fs::symlink(&dest, &link).map_err(|e| ExecError::io(link.clone(), e))?; Ok(()) } #[cfg(test)] mod tests { use super::*; use crate::command::RecordingRunner; use crate::log::Logger; use phoebus_core::Redactor; fn make_exec(runner: RecordingRunner) -> Exec { let path = tempfile::tempdir().unwrap().keep(); let logger = Logger::open(path.join("l.log"), Redactor::new(), false); Exec::new(Box::new(runner), logger, false, path.join("root"), path) } #[test] fn sshd_is_disabled_by_default_and_documented() { let runner = RecordingRunner::new(); let exec = make_exec(runner.clone()); let cfg = InstallConfig::default(); configure(&exec, &cfg).unwrap(); let recorded: Vec = runner.recorded().iter().map(|s| s.args.join(" ")).collect(); assert!( recorded.iter().any(|a| a.contains("disable sshd")), "{recorded:?}" ); // No firewall port is opened by the installer. assert!( !recorded .iter() .any(|a| a.contains("firewall") || a.contains("iptables") || a.contains("ufw")), "{recorded:?}" ); assert!(sysgen::SSH_ENABLE_DOC.contains("systemctl enable --now sshd")); // sshd is never in the enabled service set. assert!(!sysgen::target_services(&cfg).iter().any(|s| s == "sshd")); } }