use crate::config::Profile;
use crate::device::resolve_device;
use crate::net::{Cmd, CommandRunner};
use crate::plan::{Platform, bringup_commands_for};
use crate::state::State;
use anyhow::{Context, Result, bail};
use ipnet::IpNet;
use std::path::Path;
pub(crate) fn live_interfaces<R: CommandRunner + ?Sized>(runner: &mut R) -> Result<Vec<String>> {
let out = runner.run(&Cmd::new("ifconfig", &["-l"]))?;
Ok(out.split_whitespace().map(|s| s.to_string()).collect())
}
pub(crate) fn device_inet_addresses<R: CommandRunner + ?Sized>(
runner: &mut R,
device: &str,
) -> Result<Vec<IpNet>> {
let out = runner.run(&Cmd::new("ifconfig", &[device]))?;
Ok(out
.lines()
.filter_map(|line| {
let mut toks = line.split_whitespace();
if toks.next() != Some("inet") {
return None;
}
let addr = toks.next()?;
let prefix = match toks.next() {
Some("netmask") => toks.next().and_then(prefix_from_hex_netmask).unwrap_or(32),
_ => 32,
};
format!("{addr}/{prefix}").parse::<IpNet>().ok()
})
.collect())
}
fn prefix_from_hex_netmask(hex: &str) -> Option<u8> {
let hex = hex.strip_prefix("0x")?;
let mask = u32::from_str_radix(hex, 16).ok()?;
let prefix = mask.count_ones() as u8;
let contiguous = if prefix == 0 {
0
} else {
u32::MAX << (32 - u32::from(prefix))
};
(mask == contiguous).then_some(prefix)
}
pub fn apply<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
profile: &Profile,
device_override: Option<&str>,
state_path: &Path,
dry_run: bool,
) -> Result<Vec<String>> {
let mut state = State::load(state_path)?;
if state.active_profile.is_some() {
down(runner, platform, state_path, dry_run)?;
}
let device = resolve_device(
platform,
runner,
device_override.or(profile.device.as_deref()),
)?;
let interfaces: Vec<String> = profile
.interfaces
.iter()
.filter(|i| i.vlan.is_some())
.map(|i| platform.iface_name(i, &device))
.collect();
let existing = platform.list_devices(runner)?;
for iface in &interfaces {
if existing.contains(iface) {
bail!(
"interface {iface} already exists and was not created by vlanctl; \
refusing to touch it (destroy it manually if it is stale)"
);
}
}
let taken = platform.existing_vlans(runner, &device)?;
for interface in profile.interfaces.iter().filter(|i| i.vlan.is_some()) {
let Some(id) = interface.vlan else { continue };
if let Some((_, holder)) = taken.iter().find(|(taken_id, _)| *taken_id == id) {
bail!(
"vlan id {id} is already in use on {device} by interface {holder}, \
which vlanctl did not create; refusing to touch it (the kernel \
allows one VLAN per id per parent, whatever it is named)"
);
}
}
let mut created: Vec<String> = Vec::new();
for interface in &profile.interfaces {
match interface.vlan {
None => {
let already_configured = platform
.addresses_on(runner, &device)?
.iter()
.any(|net| net.addr() == interface.address.addr());
if already_configured {
continue;
}
for cmd in bringup_commands_for(platform, interface, &device) {
if let Err(e) = runner.run(&cmd) {
rollback(runner, platform, &created);
return Err(e).with_context(|| {
format!("applying profile '{}'; rolled back", profile.name)
});
}
}
}
Some(_) => {
let iface = platform.iface_name(interface, &device);
for cmd in bringup_commands_for(platform, interface, &device) {
let is_create = platform.records_created_interface(&cmd);
match runner.run(&cmd) {
Ok(_) => {
if is_create {
created.push(iface.clone());
}
}
Err(e) => {
rollback(runner, platform, &created);
return Err(e).with_context(|| {
format!("applying profile '{}'; rolled back", profile.name)
});
}
}
}
}
}
}
state.active_profile = Some(profile.name.clone());
state.interfaces = created.clone();
if !dry_run {
state.save(state_path)?;
}
Ok(created)
}
fn rollback<R: CommandRunner>(runner: &mut R, platform: &dyn Platform, created: &[String]) {
for iface in created.iter().rev() {
for cmd in platform.teardown_commands(iface) {
let _ = runner.run(&cmd);
}
}
}
pub fn down<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
state_path: &Path,
dry_run: bool,
) -> Result<()> {
let state = State::load(state_path)?;
let live = platform.list_devices(runner)?;
for iface in state.interfaces.iter().rev() {
if !live.contains(iface) {
continue;
}
for cmd in platform.teardown_commands(iface) {
runner.run(&cmd)?;
}
}
if !dry_run {
State::default().save(state_path)?;
}
Ok(())
}
pub fn show_plan(platform: &dyn Platform, profile: &Profile, device: &str) -> Vec<String> {
profile
.interfaces
.iter()
.flat_map(|interface| bringup_commands_for(platform, interface, device))
.map(|cmd| cmd.display())
.collect()
}
pub fn list_profiles(dir: &Path) -> Result<Vec<String>> {
let mut names = Vec::new();
if !dir.exists() {
return Ok(names);
}
for entry in std::fs::read_dir(dir).with_context(|| format!("reading {}", dir.display()))? {
let path = entry?.path();
if path.extension().and_then(|e| e.to_str()) == Some("toml")
&& let Some(stem) = path.file_stem().and_then(|s| s.to_str())
{
names.push(stem.to_string());
}
}
names.sort();
Ok(names)
}
pub fn status<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
state_path: &Path,
) -> Result<String> {
let state = State::load(state_path)?;
let live = platform.list_devices(runner)?;
let mut report = String::new();
match &state.active_profile {
None => report.push_str("No active profile.\n"),
Some(name) => {
report.push_str(&format!("Active profile: {name}\n"));
for iface in &state.interfaces {
let present = if live.contains(iface) {
"up"
} else {
"MISSING"
};
report.push_str(&format!(" {iface}: {present}\n"));
}
}
}
Ok(report)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::net::RecordingRunner;
use crate::plan::{Linux, MacOs};
fn profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"t\"\ndevice=\"en0\"\n\
[[interface]]\nvlan=100\naddress=\"192.168.10.2/24\"\n\
[[interface]]\nvlan=200\naddress=\"10.0.0.5/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn untagged_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"halo\"\ndevice=\"en0\"\n\
[[interface]]\naddress=\"192.168.1.100/24\"\n\
[[interface.route]]\ndestination=\"192.168.10.151/32\"\n\
[[interface]]\nvlan=12\naddress=\"192.168.10.1/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn runner_with_device() -> RecordingRunner {
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0".to_string());
r
}
fn linux_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"t\"\ndevice=\"eth0\"\n\
[[interface]]\nvlan=100\naddress=\"192.168.10.2/24\"\n\
[[interface]]\nvlan=200\naddress=\"10.0.0.5/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn linux_runner(live: &str) -> RecordingRunner {
let mut r = RecordingRunner::default();
let json = format!(
"[{}]",
live.split_whitespace()
.map(|n| format!(r#"{{"ifname":"{n}"}}"#))
.collect::<Vec<_>>()
.join(",")
);
r.stdout.insert("ip -json link show".to_string(), json);
r.stdout
.insert("ip -d -json link show".to_string(), "[]".to_string());
r
}
#[test]
fn apply_with_linux_records_what_ip_link_add_created() {
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-ok.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
let created = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap();
assert_eq!(created, vec!["eth0.100", "eth0.200"]);
let state = State::load(&state_path).unwrap();
assert_eq!(state.active_profile.as_deref(), Some("t"));
assert_eq!(state.interfaces, vec!["eth0.100", "eth0.200"]);
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn apply_with_linux_rolls_back_with_ip_link_del() {
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-fail.json");
let _ = std::fs::remove_file(&state_path);
let mut probe = linux_runner("lo eth0");
apply(
&mut probe,
&Linux,
&linux_profile(),
None,
&state_path,
true,
)
.unwrap();
let fail_at = probe
.commands
.iter()
.position(|c| {
c.display()
.starts_with("ip link add link eth0 name eth0.200 ")
})
.expect("the plan creates eth0.200");
let mut r = linux_runner("lo eth0");
r.fail_at = Some(fail_at);
let err = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap_err();
assert!(err.to_string().contains("rolled back"), "{err}");
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(&"ip link del eth0.100".to_string()),
"rollback must delete the sub-interface it created: {rendered:?}"
);
assert!(!rendered.contains(&"ip link del eth0.200".to_string()));
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_with_linux_refuses_an_existing_sub_interface() {
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-collision.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0 eth0.100");
let err = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap_err();
assert!(
err.to_string().contains("eth0.100 already exists"),
"expected the guard to refuse eth0.100: {err}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
!rendered.iter().any(|c| c.contains("link add")),
"{rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_refuses_a_vlan_id_already_taken_under_another_name() {
let state_path = std::env::temp_dir().join("vlanctl-vlan-id-collision.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0 vlan100");
r.stdout.insert(
"ip -d -json link show".to_string(),
r#"[{"ifname":"vlan100","link":"eth0",
"linkinfo":{"info_kind":"vlan","info_data":{"id":100}}}]"#
.to_string(),
);
let err = apply(
&mut r,
&Linux,
&linux_profile(),
Some("eth0"),
&state_path,
false,
)
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("vlan id 100") && msg.contains("vlan100") && msg.contains("eth0"),
"the refusal must name the id, the device holding it, and the parent: {msg}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
!rendered.iter().any(|c| c.contains("link add")),
"it must refuse BEFORE creating anything: {rendered:?}"
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn the_cli_device_override_beats_the_profile_field() {
let mut p = linux_profile();
p.device = Some("en7".to_string());
let state_path = std::env::temp_dir().join("vlanctl-device-override.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
let created = apply(&mut r, &Linux, &p, Some("eth0"), &state_path, true).unwrap();
assert!(
created.iter().all(|c| !c.contains("en7")),
"the profile's en7 must not appear: {created:?}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered
.iter()
.any(|c| c.contains("dev eth0") || c.contains("link eth0")),
"expected the override device to be used: {rendered:?}"
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_with_linux_guards_the_auto_detected_device_not_the_profile_field() {
let p: Profile = toml::from_str(
"name=\"t\"\n\
[[interface]]\nvlan=100\naddress=\"192.168.10.2/24\"\n",
)
.unwrap();
p.validate().unwrap();
assert!(p.device.is_none(), "this test exercises auto-detect");
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-autodetect-guard.json");
let _ = std::fs::remove_file(&state_path);
let mut r = RecordingRunner::default();
r.stdout.insert(
"ip -json link show".to_string(),
r#"[{"ifname":"lo"},{"ifname":"eth0"},{"ifname":"eth0.100"}]"#.to_string(),
);
r.stdout.insert(
"ls /sys/class/net/eth0".to_string(),
"carrier operstate".to_string(),
);
r.stdout.insert(
"cat /sys/class/net/eth0/carrier".to_string(),
"1\n".to_string(),
);
let err = apply(&mut r, &Linux, &p, None, &state_path, false).unwrap_err();
assert!(
err.to_string().contains("eth0.100 already exists"),
"expected the guard to refuse the resolved device's sub-interface: {err}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(&"ip -json link show".to_string())
&& rendered.contains(&"cat /sys/class/net/eth0/carrier".to_string()),
"auto-detect must actually have run: {rendered:?}"
);
assert!(
!rendered.iter().any(|c| c.contains("link add")),
"nothing may be created past a refused guard: {rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn hex_netmask_prefix_for_contiguous_masks() {
assert_eq!(prefix_from_hex_netmask("0xffffff00"), Some(24));
assert_eq!(prefix_from_hex_netmask("0xffff0000"), Some(16));
assert_eq!(prefix_from_hex_netmask("0x00000000"), Some(0));
assert_eq!(prefix_from_hex_netmask("0xffffffff"), Some(32));
}
#[test]
fn hex_netmask_prefix_is_none_for_a_non_contiguous_mask() {
assert_eq!(prefix_from_hex_netmask("0xff00ff00"), None);
}
#[test]
fn hex_netmask_prefix_is_none_for_malformed_input() {
assert_eq!(prefix_from_hex_netmask("255.255.255.0"), None);
assert_eq!(prefix_from_hex_netmask(""), None);
}
#[test]
fn apply_uses_the_platform_for_bringup() {
let state_path = std::env::temp_dir().join("vlanctl-apply-uses-platform.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
apply(&mut r, &MacOs, &profile(), None, &state_path, true).expect("dry-run apply succeeds");
assert!(
r.commands
.iter()
.any(|c| c.display().starts_with("ifconfig vlan")),
"recorded: {:?}",
r.commands
);
}
#[test]
fn apply_creates_all_vlans_and_records_state() {
let state_path = std::env::temp_dir().join("vlanctl-apply-ok.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
let created = apply(&mut r, &MacOs, &profile(), None, &state_path, false).unwrap();
assert_eq!(created, vec!["vlan100", "vlan200"]);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"ifconfig vlan100 create".to_string()));
assert!(rendered.contains(&"ifconfig vlan100 vlan 100 vlandev en0".to_string()));
assert!(rendered.contains(&"ifconfig vlan200 create".to_string()));
assert!(rendered.contains(&"ifconfig vlan200 vlan 200 vlandev en0".to_string()));
let state = State::load(&state_path).unwrap();
assert_eq!(state.active_profile.as_deref(), Some("t"));
assert_eq!(state.interfaces, vec!["vlan100", "vlan200"]);
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn apply_rolls_back_on_failure() {
let state_path = std::env::temp_dir().join("vlanctl-apply-fail.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
r.fail_at = Some(4);
let err = apply(&mut r, &MacOs, &profile(), None, &state_path, false).unwrap_err();
assert!(err.to_string().contains("rolled back"));
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"ifconfig vlan100 destroy".to_string()));
assert!(!rendered.contains(&"ifconfig vlan200 destroy".to_string()));
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn down_destroys_recorded_interfaces() {
let state_path = std::env::temp_dir().join("vlanctl-down.json");
let state = State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan0".to_string(), "vlan1".to_string()],
};
state.save(&state_path).unwrap();
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan0 vlan1".to_string());
down(&mut r, &MacOs, &state_path, false).unwrap();
let rendered: Vec<String> = r
.commands
.iter()
.map(|c| c.display())
.filter(|c| c != "ifconfig -l")
.collect();
assert_eq!(
rendered,
vec!["ifconfig vlan1 destroy", "ifconfig vlan0 destroy"]
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn down_skips_interfaces_no_longer_live() {
let state_path = std::env::temp_dir().join("vlanctl-down-reboot.json");
State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan10".to_string(), "vlan11".to_string()],
}
.save(&state_path)
.unwrap();
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan10".to_string());
down(&mut r, &MacOs, &state_path, false).unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"ifconfig vlan10 destroy".to_string()));
assert!(!rendered.contains(&"ifconfig vlan11 destroy".to_string()));
assert_eq!(State::load(&state_path).unwrap(), State::default());
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn show_plan_lists_commands() {
let lines = show_plan(&MacOs, &profile(), "en0");
assert_eq!(lines[0], "ifconfig vlan100 create");
assert_eq!(lines[1], "ifconfig vlan100 vlan 100 vlandev en0");
}
#[test]
fn apply_errors_if_interface_already_exists() {
let state_path = std::env::temp_dir().join("vlanctl-apply-collision.json");
let _ = std::fs::remove_file(&state_path);
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan100".to_string());
let err = apply(&mut r, &MacOs, &profile(), None, &state_path, false).unwrap_err();
assert!(err.to_string().contains("already exists"));
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(!rendered.iter().any(|c| c.contains("create")));
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_untagged_configures_parent_and_records_only_vlan() {
let state_path = std::env::temp_dir().join("vlanctl-apply-untagged.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device(); let created = apply(
&mut r,
&MacOs,
&untagged_profile(),
None,
&state_path,
false,
)
.unwrap();
assert_eq!(created, vec!["vlan12"]); let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(
&"ifconfig en0 inet 192.168.1.100 netmask 255.255.255.0 alias".to_string()
)
);
assert!(rendered.contains(&"route add -host 192.168.10.151 -interface en0".to_string()));
assert!(rendered.contains(&"ifconfig vlan12 create".to_string()));
}
#[test]
fn apply_untagged_skips_when_alias_already_present() {
let state_path = std::env::temp_dir().join("vlanctl-apply-untagged-idem.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
r.stdout.insert(
"ifconfig en0".to_string(),
"\tinet 192.168.1.100 netmask 0xffffff00 broadcast 192.168.1.255".to_string(),
);
apply(
&mut r,
&MacOs,
&untagged_profile(),
None,
&state_path,
false,
)
.unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(!rendered.iter().any(|c| c.contains("alias")));
assert!(
!rendered
.iter()
.any(|c| c.contains("route add -host 192.168.10.151"))
);
assert!(rendered.contains(&"ifconfig vlan12 create".to_string())); }
#[test]
fn list_profiles_finds_toml_stems() {
let dir = std::env::temp_dir().join("vlanctl-profiles-test");
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("a.toml"), "name=\"a\"").unwrap();
std::fs::write(dir.join("b.toml"), "name=\"b\"").unwrap();
std::fs::write(dir.join("notes.txt"), "x").unwrap();
let names = list_profiles(&dir).unwrap();
assert_eq!(names, vec!["a", "b"]);
std::fs::remove_dir_all(&dir).unwrap();
}
fn mac_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"halo\"\ndevice=\"en0\"\n\
[[interface]]\naddress=\"192.168.1.100/24\"\n\
[[interface.route]]\ndestination=\"192.168.10.151/32\"\nmac=\"00:00:5e:00:53:01\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
#[test]
fn apply_mac_route_emits_static_arp_and_records_nothing() {
let state_path = std::env::temp_dir().join("vlanctl-apply-mac.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
let created = apply(&mut r, &MacOs, &mac_profile(), None, &state_path, false).unwrap();
assert!(created.is_empty()); let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"route add -host 192.168.10.151 -interface en0".to_string()));
assert!(rendered.contains(&"arp -s 192.168.10.151 00:00:5e:00:53:01".to_string()));
assert!(!rendered.iter().any(|c| c.starts_with("arp -d")));
}
#[test]
fn status_flags_missing_interface() {
let state_path = std::env::temp_dir().join("vlanctl-status.json");
State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan0".to_string(), "vlan9".to_string()],
}
.save(&state_path)
.unwrap();
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan0".to_string());
let report = status(&mut r, &MacOs, &state_path).unwrap();
assert!(report.contains("vlan0: up"));
assert!(report.contains("vlan9: MISSING"));
std::fs::remove_file(&state_path).unwrap();
}
}