use super::{Platform, ipv4_netmask};
use crate::config::{Interface, Route};
use crate::net::{Cmd, CommandRunner};
use crate::state::ParentConfig;
use anyhow::{Context, Result};
use ipnet::IpNet;
use std::net::{IpAddr, Ipv4Addr};
pub const SWITCH_NAME: &str = "vlanctl";
const UNTAGGED_VNIC: &str = "untagged";
pub(super) const POWERSHELL: &str = "powershell.exe";
const SCRIPT_PREFIX: &str = "$ErrorActionPreference = 'Stop'; ";
const ADAPTER_WAIT_POLLS: u32 = 40;
const PARENT_RETURN_POLLS: u32 = 40;
pub struct WindowsHyperV;
impl WindowsHyperV {
#[must_use]
pub fn is_read_only_probe(cmd: &Cmd) -> bool {
if cmd.program != POWERSHELL {
return false;
}
let Some(script) = powershell_script(cmd) else {
return false;
};
script
.split(';')
.map(str::trim)
.filter(|s| !s.is_empty())
.all(|statement| {
statement == "$ErrorActionPreference = 'Stop'"
|| statement.starts_with("Get-NetAdapter | ForEach-Object")
|| statement.starts_with("Get-NetIPAddress -InterfaceAlias")
|| statement.starts_with("$a = Get-NetAdapter | Where-Object")
|| statement.starts_with("if (-not $a) { throw")
|| statement.starts_with("$a.")
|| statement.starts_with("$i = Get-NetIPInterface -InterfaceAlias")
|| statement.starts_with("if ($i) { 'dhcp ' + $i.Dhcp }")
|| statement.starts_with("Get-NetRoute -InterfaceAlias")
|| statement == "exit 0"
})
}
}
impl Platform for WindowsHyperV {
fn name(&self) -> &'static str {
"windows-hyperv"
}
fn iface_name(&self, interface: &Interface, _device: &str) -> String {
adapter_alias(&vnic_name(interface))
}
fn bringup_commands(&self, interface: &Interface, device: &str) -> Vec<Cmd> {
let vnic = vnic_name(interface);
let alias = adapter_alias(&vnic);
let mut cmds = vec![powershell(&create_script(interface, device))];
let addr = interface.address.addr().to_string();
let mask = ipv4_netmask(interface.address.prefix_len());
cmds.push(Cmd::new(
"netsh",
&[
"interface",
"ipv4",
"set",
"address",
&alias,
"static",
&addr,
&mask,
],
));
if let Some(mtu) = interface.mtu {
cmds.push(Cmd::new(
"netsh",
&[
"interface",
"ipv4",
"set",
"subinterface",
&alias,
&format!("mtu={mtu}"),
"store=persistent",
],
));
}
cmds
}
fn teardown_commands(&self, iface: &str) -> Vec<Cmd> {
let vnic = vnic_from_alias(iface).unwrap_or(iface);
vec![powershell(&teardown_script(vnic))]
}
fn route_commands(&self, route: &Route, _in_subnet: bool, iface: &str) -> Vec<Cmd> {
let mut cmds = Vec::new();
let prefix = route_prefix(&route.destination);
match &route.gateway {
Some(gateway) => {
let gateway = gateway.to_string();
cmds.push(Cmd::new(
"netsh",
&[
"interface",
"ipv4",
"add",
"route",
&prefix,
iface,
&gateway,
],
));
}
None => {
cmds.push(Cmd::new(
"netsh",
&["interface", "ipv4", "add", "route", &prefix, iface],
));
if let Some(mac) = &route.mac
&& let Ok(net) = route.destination.parse::<IpNet>()
{
let host = net.addr().to_string();
let mac = windows_mac(mac);
cmds.push(Cmd::new(
"netsh",
&["interface", "ipv4", "add", "neighbors", iface, &host, &mac],
));
}
}
}
cmds
}
fn existing_vlans(
&self,
_runner: &mut dyn CommandRunner,
_parent: &str,
) -> Result<Vec<(u16, String)>> {
Ok(Vec::new())
}
fn is_candidate_device(&self, name: &str) -> bool {
!name.starts_with("vEthernet")
&& !name.starts_with("Wi-Fi")
&& !name.contains('*')
&& !name.contains("Loopback")
&& !name.contains("Bluetooth")
}
fn reverts_parent_config(&self) -> bool {
true
}
fn claims_parent_exclusively(&self) -> bool {
true
}
fn list_devices(&self, runner: &mut dyn CommandRunner) -> Result<Vec<String>> {
let out = runner.run(&powershell("Get-NetAdapter | ForEach-Object { $_.Name }"))?;
Ok(out
.lines()
.map(str::trim)
.filter(|l| !l.is_empty())
.map(str::to_owned)
.collect())
}
fn addresses_on(&self, runner: &mut dyn CommandRunner, device: &str) -> Result<Vec<IpNet>> {
let script = format!(
"Get-NetIPAddress -InterfaceAlias {} -AddressFamily IPv4 -ErrorAction \
SilentlyContinue | ForEach-Object {{ $_.IPAddress + '/' + $_.PrefixLength }}; \
exit 0",
ps_literal(device)
);
let out = runner.run(&powershell(&script))?;
Ok(out
.lines()
.filter_map(|line| line.trim().parse::<IpNet>().ok())
.collect())
}
fn is_wireless(&self, runner: &mut dyn CommandRunner, device: &str) -> Result<bool> {
let out = runner
.run(&adapter_property_probe(device, "PhysicalMediaType"))
.with_context(|| format!("cannot determine whether {device} is wireless"))?;
let media = out.trim();
Ok(media.contains("802.11") || media.contains("Wireless"))
}
fn link_is_active(&self, runner: &mut dyn CommandRunner, device: &str) -> Result<bool> {
let out = runner
.run(&adapter_property_probe(device, "Status"))
.with_context(|| format!("cannot determine link state for {device}"))?;
Ok(out.trim() == "Up")
}
fn records_created_interface(&self, cmd: &Cmd) -> bool {
cmd.program == POWERSHELL
&& powershell_script(cmd)
.is_some_and(|s| s.contains("Add-VMNetworkAdapter -ManagementOS"))
}
fn parent_snapshot(
&self,
runner: &mut dyn CommandRunner,
device: &str,
) -> Result<Option<ParentConfig>> {
let out = runner
.run(&parent_config_probe(device))
.with_context(|| format!("cannot read the IPv4 configuration of {device}"))?;
Ok(parse_parent_config(device, &out))
}
fn parent_restore_commands(&self, parent: &ParentConfig) -> Vec<Cmd> {
restore_parent_commands(parent)
}
}
fn parent_config_probe(device: &str) -> Cmd {
let dev = ps_literal(device);
powershell(&format!(
"$i = Get-NetIPInterface -InterfaceAlias {dev} -AddressFamily IPv4 \
-ErrorAction SilentlyContinue; \
if ($i) {{ 'dhcp ' + $i.Dhcp }}; \
Get-NetIPAddress -InterfaceAlias {dev} -AddressFamily IPv4 -ErrorAction SilentlyContinue \
| Where-Object {{ $_.PrefixOrigin -eq 'Manual' }} \
| ForEach-Object {{ 'address ' + $_.IPAddress + '/' + $_.PrefixLength }}; \
Get-NetRoute -InterfaceAlias {dev} -DestinationPrefix '0.0.0.0/0' -AddressFamily IPv4 \
-ErrorAction SilentlyContinue | ForEach-Object {{ 'gateway ' + $_.NextHop }}; \
exit 0"
))
}
fn parse_parent_config(device: &str, out: &str) -> Option<ParentConfig> {
let mut dhcp = None;
let mut addresses = Vec::new();
let mut gateway = None;
for line in out.lines().map(str::trim) {
if let Some(v) = line.strip_prefix("dhcp ") {
dhcp = Some(v.trim().eq_ignore_ascii_case("Enabled"));
} else if let Some(v) = line.strip_prefix("address ") {
if let Ok(net) = v.trim().parse::<IpNet>()
&& matches!(net, IpNet::V4(_))
{
addresses.push(net);
}
} else if let Some(v) = line.strip_prefix("gateway ")
&& let Ok(ip) = v.trim().parse::<Ipv4Addr>()
&& !ip.is_unspecified()
{
gateway = Some(ip);
}
}
Some(ParentConfig {
device: device.to_string(),
dhcp: dhcp?,
addresses,
gateway,
})
}
fn restore_parent_commands(parent: &ParentConfig) -> Vec<Cmd> {
let statics: Vec<(String, String)> = parent
.addresses
.iter()
.filter_map(|net| match net.addr() {
IpAddr::V4(addr) => Some((addr.to_string(), ipv4_netmask(net.prefix_len()))),
IpAddr::V6(_) => None,
})
.collect();
if !parent.dhcp && statics.is_empty() {
return Vec::new();
}
let dev = parent.device.as_str();
let mut cmds = vec![powershell(&parent_return_script(dev))];
if parent.dhcp {
cmds.push(Cmd::new(
"netsh",
&["interface", "ipv4", "set", "address", dev, "dhcp"],
));
}
for (index, (addr, mask)) in statics.iter().enumerate() {
if index == 0 && !parent.dhcp {
let mut args = vec![
"interface",
"ipv4",
"set",
"address",
dev,
"static",
addr,
mask,
];
let gateway = parent.gateway.map(|g| g.to_string());
if let Some(gateway) = gateway.as_deref() {
args.push(gateway);
}
cmds.push(Cmd::new("netsh", &args));
} else {
cmds.push(Cmd::new(
"netsh",
&["interface", "ipv4", "add", "address", dev, addr, mask],
));
}
}
cmds
}
fn parent_return_script(device: &str) -> String {
let dev = ps_literal(device);
format!(
"$tries = 0; \
while (-not (Get-NetIPInterface -InterfaceAlias {dev} -AddressFamily IPv4 \
-ErrorAction SilentlyContinue)) {{ \
if (++$tries -gt {PARENT_RETURN_POLLS}) {{ \
throw 'adapter ' + {dev} + ' did not return to the IP stack after the switch was removed' }}; \
Start-Sleep -Milliseconds 500 }}"
)
}
fn vnic_name(interface: &Interface) -> String {
match interface.vlan {
Some(id) => format!("vlan{id}"),
None => UNTAGGED_VNIC.to_string(),
}
}
fn adapter_alias(vnic: &str) -> String {
format!("vEthernet ({vnic})")
}
fn vnic_from_alias(alias: &str) -> Option<&str> {
alias.strip_prefix("vEthernet (")?.strip_suffix(')')
}
pub(super) fn powershell(script: &str) -> Cmd {
let script = format!("{SCRIPT_PREFIX}{script}");
Cmd::new(
POWERSHELL,
&[
"-NoProfile",
"-NonInteractive",
"-ExecutionPolicy",
"Bypass",
"-Command",
&script,
],
)
}
pub(super) fn powershell_script(cmd: &Cmd) -> Option<&str> {
match cmd.args.as_slice() {
[no_profile, non_interactive, exec, bypass, command, script]
if no_profile == "-NoProfile"
&& non_interactive == "-NonInteractive"
&& exec == "-ExecutionPolicy"
&& bypass == "Bypass"
&& command == "-Command" =>
{
Some(script)
}
_ => None,
}
}
pub(super) fn ps_literal(s: &str) -> String {
format!("'{}'", s.replace('\'', "''"))
}
pub(super) fn route_prefix(destination: &str) -> String {
if destination == "default" {
"0.0.0.0/0".to_string()
} else {
destination.to_string()
}
}
pub(super) fn windows_mac(mac: &str) -> String {
mac.replace(':', "-")
}
pub(super) fn adapter_property_probe(device: &str, property: &str) -> Cmd {
powershell(&format!(
"$a = Get-NetAdapter | Where-Object {{ $_.Name -eq {lit} }}; \
if (-not $a) {{ throw 'no adapter named ' + {lit} }}; $a.{property}",
lit = ps_literal(device)
))
}
fn create_script(interface: &Interface, device: &str) -> String {
let vnic = ps_literal(&vnic_name(interface));
let alias = ps_literal(&adapter_alias(&vnic_name(interface)));
let switch = ps_literal(SWITCH_NAME);
let device = ps_literal(device);
let vlan_mode = match interface.vlan {
Some(id) => format!("-Access -VlanId {id}"),
None => "-Untagged".to_string(),
};
format!(
"$created = $false; \
if (-not (Get-VMSwitch -Name {switch} -ErrorAction SilentlyContinue)) {{ \
New-VMSwitch -Name {switch} -NetAdapterName {device} -AllowManagementOS $false | Out-Null; \
$created = $true }}; \
try {{ \
$swType = (Get-VMSwitch -Name {switch}).SwitchType; \
if ($swType -ne 'External') {{ \
throw 'switch ' + {switch} + ' is ' + $swType + ', not External — ' + \
{device} + ' was not bound (Hyper-V accepted the request without ' + \
'erroring, which happens when the adapter cannot be claimed as an ' + \
'external uplink right now)' }}; \
Add-VMNetworkAdapter -ManagementOS -SwitchName {switch} -Name {vnic} | Out-Null; \
Set-VMNetworkAdapterVlan -ManagementOS -VMNetworkAdapterName {vnic} {vlan_mode}; \
$tries = 0; \
while (-not (Get-NetAdapter -InterfaceAlias {alias} -ErrorAction SilentlyContinue)) {{ \
if (++$tries -gt {ADAPTER_WAIT_POLLS}) {{ throw 'adapter ' + {alias} + ' did not appear' }}; \
Start-Sleep -Milliseconds 500 }} \
}} catch {{ \
Remove-VMNetworkAdapter -ManagementOS -Name {vnic} -ErrorAction SilentlyContinue; \
if ($created) {{ Remove-VMSwitch -Name {switch} -Force -ErrorAction SilentlyContinue }}; \
throw }}"
)
}
fn teardown_script(vnic: &str) -> String {
let alias = ps_literal(&adapter_alias(vnic));
let vnic = ps_literal(vnic);
let switch = ps_literal(SWITCH_NAME);
format!(
"if (Get-VMNetworkAdapter -ManagementOS -Name {vnic} -ErrorAction SilentlyContinue) {{ \
Get-NetRoute -InterfaceAlias {alias} -PolicyStore PersistentStore -ErrorAction SilentlyContinue \
| Remove-NetRoute -Confirm:$false -ErrorAction SilentlyContinue; \
Remove-VMNetworkAdapter -ManagementOS -Name {vnic} }}; \
if ((Get-VMSwitch -Name {switch} -ErrorAction SilentlyContinue) -and \
-not (Get-VMNetworkAdapter -ManagementOS -SwitchName {switch} -ErrorAction SilentlyContinue)) {{ \
Remove-VMSwitch -Name {switch} -Force }}"
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::net::RecordingRunner;
use crate::plan::bringup_commands_for;
fn tagged(id: u16, cidr: &str) -> Interface {
Interface {
vlan: Some(id),
address: cidr.parse().unwrap(),
mtu: None,
routes: vec![],
}
}
fn render(cmds: &[Cmd]) -> Vec<String> {
cmds.iter().map(Cmd::display).collect()
}
#[test]
fn a_tagged_entry_is_the_vethernet_alias_of_its_vlan() {
assert_eq!(
WindowsHyperV.iface_name(&tagged(11, "192.168.11.87/24"), "Ethernet 2"),
"vEthernet (vlan11)"
);
}
#[test]
fn an_untagged_entry_is_an_adapter_too_not_the_parent() {
let i = Interface {
vlan: None,
address: "192.168.1.100/24".parse().unwrap(),
mtu: None,
routes: vec![],
};
assert_eq!(
WindowsHyperV.iface_name(&i, "Ethernet 2"),
"vEthernet (untagged)"
);
}
#[test]
fn the_alias_round_trips_to_the_adapter_name() {
assert_eq!(vnic_from_alias("vEthernet (vlan11)"), Some("vlan11"));
assert_eq!(vnic_from_alias("vEthernet (untagged)"), Some("untagged"));
assert_eq!(vnic_from_alias("Ethernet 2"), None);
assert_eq!(vnic_from_alias("vEthernet (vlan11) 2"), None);
}
#[test]
fn rendering_of_a_tagged_profile_with_routes_is_pinned() {
let i = Interface {
vlan: Some(11),
address: "192.168.11.87/24".parse().unwrap(),
mtu: None,
routes: vec![
Route {
destination: "192.168.11.151/32".to_string(),
gateway: None,
mac: None,
},
Route {
destination: "239.255.0.255/32".to_string(),
gateway: None,
mac: None,
},
],
};
let rendered = render(&bringup_commands_for(&WindowsHyperV, &i, "Ethernet 2"));
assert_eq!(
rendered,
vec![
format!(
"powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command \
$ErrorActionPreference = 'Stop'; {}",
create_script(&i, "Ethernet 2")
),
"netsh interface ipv4 set address vEthernet (vlan11) static 192.168.11.87 \
255.255.255.0"
.to_string(),
"netsh interface ipv4 add route 192.168.11.151/32 vEthernet (vlan11)".to_string(),
"netsh interface ipv4 add route 239.255.0.255/32 vEthernet (vlan11)".to_string(),
],
"Windows rendering changed"
);
}
#[test]
fn the_create_script_is_pinned() {
let i = tagged(11, "192.168.11.87/24");
assert_eq!(
create_script(&i, "Ethernet 2"),
"$created = $false; \
if (-not (Get-VMSwitch -Name 'vlanctl' -ErrorAction SilentlyContinue)) { \
New-VMSwitch -Name 'vlanctl' -NetAdapterName 'Ethernet 2' -AllowManagementOS $false | Out-Null; \
$created = $true }; \
try { \
$swType = (Get-VMSwitch -Name 'vlanctl').SwitchType; \
if ($swType -ne 'External') { \
throw 'switch ' + 'vlanctl' + ' is ' + $swType + ', not External — ' + \
'Ethernet 2' + ' was not bound (Hyper-V accepted the request without ' + \
'erroring, which happens when the adapter cannot be claimed as an ' + \
'external uplink right now)' }; \
Add-VMNetworkAdapter -ManagementOS -SwitchName 'vlanctl' -Name 'vlan11' | Out-Null; \
Set-VMNetworkAdapterVlan -ManagementOS -VMNetworkAdapterName 'vlan11' -Access -VlanId 11; \
$tries = 0; \
while (-not (Get-NetAdapter -InterfaceAlias 'vEthernet (vlan11)' -ErrorAction SilentlyContinue)) { \
if (++$tries -gt 40) { throw 'adapter ' + 'vEthernet (vlan11)' + ' did not appear' }; \
Start-Sleep -Milliseconds 500 } \
} catch { \
Remove-VMNetworkAdapter -ManagementOS -Name 'vlan11' -ErrorAction SilentlyContinue; \
if ($created) { Remove-VMSwitch -Name 'vlanctl' -Force -ErrorAction SilentlyContinue }; \
throw }"
);
}
#[test]
fn the_create_script_checks_switch_type_before_adding_the_vnic() {
let script = create_script(&tagged(11, "192.168.11.87/24"), "Ethernet 2");
let switch_check_pos = script
.find("$swType = (Get-VMSwitch -Name 'vlanctl')")
.unwrap();
let add_vnic_pos = script.find("Add-VMNetworkAdapter").unwrap();
assert!(
switch_check_pos < add_vnic_pos,
"the SwitchType check must run before a vNIC is ever added to the switch"
);
let try_pos = script.find("try {").unwrap();
let catch_pos = script.find("} catch {").unwrap();
assert!(
try_pos < switch_check_pos && switch_check_pos < catch_pos,
"the check must be inside the try block so a throw reaches the rollback catch"
);
assert!(
script.contains("not External"),
"the failure must name what went wrong, not just that something did: {script}"
);
}
#[test]
fn an_untagged_entry_creates_an_untagged_adapter_and_a_static_neighbor() {
let i = Interface {
vlan: None,
address: "192.168.1.100/24".parse().unwrap(),
mtu: Some(1500),
routes: vec![Route {
destination: "192.168.10.151/32".to_string(),
gateway: None,
mac: Some("00:00:5e:00:53:01".to_string()),
}],
};
let cmds = bringup_commands_for(&WindowsHyperV, &i, "Ethernet 2");
let script = powershell_script(&cmds[0]).unwrap();
assert!(
script.contains("-Name 'untagged' | Out-Null")
&& script.contains("-VMNetworkAdapterName 'untagged' -Untagged;"),
"untagged adapter in untagged mode: {script}"
);
assert_eq!(
render(&cmds[1..]),
vec![
"netsh interface ipv4 set address vEthernet (untagged) static 192.168.1.100 \
255.255.255.0",
"netsh interface ipv4 set subinterface vEthernet (untagged) mtu=1500 \
store=persistent",
"netsh interface ipv4 add route 192.168.10.151/32 vEthernet (untagged)",
"netsh interface ipv4 add neighbors vEthernet (untagged) 192.168.10.151 \
00-00-5e-00-53-01",
]
);
}
#[test]
fn a_gateway_route_names_the_next_hop_and_default_becomes_a_zero_prefix() {
let route = Route {
destination: "default".to_string(),
gateway: Some("192.168.11.1".parse().unwrap()),
mac: None,
};
assert_eq!(
render(&WindowsHyperV.route_commands(&route, false, "vEthernet (vlan11)")),
vec!["netsh interface ipv4 add route 0.0.0.0/0 vEthernet (vlan11) 192.168.11.1"]
);
}
#[test]
fn teardown_removes_the_adapter_and_the_switch_when_it_was_the_last() {
let rendered = render(&WindowsHyperV.teardown_commands("vEthernet (vlan11)"));
assert_eq!(rendered.len(), 1);
let script = powershell_script(&WindowsHyperV.teardown_commands("vEthernet (vlan11)")[0])
.unwrap()
.to_string();
assert_eq!(
script,
"$ErrorActionPreference = 'Stop'; \
if (Get-VMNetworkAdapter -ManagementOS -Name 'vlan11' -ErrorAction SilentlyContinue) { \
Get-NetRoute -InterfaceAlias 'vEthernet (vlan11)' -PolicyStore PersistentStore -ErrorAction SilentlyContinue \
| Remove-NetRoute -Confirm:$false -ErrorAction SilentlyContinue; \
Remove-VMNetworkAdapter -ManagementOS -Name 'vlan11' }; \
if ((Get-VMSwitch -Name 'vlanctl' -ErrorAction SilentlyContinue) -and \
-not (Get-VMNetworkAdapter -ManagementOS -SwitchName 'vlanctl' -ErrorAction SilentlyContinue)) { \
Remove-VMSwitch -Name 'vlanctl' -Force }"
);
}
#[test]
fn the_parent_probe_is_read_only_and_parses_a_static_configuration() {
let probe = parent_config_probe("Ethernet 2");
assert!(
WindowsHyperV::is_read_only_probe(&probe),
"{}",
probe.display()
);
let script = powershell_script(&probe).unwrap();
assert!(script.contains("Get-NetIPInterface -InterfaceAlias 'Ethernet 2'"));
assert!(script.contains("$_.PrefixOrigin -eq 'Manual'"));
assert!(script.ends_with("exit 0"));
let parsed = parse_parent_config(
"Ethernet 2",
"dhcp Disabled\r\naddress 192.168.11.87/24\r\naddress 192.168.10.90/24\r\n\
gateway 192.168.11.1\r\n",
)
.unwrap();
assert_eq!(parsed.device, "Ethernet 2");
assert!(!parsed.dhcp);
assert_eq!(
parsed.addresses,
vec![
"192.168.11.87/24".parse::<IpNet>().unwrap(),
"192.168.10.90/24".parse::<IpNet>().unwrap()
]
);
assert_eq!(parsed.gateway, Some("192.168.11.1".parse().unwrap()));
}
#[test]
fn the_parent_probe_parses_dhcp_and_nothing_at_all() {
let dhcp = parse_parent_config("Ethernet 2", "dhcp Enabled\n").unwrap();
assert!(dhcp.dhcp);
assert!(dhcp.addresses.is_empty());
assert_eq!(dhcp.gateway, None);
assert_eq!(parse_parent_config("Ethernet 2", ""), None);
assert_eq!(
parse_parent_config("Ethernet 2", "address 10.0.0.1/8\n"),
None
);
let odd = parse_parent_config(
"Ethernet 2",
"dhcp Disabled\naddress fe80::1/64\ngateway 0.0.0.0\n",
)
.unwrap();
assert!(odd.addresses.is_empty());
assert_eq!(odd.gateway, None);
}
#[test]
fn restoring_a_static_parent_waits_for_it_and_sets_every_address() {
let parent = ParentConfig {
device: "Ethernet 2".to_string(),
dhcp: false,
addresses: vec![
"192.168.11.87/24".parse().unwrap(),
"192.168.10.90/24".parse().unwrap(),
],
gateway: Some("192.168.11.1".parse().unwrap()),
};
let cmds = WindowsHyperV.parent_restore_commands(&parent);
let wait = powershell_script(&cmds[0]).unwrap();
assert!(
wait.contains("Get-NetIPInterface -InterfaceAlias 'Ethernet 2'")
&& wait.contains("did not return to the IP stack"),
"{wait}"
);
assert_eq!(
render(&cmds[1..]),
vec![
"netsh interface ipv4 set address Ethernet 2 static 192.168.11.87 255.255.255.0 \
192.168.11.1",
"netsh interface ipv4 add address Ethernet 2 192.168.10.90 255.255.255.0",
]
);
for cmd in &cmds {
assert!(!WindowsHyperV::is_read_only_probe(cmd), "{}", cmd.display());
}
}
#[test]
fn restoring_a_dhcp_parent_puts_it_back_on_dhcp_and_a_bare_static_one_is_left_alone() {
let dhcp = ParentConfig {
device: "Ethernet 2".to_string(),
dhcp: true,
addresses: vec![],
gateway: None,
};
let cmds = WindowsHyperV.parent_restore_commands(&dhcp);
assert_eq!(cmds.len(), 2);
assert_eq!(
cmds[1].display(),
"netsh interface ipv4 set address Ethernet 2 dhcp"
);
let bare = ParentConfig {
device: "Ethernet 2".to_string(),
dhcp: false,
addresses: vec![],
gateway: None,
};
assert!(WindowsHyperV.parent_restore_commands(&bare).is_empty());
}
#[test]
fn teardown_of_an_unrecognised_name_treats_it_as_an_adapter_name() {
let cmds = WindowsHyperV.teardown_commands("vlan11");
assert!(
powershell_script(&cmds[0])
.unwrap()
.contains("-Name 'vlan11'")
);
}
#[test]
fn only_the_create_script_is_recorded() {
let i = tagged(11, "192.168.11.87/24");
let cmds = bringup_commands_for(&WindowsHyperV, &i, "Ethernet 2");
let recorded: Vec<bool> = cmds
.iter()
.map(|c| WindowsHyperV.records_created_interface(c))
.collect();
assert_eq!(recorded, vec![true, false]);
assert!(!WindowsHyperV.records_created_interface(&WindowsHyperV.teardown_commands("x")[0]));
}
#[test]
fn a_quote_in_a_device_name_cannot_end_the_literal() {
assert_eq!(ps_literal("Ethernet 2"), "'Ethernet 2'");
assert_eq!(ps_literal("it's"), "'it''s'");
assert_eq!(ps_literal("$env:X; Remove-Item"), "'$env:X; Remove-Item'");
let script = create_script(
&tagged(11, "192.168.11.87/24"),
"x'; Remove-VMSwitch -Name 'vlanctl",
);
assert!(script.contains("-NetAdapterName 'x''; Remove-VMSwitch -Name ''vlanctl'"));
}
#[test]
fn scripts_carry_no_double_quotes() {
let i = Interface {
vlan: Some(11),
address: "192.168.11.87/24".parse().unwrap(),
mtu: Some(9000),
routes: vec![Route {
destination: "192.168.11.151/32".to_string(),
gateway: None,
mac: Some("00:00:5e:00:53:01".to_string()),
}],
};
let mut all = bringup_commands_for(&WindowsHyperV, &i, "Ethernet 2");
all.extend(WindowsHyperV.teardown_commands("vEthernet (vlan11)"));
all.push(adapter_property_probe("Ethernet 2", "Status"));
for cmd in &all {
if let Some(script) = powershell_script(cmd) {
assert!(!script.contains('"'), "double quote in script: {script}");
}
}
}
fn runner_with(cmd: &Cmd, output: &str) -> RecordingRunner {
let mut runner = RecordingRunner::default();
runner.stdout.insert(cmd.display(), output.to_string());
runner
}
#[test]
fn list_devices_reads_one_adapter_name_per_line() {
let probe = powershell("Get-NetAdapter | ForEach-Object { $_.Name }");
let mut runner = runner_with(&probe, "Ethernet 2\r\nWi-Fi\r\nvEthernet (vlan11)\r\n");
assert_eq!(
WindowsHyperV.list_devices(&mut runner).unwrap(),
vec!["Ethernet 2", "Wi-Fi", "vEthernet (vlan11)"]
);
}
#[test]
fn addresses_on_parses_cidrs_and_an_absent_adapter_has_none() {
let probe = powershell(
"Get-NetIPAddress -InterfaceAlias 'vEthernet (vlan11)' -AddressFamily IPv4 \
-ErrorAction SilentlyContinue | ForEach-Object { $_.IPAddress + '/' + $_.PrefixLength }; \
exit 0",
);
let mut runner = runner_with(&probe, "192.168.11.87/24\r\n169.254.12.34/16\r\n");
assert_eq!(
WindowsHyperV
.addresses_on(&mut runner, "vEthernet (vlan11)")
.unwrap(),
vec![
"192.168.11.87/24".parse::<IpNet>().unwrap(),
"169.254.12.34/16".parse::<IpNet>().unwrap()
]
);
let mut runner = runner_with(&probe, "");
assert_eq!(
WindowsHyperV
.addresses_on(&mut runner, "vEthernet (vlan11)")
.unwrap(),
Vec::<IpNet>::new()
);
}
#[test]
fn is_wireless_reads_the_physical_media_type() {
let mut runner = runner_with(
&adapter_property_probe("Wi-Fi", "PhysicalMediaType"),
"Native 802.11\r\n",
);
assert!(WindowsHyperV.is_wireless(&mut runner, "Wi-Fi").unwrap());
let mut runner = runner_with(
&adapter_property_probe("Ethernet 2", "PhysicalMediaType"),
"802.3\r\n",
);
assert!(
!WindowsHyperV
.is_wireless(&mut runner, "Ethernet 2")
.unwrap()
);
}
#[test]
fn link_is_active_only_for_status_up() {
let mut runner = runner_with(&adapter_property_probe("Ethernet 2", "Status"), "Up\r\n");
assert!(
WindowsHyperV
.link_is_active(&mut runner, "Ethernet 2")
.unwrap()
);
let mut runner = runner_with(
&adapter_property_probe("Ethernet 2", "Status"),
"Disconnected\r\n",
);
assert!(
!WindowsHyperV
.link_is_active(&mut runner, "Ethernet 2")
.unwrap()
);
}
#[test]
fn a_missing_adapter_is_a_failure_to_ask_not_an_answer() {
let failing = || RecordingRunner {
fail_at: Some(0),
..RecordingRunner::default()
};
let err = WindowsHyperV
.link_is_active(&mut failing(), "Nope")
.unwrap_err();
assert!(err.to_string().contains("Nope"), "{err}");
assert!(WindowsHyperV.is_wireless(&mut failing(), "Nope").is_err());
}
#[test]
fn candidate_devices_exclude_virtual_wireless_and_placeholder_adapters() {
assert!(WindowsHyperV.is_candidate_device("Ethernet"));
assert!(WindowsHyperV.is_candidate_device("Ethernet 2"));
assert!(!WindowsHyperV.is_candidate_device("vEthernet (vlan11)"));
assert!(!WindowsHyperV.is_candidate_device("vEthernet (Default Switch)"));
assert!(!WindowsHyperV.is_candidate_device("Wi-Fi"));
assert!(!WindowsHyperV.is_candidate_device("Local Area Connection* 1"));
assert!(!WindowsHyperV.is_candidate_device("Loopback Pseudo-Interface 1"));
assert!(!WindowsHyperV.is_candidate_device("Bluetooth Network Connection"));
}
#[test]
fn every_probe_is_read_only_and_nothing_else_is() {
for probe in [
powershell("Get-NetAdapter | ForEach-Object { $_.Name }"),
powershell(
"Get-NetIPAddress -InterfaceAlias 'Ethernet 2' -AddressFamily IPv4 \
-ErrorAction SilentlyContinue | ForEach-Object { $_.IPAddress + '/' + $_.PrefixLength }; \
exit 0",
),
adapter_property_probe("Ethernet 2", "Status"),
adapter_property_probe("Ethernet 2", "PhysicalMediaType"),
parent_config_probe("Ethernet 2"),
] {
assert!(
WindowsHyperV::is_read_only_probe(&probe),
"{}",
probe.display()
);
}
let smuggled = parent_config_probe("x'; Remove-VMSwitch -Name 'vlanctl");
assert!(!WindowsHyperV::is_read_only_probe(&smuggled));
let i = tagged(11, "192.168.11.87/24");
for mutation in bringup_commands_for(&WindowsHyperV, &i, "Ethernet 2")
.iter()
.chain(WindowsHyperV.teardown_commands("vEthernet (vlan11)").iter())
{
assert!(
!WindowsHyperV::is_read_only_probe(mutation),
"{}",
mutation.display()
);
}
let smuggled = adapter_property_probe("x'; Remove-VMSwitch -Name 'vlanctl", "Status");
assert!(!WindowsHyperV::is_read_only_probe(&smuggled));
assert!(!WindowsHyperV::is_read_only_probe(&Cmd::new(
"powershell.exe",
&["-Command", "Get-NetAdapter"]
)));
assert!(!WindowsHyperV::is_read_only_probe(&Cmd::new(
"netsh",
&["interface", "ipv4", "show", "addresses"]
)));
}
}