ICE: gather TURN relays over TCP/TLS through the HTTP proxy with UU_USE_PROXY=1

Upstream webrtc-ice only gathers UDP relays. Forced-relay sessions also offer
turns:<ip>:<port>?transport=tcp, the only media path on hosts whose UDP cannot
reach the TURN servers but whose TCP goes through an HTTP proxy. Vendor
webrtc-ice 0.10.1 with a TCP/TLS dialer (optional HTTP CONNECT) that frames
STUN/ChannelData for the unchanged turn client. Certificates are chain-verified;
a name mismatch is accepted only for IP-literal TURN URLs. Enabled only with
UU_USE_PROXY=1; default UDP gathering is unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
VallierDevandClaude Opus 5.5 committed 2026-10-28 19:34:24 +08:00
1 parent ab137a1b20
commit 6a633e1bc4
70 files changed
+14808 -5

No files matched your search

+1
View File
@@ -630,6 +630,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
let _ = install_host_signals(None);
video::warm_auto_probe();
+75
View File
@@ -56,6 +56,31 @@ impl SessionIce {
}
}
/// With `UU_USE_PROXY=1`, also gather TURN relays over TCP/TLS (through the HTTP proxy when
/// one is configured); hosts whose UDP cannot reach the TURN servers then still get a relay.
pub fn configure_relay_transport() {
if !crate::auth::proxy_enabled() { return; }
let value = ["HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"].iter().find_map(|name| std::env::var(name).ok()).filter(|v| !v.is_empty());
let proxy = match value.as_deref().map(relay_proxy) {
Some(Ok(proxy)) => Some(proxy),
Some(Err(reason)) => { log::warn!("TURN over TCP/TLS disabled: {reason}"); return; }
None => None,
};
log::info!("TURN over TCP/TLS enabled: via_http_proxy={}", proxy.is_some());
webrtc::ice::agent::turn_tcp::set_relay_transport(webrtc::ice::agent::turn_tcp::RelayTransport { http_proxy: proxy });
}
/// `host:port` of an unauthenticated HTTP proxy URL; never echoes the value.
fn relay_proxy(value: &str) -> Result<String, &'static str> {
let url = reqwest::Url::parse(&if value.contains("://") { value.to_owned() } else { format!("http://{value}") })
.map_err(|_| "invalid proxy URL")?;
if url.scheme() != "http" { return Err("only http:// proxies are supported for TURN"); }
if !url.username().is_empty() || url.password().is_some() { return Err("proxy authentication is not supported for TURN"); }
let host = url.host_str().ok_or("invalid proxy URL")?;
let port = url.port_or_known_default().ok_or("invalid proxy URL")?;
Ok(format!("{host}:{port}")) // host_str() keeps IPv6 brackets
}
#[cfg(test)]
mod tests {
use super::*;
@@ -74,4 +99,54 @@ mod tests {
assert_eq!(config.ice_servers.len(),1);
assert!(config.ice_servers[0].urls.iter().all(|s|s.starts_with("stun:")));
}
#[test]
fn relay_proxy_accepts_plain_http_only() {
assert_eq!(super::relay_proxy("http://proxy.invalid:8889").unwrap(), "proxy.invalid:8889");
assert_eq!(super::relay_proxy("proxy.invalid:8889/").unwrap(), "proxy.invalid:8889");
assert_eq!(super::relay_proxy("http://[::1]:3128").unwrap(), "[::1]:3128");
for bad in ["socks5://proxy.invalid:1080", "https://proxy.invalid:443", "http://user:[email protected]:8889", "::"] {
assert!(super::relay_proxy(bad).is_err());
}
}
#[test]
fn turn_tcp_frames_stun_and_padded_channel_data() {
use webrtc::ice::agent::turn_tcp::frame_len;
assert_eq!(frame_len([0x01, 0x01, 0x00, 0x08]), Some(28));
assert_eq!(frame_len([0x40, 0x00, 0x00, 0x05]), Some(12));
assert_eq!(frame_len([0x40, 0x00, 0x00, 0x08]), Some(12));
assert_eq!(frame_len([0x80, 0x00, 0x00, 0x00]), None);
}
#[tokio::test]
async fn turn_tcp_connects_through_the_proxy_and_frames_the_stream() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use webrtc::ice::agent::turn_tcp::{dial, set_relay_transport, RelayTransport};
use webrtc::util::Conn;
let proxy = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy_addr = proxy.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut socket, _) = proxy.accept().await.unwrap();
let mut head = Vec::new();
while !head.ends_with(b"\r\n\r\n") { let mut b = [0u8; 1]; socket.read_exact(&mut b).await.unwrap(); head.push(b[0]); }
assert!(String::from_utf8_lossy(&head).starts_with("CONNECT 192.0.2.1:2483 HTTP/1.1\r\n"));
socket.write_all(b"HTTP/1.1 200 Connection established\r\n\r\n").await.unwrap();
let mut frames = [0u8; 20 + 12];
socket.read_exact(&mut frames).await.unwrap();
socket.write_all(&frames).await.unwrap();
});
set_relay_transport(RelayTransport { http_proxy: Some(proxy_addr.to_string()) });
let target: std::net::SocketAddr = "192.0.2.1:2483".parse().unwrap();
let conn = dial("192.0.2.1", 2483, target, false).await.unwrap();
let mut stun = [0u8; 20]; stun[1] = 0x01;
let channel = [0x40, 0x00, 0x00, 0x05, 1, 2, 3, 4, 5, 0, 0, 0];
conn.send_to(&stun, target).await.unwrap();
conn.send_to(&channel, target).await.unwrap();
let mut buf = [0u8; 64];
assert_eq!(conn.recv_from(&mut buf).await.unwrap(), (20, target));
assert_eq!(conn.recv_from(&mut buf).await.unwrap(), (12, target));
assert_eq!(&buf[..12], &channel);
server.await.unwrap();
}
}