Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Use bounded fallback ports for Windows managed proxies (#38265)

chess631bbb33cc0b
diff --git a/codex-rs/network-proxy/README.md b/codex-rs/network-proxy/README.md
index 65929c8682..402585108d 100644
--- a/codex-rs/network-proxy/README.md
+++ b/codex-rs/network-proxy/README.md
@@ -5,6 +5,10 @@
- an HTTP proxy (default `127.0.0.1:3128`)
- a SOCKS5 proxy (default `127.0.0.1:8081`, enabled by default)
+On Windows, managed HTTP listeners prefer ports `3128-3159`, and SOCKS5 listeners prefer ports
+`8081-8112`. An explicitly configured port is attempted first. If every preferred port is occupied,
+the proxy preserves its existing ephemeral loopback fallback.
+
It enforces an allow/deny policy and a "limited" mode intended for read-only network access.
## Quickstart
diff --git a/codex-rs/network-proxy/src/proxy.rs b/codex-rs/network-proxy/src/proxy.rs
index dfdfc788b8..6577259405 100644
--- a/codex-rs/network-proxy/src/proxy.rs
+++ b/codex-rs/network-proxy/src/proxy.rs
@@ -30,6 +30,8 @@ use serde::Serialize;
use std::collections::HashMap;
use std::net::SocketAddr;
use std::net::TcpListener as StdTcpListener;
+#[cfg(target_os = "windows")]
+use std::ops::RangeInclusive;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::RwLock;
@@ -38,6 +40,11 @@ use tracing::warn;
use self::execution_scope::ExecutionScope;
+#[cfg(target_os = "windows")]
+const WINDOWS_MANAGED_HTTP_PROXY_PORTS: RangeInclusive<u16> = 3128..=3159;
+#[cfg(target_os = "windows")]
+const WINDOWS_MANAGED_SOCKS_PROXY_PORTS: RangeInclusive<u16> = 8081..=8112;
+
#[derive(Debug, Clone, Parser)]
#[command(name = "codex-network-proxy", about = "Codex network sandbox proxy")]
pub struct Args {}
@@ -317,49 +324,75 @@ pub(super) fn reserve_windows_managed_listeners(
) -> Result<ReservedListenerSet> {
let http_addr = windows_managed_loopback_addr(http_addr);
let socks_addr = windows_managed_loopback_addr(socks_addr);
-
- match try_reserve_windows_managed_listeners(http_addr, socks_addr, reserve_socks_listener) {
- Ok(listeners) => Ok(listeners),
- Err(err) if err.kind() == std::io::ErrorKind::AddrInUse => {
- warn!("managed Windows proxy ports are busy; falling back to ephemeral loopback ports");
- reserve_loopback_ephemeral_listeners(reserve_socks_listener)
- .context("reserve fallback loopback proxy listeners")
- }
- Err(err) => Err(err).context("reserve Windows managed proxy listeners"),
- }
+ let http_listener =
+ reserve_windows_managed_listener(http_addr, WINDOWS_MANAGED_HTTP_PROXY_PORTS, "HTTP")?;
+ let socks_listener = if reserve_socks_listener {
+ Some(reserve_windows_managed_listener(
+ socks_addr,
+ WINDOWS_MANAGED_SOCKS_PROXY_PORTS,
+ "SOCKS5",
+ )?)
+ } else {
+ None
+ };
+ Ok(ReservedListenerSet::new(http_listener, socks_listener))
}
#[cfg(target_os = "windows")]
pub(super) fn reserve_windows_managed_socks_listener(
socks_addr: SocketAddr,
) -> Result<StdTcpListener> {
- let socks_addr = windows_managed_loopback_addr(socks_addr);
- match StdTcpListener::bind(socks_addr) {
- Ok(listener) => Ok(listener),
- Err(err) if err.kind() == std::io::ErrorKind::AddrInUse => {
- warn!(
- "managed Windows SOCKS5 proxy port is busy; falling back to an ephemeral loopback port"
- );
- reserve_loopback_ephemeral_listener()
- .context("reserve fallback loopback SOCKS5 proxy listener")
- }
- Err(err) => Err(err).context("reserve Windows managed SOCKS5 proxy listener"),
- }
+ reserve_windows_managed_listener(
+ windows_managed_loopback_addr(socks_addr),
+ WINDOWS_MANAGED_SOCKS_PROXY_PORTS,
+ "SOCKS5",
+ )
}
#[cfg(target_os = "windows")]
-fn try_reserve_windows_managed_listeners(
- http_addr: SocketAddr,
- socks_addr: SocketAddr,
- reserve_socks_listener: bool,
-) -> std::io::Result<ReservedListenerSet> {
- let http_listener = StdTcpListener::bind(http_addr)?;
- let socks_listener = if reserve_socks_listener {
- Some(StdTcpListener::bind(socks_addr)?)
- } else {
- None
- };
- Ok(ReservedListenerSet::new(http_listener, socks_listener))
+fn reserve_windows_managed_listener(
+ requested_addr: SocketAddr,
+ ports: RangeInclusive<u16>,
+ protocol: &str,
+) -> Result<StdTcpListener> {
+ let requested_port = requested_addr.port();
+ anyhow::ensure!(
+ requested_port != 0,
+ "managed Windows {protocol} proxy must use a fixed non-zero port"
+ );
+ let start = *ports.start();
+ let end = *ports.end();
+
+ for port in std::iter::once(requested_port).chain(ports.filter(|port| *port != requested_port))
+ {
+ let addr = SocketAddr::new(requested_addr.ip(), port);
+ match StdTcpListener::bind(addr) {
+ Ok(listener) => {
+ if port != requested_port {
+ warn!(
+ "managed Windows {protocol} proxy port {requested_port} is unavailable; using bounded fallback port {port}"
+ );
+ }
+ return Ok(listener);
+ }
+ Err(err)
+ if matches!(
+ err.kind(),
+ std::io::ErrorKind::AddrInUse | std::io::ErrorKind::PermissionDenied
+ ) => {}
+ Err(err) => {
+ return Err(err).with_context(|| {
+ format!("reserve managed Windows {protocol} proxy listener on {addr}")
+ });
+ }
+ }
+ }
+
+ warn!(
+ "managed Windows {protocol} proxy port {requested_port} and preferred ports {start}-{end} are unavailable; falling back to an ephemeral loopback port"
+ );
+ reserve_loopback_ephemeral_listener()
+ .with_context(|| format!("reserve fallback loopback Windows {protocol} proxy listener"))
}
#[cfg(target_os = "windows")]
@@ -2167,6 +2200,7 @@ mod tests {
assert_eq!(socks_proxy.http_addr(), proxy.http_addr());
assert!(actual_socks_addr.ip().is_loopback());
assert_ne!(actual_socks_addr, requested_socks_addr);
+ assert!(WINDOWS_MANAGED_SOCKS_PROXY_PORTS.contains(&actual_socks_addr.port()));
assert_eq!(proxy.socks_addr(), actual_socks_addr);
let socks_handle = socks_proxy
.run()
@@ -2279,12 +2313,55 @@ mod tests {
.ip()
.is_loopback()
);
- assert_ne!(
- reserved.http_listener.local_addr().unwrap().port(),
- busy_port
+ let fallback_port = reserved.http_listener.local_addr().unwrap().port();
+ assert_ne!(fallback_port, busy_port);
+ assert!(WINDOWS_MANAGED_HTTP_PROXY_PORTS.contains(&fallback_port));
+ }
+
+ #[cfg(target_os = "windows")]
+ #[test]
+ fn reserve_windows_managed_listeners_preserves_http_when_socks_port_is_busy() {
+ let http_listener = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
+ let http_addr = http_listener.local_addr().unwrap();
+ drop(http_listener);
+ let occupied_socks = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
+
+ let reserved = reserve_windows_managed_listeners(
+ http_addr,
+ occupied_socks.local_addr().unwrap(),
+ /*reserve_socks_listener*/ true,
+ )
+ .unwrap();
+
+ assert_eq!(reserved.http_listener.local_addr().unwrap(), http_addr);
+ assert!(
+ WINDOWS_MANAGED_SOCKS_PROXY_PORTS.contains(
+ &reserved
+ .socks_listener
+ .unwrap()
+ .local_addr()
+ .unwrap()
+ .port()
+ )
);
}
+ #[cfg(target_os = "windows")]
+ #[test]
+ fn reserve_windows_managed_listener_uses_ephemeral_port_when_preferred_ports_are_busy() {
+ let occupied = StdTcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0))).unwrap();
+ let occupied_addr = occupied.local_addr().unwrap();
+ let occupied_port = occupied_addr.port();
+
+ let listener =
+ reserve_windows_managed_listener(occupied_addr, occupied_port..=occupied_port, "HTTP")
+ .unwrap();
+
+ let fallback_addr = listener.local_addr().unwrap();
+ assert!(fallback_addr.ip().is_loopback());
+ assert_ne!(fallback_addr.port(), occupied_port);
+ }
+
#[test]
fn proxy_url_env_value_resolves_lowercase_aliases() {
let mut env = HashMap::new();