Lightweight coding agent that runs in your terminal
Rust
Add a hidden HTTP/3 TCP tunnel command (#45900)
richardopenai2aff7208fe95
diff --git a/MODULE.bazel.lock b/MODULE.bazel.lockindex 55bde0a88c..bd2e8f7316 100644--- a/MODULE.bazel.lock+++ b/MODULE.bazel.lock@@ -1084,6 +1084,8 @@"git+https://github.com/dzbarsky/rules_rust?rev=b56cbaa8465e74127f1ea216f813cd377295ad81#b56cbaa8465e74127f1ea216f813cd377295ad81_runfiles": "{\"dependencies\":[],\"features\":{},\"strip_prefix\":\"\"}","git+https://github.com/helix-editor/nucleo.git?rev=4253de9faabb4e5c6d81d946a5e35a90f87347ee#4253de9faabb4e5c6d81d946a5e35a90f87347ee_nucleo": "{\"dependencies\":[{\"default_features\":true,\"features\":[],\"name\":\"nucleo-matcher\",\"optional\":false},{\"default_features\":true,\"features\":[\"send_guard\",\"arc_lock\"],\"name\":\"parking_lot\",\"optional\":false},{\"name\":\"rayon\"}],\"features\":{},\"strip_prefix\":\"\"}","git+https://github.com/helix-editor/nucleo.git?rev=4253de9faabb4e5c6d81d946a5e35a90f87347ee#4253de9faabb4e5c6d81d946a5e35a90f87347ee_nucleo-matcher": "{\"dependencies\":[{\"name\":\"memchr\"},{\"default_features\":true,\"features\":[],\"name\":\"unicode-segmentation\",\"optional\":true}],\"features\":{\"default\":[\"unicode-normalization\",\"unicode-casefold\",\"unicode-segmentation\"],\"unicode-casefold\":[],\"unicode-normalization\":[],\"unicode-segmentation\":[\"dep:unicode-segmentation\"]},\"strip_prefix\":\"matcher\"}",+ "git+https://github.com/hyperium/h3?rev=e07e69412876f7e26f026bd75a48b2704d8c8283#e07e69412876f7e26f026bd75a48b2704d8c8283_h3": "{\"dependencies\":[{\"name\":\"bytes\",\"req\":\"1\"},{\"name\":\"fastrand\",\"req\":\"2.0.1\"},{\"default_features\":false,\"features\":[\"io\"],\"name\":\"futures-util\",\"optional\":false,\"req\":\"0.3\"},{\"name\":\"http\",\"req\":\"1\"},{\"default_features\":false,\"features\":[],\"name\":\"pin-project-lite\",\"optional\":false,\"req\":\"0.2\"},{\"default_features\":true,\"features\":[\"sync\"],\"name\":\"tokio\",\"optional\":false,\"req\":\"1\"},{\"default_features\":true,\"features\":[],\"name\":\"tracing\",\"optional\":true,\"req\":\"0.1.40\"}],\"features\":{\"i-implement-a-third-party-backend-and-opt-into-breaking-changes\":[],\"tracing\":[\"dep:tracing\"]},\"strip_prefix\":\"h3\"}",+ "git+https://github.com/hyperium/h3?rev=e07e69412876f7e26f026bd75a48b2704d8c8283#e07e69412876f7e26f026bd75a48b2704d8c8283_h3-quinn": "{\"dependencies\":[{\"name\":\"bytes\",\"req\":\"1\"},{\"default_features\":true,\"features\":[],\"name\":\"futures\",\"optional\":false,\"req\":\"0.3.28\"},{\"default_features\":true,\"features\":[],\"name\":\"h3\",\"optional\":false,\"req\":\"0.0.8\"},{\"default_features\":true,\"features\":[],\"name\":\"h3-datagram\",\"optional\":true,\"req\":\"0.0.2\"},{\"default_features\":false,\"features\":[\"futures-io\"],\"name\":\"quinn\",\"optional\":false,\"req\":\"0.11.7\"},{\"default_features\":false,\"features\":[\"io-util\"],\"name\":\"tokio\",\"optional\":false,\"req\":\"1\"},{\"default_features\":true,\"features\":[],\"name\":\"tokio-util\",\"optional\":false,\"req\":\"0.7.9\"},{\"default_features\":true,\"features\":[],\"name\":\"tracing\",\"optional\":true,\"req\":\"0.1.40\"}],\"features\":{\"datagram\":[\"dep:h3-datagram\"],\"tracing\":[\"dep:tracing\"]},\"strip_prefix\":\"h3-quinn\"}","git+https://github.com/microsoft/mxc?rev=6cd3d58f05d3447e67109cfb75e042803b843ca4#6cd3d58f05d3447e67109cfb75e042803b843ca4_appcontainer_common": "{\"dependencies\":[{\"name\":\"getrandom\",\"req\":\"0.2\"},{\"default_features\":true,\"features\":[\"derive\"],\"name\":\"serde\",\"optional\":false,\"req\":\"1\"},{\"name\":\"serde_json\",\"req\":\"1\"},{\"name\":\"thiserror\",\"req\":\"2\"},{\"default_features\":true,\"features\":[],\"name\":\"wxc_common\",\"optional\":false},{\"name\":\"flatbuffers\",\"req\":\"25\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[],\"name\":\"learning_mode_core\",\"optional\":false,\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[],\"name\":\"learning_mode_windows\",\"optional\":false,\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[],\"name\":\"process_security_environment_spec\",\"optional\":false,\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[],\"name\":\"sandbox_spec\",\"optional\":false,\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"name\":\"widestring\",\"req\":\"1\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[\"Win32_Foundation\",\"Win32_Networking_WinSock\",\"Win32_NetworkManagement_WindowsFirewall\",\"Win32_Security\",\"Win32_Security_Authorization\",\"Win32_Security_Credentials\",\"Win32_Security_Isolation\",\"Win32_Storage_FileSystem\",\"Win32_System_Com\",\"Win32_System_Console\",\"Win32_System_Diagnostics_Debug\",\"Win32_System_Diagnostics_Etw\",\"Win32_System_Diagnostics_ToolHelp\",\"Win32_System_Environment\",\"Win32_System_IO\",\"Win32_System_JobObjects\",\"Win32_System_LibraryLoader\",\"Win32_System_Memory\",\"Win32_System_Ole\",\"Win32_System_Pipes\",\"Win32_System_ProcessStatus\",\"Win32_System_Registry\",\"Win32_System_SystemInformation\",\"Win32_System_SystemServices\",\"Win32_System_Threading\",\"Win32_System_Time\",\"Win32_System_Variant\",\"Win32_System_WindowsProgramming\",\"Win32_UI_Shell\"],\"name\":\"windows\",\"optional\":false,\"req\":\"0.62\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"name\":\"windows-core\",\"req\":\"0.62\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"name\":\"winreg\",\"req\":\"0.55\",\"target\":\"cfg(target_os = \\\"windows\\\")\"}],\"features\":{\"tier2_bfs\":[]},\"strip_prefix\":\"backends/appcontainer/common\"}","git+https://github.com/microsoft/mxc?rev=6cd3d58f05d3447e67109cfb75e042803b843ca4#6cd3d58f05d3447e67109cfb75e042803b843ca4_learning_mode_core": "{\"dependencies\":[{\"name\":\"same-file\",\"req\":\"1\"},{\"default_features\":true,\"features\":[\"derive\"],\"name\":\"serde\",\"optional\":false,\"req\":\"1\"},{\"name\":\"serde_json\",\"req\":\"1\"},{\"name\":\"sha2\",\"req\":\"0.10\"},{\"name\":\"tempfile\",\"req\":\"3\"},{\"name\":\"thiserror\",\"req\":\"2\"}],\"features\":{},\"strip_prefix\":\"core/learning_mode_core\"}","git+https://github.com/microsoft/mxc?rev=6cd3d58f05d3447e67109cfb75e042803b843ca4#6cd3d58f05d3447e67109cfb75e042803b843ca4_learning_mode_windows": "{\"dependencies\":[{\"default_features\":true,\"features\":[],\"name\":\"learning_mode_core\",\"optional\":false},{\"name\":\"thiserror\",\"req\":\"2\"},{\"name\":\"sha2\",\"req\":\"0.10\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[\"Win32_Foundation\",\"Win32_Networking_WinSock\",\"Win32_NetworkManagement_WindowsFirewall\",\"Win32_Security\",\"Win32_Security_Authorization\",\"Win32_Security_Credentials\",\"Win32_Security_Isolation\",\"Win32_Storage_FileSystem\",\"Win32_System_Com\",\"Win32_System_Console\",\"Win32_System_Diagnostics_Debug\",\"Win32_System_Diagnostics_Etw\",\"Win32_System_Diagnostics_ToolHelp\",\"Win32_System_Environment\",\"Win32_System_IO\",\"Win32_System_JobObjects\",\"Win32_System_LibraryLoader\",\"Win32_System_Memory\",\"Win32_System_Ole\",\"Win32_System_Pipes\",\"Win32_System_ProcessStatus\",\"Win32_System_Registry\",\"Win32_System_SystemInformation\",\"Win32_System_SystemServices\",\"Win32_System_Threading\",\"Win32_System_Time\",\"Win32_System_Variant\",\"Win32_System_WindowsProgramming\",\"Win32_UI_Shell\"],\"name\":\"windows\",\"optional\":false,\"req\":\"0.62\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"name\":\"windows-core\",\"req\":\"0.62\",\"target\":\"cfg(target_os = \\\"windows\\\")\"},{\"default_features\":true,\"features\":[],\"name\":\"wxc_common\",\"optional\":false,\"target\":\"cfg(target_os = \\\"windows\\\")\"}],\"features\":{},\"strip_prefix\":\"backends/learning_mode/windows\"}",diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex 757328f641..d2f5babd5b 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -2628,6 +2628,7 @@ dependencies = ["codex-skills-extension","codex-state","codex-stdio-to-uds",+ "codex-tcp-tunnel","codex-terminal-detection","codex-thread-store","codex-tui",@@ -4634,6 +4635,27 @@ dependencies = ["tokio",]+[[package]]+name = "codex-tcp-tunnel"+version = "0.0.0"+dependencies = [+ "anyhow",+ "bytes",+ "clap",+ "h3",+ "h3-quinn",+ "http 1.4.0",+ "pretty_assertions",+ "quinn",+ "rand 0.9.3",+ "rcgen",+ "rustls",+ "rustls-native-certs",+ "serde_json",+ "tokio",+ "url",+]+[[package]]name = "codex-terminal-detection"version = "0.0.0"@@ -8468,6 +8490,32 @@ dependencies = ["tracing",]+[[package]]+name = "h3"+version = "0.0.8"+source = "git+https://github.com/hyperium/h3?rev=e07e69412876f7e26f026bd75a48b2704d8c8283#e07e69412876f7e26f026bd75a48b2704d8c8283"+dependencies = [+ "bytes",+ "fastrand",+ "futures-util",+ "http 1.4.0",+ "pin-project-lite",+ "tokio",+]++[[package]]+name = "h3-quinn"+version = "0.0.10"+source = "git+https://github.com/hyperium/h3?rev=e07e69412876f7e26f026bd75a48b2704d8c8283#e07e69412876f7e26f026bd75a48b2704d8c8283"+dependencies = [+ "bytes",+ "futures",+ "h3",+ "quinn",+ "tokio",+ "tokio-util",+]+[[package]]name = "half"version = "2.7.1"@@ -12045,6 +12093,7 @@ checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"dependencies = ["bytes","cfg_aliases 0.2.1",+ "futures-io","pin-project-lite","quinn-proto","quinn-udp 0.5.14",diff --git a/codex-rs/Cargo.toml b/codex-rs/Cargo.tomlindex f4ecb1ce04..5963eaba18 100644--- a/codex-rs/Cargo.toml+++ b/codex-rs/Cargo.toml@@ -102,6 +102,7 @@ members = ["stdio-to-uds","otel","otel-trace-websocket",+ "tcp-tunnel","tui","user-verification","tools",@@ -271,6 +272,7 @@ codex-terminal-detection = { path = "terminal-detection" }codex-test-binary-support = { path = "test-binary-support" }codex-thread-store = { path = "thread-store" }codex-tools = { path = "tools" }+codex-tcp-tunnel = { path = "tcp-tunnel" }codex-tui = { path = "tui" }codex-uds = { path = "uds" }codex-utils-absolute-path = { path = "utils/absolute-path" }diff --git a/codex-rs/cli/Cargo.toml b/codex-rs/cli/Cargo.tomlindex 8668aee897..51181994e5 100644--- a/codex-rs/cli/Cargo.toml+++ b/codex-rs/cli/Cargo.toml@@ -61,6 +61,7 @@ codex-models-manager = { workspace = true }codex-plugin = { workspace = true }codex-protocol = { workspace = true }codex-responses-api-proxy = { workspace = true }+codex-tcp-tunnel = { workspace = true }codex-rmcp-client = { workspace = true }codex-rollout = { workspace = true }codex-rollout-trace = { workspace = true }diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rsindex 39048c90f6..339ab94573 100644--- a/codex-rs/cli/src/main.rs+++ b/codex-rs/cli/src/main.rs@@ -150,6 +150,9 @@ enum Subcommand {/// Browse all agent sessions on the shared local app-server daemon.Agents(AgentsCommand),+ /// Internal: forward a local TCP socket through an HTTP/3 CONNECT proxy.+ #[clap(hide = true)]+ TcpTunnel(codex_tcp_tunnel::Args),/// Run Codex non-interactively.#[clap(visible_alias = "e")]Exec(ExecCli),@@ -1276,6 +1279,9 @@ async fn cli_main(.await?;handle_app_exit(exit_info, daemon_cli_executable.as_deref())?;}+ Some(Subcommand::TcpTunnel(args)) => {+ return codex_tcp_tunnel::run(args).await;+ }Some(Subcommand::Exec(mut exec_cli)) => {reject_remote_mode_for_subcommand(root_remote.as_deref(),@@ -2674,6 +2680,7 @@ fn unsupported_subcommand_name_for_strict_config(Some(Subcommand::ResponsesApiProxy(_)) => Some("responses-api-proxy"),Some(Subcommand::StdioToUds(_)) => Some("stdio-to-uds"),Some(Subcommand::Features(_)) => Some("features"),+ Some(Subcommand::TcpTunnel(_)) => Some("tcp-tunnel"),}}@@ -3780,6 +3787,36 @@ mod tests {err.to_string()}+ #[test]+ fn tcp_tunnel_is_hidden_and_accepts_its_control_input_contract() {+ let root_help = help_from_args(&["codex", "--help"]);+ assert!(!root_help.contains("tcp-tunnel"), "{root_help}");+ let help = help_from_args(&["codex", "tcp-tunnel", "--help"]);+ for option in [+ "--target",+ "--auth-token-stdin",+ "--auth-token-updates-stdin",+ "--connect-headers-stdin",+ ] {+ assert!(help.contains(option), "{help}");+ }+ let cli = MultitoolCli::try_parse_from([+ "codex",+ "tcp-tunnel",+ "--proxy-url",+ "https://proxy.example.org",+ "--proxy-origins-file",+ "/tmp/approved-origins",+ "--target",+ "[::1]:22",+ "--auth-token-stdin",+ "--auth-token-updates-stdin",+ "--connect-headers-stdin",+ ])+ .expect("generic tunnel should parse");+ assert!(matches!(cli.subcommand, Some(Subcommand::TcpTunnel(_))));+ }+#[test]fn plugin_marketplace_help_uses_plugin_namespace() {let help = help_from_args(&["codex", "plugin", "marketplace", "--help"]);diff --git a/codex-rs/tcp-tunnel/BUILD.bazel b/codex-rs/tcp-tunnel/BUILD.bazelnew file mode 100644index 0000000000..4cab3ab94f--- /dev/null+++ b/codex-rs/tcp-tunnel/BUILD.bazel@@ -0,0 +1,6 @@+load("//:defs.bzl", "codex_rust_crate")++codex_rust_crate(+ name = "tcp-tunnel",+ crate_name = "codex_tcp_tunnel",+)diff --git a/codex-rs/tcp-tunnel/Cargo.toml b/codex-rs/tcp-tunnel/Cargo.tomlnew file mode 100644index 0000000000..617ed7e067--- /dev/null+++ b/codex-rs/tcp-tunnel/Cargo.toml@@ -0,0 +1,30 @@+[package]+name = "codex-tcp-tunnel"+version.workspace = true+edition.workspace = true+license.workspace = true++[lib]+doctest = false++[dependencies]+anyhow = { workspace = true }+bytes = { workspace = true }+clap = { workspace = true, features = ["derive"] }+h3 = { git = "https://github.com/hyperium/h3", rev = "e07e69412876f7e26f026bd75a48b2704d8c8283" }+h3-quinn = { git = "https://github.com/hyperium/h3", rev = "e07e69412876f7e26f026bd75a48b2704d8c8283" }+http = { workspace = true }+quinn = { version = "0.11", default-features = false, features = ["runtime-tokio", "rustls-ring"] }+rand = { workspace = true }+rustls = { workspace = true, features = ["ring", "std"] }+rustls-native-certs = { workspace = true }+serde_json = { workspace = true }+tokio = { workspace = true, features = ["io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }+url = { workspace = true }++[dev-dependencies]+pretty_assertions = { workspace = true }+rcgen = { workspace = true }++[lints]+workspace = truediff --git a/codex-rs/tcp-tunnel/README.md b/codex-rs/tcp-tunnel/README.mdnew file mode 100644index 0000000000..0e49499f05--- /dev/null+++ b/codex-rs/tcp-tunnel/README.md@@ -0,0 +1,7 @@+# HTTP/3 TCP tunnel++The ordinary Codex binary includes the hidden `codex tcp-tunnel` command. It forwards a loopback TCP listener to an explicitly selected host and port through a TLS-verified HTTP/3 CONNECT proxy. The proxy URL must be an exact HTTPS origin in the supplied policy file; the target is provided separately as `host:port` or `[IPv6]:port`.++The initial bearer must be provided as a single line on standard input (`--auth-token-stdin`). With `--auth-token-updates-stdin`, later lines replace the bearer for new connections, emit `AUTH_UPDATED`, and closure of the controlling pipe stops the tunnel. With `--connect-headers-stdin`, the first line is instead a JSON list of `["x-name","value"]` pairs; token lines follow. Only non-forwarding `x-` extension headers are accepted. No header values or credentials belong in the command arguments.++The process emits `LISTENING 127.0.0.1:<port>` after connecting to the proxy. A proxy handshake does not authorize the target; each local connection makes its own authenticated CONNECT. The listener survives transport reconnects, but TCP streams are never replayed.diff --git a/codex-rs/tcp-tunnel/src/control.rs b/codex-rs/tcp-tunnel/src/control.rsnew file mode 100644index 0000000000..801658aa59--- /dev/null+++ b/codex-rs/tcp-tunnel/src/control.rs@@ -0,0 +1,77 @@+//! Bounded parsing of HTTP/3 CONNECT metadata and bearer input.+//! Extension values remain sensitive and may never replace authorization or forwarding headers.+use std::io::BufRead;++use anyhow::Context;+use anyhow::Result;+use anyhow::anyhow;+use anyhow::ensure;+use http::HeaderMap;+use http::HeaderValue;+use http::header;++pub(super) const MAX_TOKEN_BYTES: usize = 64 * 1024;+pub(super) const MAX_CONNECT_METADATA_BYTES: usize = 16 * 1024;+pub(super) const MAX_CONNECT_HEADERS: usize = 16;+pub(super) const MAX_CONNECT_HEADER_VALUE_BYTES: usize = 4 * 1024;++pub(super) fn read_connect_headers(reader: &mut impl BufRead) -> Result<HeaderMap> {+ let mut line = Vec::new();+ std::io::Read::take(&mut *reader, (MAX_CONNECT_METADATA_BYTES + 1) as u64)+ .read_until(b'\n', &mut line)+ .context("reading CONNECT metadata")?;+ ensure!(+ !line.is_empty() && line.len() <= MAX_CONNECT_METADATA_BYTES && line.ends_with(b"\n"),+ "invalid or oversized CONNECT metadata"+ );+ let pairs: Vec<(String, String)> =+ serde_json::from_slice(&line).map_err(|_| anyhow!("invalid CONNECT metadata"))?;+ ensure!(+ pairs.len() <= MAX_CONNECT_HEADERS,+ "too many CONNECT metadata headers"+ );+ let mut headers = HeaderMap::new();+ for (name, value) in pairs {+ let name = header::HeaderName::from_bytes(name.as_bytes())+ .map_err(|_| anyhow!("invalid CONNECT metadata header name"))?;+ ensure!(+ !headers.contains_key(&name),+ "duplicate CONNECT metadata header"+ );+ let extension = name.as_str();+ ensure!(+ extension.starts_with("x-")+ && !extension.starts_with("x-forwarded-")+ && extension != "x-real-ip",+ "CONNECT metadata must use non-forwarding extension headers"+ );+ let mut value = HeaderValue::from_str(&value)+ .map_err(|_| anyhow!("invalid CONNECT metadata header value"))?;+ ensure!(+ value.as_bytes().len() <= MAX_CONNECT_HEADER_VALUE_BYTES,+ "CONNECT metadata header value is too long"+ );+ value.set_sensitive(true);+ headers.insert(name, value);+ }+ Ok(headers)+}++pub(super) fn read_auth_token(reader: &mut impl BufRead) -> Result<Option<HeaderValue>> {+ let mut line = Vec::new();+ std::io::Read::take(&mut *reader, (MAX_TOKEN_BYTES + 1) as u64)+ .read_until(b'\n', &mut line)+ .context("reading MASQUE token")?;+ if line.is_empty() {+ return Ok(None);+ }+ ensure!(line.len() <= MAX_TOKEN_BYTES, "MASQUE token is too long");+ let token = std::str::from_utf8(&line)+ .context("invalid MASQUE token encoding")?+ .trim();+ ensure!(!token.is_empty(), "empty MASQUE token");+ let mut auth =+ HeaderValue::from_str(&format!("Bearer {token}")).context("invalid MASQUE token header")?;+ auth.set_sensitive(true);+ Ok(Some(auth))+}diff --git a/codex-rs/tcp-tunnel/src/lib.rs b/codex-rs/tcp-tunnel/src/lib.rsnew file mode 100644index 0000000000..2908a504fd--- /dev/null+++ b/codex-rs/tcp-tunnel/src/lib.rs@@ -0,0 +1,483 @@+//! Loopback TCP forwarding through an HTTP/3 CONNECT proxy.+//! Bearer credentials and optional proxy-specific metadata enter only via stdin.+//! The listener survives transport loss; individual TCP streams are never replayed.+use std::io::BufRead;+use std::io::Write;+use std::net::IpAddr;+use std::net::SocketAddr;+use std::path::PathBuf;+use std::sync::Arc;+use std::time::Duration;++use anyhow::Context;+use anyhow::Result;+use anyhow::anyhow;+use anyhow::bail;+use anyhow::ensure;+use bytes::Buf;+use bytes::Bytes;+use clap::Args as ClapArgs;+use http::HeaderMap;+use http::HeaderValue;+use http::Method;+use http::Request;+use http::Uri;+use http::header;+use http::uri::Authority;+use quinn::crypto::rustls::QuicClientConfig;+use tokio::io::AsyncReadExt;+use tokio::io::AsyncWriteExt;+use tokio::net::TcpListener;+use tokio::net::TcpStream;+use tokio::sync::mpsc;+use tokio::sync::oneshot;+use tokio::sync::watch;+use url::Host;+use url::Url;++mod control;++use control::read_auth_token;+use control::read_connect_headers;++const PROXY_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);++#[derive(Debug, ClapArgs)]+pub struct Args {+ /// HTTPS origin of the HTTP/3 proxy.+ #[arg(long)]+ proxy_url: Url,+ /// File containing one exact approved HTTPS proxy origin per line.+ #[arg(long)]+ proxy_origins_file: PathBuf,+ /// CONNECT target authority, including a nonzero port.+ #[arg(long)]+ target: String,+ #[arg(long, default_value = "127.0.0.1:0")]+ listen_addr: SocketAddr,+ /// Read the initial bearer from stdin.+ #[arg(long, default_value_t = false)]+ auth_token_stdin: bool,+ /// Read replacement bearers from stdin and stop when the controlling pipe closes.+ #[arg(long, requires = "auth_token_stdin")]+ auth_token_updates_stdin: bool,+ /// Read a JSON list of extension-header name/value pairs before the first bearer.+ #[arg(long, requires = "auth_token_stdin")]+ connect_headers_stdin: bool,+}++#[derive(Debug, PartialEq, Eq)]+struct ProxyTarget {+ host: String,+ port: u16,+ authority: String,+}++struct TunnelHeaders {+ auth: watch::Receiver<HeaderValue>,+ connect: HeaderMap,+}++struct ProxyConnection {+ endpoint: quinn::Endpoint,+ quic: quinn::Connection,+ connection: h3::client::Connection<h3_quinn::Connection, Bytes>,+ sender: h3::client::SendRequest<h3_quinn::OpenStreams, Bytes>,+}++enum ProxyClosure {+ Draining,+ Closed(anyhow::Error),+}++impl ProxyTarget {+ fn parse(proxy_url: &Url, trusted_origins: &[String], target: &str) -> Result<Self> {+ ensure!(proxy_url.scheme() == "https", "proxy URL must use HTTPS");+ ensure!(+ proxy_url.username().is_empty()+ && proxy_url.password().is_none()+ && proxy_url.query().is_none()+ && proxy_url.fragment().is_none()+ && proxy_url.path() == "/",+ "proxy URL must be an HTTPS origin"+ );+ ensure!(+ trusted_origins.contains(&proxy_url.origin().ascii_serialization()),+ "proxy URL origin is not trusted"+ );+ let host = match proxy_url.host().context("proxy URL has no host")? {+ Host::Domain(host) => host.to_owned(),+ Host::Ipv4(address) => address.to_string(),+ Host::Ipv6(address) => address.to_string(),+ };+ ensure!(+ !target.contains('@'),+ "CONNECT target must not contain credentials"+ );+ let authority: Authority = target.parse().context("invalid CONNECT target")?;+ ensure!(+ !authority.host().is_empty() && authority.port_u16().is_some_and(|port| port != 0),+ "CONNECT target must include a nonzero port"+ );+ Ok(Self {+ host,+ port: proxy_url.port_or_known_default().unwrap_or(443),+ authority: authority.to_string(),+ })+ }+}++fn parse_trusted_origins(origins: &str) -> Result<Vec<String>> {+ let trusted_origins = origins+ .lines()+ .map(str::trim)+ .filter(|line| !line.is_empty())+ .map(|line| {+ let origin = Url::parse(line).context("invalid trusted proxy origin")?;+ ensure!(+ origin.scheme() == "https"+ && origin.username().is_empty()+ && origin.password().is_none()+ && origin.query().is_none()+ && origin.fragment().is_none()+ && origin.path() == "/"+ && line == origin.origin().ascii_serialization(),+ "trusted proxy origins must be exact HTTPS origins"+ );+ Ok(line.to_owned())+ })+ .collect::<Result<Vec<_>>>()?;+ ensure!(!trusted_origins.is_empty(), "no trusted proxy origins");+ Ok(trusted_origins)+}++#[cfg(test)]+#[path = "lib_tests.rs"]+mod tests;++pub async fn run(args: Args) -> Result<()> {+ ensure!(args.auth_token_stdin, "--auth-token-stdin is required");+ ensure!(+ args.listen_addr.ip().is_loopback(),+ "listener must be loopback"+ );+ let origins = std::fs::read_to_string(&args.proxy_origins_file)+ .context("reading trusted proxy origins")?;+ let trusted_origins = parse_trusted_origins(&origins)?;+ let target = ProxyTarget::parse(&args.proxy_url, &trusted_origins, &args.target)?;+ let (metadata, mut tokens) = control_input(+ std::io::BufReader::new(std::io::stdin()),+ args.connect_headers_stdin,+ )?;+ let connect = metadata.await.context("CONNECT metadata input closed")??;+ let initial_auth = tokens+ .recv()+ .await+ .context("MASQUE credential input closed")??+ .context("empty MASQUE token")?;+ let (updates, auth) = watch::channel(initial_auth);+ let headers = TunnelHeaders { auth, connect };++ let listener = TcpListener::bind(args.listen_addr)+ .await+ .context("binding loopback listener")?;+ let native = rustls_native_certs::load_native_certs();+ let mut roots = rustls::RootCertStore::empty();+ roots.add_parsable_certificates(native.certs);+ ensure!(+ !roots.is_empty(),+ "no native TLS roots: {:?}",+ native.errors+ );+ let mut tls = rustls::ClientConfig::builder_with_provider(Arc::new(+ rustls::crypto::ring::default_provider(),+ ))+ .with_safe_default_protocol_versions()?+ .with_root_certificates(roots)+ .with_no_client_auth();+ tls.alpn_protocols = vec![b"h3".to_vec()];+ let mut config = quinn::ClientConfig::new(Arc::new(QuicClientConfig::try_from(tls)?));+ let mut transport = quinn::TransportConfig::default();+ transport.max_idle_timeout(Some(Duration::from_secs(30).try_into()?));+ transport.keep_alive_interval(Some(Duration::from_secs(10)));+ config.transport_config(Arc::new(transport));+ let (ready, readiness) = oneshot::channel();+ let tunnel = async move {+ let connected = ProxyConnection::connect(&target, &config).await?;+ // The line is the caller readiness contract, including the assigned port.+ writeln!(std::io::stdout(), "LISTENING {}", listener.local_addr()?)?;+ std::io::stdout().flush()?;+ let _ = ready.send(());+ serve(listener, target, config, headers, connected).await+ };+ if args.auth_token_updates_stdin {+ tokio::select! {+ result = tunnel => result,+ result = update_auth_tokens(&mut tokens, updates, readiness, std::io::stdout()) => result,+ }+ } else {+ tunnel.await+ }+}++type TokenStream = mpsc::Receiver<Result<Option<HeaderValue>>>;++async fn update_auth_tokens(+ tokens: &mut TokenStream,+ updates: watch::Sender<HeaderValue>,+ readiness: oneshot::Receiver<()>,+ mut output: impl Write,+) -> Result<()> {+ let mut readiness = Some(readiness);+ while let Some(result) = tokens.recv().await {+ let Some(token) = result? else {+ break;+ };+ updates.send_replace(token);+ if let Some(readiness) = readiness.take() {+ readiness.await.context("MASQUE tunnel did not start")?;+ }+ writeln!(output, "AUTH_UPDATED")?;+ output.flush()?;+ }+ Ok(())+}++fn control_input(+ mut reader: impl BufRead + Send + 'static,+ connect_headers_stdin: bool,+) -> Result<(oneshot::Receiver<Result<HeaderMap>>, TokenStream)> {+ let (metadata, initial_metadata) = oneshot::channel();+ let (send, tokens) = mpsc::channel(1);+ // Tokio's blocking stdin can prevent runtime shutdown after a proxy startup failure.+ std::thread::Builder::new()+ .name("masque-credentials".to_owned())+ .spawn(move || {+ let headers = if connect_headers_stdin {+ read_connect_headers(&mut reader)+ } else {+ Ok(HeaderMap::new())+ };+ let valid = headers.is_ok();+ let _ = metadata.send(headers);+ if !valid {+ return;+ }+ loop {+ let token = read_auth_token(&mut reader);+ let finished = !matches!(&token, Ok(Some(_)));+ if send.blocking_send(token).is_err() || finished {+ break;+ }+ }+ })+ .context("starting MASQUE credential input")?;+ Ok((initial_metadata, tokens))+}++impl ProxyConnection {+ async fn connect(target: &ProxyTarget, config: &quinn::ClientConfig) -> Result<Self> {+ tokio::time::timeout(PROXY_CONNECT_TIMEOUT, async {+ let mut last_error = "MASQUE proxy resolved to no addresses".to_owned();+ for peer in tokio::net::lookup_host((target.host.as_str(), target.port)).await? {+ let bind = match peer.ip() {+ IpAddr::V4(_) => "0.0.0.0:0",+ IpAddr::V6(_) => "[::]:0",+ };+ let mut endpoint = match quinn::Endpoint::client(bind.parse()?) {+ Ok(endpoint) => endpoint,+ Err(error) => {+ last_error = error.to_string();+ continue;+ }+ };+ endpoint.set_default_client_config(config.clone());+ let connecting = match endpoint.connect(peer, &target.host) {+ Ok(connecting) => connecting,+ Err(error) => {+ last_error = error.to_string();+ continue;+ }+ };+ let quic = match tokio::time::timeout(Duration::from_secs(5), connecting).await {+ Ok(Ok(quic)) => quic,+ Ok(Err(error)) => {+ last_error = error.to_string();+ continue;+ }+ Err(_) => {+ last_error = "QUIC handshake timed out".to_owned();+ continue;+ }+ };+ let (connection, sender) = match h3::client::builder()+ .enable_extended_connect(true)+ .build(h3_quinn::Connection::new(quic.clone()))+ .await+ {+ Ok(connection) => connection,+ Err(error) => {+ last_error = error.to_string();+ continue;+ }+ };+ return Ok(Self {+ endpoint,+ quic,+ connection,+ sender,+ });+ }+ bail!("QUIC handshake failed: {last_error}");+ })+ .await+ .context("connecting to MASQUE proxy timed out")?+ }+}++async fn serve(+ listener: TcpListener,+ target: ProxyTarget,+ config: quinn::ClientConfig,+ headers: TunnelHeaders,+ mut connected: ProxyConnection,+) -> Result<()> {+ loop {+ let ProxyConnection {+ endpoint,+ quic,+ mut connection,+ sender,+ } = connected;+ let mut driver = tokio::spawn(async move { connection.wait_idle().await });+ let (draining, mut drain_started) = mpsc::channel(1);+ let failure = loop {+ tokio::select! {+ incoming = listener.accept() => {+ let (socket, _) = incoming?;+ let mut sender = sender.clone();+ let draining = draining.clone();+ let mut request = Request::builder().method(Method::CONNECT)+ .uri(Uri::builder().authority(target.authority.as_str()).build()?)+ .body(())?;+ *request.headers_mut() = headers.connect.clone();+ request.headers_mut().insert(header::AUTHORIZATION, headers.auth.borrow().clone());+ tokio::spawn(async move {+ if let Err(error) = bridge(socket, &mut sender, request, draining).await {+ eprintln!("MASQUE TCP connection failed: {error:#}");+ }+ });+ }+ _ = drain_started.recv() => break ProxyClosure::Draining,+ closed = &mut driver => break ProxyClosure::Closed(match closed {+ Ok(error) => anyhow!("MASQUE HTTP/3 connection closed: {error}"),+ Err(error) => anyhow!("MASQUE HTTP/3 driver stopped: {error}"),+ }),+ closed = quic.closed() => break ProxyClosure::Closed(anyhow!(closed).context("MASQUE QUIC connection closed")),+ }+ };+ drop(sender);+ match failure {+ ProxyClosure::Draining => {+ eprintln!("MASQUE HTTP/3 proxy is draining; reconnecting");+ // A refused new CONNECT is not replayed. Accepted streams keep their old transport.+ tokio::spawn(async move {+ tokio::select! {+ _ = &mut driver => {},+ _ = quic.closed() => driver.abort(),+ }+ drop(endpoint);+ });+ }+ ProxyClosure::Closed(error) => {+ driver.abort();+ quic.close(/*error_code*/ 0_u8.into(), b"reconnecting");+ drop(endpoint);+ eprintln!("MASQUE proxy connection lost; reconnecting: {error:#}");+ }+ }++ let mut retry_delay = Duration::from_secs(1);+ loop {+ let result = {+ let attempt = async {+ tokio::time::sleep(rand::random_range(retry_delay / 2..=retry_delay)).await;+ ProxyConnection::connect(&target, &config).await+ };+ tokio::pin!(attempt);+ loop {+ tokio::select! {+ incoming = listener.accept() => {+ // Offline local connections fail promptly; their traffic is never queued or replayed.+ let (socket, _) = incoming?;+ drop(socket);+ }+ result = &mut attempt => break result,+ }+ }+ };+ match result {+ Ok(reconnected) => {+ connected = reconnected;+ break;+ }+ Err(error) => {+ eprintln!("MASQUE proxy reconnect failed: {error:#}");+ retry_delay = (retry_delay * 2).min(Duration::from_secs(15));+ }+ }+ }+ }+}++async fn bridge(+ mut socket: TcpStream,+ sender: &mut h3::client::SendRequest<h3_quinn::OpenStreams, Bytes>,+ request: Request<()>,+ draining: mpsc::Sender<()>,+) -> Result<()> {+ let mut stream = match sender.send_request(request).await {+ Ok(stream) => stream,+ Err(error) => {+ if matches!(error, h3::error::StreamError::RemoteClosing { .. }) {+ let _ = draining.try_send(());+ }+ return Err(error).context("sending CONNECT");+ }+ };+ let status = stream+ .recv_response()+ .await+ .context("receiving CONNECT response")?+ .status();+ if !status.is_success() {+ bail!("MASQUE CONNECT rejected with status {}", status.as_u16());+ }+ let (mut send, mut recv) = stream.split();+ let (mut local_read, mut local_write) = socket.split();+ let upload = async {+ let mut buffer = vec![0; 64 * 1024];+ loop {+ let count = local_read.read(&mut buffer).await?;+ if count == 0 {+ send.finish().await?;+ return Ok::<_, anyhow::Error>(());+ }+ send.send_data(Bytes::copy_from_slice(&buffer[..count]))+ .await?;+ }+ };+ let download = async {+ while let Some(mut data) = recv.recv_data().await? {+ while data.has_remaining() {+ let chunk = data.chunk();+ local_write.write_all(chunk).await?;+ data.advance(chunk.len());+ }+ }+ local_write.shutdown().await?;+ Ok::<_, anyhow::Error>(())+ };+ tokio::try_join!(upload, download)?;+ Ok(())+}diff --git a/codex-rs/tcp-tunnel/src/lib_tests.rs b/codex-rs/tcp-tunnel/src/lib_tests.rsnew file mode 100644index 0000000000..1a3d83699a--- /dev/null+++ b/codex-rs/tcp-tunnel/src/lib_tests.rs@@ -0,0 +1,379 @@+use std::io::Cursor;+use std::sync::Arc;+use std::sync::atomic::AtomicUsize;+use std::sync::atomic::Ordering;+use std::time::Duration;++use anyhow::Result;+use bytes::Buf;+use bytes::Bytes;+use http::Response;+use pretty_assertions::assert_eq;+use rcgen::CertifiedKey;+use rcgen::generate_simple_self_signed;+use rustls::pki_types::PrivatePkcs8KeyDer;+use tokio::io::AsyncReadExt;+use tokio::io::AsyncWriteExt;+use tokio::net::TcpListener;+use tokio::net::TcpStream;+use tokio::sync::mpsc;+use tokio::sync::oneshot;+use tokio::sync::watch;+use tokio::time::timeout;+use url::Url;++use super::ProxyConnection;+use super::ProxyTarget;+use super::TunnelHeaders;+use super::control::MAX_CONNECT_HEADER_VALUE_BYTES;+use super::control::MAX_CONNECT_HEADERS;+use super::control::MAX_CONNECT_METADATA_BYTES;+use super::control::MAX_TOKEN_BYTES;+use super::control::read_connect_headers;+use super::control_input;+use super::parse_trusted_origins;+use super::serve;+use super::update_auth_tokens;++#[test]+fn proxy_policy_and_target_admission() {+ let origins = parse_trusted_origins("\nhttps://proxy.example.org\n").unwrap();+ assert_eq!(origins, vec!["https://proxy.example.org".to_string()]);+ let proxy = Url::parse("https://proxy.example.org").unwrap();+ for target in ["127.0.0.1:22", "[::1]:2222", "target.example:443"] {+ assert_eq!(+ ProxyTarget::parse(&proxy, &origins, target).unwrap(),+ ProxyTarget {+ host: "proxy.example.org".into(),+ port: 443,+ authority: target.into()+ },+ );+ }+ let ipv6 = "https://[::1]:8443";+ assert_eq!(+ ProxyTarget::parse(+ &Url::parse(ipv6).unwrap(),+ &parse_trusted_origins(ipv6).unwrap(),+ "target.example:22"+ )+ .unwrap(),+ ProxyTarget {+ host: "::1".into(),+ port: 8443,+ authority: "target.example:22".into()+ },+ );+ for origin in [+ "http://proxy.example.org",+ "https://proxy.example.org/path",+ "https://[email protected]",+ "https://proxy.example.org?query",+ "https://proxy.example.org#fragment",+ ] {+ assert!(parse_trusted_origins(origin).is_err(), "{origin}");+ assert!(+ ProxyTarget::parse(&Url::parse(origin).unwrap(), &origins, "127.0.0.1:22").is_err(),+ "{origin}"+ );+ }+ for origin in [+ "",+ "https://proxy.example.org:443",+ "https://proxy.example.org/",+ ] {+ assert!(parse_trusted_origins(origin).is_err(), "{origin}");+ }+ for (proxy, target) in [+ ("https://evil.example", "127.0.0.1:22"),+ ("https://proxy.example.org.attacker.net", "127.0.0.1:22"),+ ("https://proxy.example.org", "127.0.0.1:0"),+ ("https://proxy.example.org", "target.example"),+ ("https://proxy.example.org", "[email protected]:22"),+ ("https://proxy.example.org", "target.example:65536"),+ ("https://proxy.example.org", "target.example:22/path"),+ ] {+ assert!(+ ProxyTarget::parse(&Url::parse(proxy).unwrap(), &origins, target).is_err(),+ "{proxy} {target}"+ );+ }+}++#[tokio::test]+async fn control_input_acknowledges_bearer_renewal_with_or_without_metadata() -> Result<()> {+ for (input, includes_metadata) in [+ (&b"first-secret\nsecond-secret\n"[..], false),+ (+ &b"[[\"x-test-route\",\"private-value\"]]\nfirst-secret\nsecond-secret\n"[..],+ true,+ ),+ ] {+ let (metadata, mut tokens) = control_input(Cursor::new(input), includes_metadata)?;+ let metadata = metadata.await??;+ if includes_metadata {+ assert_eq!(metadata["x-test-route"], "private-value");+ assert!(metadata["x-test-route"].is_sensitive());+ } else {+ assert!(metadata.is_empty());+ }+ let initial = tokens.recv().await.unwrap()?.unwrap();+ assert_eq!(initial, "Bearer first-secret");+ assert!(initial.is_sensitive());+ let (updates, latest) = watch::channel(initial);+ let (ready, readiness) = oneshot::channel();+ let mut output = Vec::new();+ ready.send(()).unwrap();+ update_auth_tokens(&mut tokens, updates, readiness, &mut output).await?;+ assert_eq!(*latest.borrow(), "Bearer second-secret");+ assert!(latest.borrow().is_sensitive());+ assert_eq!(output, b"AUTH_UPDATED\n");+ }+ Ok(())+}++#[tokio::test]+async fn closed_parent_pipe_finishes_even_before_proxy_readiness() -> Result<()> {+ let (_, mut tokens) = control_input(Cursor::new([]), /*connect_headers_stdin*/ false)?;+ let (updates, _) = watch::channel("Bearer initial".parse()?);+ let (_ready, readiness) = oneshot::channel();+ let mut output = Vec::new();+ timeout(+ Duration::from_secs(1),+ update_auth_tokens(&mut tokens, updates, readiness, &mut output),+ )+ .await??;+ assert!(output.is_empty());+ Ok(())+}++#[tokio::test]+async fn invalid_control_input_stops_credentials_without_exposing_secrets() -> Result<()> {+ let oversized_header = format!(+ "[[\"x-test\",\"private-value{}\"]]\n",+ "x".repeat(MAX_CONNECT_HEADER_VALUE_BYTES)+ );+ let oversized_metadata = vec![b'x'; MAX_CONNECT_METADATA_BYTES + 1];+ let mut oversized_count = serde_json::to_vec(+ &(0..=MAX_CONNECT_HEADERS)+ .map(|index| (format!("x-test-{index}"), "private-value"))+ .collect::<Vec<_>>(),+ )?;+ oversized_count.push(b'\n');+ let invalid_metadata: &[(&str, &[u8])] = &[+ (+ "authorization",+ b"[[\"authorization\",\"private-value\"]]\n",+ ),+ ("forwarding", b"[[\"x-forwarded-for\",\"private-value\"]]\n"),+ ("real IP", b"[[\"x-real-ip\",\"private-value\"]]\n"),+ (+ "duplicate",+ b"[[\"x-test\",\"one\"],[\"X-Test\",\"private-value\"]]\n",+ ),+ (+ "invalid value",+ b"[[\"x-test\",\"private-value\\nmore\"]]\n",+ ),+ ("invalid JSON", b"\"private-value\"\n"),+ ("missing newline", b"[[\"x-test\",\"private-value\"]]"),+ ("value limit", oversized_header.as_bytes()),+ ("metadata limit", &oversized_metadata),+ ("header count", &oversized_count),+ ];+ for &(case, input) in invalid_metadata {+ let mut input = input.to_vec();+ input.extend_from_slice(b"private-secret\n");+ let (metadata, mut tokens) =+ control_input(Cursor::new(input), /*connect_headers_stdin*/ true)?;+ let error = metadata.await?.expect_err(case);+ assert!(!format!("{error:#}").contains("private-"), "{case}");+ assert!(tokens.recv().await.is_none(), "{case}");+ }+ for (case, input) in [+ ("invalid bearer", b" private-secret\0 \n".to_vec()),+ ("empty bearer", b"\n".to_vec()),+ ("bearer limit", vec![b'x'; MAX_TOKEN_BYTES + 1]),+ ] {+ let (metadata, mut tokens) =+ control_input(Cursor::new(input), /*connect_headers_stdin*/ false)?;+ assert!(metadata.await??.is_empty(), "{case}");+ let error = tokens.recv().await.expect(case).expect_err(case);+ assert!(!format!("{error:#}").contains("private-"), "{case}");+ assert!(tokens.recv().await.is_none(), "{case}");+ }+ Ok(())+}++#[tokio::test]+async fn transport_reconnect_keeps_listener_and_does_not_replay_old_tcp_streams() -> Result<()> {+ let CertifiedKey { cert, signing_key } =+ generate_simple_self_signed(vec!["127.0.0.1".to_string()])?;+ let provider = Arc::new(rustls::crypto::ring::default_provider());+ let mut server_tls = rustls::ServerConfig::builder_with_provider(provider.clone())+ .with_safe_default_protocol_versions()?+ .with_no_client_auth()+ .with_single_cert(+ vec![cert.der().clone()],+ PrivatePkcs8KeyDer::from(signing_key.serialize_der()).into(),+ )?;+ server_tls.alpn_protocols = vec![b"h3".to_vec()];+ let server_config = quinn::ServerConfig::with_crypto(Arc::new(+ quinn::crypto::rustls::QuicServerConfig::try_from(server_tls)?,+ ));+ let endpoint = quinn::Endpoint::server(server_config, "127.0.0.1:0".parse()?)?;+ let proxy_address = endpoint.local_addr()?;++ let mut roots = rustls::RootCertStore::empty();+ roots.add(cert.der().clone())?;+ let mut client_tls = rustls::ClientConfig::builder_with_provider(provider)+ .with_safe_default_protocol_versions()?+ .with_root_certificates(roots)+ .with_no_client_auth();+ client_tls.alpn_protocols = vec![b"h3".to_vec()];+ let config = quinn::ClientConfig::new(Arc::new(+ quinn::crypto::rustls::QuicClientConfig::try_from(client_tls)?,+ ));++ let request_count = Arc::new(AtomicUsize::new(0));+ let server_request_count = request_count.clone();+ let (accepted, mut connections) = mpsc::unbounded_channel();+ let (authorizations, mut tokens) = mpsc::unbounded_channel();+ let server = tokio::spawn(async move {+ while let Some(incoming) = endpoint.accept().await {+ let accepted = accepted.clone();+ let request_count = server_request_count.clone();+ let authorizations = authorizations.clone();+ tokio::spawn(async move {+ let quic = incoming.await.unwrap();+ let (shutdown, mut shutdown_requests) = mpsc::channel::<oneshot::Sender<()>>(1);+ accepted.send((quic.clone(), shutdown)).unwrap();+ let mut http = h3::server::builder()+ .enable_extended_connect(true)+ .build(h3_quinn::Connection::new(quic))+ .await+ .unwrap();+ loop {+ let request = tokio::select! {+ Some(finished) = shutdown_requests.recv() => {+ http.shutdown(/*max_requests*/ 0).await.unwrap();+ let _ = finished.send(());+ continue;+ }+ request = http.accept() => match request {+ Ok(Some(request)) => request,+ _ => break,+ },+ };+ let (request, mut stream) = request.resolve_request().await.unwrap();+ authorizations+ .send((+ request.headers()[http::header::AUTHORIZATION].clone(),+ request.headers()["x-test-route"].clone(),+ ))+ .unwrap();+ request_count.fetch_add(1, Ordering::SeqCst);+ tokio::spawn(async move {+ if stream+ .send_response(Response::builder().status(200).body(()).unwrap())+ .await+ .is_ok()+ && stream.send_data(Bytes::from_static(b"ready")).await.is_ok()+ {+ while let Ok(Some(mut data)) = stream.recv_data().await {+ let count = data.remaining();+ if stream.send_data(data.copy_to_bytes(count)).await.is_err() {+ break;+ }+ }+ }+ });+ }+ });+ }+ });++ let listener = TcpListener::bind("127.0.0.1:0").await?;+ let address = listener.local_addr()?;+ let target = ProxyTarget {+ host: proxy_address.ip().to_string(),+ port: proxy_address.port(),+ authority: "127.0.0.1:22".to_string(),+ };+ let (updates, auth) = watch::channel("Bearer local-test".parse()?);+ let headers = TunnelHeaders {+ auth,+ connect: read_connect_headers(&mut &b"[[\"x-test-route\",\"custom-route\"]]\n"[..])?,+ };+ let initial = ProxyConnection::connect(&target, &config).await?;+ let client = tokio::spawn(serve(listener, target, config, headers, initial));+ let (first_connection, _) = timeout(Duration::from_secs(5), connections.recv())+ .await?+ .unwrap();+ let mut first = TcpStream::connect(address).await?;+ let mut data = [0; 5];+ timeout(Duration::from_secs(5), first.read_exact(&mut data)).await??;+ assert_eq!(data, *b"ready");+ assert_eq!(+ tokens.recv().await.unwrap(),+ ("Bearer local-test".parse()?, "custom-route".parse()?)+ );++ updates.send_replace("Bearer replacement-test".parse()?);+ let mut refreshed = TcpStream::connect(address).await?;+ timeout(Duration::from_secs(5), refreshed.read_exact(&mut data)).await??;+ assert_eq!(+ tokens.recv().await.unwrap(),+ ("Bearer replacement-test".parse()?, "custom-route".parse()?)+ );++ first_connection.close(/*error_code*/ 0_u8.into(), b"test interruption");+ let old_stream = timeout(Duration::from_secs(5), first.read(&mut data)).await?;+ assert!(matches!(old_stream, Ok(0) | Err(_)));+ let (_, graceful_shutdown) = timeout(Duration::from_secs(10), connections.recv())+ .await?+ .unwrap();+ assert_eq!(request_count.load(Ordering::SeqCst), 2);++ let connect_ready_listener = move || async move {+ loop {+ let mut candidate = TcpStream::connect(address).await?;+ let mut data = [0; 5];+ if timeout(Duration::from_millis(250), candidate.read_exact(&mut data))+ .await+ .is_ok_and(|result| result.is_ok())+ {+ return Ok::<_, anyhow::Error>((data, candidate));+ }+ tokio::time::sleep(Duration::from_millis(50)).await;+ }+ };+ let (recovered, mut persistent) =+ timeout(Duration::from_secs(5), connect_ready_listener()).await??;+ assert_eq!(recovered, *b"ready");+ assert_eq!(+ tokens.recv().await.unwrap(),+ ("Bearer replacement-test".parse()?, "custom-route".parse()?)+ );+ assert_eq!(request_count.load(Ordering::SeqCst), 3);++ let (sent, goaway_sent) = oneshot::channel();+ graceful_shutdown.send(sent).await?;+ goaway_sent.await?;+ persistent.write_all(b"still").await?;+ timeout(Duration::from_secs(5), persistent.read_exact(&mut data)).await??;+ assert_eq!(data, *b"still");++ let new_request = tokio::spawn(connect_ready_listener());+ timeout(Duration::from_secs(10), connections.recv())+ .await?+ .unwrap();+ let (ready, _) = timeout(Duration::from_secs(5), new_request).await???;+ assert_eq!(ready, *b"ready");+ persistent.write_all(b"alive").await?;+ timeout(Duration::from_secs(5), persistent.read_exact(&mut data)).await??;+ assert_eq!(data, *b"alive");+ client.abort();+ server.abort();+ Ok(())+}