#![cfg_attr(not(target_os = "windows"), allow(dead_code))]
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Instant;
#[cfg(target_os = "windows")]
use crate::error::{ErrorContext, WindowsReachabilityDiagnostic, WindowsReachabilityOperation};
use crate::error::{ErrorKind, ErrorStage, NetError};
use crate::net_status::{NetworkNameSource, NetworkStatus};
const MAX_OUTPUT_BYTES: usize = 64 * 1024;
pub(crate) struct WindowsObservation {
pub(crate) reachability: NetworkStatus,
}
pub(crate) struct NameSample {
pub(crate) name: Option<String>,
pub(crate) source: NetworkNameSource,
pub(crate) diagnostics: Vec<NetError>,
}
fn check_request(deadline: Instant, cancelled: &AtomicBool) -> Result<(), NetError> {
let kind = if cancelled.load(Ordering::Acquire) {
Some(ErrorKind::Cancelled)
} else if Instant::now() >= deadline {
Some(ErrorKind::TimedOut)
} else {
None
};
kind.map_or(Ok(()), |kind| {
Err(NetError::from(kind).with_stage(ErrorStage::NetworkMonitor))
})
}
fn monitor_io(error: impl Into<crate::error::BoxError>) -> NetError {
NetError::with_source(ErrorKind::Io, error).with_stage(ErrorStage::NetworkMonitor)
}
fn reachability_from_bits(bits: u32) -> NetworkStatus {
if bits & (0x40 | 0x400) != 0 {
NetworkStatus::Available
} else {
NetworkStatus::Unavailable
}
}
fn parse_wifi_ssid(output: &[u8]) -> Result<Option<String>, NetError> {
let output = std::str::from_utf8(output).map_err(monitor_io)?;
Ok(output.lines().find_map(|line| {
let (key, value) = line.split_once(':')?;
let name = value.trim();
(key.trim().eq_ignore_ascii_case("SSID") && !name.is_empty()).then(|| name.to_owned())
}))
}
fn resolve_name(
wifi: Result<Option<String>, NetError>,
fallback: impl FnOnce() -> Result<Option<String>, NetError>,
) -> Result<NameSample, NetError> {
let mut diagnostics = Vec::new();
match wifi {
Ok(Some(name)) => {
return Ok(NameSample {
name: Some(name),
source: NetworkNameSource::WifiSsid,
diagnostics,
});
}
Ok(None) => {}
Err(error) if matches!(error.kind(), ErrorKind::TimedOut | ErrorKind::Cancelled) => {
return Err(error);
}
Err(error) => diagnostics.push(error),
}
let name = fallback()?;
let source = if name.is_some() {
NetworkNameSource::NetworkListManager
} else {
NetworkNameSource::None
};
Ok(NameSample {
name,
source,
diagnostics,
})
}
fn append_output(output: &mut Vec<u8>, bytes: &[u8]) -> Result<(), NetError> {
if bytes.len() > MAX_OUTPUT_BYTES.saturating_sub(output.len()) {
return Err(NetError::from(ErrorKind::ItemTooLarge).with_stage(ErrorStage::NetworkMonitor));
}
output.extend_from_slice(bytes);
Ok(())
}
struct ManagedChild {
child: std::process::Child,
reaped: bool,
}
impl ManagedChild {
fn new(child: std::process::Child) -> Self {
Self {
child,
reaped: false,
}
}
fn try_wait(&mut self) -> std::io::Result<Option<std::process::ExitStatus>> {
let status = self.child.try_wait()?;
self.reaped = status.is_some();
Ok(status)
}
fn terminate(&mut self) -> std::io::Result<()> {
if self.reaped {
return Ok(());
}
let killed = self.child.kill();
match self.child.wait() {
Ok(_) => {
self.reaped = true;
Ok(())
}
Err(error) => Err(killed.err().unwrap_or(error)),
}
}
}
impl Drop for ManagedChild {
fn drop(&mut self) {
if let Err(error) = self.terminate() {
crate::log_e!(crate::common::log::log_def::LogType::Engine;
"net_status.drop", "event|error", "network_status_query_child_cleanup",
format!("{:?}", error.kind()));
}
}
}
#[cfg(target_os = "windows")]
pub(crate) fn sample_reachability(
deadline: Instant,
cancelled: &AtomicBool,
) -> Result<WindowsObservation, NetError> {
sample_reachability_using(&NativeWindowsApi, deadline, cancelled)
}
#[cfg(target_os = "windows")]
fn sample_reachability_using(
api: &impl WindowsApi,
deadline: Instant,
cancelled: &AtomicBool,
) -> Result<WindowsObservation, NetError> {
with_manager_using(
api,
deadline,
cancelled,
QueryKind::Reachability,
|manager| {
QueryKind::Reachability.record(WindowsReachabilityOperation::NlmGetConnectivity);
let connectivity = api.get_connectivity(manager).map_err(|error| {
QueryKind::Reachability
.error(WindowsReachabilityOperation::NlmGetConnectivity, error)
})?;
check_request(deadline, cancelled)?;
Ok(WindowsObservation {
reachability: reachability_from_bits(connectivity),
})
},
)
}
#[cfg(any(target_os = "windows", test))]
pub(crate) fn query_name(
deadline: Instant,
cancelled: &AtomicBool,
) -> Result<NameSample, NetError> {
#[cfg(target_os = "windows")]
{
with_manager(deadline, cancelled, |manager| {
let sample = resolve_name(query_wifi_ssid(deadline, cancelled), || {
query_nlm_name(manager, deadline, cancelled)
})?;
check_request(deadline, cancelled)?;
Ok(sample)
})
}
#[cfg(not(target_os = "windows"))]
{
check_request(deadline, cancelled)?;
Err(NetError::from(ErrorKind::Unsupported).with_stage(ErrorStage::NetworkMonitor))
}
}
#[cfg(target_os = "windows")]
fn with_manager<T>(
deadline: Instant,
cancelled: &AtomicBool,
query: impl FnOnce(
&windows::Win32::Networking::NetworkListManager::INetworkListManager,
) -> Result<T, NetError>,
) -> Result<T, NetError> {
with_manager_using(
&NativeWindowsApi,
deadline,
cancelled,
QueryKind::Name,
query,
)
}
#[cfg(target_os = "windows")]
#[derive(Clone, Copy)]
enum QueryKind {
Reachability,
Name,
}
#[cfg(target_os = "windows")]
impl QueryKind {
fn record(self, operation: WindowsReachabilityOperation) {
if matches!(self, Self::Reachability) {
super::super::sample_diagnostics::native_operation(operation);
}
}
fn error(
self,
operation: WindowsReachabilityOperation,
source: windows::core::Error,
) -> NetError {
match self {
Self::Name => monitor_io(source),
Self::Reachability => {
let diagnostic = WindowsReachabilityDiagnostic {
operation,
hresult: source.code().0 as u32,
};
let phase = match operation {
WindowsReachabilityOperation::ComInit => {
crate::error::NetworkMonitorPhase::ComInit
}
WindowsReachabilityOperation::NlmCreate => {
crate::error::NetworkMonitorPhase::NlmCreate
}
WindowsReachabilityOperation::NlmGetConnectivity => {
crate::error::NetworkMonitorPhase::NlmGetConnectivity
}
};
NetError::with_source(ErrorKind::Io, source)
.with_context(ErrorContext {
stage: Some(ErrorStage::NetworkMonitor),
windows_reachability: Some(diagnostic),
..ErrorContext::default()
})
.with_network_monitor_phase(phase)
}
}
}
}
#[cfg(target_os = "windows")]
trait WindowsApi {
type Apartment;
type Manager;
fn initialize(&self) -> windows::core::Result<Self::Apartment>;
fn create_manager(&self) -> windows::core::Result<Self::Manager>;
fn get_connectivity(&self, manager: &Self::Manager) -> windows::core::Result<u32>;
}
#[cfg(target_os = "windows")]
fn with_manager_using<A: WindowsApi, T>(
api: &A,
deadline: Instant,
cancelled: &AtomicBool,
kind: QueryKind,
query: impl FnOnce(&A::Manager) -> Result<T, NetError>,
) -> Result<T, NetError> {
check_request(deadline, cancelled)?;
kind.record(WindowsReachabilityOperation::ComInit);
let _apartment = api
.initialize()
.map_err(|error| kind.error(WindowsReachabilityOperation::ComInit, error))?;
check_request(deadline, cancelled)?;
kind.record(WindowsReachabilityOperation::NlmCreate);
let manager = api
.create_manager()
.map_err(|error| kind.error(WindowsReachabilityOperation::NlmCreate, error))?;
check_request(deadline, cancelled)?;
let observation = query(&manager)?;
check_request(deadline, cancelled)?;
Ok(observation)
}
#[cfg(target_os = "windows")]
struct NativeWindowsApi;
#[cfg(target_os = "windows")]
struct ComApartment;
#[cfg(target_os = "windows")]
impl Drop for ComApartment {
fn drop(&mut self) {
use windows::Win32::System::Com::CoUninitialize;
unsafe { CoUninitialize() };
}
}
#[cfg(target_os = "windows")]
impl WindowsApi for NativeWindowsApi {
type Apartment = ComApartment;
type Manager = windows::Win32::Networking::NetworkListManager::INetworkListManager;
fn initialize(&self) -> windows::core::Result<ComApartment> {
use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) }.ok()?;
Ok(ComApartment)
}
fn create_manager(&self) -> windows::core::Result<Self::Manager> {
use windows::Win32::Networking::NetworkListManager::NetworkListManager;
use windows::Win32::System::Com::{CoCreateInstance, CLSCTX_ALL};
unsafe { CoCreateInstance(&NetworkListManager, None, CLSCTX_ALL) }
}
fn get_connectivity(&self, manager: &Self::Manager) -> windows::core::Result<u32> {
unsafe { manager.GetConnectivity() }.map(|connectivity| connectivity.0 as u32)
}
}
#[cfg(target_os = "windows")]
fn query_nlm_name(
manager: &windows::Win32::Networking::NetworkListManager::INetworkListManager,
deadline: Instant,
cancelled: &AtomicBool,
) -> Result<Option<String>, NetError> {
use windows::Win32::Networking::NetworkListManager::NLM_ENUM_NETWORK_CONNECTED;
check_request(deadline, cancelled)?;
let networks =
unsafe { manager.GetNetworks(NLM_ENUM_NETWORK_CONNECTED) }.map_err(monitor_io)?;
for _ in 0..1024 {
check_request(deadline, cancelled)?;
let mut fetched = 0;
let mut items = [None];
unsafe { networks.Next(&mut items, Some(&mut fetched)) }.map_err(monitor_io)?;
check_request(deadline, cancelled)?;
if fetched == 0 {
return Ok(None);
}
let network = items[0]
.as_ref()
.ok_or_else(|| NetError::from(ErrorKind::Internal))?;
let name = unsafe { network.GetName() }
.map_err(monitor_io)?
.to_string();
check_request(deadline, cancelled)?;
if !name.trim().is_empty() {
return Ok(Some(name));
}
}
Err(NetError::from(ErrorKind::ResourceExhausted).with_stage(ErrorStage::NetworkMonitor))
}
#[cfg(target_os = "windows")]
fn query_wifi_ssid(deadline: Instant, cancelled: &AtomicBool) -> Result<Option<String>, NetError> {
check_request(deadline, cancelled)?;
let mut command = std::process::Command::new(system_netsh_path()?);
command.args(["wlan", "show", "interfaces"]);
parse_wifi_ssid(&command_output(command, deadline, cancelled)?)
}
#[cfg(target_os = "windows")]
fn system_netsh_path() -> Result<std::path::PathBuf, NetError> {
use std::os::windows::ffi::OsStringExt;
use windows::Win32::System::SystemInformation::GetSystemDirectoryW;
let mut directory = vec![0u16; 32_768];
let length = unsafe { GetSystemDirectoryW(Some(&mut directory)) } as usize;
if length == 0 {
return Err(monitor_io(std::io::Error::last_os_error()));
}
if length >= directory.len() {
return Err(NetError::from(ErrorKind::ItemTooLarge).with_stage(ErrorStage::NetworkMonitor));
}
directory.truncate(length);
let directory = std::path::PathBuf::from(std::ffi::OsString::from_wide(&directory));
if !directory.is_absolute() {
return Err(NetError::from(ErrorKind::InvalidConfig).with_stage(ErrorStage::NetworkMonitor));
}
Ok(directory.join("netsh.exe"))
}
#[cfg(target_os = "windows")]
fn command_output(
mut command: std::process::Command,
deadline: Instant,
cancelled: &AtomicBool,
) -> Result<Vec<u8>, NetError> {
use std::io::Read;
use std::os::windows::io::AsRawHandle;
use std::os::windows::process::CommandExt;
use std::process::Stdio;
use std::time::Duration;
use windows::Win32::Foundation::{ERROR_BROKEN_PIPE, HANDLE};
use windows::Win32::System::Pipes::PeekNamedPipe;
check_request(deadline, cancelled)?;
let child = command
.creation_flags(0x0800_0000) .stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()
.map_err(monitor_io)?;
let mut child = ManagedChild::new(child);
let mut stdout = child
.child
.stdout
.take()
.ok_or_else(|| NetError::from(ErrorKind::Internal))?;
let mut output = Vec::new();
let mut chunk = [0; 4096];
let mut exit = None;
loop {
check_request(deadline, cancelled)?;
let mut available = 0;
let peeked = unsafe {
PeekNamedPipe(
HANDLE(stdout.as_raw_handle()),
None,
0,
None,
Some(&mut available),
None,
)
};
if let Err(error) = peeked {
if error.code() != windows::core::HRESULT::from_win32(ERROR_BROKEN_PIPE.0) {
return Err(monitor_io(error));
}
}
if available > 0 {
let length = (available as usize).min(chunk.len());
let read = stdout.read(&mut chunk[..length]).map_err(monitor_io)?;
append_output(&mut output, &chunk[..read])?;
if read != 0 {
continue;
}
}
if exit.is_none() {
exit = child.try_wait().map_err(monitor_io)?;
if exit.is_some() {
continue;
}
}
if let Some(status) = exit {
if !status.success() {
return Err(monitor_io(std::io::Error::other(format!(
"Windows network-name query exited with {status}"
))));
}
check_request(deadline, cancelled)?;
return Ok(output);
}
std::thread::sleep(
deadline
.saturating_duration_since(Instant::now())
.min(Duration::from_millis(5)),
);
}
}
#[cfg(all(test, target_os = "windows"))]
#[path = "windows_diagnostics_tests.rs"]
mod windows_diagnostics_tests;
#[cfg(test)]
mod tests {
use super::*;
use std::time::Duration;
#[test]
fn only_internet_flags_establish_reachability() {
for bits in [0, 0x01, 0x02, 0x10, 0x20, 0x100, 0x200, 0x333] {
assert_eq!(reachability_from_bits(bits), NetworkStatus::Unavailable);
}
for bits in [0x40, 0x400, 0x440, 0x773] {
assert_eq!(reachability_from_bits(bits), NetworkStatus::Available);
}
}
#[test]
fn ssid_parser_does_not_confuse_bssid_or_empty_values() {
assert_eq!(
parse_wifi_ssid(b" BSSID : 00:11:22:33:44:55\n SSID : \n SSID : cafe:guest\n").unwrap(),
Some("cafe:guest".into())
);
assert!(parse_wifi_ssid(b"State : disconnected\n")
.unwrap()
.is_none());
assert_eq!(
parse_wifi_ssid(b"SSID : \xff").unwrap_err().kind(),
ErrorKind::Io
);
}
#[test]
fn wifi_success_does_not_query_fallback() {
let resolved =
resolve_name(Ok(Some("wifi".into())), || panic!("unneeded fallback")).unwrap();
assert_eq!(resolved.name.as_deref(), Some("wifi"));
assert!(matches!(resolved.source, NetworkNameSource::WifiSsid));
assert!(resolved.diagnostics.is_empty());
}
#[test]
fn fallback_retains_wifi_failure_but_never_hides_its_own_failure() {
let resolved = resolve_name(Err(NetError::from(ErrorKind::Io)), || {
Ok(Some("wired".into()))
})
.unwrap();
assert_eq!(resolved.name.as_deref(), Some("wired"));
assert!(matches!(
resolved.source,
NetworkNameSource::NetworkListManager
));
assert_eq!(resolved.diagnostics[0].kind(), ErrorKind::Io);
let failed = resolve_name(Ok(None), || Err(NetError::from(ErrorKind::Io)));
assert!(matches!(failed, Err(error) if error.kind() == ErrorKind::Io));
let absent = resolve_name(Err(NetError::from(ErrorKind::Io)), || Ok(None)).unwrap();
assert!(absent.name.is_none());
assert!(matches!(absent.source, NetworkNameSource::None));
assert_eq!(absent.diagnostics.len(), 1);
}
#[test]
fn cancellation_and_timeout_do_not_attempt_name_fallback() {
for kind in [ErrorKind::Cancelled, ErrorKind::TimedOut] {
let result = resolve_name(Err(NetError::from(kind)), || panic!("invalid fallback"));
assert!(matches!(result, Err(error) if error.kind() == kind));
}
let cancelled = AtomicBool::new(true);
assert_eq!(
check_request(Instant::now() + Duration::from_secs(1), &cancelled)
.unwrap_err()
.kind(),
ErrorKind::Cancelled
);
cancelled.store(false, Ordering::Release);
assert_eq!(
check_request(Instant::now(), &cancelled)
.unwrap_err()
.kind(),
ErrorKind::TimedOut
);
}
#[test]
fn oversized_stdout_does_not_grow_the_retained_buffer() {
let mut output = vec![0; MAX_OUTPUT_BYTES - 1];
assert_eq!(
append_output(&mut output, b"12").unwrap_err().kind(),
ErrorKind::ItemTooLarge
);
assert_eq!(output.len(), MAX_OUTPUT_BYTES - 1);
append_output(&mut output, b"1").unwrap();
assert_eq!(output.len(), MAX_OUTPUT_BYTES);
}
#[cfg(unix)]
#[test]
fn interrupted_child_is_killed_and_waited_for() {
let child = std::process::Command::new("/bin/sh")
.args(["-c", "exec sleep 30"])
.spawn()
.unwrap();
let mut child = ManagedChild::new(child);
child.terminate().unwrap();
assert!(child.reaped);
assert!(child.try_wait().unwrap().is_some());
child.terminate().unwrap();
}
#[cfg(target_os = "windows")]
#[test]
fn portable_flags_match_the_windows_api() {
use windows::Win32::Networking::NetworkListManager::{
NLM_CONNECTIVITY_IPV4_INTERNET, NLM_CONNECTIVITY_IPV6_INTERNET,
};
assert_eq!(NLM_CONNECTIVITY_IPV4_INTERNET.0, 0x40);
assert_eq!(NLM_CONNECTIVITY_IPV6_INTERNET.0, 0x400);
}
#[cfg(target_os = "windows")]
fn shell_command(script: &str) -> std::process::Command {
let mut command = std::process::Command::new("cmd");
command.args(["/D", "/C", script]);
command
}
#[cfg(target_os = "windows")]
#[test]
fn completed_child_output_is_drained_and_nonzero_exit_is_an_error() {
let cancelled = AtomicBool::new(false);
let deadline = Instant::now() + Duration::from_secs(10);
let output =
command_output(shell_command("echo SSID : test"), deadline, &cancelled).unwrap();
assert_eq!(parse_wifi_ssid(&output).unwrap().as_deref(), Some("test"));
assert_eq!(
command_output(shell_command("exit /B 7"), deadline, &cancelled)
.unwrap_err()
.kind(),
ErrorKind::Io
);
}
#[cfg(target_os = "windows")]
#[test]
fn live_child_output_is_bounded_and_silent_child_times_out() {
let cancelled = AtomicBool::new(false);
let output = command_output(
shell_command("for /L %i in (1,1,4096) do @echo 0123456789abcdef"),
Instant::now() + Duration::from_secs(10),
&cancelled,
);
assert_eq!(output.unwrap_err().kind(), ErrorKind::ItemTooLarge);
let timeout = command_output(
shell_command("for /L %i in (1,1,2147483647) do @rem busy"),
Instant::now() + Duration::from_millis(30),
&cancelled,
);
assert_eq!(timeout.unwrap_err().kind(), ErrorKind::TimedOut);
}
}