Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
fix(cua-driver): make Windows listener discovery locale independent (#3275)
injaneityed00ede10ec6
diff --git a/libs/cua-driver/rust/crates/platform-windows/Cargo.toml b/libs/cua-driver/rust/crates/platform-windows/Cargo.tomlindex 1821d5ba74..719f59d18d 100644--- a/libs/cua-driver/rust/crates/platform-windows/Cargo.toml+++ b/libs/cua-driver/rust/crates/platform-windows/Cargo.toml@@ -61,6 +61,9 @@ windows = { version = "0.58", features = ["Win32_System_Com_StructuredStorage","Win32_Media","Win32_System_Registry",+ # Locale-independent TCP listener ownership for browser endpoint proof.+ "Win32_NetworkManagement_IpHelper",+ "Win32_Networking_WinSock",# `cua-driver doctor` interactive-session probe:# - Win32_System_RemoteDesktop → ProcessIdToSessionId# - Win32_System_StationsAndDesktops → OpenWindowStationWdiff --git a/libs/cua-driver/rust/crates/platform-windows/src/browser_platform.rs b/libs/cua-driver/rust/crates/platform-windows/src/browser_platform.rsindex ab31d7ea59..7f0be35414 100644--- a/libs/cua-driver/rust/crates/platform-windows/src/browser_platform.rs+++ b/libs/cua-driver/rust/crates/platform-windows/src/browser_platform.rs@@ -1,7 +1,9 @@//! Windows identity and endpoint evidence for the first-class browser tools.use std::collections::HashMap;+use std::ffi::c_void;use std::future::Future;+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};use std::path::PathBuf;use std::process::Stdio;use std::sync::{Arc, Mutex};@@ -34,7 +36,14 @@ use crate::browser_standard_user::{BrowserLaunchContext,};use windows::core::PCWSTR;-use windows::Win32::Foundation::{CloseHandle, E_ACCESSDENIED, FILETIME, HWND, RECT};+use windows::Win32::Foundation::{+ CloseHandle, ERROR_INSUFFICIENT_BUFFER, E_ACCESSDENIED, FILETIME, HWND, NO_ERROR, RECT,+};+use windows::Win32::NetworkManagement::IpHelper::{+ GetExtendedTcpTable, MIB_TCP6ROW_OWNER_PID, MIB_TCP6TABLE_OWNER_PID, MIB_TCPROW_OWNER_PID,+ MIB_TCPTABLE_OWNER_PID, MIB_TCP_STATE_LISTEN, TCP_TABLE_OWNER_PID_LISTENER,+};+use windows::Win32::Networking::WinSock::{AF_INET, AF_INET6};use windows::Win32::Storage::FileSystem::{CreateFileW, DELETE, FILE_ADD_FILE, FILE_ADD_SUBDIRECTORY, FILE_APPEND_DATA, FILE_DELETE_CHILD,FILE_FLAGS_AND_ATTRIBUTES, FILE_FLAG_BACKUP_SEMANTICS, FILE_SHARE_DELETE, FILE_SHARE_READ,@@ -505,16 +514,7 @@ fn user_data_dir_from_command_line(}fn system_powershell_path() -> Result<PathBuf, BrowserRefusal> {- let system = system_netstat_path()?- .parent()- .map(PathBuf::from)- .ok_or_else(|| {- refusal(- BrowserRefusalCode::BrowserRouteUnavailable,- "could not resolve the trusted Windows system directory",- )- })?;- Ok(system.join("WindowsPowerShell\\v1.0\\powershell.exe"))+ Ok(system_directory_path()?.join("WindowsPowerShell\\v1.0\\powershell.exe"))}async fn browser_command_line(pid: u32) -> Result<String, BrowserRefusal> {@@ -783,34 +783,226 @@ fn overlay_window_and_scale(window_id: u64) -> Option<(u64, f64)> {Some((overlay_window, scale))}-fn parse_netstat_loopback_listeners(text: &str, allowed_pids: &[u32]) -> Vec<(u16, u32)> {- let mut listeners = text- .lines()- .filter_map(|line| {- let fields = line.split_whitespace().collect::<Vec<_>>();- if fields.len() < 5- || !fields[0].eq_ignore_ascii_case("TCP")- || !fields[3].eq_ignore_ascii_case("LISTENING")- {- return None;- }- let owner_pid = fields[4].parse::<u32>().ok()?;- if !allowed_pids.contains(&owner_pid) {- return None;- }- let local = fields[1];- let (host, port) = local.rsplit_once(':')?;- let host = host.trim_matches(['[', ']']);- matches!(host, "127.0.0.1" | "::1" | "localhost")- .then(|| port.parse::<u16>().ok().map(|port| (port, owner_pid)))- .flatten()+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+struct TcpOwnerRow {+ local_ip: IpAddr,+ local_port: u16,+ state: u32,+ owner_pid: u32,+}++fn network_port(value: u32) -> u16 {+ u16::from_be((value & u32::from(u16::MAX)) as u16)+}++const MAX_TCP_OWNER_TABLE_BYTES: usize = 64 * 1024 * 1024;+const TCP_OWNER_TABLE_READ_ATTEMPTS: usize = 3;++fn select_loopback_listeners(rows: &[TcpOwnerRow], allowed_pids: &[u32]) -> Vec<(u16, u32)> {+ let mut listeners = rows+ .iter()+ .filter(|row| {+ row.state == MIB_TCP_STATE_LISTEN.0 as u32+ && row.local_ip.is_loopback()+ && allowed_pids.contains(&row.owner_pid)})+ .map(|row| (row.local_port, row.owner_pid)).collect::<Vec<_>>();listeners.sort_unstable();listeners.dedup();listeners}+/// # Safety+///+/// `R` must be a Windows owner-table row whose every bit pattern is valid.+/// `row_offset` must identify the first row in the table; invalid offsets are+/// bounds-checked and refused rather than read.+unsafe fn decode_owner_table<R: Copy>(+ bytes: &[u8],+ row_offset: usize,+) -> Result<Vec<R>, BrowserRefusal> {+ let count_bytes: [u8; 4] = bytes+ .get(..4)+ .and_then(|part| part.try_into().ok())+ .ok_or_else(|| {+ refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ "Windows returned a truncated TCP owner table",+ )+ })?;+ let count = u32::from_ne_bytes(count_bytes) as usize;+ let row_size = std::mem::size_of::<R>();+ if row_offset < count_bytes.len() || row_size == 0 {+ return Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ "Windows returned an invalid TCP owner table layout",+ ));+ }+ let required = count+ .checked_mul(row_size)+ .and_then(|rows| rows.checked_add(row_offset))+ .filter(|required| *required <= bytes.len())+ .ok_or_else(|| {+ refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ "Windows returned an invalid TCP owner table length",+ )+ })?;++ let mut rows = Vec::with_capacity(count);+ let mut offset = row_offset;+ while offset < required {+ rows.push(unsafe { std::ptr::read_unaligned(bytes.as_ptr().add(offset).cast::<R>()) });+ offset += row_size;+ }+ Ok(rows)+}++fn query_tcp_owner_table_with(+ mut query: impl FnMut(Option<*mut c_void>, &mut u32) -> u32,+) -> Result<Vec<u8>, BrowserRefusal> {+ let mut size = 0u32;+ let status = query(None, &mut size);+ if status != ERROR_INSUFFICIENT_BUFFER.0 && status != NO_ERROR.0 {+ return Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ format!("could not size the Windows TCP owner table: error {status}"),+ ));+ }+ if size == 0 {+ return Ok(0u32.to_ne_bytes().to_vec());+ }++ for _ in 0..TCP_OWNER_TABLE_READ_ATTEMPTS {+ let requested = size as usize;+ if requested > MAX_TCP_OWNER_TABLE_BYTES {+ return Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ format!("Windows TCP owner table exceeded {MAX_TCP_OWNER_TABLE_BYTES} bytes"),+ ));+ }+ let word_count = requested.div_ceil(std::mem::size_of::<u32>());+ let mut buffer = vec![0u32; word_count];+ let mut buffer_size = (word_count * std::mem::size_of::<u32>()) as u32;+ let status = query(Some(buffer.as_mut_ptr().cast()), &mut buffer_size);+ if status == NO_ERROR.0 {+ let returned = buffer_size as usize;+ let allocated = buffer.len() * std::mem::size_of::<u32>();+ if returned > allocated {+ return Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ "Windows returned an oversized TCP owner table",+ ));+ }+ let bytes =+ unsafe { std::slice::from_raw_parts(buffer.as_ptr().cast::<u8>(), returned) };+ return Ok(bytes.to_vec());+ }+ if status != ERROR_INSUFFICIENT_BUFFER.0 {+ return Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ format!("could not read the Windows TCP owner table: error {status}"),+ ));+ }+ size = buffer_size;+ }++ Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ format!(+ "Windows TCP owner table changed during {TCP_OWNER_TABLE_READ_ATTEMPTS} consecutive reads"+ ),+ ))+}++fn query_tcp_owner_table(address_family: u32) -> Result<Vec<u8>, BrowserRefusal> {+ query_tcp_owner_table_with(|buffer, size| unsafe {+ GetExtendedTcpTable(+ buffer,+ size,+ false,+ address_family,+ TCP_TABLE_OWNER_PID_LISTENER,+ 0,+ )+ })+}++fn windows_loopback_listeners_with(+ allowed_pids: &[u32],+ mut query: impl FnMut(u32) -> Result<Vec<u8>, BrowserRefusal>,+) -> Result<Vec<(u16, u32)>, BrowserRefusal> {+ let ipv4 = query(u32::from(AF_INET.0));+ let ipv6 = query(u32::from(AF_INET6.0));+ if let (Err(ipv4), Err(ipv6)) = (&ipv4, &ipv6) {+ return Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ format!(+ "could not inspect either Windows TCP owner table: IPv4: {}; IPv6: {}",+ ipv4.message, ipv6.message+ ),+ ));+ }+ if let Err(error) = &ipv4 {+ tracing::warn!(+ code = ?error.code,+ message = %error.message,+ "continuing Windows listener discovery without the IPv4 owner table"+ );+ }+ if let Err(error) = &ipv6 {+ tracing::warn!(+ code = ?error.code,+ message = %error.message,+ "continuing Windows listener discovery without the IPv6 owner table"+ );+ }++ // These Win32 rows contain only integer fields and byte arrays, so every+ // bit pattern returned by the operating system is a valid Rust value.+ let mut rows = Vec::new();+ if let Ok(ipv4) = ipv4 {+ rows.extend(+ unsafe {+ decode_owner_table::<MIB_TCPROW_OWNER_PID>(+ &ipv4,+ std::mem::offset_of!(MIB_TCPTABLE_OWNER_PID, table),+ )+ }?+ .into_iter()+ .map(|row| TcpOwnerRow {+ local_ip: IpAddr::V4(Ipv4Addr::from(u32::from_be(row.dwLocalAddr))),+ local_port: network_port(row.dwLocalPort),+ state: row.dwState,+ owner_pid: row.dwOwningPid,+ }),+ );+ }+ if let Ok(ipv6) = ipv6 {+ rows.extend(+ unsafe {+ decode_owner_table::<MIB_TCP6ROW_OWNER_PID>(+ &ipv6,+ std::mem::offset_of!(MIB_TCP6TABLE_OWNER_PID, table),+ )+ }?+ .into_iter()+ .map(|row| TcpOwnerRow {+ local_ip: IpAddr::V6(Ipv6Addr::from(row.ucLocalAddr)),+ local_port: network_port(row.dwLocalPort),+ state: row.dwState,+ owner_pid: row.dwOwningPid,+ }),+ );+ }+ Ok(select_loopback_listeners(&rows, allowed_pids))+}++fn windows_loopback_listeners(allowed_pids: &[u32]) -> Result<Vec<(u16, u32)>, BrowserRefusal> {+ windows_loopback_listeners_with(allowed_pids, query_tcp_owner_table)+}+fn system_directory_path() -> Result<PathBuf, BrowserRefusal> {let mut buffer = [0u16; 32768];let length = unsafe { GetSystemDirectoryW(Some(&mut buffer)) } as usize;@@ -823,30 +1015,18 @@ fn system_directory_path() -> Result<PathBuf, BrowserRefusal> {Ok(PathBuf::from(String::from_utf16_lossy(&buffer[..length])))}-fn system_netstat_path() -> Result<PathBuf, BrowserRefusal> {- Ok(system_directory_path()?.join("netstat.exe"))-}--async fn netstat_loopback_listeners(+async fn native_loopback_listeners(allowed_pids: &[u32],) -> Result<Vec<(u16, u32)>, BrowserRefusal> {- let netstat = system_netstat_path()?;- let output = tokio::process::Command::new(netstat)- .args(["-ano", "-p", "tcp"])- .stdin(Stdio::null())- .stderr(Stdio::null())- .output()+ let allowed_pids = allowed_pids.to_vec();+ tokio::task::spawn_blocking(move || windows_loopback_listeners(&allowed_pids)).await.map_err(|error| {refusal(BrowserRefusalCode::BrowserRouteUnavailable,- format!("could not inspect browser listeners: {error}"),+ format!("could not inspect Windows TCP listener ownership: {error}"),)- })?;- Ok(parse_netstat_loopback_listeners(- &String::from_utf8_lossy(&output.stdout),- allowed_pids,- ))+ })?}async fn raw_loopback_listeners_for_process_tree(@@ -861,7 +1041,7 @@ async fn raw_loopback_listeners_for_process_tree(format!("could not inspect browser process tree: {error}"),)})?;- let observed = netstat_loopback_listeners(&allowed_pids).await?;+ let observed = native_loopback_listeners(&allowed_pids).await?;tokio::task::spawn_blocking(move || {observed.into_iter()@@ -900,7 +1080,7 @@ async fn loopback_listeners_for_process_tree()})?;- let observed = netstat_loopback_listeners(&tree.pids).await?;+ let observed = native_loopback_listeners(&tree.pids).await?;let expected_starts = tree.started_at;tokio::task::spawn_blocking(move || {retain_identity_matched_listeners(observed, &expected_starts, |pid| {@@ -926,7 +1106,7 @@ async fn loopback_listeners_for_exact_pid(pid: u32) -> Result<Vec<(u16, u32)>, Bformat!("could not inspect browser process identity: {error}"),)})??;- let observed = netstat_loopback_listeners(&[pid]).await?;+ let observed = native_loopback_listeners(&[pid]).await?;tokio::task::spawn_blocking(move || {retain_identity_matched_listeners(observed,@@ -959,7 +1139,7 @@ async fn loopback_ports_for_exact_pid(pid: u32) -> Result<Vec<u16>, BrowserRefus}async fn unfiltered_loopback_ports_for_exact_pid(pid: u32) -> Result<Vec<u16>, BrowserRefusal> {- let mut ports = netstat_loopback_listeners(&[pid])+ let mut ports = native_loopback_listeners(&[pid]).await?.into_iter().map(|(port, _owner_pid)| port)@@ -2317,30 +2497,246 @@ mod tests {use std::sync::Arc;#[test]- fn netstat_parser_requires_loopback_listening_and_browser_process_tree() {- let input = "\- TCP 127.0.0.1:9222 0.0.0.0:0 LISTENING 42\n\- TCP 0.0.0.0:9333 0.0.0.0:0 LISTENING 43\n\- TCP [::1]:9444 [::]:0 LISTENING 43\n\- TCP 127.0.0.1:9666 127.0.0.1:50000 ESTABLISHED 42\n\- TCP 127.0.0.1:9555 0.0.0.0:0 LISTENING 7\n";+ fn native_listener_selection_requires_loopback_listen_state_and_process_tree() {+ let rows = [+ TcpOwnerRow {+ local_ip: "127.0.0.1".parse().unwrap(),+ local_port: 9222,+ state: MIB_TCP_STATE_LISTEN.0 as u32,+ owner_pid: 42,+ },+ TcpOwnerRow {+ local_ip: "0.0.0.0".parse().unwrap(),+ local_port: 9333,+ state: MIB_TCP_STATE_LISTEN.0 as u32,+ owner_pid: 43,+ },+ TcpOwnerRow {+ local_ip: "::1".parse().unwrap(),+ local_port: 9444,+ state: MIB_TCP_STATE_LISTEN.0 as u32,+ owner_pid: 43,+ },+ TcpOwnerRow {+ local_ip: "127.0.0.1".parse().unwrap(),+ local_port: 9555,+ state: MIB_TCP_STATE_LISTEN.0 as u32,+ owner_pid: 7,+ },+ TcpOwnerRow {+ local_ip: "127.0.0.1".parse().unwrap(),+ local_port: 9666,+ state: 5,+ owner_pid: 42,+ },+ ];assert_eq!(- parse_netstat_loopback_listeners(input, &[42, 43]),+ select_loopback_listeners(&rows, &[42, 43]),vec![(9222, 42), (9444, 43)]);}#[test]- fn netstat_parser_preserves_the_exact_listener_owner() {- let input = "\- TCP 127.0.0.1:9222 0.0.0.0:0 LISTENING 43\n\- TCP 127.0.0.1:9555 0.0.0.0:0 LISTENING 99\n";+ fn native_listener_selection_preserves_owner_and_deduplicates_rows() {+ let row = TcpOwnerRow {+ local_ip: "127.0.0.1".parse().unwrap(),+ local_port: 9222,+ state: MIB_TCP_STATE_LISTEN.0 as u32,+ owner_pid: 43,+ };assert_eq!(- parse_netstat_loopback_listeners(input, &[42, 43]),+ select_loopback_listeners(&[row, row], &[42, 43]),vec![(9222, 43)]);}+ #[test]+ fn native_owner_table_port_uses_network_byte_order() {+ assert_eq!(network_port(0x0000_0624), 9222);+ }++ fn owner_table_bytes<R: Copy>(row_offset: usize, rows: &[R]) -> Vec<u8> {+ // The Win32 owner rows used by these tests contain no padding.+ let mut bytes = vec![0; row_offset + std::mem::size_of_val(rows)];+ bytes[..4].copy_from_slice(&(rows.len() as u32).to_ne_bytes());+ unsafe {+ std::ptr::copy_nonoverlapping(+ rows.as_ptr().cast::<u8>(),+ bytes.as_mut_ptr().add(row_offset),+ std::mem::size_of_val(rows),+ );+ }+ bytes+ }++ #[test]+ fn native_owner_table_decoder_rejects_truncated_and_invalid_counts() {+ let truncated = unsafe { decode_owner_table::<u32>(&[0, 0, 0], 4) }.unwrap_err();+ assert!(truncated.message.contains("truncated TCP owner table"));++ let invalid_offset = unsafe { decode_owner_table::<u32>(&[0; 8], 3) }.unwrap_err();+ assert!(invalid_offset+ .message+ .contains("invalid TCP owner table layout"));++ let impossible_count = u32::MAX.to_ne_bytes();+ let invalid = unsafe { decode_owner_table::<u32>(&impossible_count, 4) }.unwrap_err();+ assert!(invalid.message.contains("invalid TCP owner table length"));+ }++ #[test]+ fn native_owner_table_decoder_uses_the_real_ipv4_and_ipv6_layouts() {+ let ipv4_offset = std::mem::offset_of!(MIB_TCPTABLE_OWNER_PID, table);+ assert_eq!(ipv4_offset, 4);+ assert_eq!(std::mem::size_of::<MIB_TCPROW_OWNER_PID>(), 24);+ let ipv4_row = MIB_TCPROW_OWNER_PID {+ dwState: MIB_TCP_STATE_LISTEN.0 as u32,+ dwLocalAddr: u32::from_ne_bytes(Ipv4Addr::LOCALHOST.octets()),+ dwLocalPort: 0x0000_0624,+ dwRemoteAddr: 0,+ dwRemotePort: 0,+ dwOwningPid: 42,+ };+ let ipv4_bytes = owner_table_bytes(ipv4_offset, &[ipv4_row]);+ let decoded_ipv4 =+ unsafe { decode_owner_table::<MIB_TCPROW_OWNER_PID>(&ipv4_bytes, ipv4_offset) }+ .unwrap();+ assert_eq!(decoded_ipv4, vec![ipv4_row]);++ let ipv6_offset = std::mem::offset_of!(MIB_TCP6TABLE_OWNER_PID, table);+ assert_eq!(ipv6_offset, 4);+ assert_eq!(std::mem::size_of::<MIB_TCP6ROW_OWNER_PID>(), 56);+ let ipv6_row = MIB_TCP6ROW_OWNER_PID {+ ucLocalAddr: Ipv6Addr::LOCALHOST.octets(),+ dwLocalScopeId: 0,+ dwLocalPort: 0x0000_0624,+ ucRemoteAddr: Ipv6Addr::UNSPECIFIED.octets(),+ dwRemoteScopeId: 0,+ dwRemotePort: 0,+ dwState: MIB_TCP_STATE_LISTEN.0 as u32,+ dwOwningPid: 43,+ };+ let ipv6_bytes = owner_table_bytes(ipv6_offset, &[ipv6_row]);+ let decoded_ipv6 =+ unsafe { decode_owner_table::<MIB_TCP6ROW_OWNER_PID>(&ipv6_bytes, ipv6_offset) }+ .unwrap();+ assert_eq!(decoded_ipv6, vec![ipv6_row]);+ }++ #[test]+ fn native_listener_discovery_keeps_ipv4_when_ipv6_is_unavailable() {+ let ipv4_offset = std::mem::offset_of!(MIB_TCPTABLE_OWNER_PID, table);+ let ipv4 = owner_table_bytes(+ ipv4_offset,+ &[MIB_TCPROW_OWNER_PID {+ dwState: MIB_TCP_STATE_LISTEN.0 as u32,+ dwLocalAddr: u32::from_ne_bytes(Ipv4Addr::LOCALHOST.octets()),+ dwLocalPort: 0x0000_0624,+ dwRemoteAddr: 0,+ dwRemotePort: 0,+ dwOwningPid: 42,+ }],+ );++ let listeners = windows_loopback_listeners_with(&[42], |family| {+ if family == u32::from(AF_INET.0) {+ Ok(ipv4.clone())+ } else {+ Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ "IPv6 owner table is unsupported",+ ))+ }+ })+ .unwrap();+ assert_eq!(listeners, vec![(9222, 42)]);+ }++ #[test]+ fn native_listener_discovery_refuses_when_both_families_fail() {+ let error = windows_loopback_listeners_with(&[42], |family| {+ Err(refusal(+ BrowserRefusalCode::BrowserRouteUnavailable,+ format!("family {family} unavailable"),+ ))+ })+ .unwrap_err();+ assert!(error.message.contains("either Windows TCP owner table"));+ assert!(error.message.contains("IPv4:"));+ assert!(error.message.contains("IPv6:"));+ }++ #[test]+ fn native_owner_table_query_rejects_sizing_and_read_errors() {+ let sizing = query_tcp_owner_table_with(|_, _| 5).unwrap_err();+ assert!(sizing.message.contains("size the Windows TCP owner table"));++ let mut calls = 0;+ let reading = query_tcp_owner_table_with(|buffer, size| {+ calls += 1;+ if buffer.is_none() {+ *size = 4;+ ERROR_INSUFFICIENT_BUFFER.0+ } else {+ 5+ }+ })+ .unwrap_err();+ assert_eq!(calls, 2);+ assert!(reading.message.contains("read the Windows TCP owner table"));+ }++ #[test]+ fn native_owner_table_query_bounds_growth_and_retry_churn() {+ let oversized = query_tcp_owner_table_with(|buffer, size| {+ assert!(buffer.is_none());+ *size = (MAX_TCP_OWNER_TABLE_BYTES as u32) + 1;+ ERROR_INSUFFICIENT_BUFFER.0+ })+ .unwrap_err();+ assert!(oversized+ .message+ .contains("TCP owner table exceeded 67108864 bytes"));++ let mut calls = 0;+ let churn = query_tcp_owner_table_with(|buffer, size| {+ calls += 1;+ *size = if buffer.is_none() { 4 } else { *size + 4 };+ ERROR_INSUFFICIENT_BUFFER.0+ })+ .unwrap_err();+ assert_eq!(calls, TCP_OWNER_TABLE_READ_ATTEMPTS + 1);+ assert!(churn.message.contains("changed during 3 consecutive reads"));+ }++ #[test]+ fn native_owner_table_query_rejects_oversized_success_length() {+ let oversized = query_tcp_owner_table_with(|buffer, size| {+ if buffer.is_none() {+ *size = 4;+ ERROR_INSUFFICIENT_BUFFER.0+ } else {+ *size = 8;+ NO_ERROR.0+ }+ })+ .unwrap_err();+ assert!(oversized.message.contains("oversized TCP owner table"));+ }++ #[test]+ fn native_owner_table_observes_a_real_loopback_listener() {+ let listener = std::net::TcpListener::bind((Ipv4Addr::LOCALHOST, 0)).unwrap();+ let port = listener.local_addr().unwrap().port();+ let pid = std::process::id();++ let listeners = windows_loopback_listeners(&[pid]).unwrap();+ assert!(+ listeners.contains(&(port, pid)),+ "native owner table did not report current-process listener {port}: {listeners:?}"+ );+ }+#[test]fn process_tree_endpoint_uses_the_authorized_root_and_retains_listener_evidence() {let endpoint = owned_endpoint_from_listener(