150 lines
5.5 KiB
Rust
150 lines
5.5 KiB
Rust
//! 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<String> = 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"));
|
|
}
|
|
}
|