#![allow(
missing_docs,
dead_code,
unused_mut,
clippy::large_futures,
clippy::missing_panics_doc,
clippy::redundant_closure_for_method_calls,
clippy::inefficient_to_string,
clippy::manual_let_else,
clippy::single_char_pattern,
clippy::match_same_arms,
clippy::needless_borrow,
clippy::trim_split_whitespace,
clippy::too_many_lines,
clippy::unused_self,
clippy::items_after_statements,
clippy::expect_fun_call,
clippy::len_zero,
clippy::unnecessary_debug_formatting,
clippy::format_push_string,
clippy::new_without_default,
clippy::map_unwrap_or
)]
#![cfg(all(feature = "advanced-routing", feature = "high-level-url"))]
use std::io::{Read, Write};
use std::net::TcpListener;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
use eggfetch_core::network_stream::{
ConnectionMetadata, ExtraInfo, NetworkStream, TlsInfo, TransportKind, UpgradedStream,
};
use tokio::io::AsyncWriteExt;
fn start_upgrade_server() -> (u16, Arc<std::sync::atomic::AtomicBool>) {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let shutdown = Arc::new(std::sync::atomic::AtomicBool::new(false));
let sd = shutdown.clone();
thread::spawn(move || {
while !sd.load(std::sync::atomic::Ordering::Relaxed) {
if let Ok((mut stream, _)) = listener.accept() {
stream.set_read_timeout(Some(Duration::from_secs(1))).ok();
stream.set_write_timeout(Some(Duration::from_secs(1))).ok();
let mut buf = Vec::new();
let mut tmp = [0u8; 1];
let mut headers_done = false;
while let Ok(n) = Read::read(&mut stream, &mut tmp) {
if n == 0 {
break;
}
buf.push(tmp[0]);
if buf.len() >= 4 && &buf[buf.len() - 4..] == b"\r\n\r\n" {
headers_done = true;
break;
}
}
if !headers_done {
continue;
}
let response = "HTTP/1.1 101 Switching Protocols\r\n\
Upgrade: echo\r\n\
Connection: Upgrade\r\n\
\r\n";
let leading = b"LEADING";
let _ = stream.write_all(response.as_bytes());
let _ = stream.write_all(leading);
let _ = stream.flush();
let mut echo_buf = [0u8; 1024];
loop {
match Read::read(&mut stream, &mut echo_buf) {
Ok(0) | Err(_) => break,
Ok(n) => {
if stream.write_all(&echo_buf[..n]).is_err() {
break;
}
if stream.flush().is_err() {
break;
}
}
}
}
}
}
});
(port, shutdown)
}
#[tokio::test]
async fn upgrade_101_response_has_network_stream() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
assert!(response.network_stream().is_some());
let ns = response.network_stream().unwrap();
assert!(ns.is_upgraded());
let upgraded = ns.as_upgraded().unwrap();
let metadata = upgraded.metadata();
assert_eq!(metadata.transport_kind, TransportKind::Tcp);
}
#[tokio::test]
async fn upgraded_stream_read_write_roundtrip() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let mut ns = response.into_network_stream().expect("network stream");
let mut upgraded = ns.into_upgraded().expect("upgraded stream");
let _leading = upgraded.read(1024).await.unwrap();
let test_data = b"Hello, upgraded world!";
upgraded.write_all(test_data).await.unwrap();
let data = upgraded.read(1024).await.unwrap();
assert_eq!(&data[..], test_data);
upgraded.close().await.unwrap();
}
#[tokio::test]
async fn upgraded_stream_partial_reads() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
let mut ns = response.into_network_stream().expect("network stream");
let mut upgraded = ns.into_upgraded().expect("upgraded stream");
let _leading = upgraded.read(1024).await.unwrap();
let large_data = vec![0xABu8; 10_000];
upgraded.write_all(&large_data).await.unwrap();
let mut received = Vec::new();
while received.len() < large_data.len() {
let chunk = upgraded.read(256).await.unwrap();
if chunk.is_empty() {
break;
}
received.extend_from_slice(&chunk);
}
assert_eq!(received, large_data);
}
#[tokio::test]
async fn upgraded_stream_close_is_idempotent() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
let mut ns = response.into_network_stream().expect("network stream");
let mut upgraded = ns.into_upgraded().expect("upgraded stream");
upgraded.close().await.unwrap();
upgraded.close().await.unwrap();
}
#[test]
fn network_stream_metadata_accessors() {
let meta = Arc::new(ConnectionMetadata {
local_addr: Some("127.0.0.1:12345".parse().unwrap()),
peer_addr: Some("93.184.216.34:443".parse().unwrap()),
transport_kind: TransportKind::Tls,
tls_info: Some(TlsInfo {
alpn_protocol: Some("h2".into()),
tls_version: Some("TLSv1.3".into()),
cipher_suite: Some("TLS_AES_256_GCM_SHA384".into()),
server_name: Some("example.com".into()),
}),
});
let ns = NetworkStream::Metadata(meta);
assert!(!ns.is_upgraded());
assert!(ns.as_upgraded().is_none());
let info = ns.metadata();
assert_eq!(info.local_addr.unwrap().port(), 12345);
assert_eq!(info.peer_addr.unwrap().port(), 443);
}
#[test]
fn extra_info_from_metadata() {
let meta = ConnectionMetadata {
local_addr: Some("127.0.0.1:1000".parse().unwrap()),
peer_addr: Some("10.0.0.1:443".parse().unwrap()),
transport_kind: TransportKind::Tcp,
tls_info: None,
};
let info = ExtraInfo::from_metadata(&meta);
assert_eq!(info.client_addr.unwrap().port(), 1000);
assert_eq!(info.server_addr.unwrap().port(), 443);
assert!(info.tls_info.is_none());
}
#[tokio::test]
async fn upgraded_stream_leading_data_through_hyper() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let mut ns = response.into_network_stream().expect("network stream");
let mut upgraded = ns.into_upgraded().expect("upgraded stream");
let leading = upgraded.read(1024).await.unwrap();
assert_eq!(
&leading[..],
b"LEADING",
"leading data must be preserved through Hyper adapter"
);
let test_data = b"after leading";
upgraded.write_all(test_data).await.unwrap();
let echoed = upgraded.read(1024).await.unwrap();
assert_eq!(&echoed[..], test_data);
upgraded.close().await.unwrap();
}
#[tokio::test]
async fn upgraded_stream_leading_data() {
let leading = bytes::Bytes::from("hello leading");
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let _handle = tokio::task::spawn_blocking(move || {
let _ = std::net::TcpStream::connect(addr);
});
let (std_stream, _) = listener.accept().unwrap();
std_stream.set_nonblocking(true).ok();
let tokio_stream = tokio::net::TcpStream::from_std(std_stream).unwrap();
let mut us = UpgradedStream::from_tcp(tokio_stream, leading.clone());
assert_eq!(us.leading_data(), &leading);
let taken = us.take_leading_data();
assert_eq!(taken, leading);
assert!(us.leading_data().is_empty());
}
#[tokio::test]
async fn upgraded_stream_read_timeout() {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
let shutdown = Arc::new(std::sync::atomic::AtomicBool::new(false));
let sd = shutdown.clone();
thread::spawn(move || {
while !sd.load(std::sync::atomic::Ordering::Relaxed) {
if let Ok((mut stream, _)) = listener.accept() {
stream.set_read_timeout(Some(Duration::from_secs(30))).ok();
let mut buf = Vec::new();
let mut tmp = [0u8; 1];
while let Ok(n) = Read::read(&mut stream, &mut tmp) {
if n == 0 {
break;
}
buf.push(tmp[0]);
if buf.len() >= 4 && &buf[buf.len() - 4..] == b"\r\n\r\n" {
break;
}
}
let response = "HTTP/1.1 101 Switching Protocols\r\n\
Upgrade: echo\r\n\
Connection: Upgrade\r\n\
\r\n";
let _ = stream.write_all(response.as_bytes());
let _ = stream.flush();
thread::sleep(Duration::from_secs(5));
}
}
});
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let mut ns = response.into_network_stream().expect("network stream");
let mut upgraded = ns.into_upgraded().expect("upgraded stream");
let result = tokio::time::timeout(Duration::from_millis(200), upgraded.read(1024)).await;
let _ = result;
upgraded.close().await.unwrap();
}
#[tokio::test]
async fn client_close_with_owned_upgraded_stream() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let mut ns = response.into_network_stream().expect("network stream");
let mut upgraded = ns.into_upgraded().expect("upgraded stream");
drop(client);
let _leading = upgraded.read(1024).await.unwrap();
let test_data = b"survived client drop";
upgraded.write_all(test_data).await.unwrap();
let data = upgraded.read(1024).await.unwrap();
assert_eq!(&data[..], test_data);
upgraded.close().await.unwrap();
}
#[test]
fn network_stream_metadata_fixture() {
let meta = Arc::new(ConnectionMetadata {
local_addr: Some("127.0.0.1:54321".parse().unwrap()),
peer_addr: Some("93.184.216.34:443".parse().unwrap()),
transport_kind: TransportKind::Tls,
tls_info: Some(TlsInfo {
alpn_protocol: Some("http/1.1".into()),
tls_version: Some("TLSv1.3".into()),
cipher_suite: Some("TLS_AES_128_GCM_SHA256".into()),
server_name: Some("example.com".into()),
}),
});
let ns = NetworkStream::Metadata(meta.clone());
let info = ns.metadata();
assert_eq!(info.local_addr.unwrap().port(), 54321);
assert_eq!(info.peer_addr.unwrap().port(), 443);
assert_eq!(info.transport_kind, TransportKind::Tls);
let tls = info.tls_info.as_ref().unwrap();
assert_eq!(tls.alpn_protocol.as_deref(), Some("http/1.1"));
assert_eq!(tls.tls_version.as_deref(), Some("TLSv1.3"));
assert_eq!(tls.server_name.as_deref(), Some("example.com"));
assert!(!ns.is_upgraded());
assert!(ns.as_upgraded().is_none());
assert!(ns.into_upgraded().is_none());
}
#[tokio::test]
async fn ordinary_response_has_no_network_stream() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
loop {
if let Ok((mut stream, _)) = listener.accept().await {
let response = "HTTP/1.1 200 OK\r\n\
Content-Length: 2\r\n\
\r\n\
ok";
let _ = stream.write_all(response.as_bytes()).await;
}
}
});
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client.get(&url).unwrap().send().await.unwrap();
assert_eq!(response.status().as_u16(), 200);
assert!(response.network_stream().is_none());
}
#[tokio::test]
async fn ordinary_response_metadata_is_none() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
loop {
if let Ok((mut stream, _)) = listener.accept().await {
let response = "HTTP/1.1 200 OK\r\n\
Content-Length: 2\r\n\
\r\n\
ok";
let _ = stream.write_all(response.as_bytes()).await;
}
}
});
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let response = client.get(&url).unwrap().send().await.unwrap();
assert!(response.network_stream().is_none());
}
#[test]
fn connection_metadata_default() {
let meta = ConnectionMetadata::default();
assert!(meta.local_addr.is_none());
assert!(meta.peer_addr.is_none());
assert_eq!(meta.transport_kind, TransportKind::Tcp);
assert!(meta.tls_info.is_none());
}
#[tokio::test]
async fn direct_connector_upgrade_captures_real_addrs() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::builder()
.local_address("127.0.0.1:0".parse().unwrap())
.build();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let ns = response
.network_stream()
.expect("direct upgrade has stream");
let meta = ns.metadata();
assert_eq!(meta.transport_kind, TransportKind::Tcp);
let local = meta.local_addr.expect("direct captures local addr");
let peer = meta.peer_addr.expect("direct captures peer addr");
assert_eq!(local.ip().to_string(), "127.0.0.1");
assert_eq!(peer.port(), port);
assert!(meta.tls_info.is_none());
}
#[tokio::test]
async fn standard_upgrade_opaque_metadata_unavailable() {
let (port, _shutdown) = start_upgrade_server();
let url = format!("http://127.0.0.1:{port}/");
let client = eggfetch_core::Client::new();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let ns = response.network_stream().expect("upgrade stream");
let meta = ns.metadata();
assert!(meta.local_addr.is_none());
assert!(meta.peer_addr.is_none());
assert!(meta.tls_info.is_none());
}
#[cfg(unix)]
#[tokio::test]
async fn uds_upgrade_reports_uds_without_ips() {
use std::io::{Read, Write};
use std::os::unix::net::UnixListener;
let path =
std::env::temp_dir().join(format!("eggfetch_metadata_uds_{}.sock", std::process::id()));
let _ = std::fs::remove_file(&path);
let shutdown = Arc::new(std::sync::atomic::AtomicBool::new(false));
let sd = shutdown.clone();
let listener = UnixListener::bind(&path).unwrap();
listener.set_nonblocking(true).unwrap();
let handle = std::thread::spawn(move || {
while !sd.load(std::sync::atomic::Ordering::Relaxed) {
match listener.accept() {
Ok((mut stream, _)) => {
stream.set_nonblocking(false).unwrap();
let mut buf = [0u8; 4096];
let mut acc = Vec::new();
stream.set_read_timeout(Some(Duration::from_secs(1))).ok();
loop {
let mut tmp = [0u8; 1];
match Read::read(&mut stream, &mut tmp) {
Ok(0) | Err(_) => break,
Ok(_) => {
acc.push(tmp[0]);
if acc.len() >= 4 && &acc[acc.len() - 4..] == b"\r\n\r\n" {
break;
}
}
}
}
let _ = stream.write_all(
b"HTTP/1.1 101 Switching Protocols\r\nUpgrade: echo\r\nConnection: Upgrade\r\n\r\n",
);
let _ = stream.flush();
std::thread::sleep(Duration::from_millis(200));
let _ = buf;
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
std::thread::sleep(Duration::from_millis(10));
}
Err(_) => break,
}
}
});
let client = eggfetch_core::Client::builder()
.uds_path(path.to_string_lossy().into_owned())
.build();
let mut response = client
.get("http://localhost/")
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let ns = response.network_stream().expect("uds upgrade has stream");
let meta = ns.metadata();
assert_eq!(meta.transport_kind, TransportKind::Unix);
assert!(meta.local_addr.is_none(), "UDS must not invent IPs");
assert!(meta.peer_addr.is_none(), "UDS must not invent IPs");
assert!(meta.tls_info.is_none());
shutdown.store(true, std::sync::atomic::Ordering::SeqCst);
let _ = handle.join();
let _ = std::fs::remove_file(&path);
}
#[tokio::test]
async fn tls_upgrade_captures_version_cipher_alpn() {
let cert_key =
rcgen::generate_simple_self_signed(vec!["localhost".into()]).expect("rcgen cert");
let cert_der = rustls::pki_types::CertificateDer::from(cert_key.cert.der().to_vec());
let key_der = rustls::pki_types::PrivateKeyDer::Pkcs8(
rustls::pki_types::PrivatePkcs8KeyDer::from(cert_key.key_pair.serialize_der()),
);
let mut server_tls = rustls::ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(vec![cert_der], key_der)
.expect("cert");
server_tls.alpn_protocols = vec![b"http/1.1".to_vec()];
let acceptor = tokio_rustls::TlsAcceptor::from(std::sync::Arc::new(server_tls));
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
if let Ok((tcp, _)) = listener.accept().await {
if let Ok(mut tls) = acceptor.accept(tcp).await {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let mut buf = vec![0u8; 4096];
let _ = tokio::time::timeout(Duration::from_secs(5), tls.read(&mut buf)).await;
let _ = tls
.write_all(
b"HTTP/1.1 101 Switching Protocols\r\nUpgrade: echo\r\nConnection: Upgrade\r\n\r\n",
)
.await;
let _ = tls.flush().await;
tokio::time::sleep(Duration::from_millis(300)).await;
}
}
});
let url = format!("https://127.0.0.1:{port}/");
let client = eggfetch_core::Client::builder()
.local_address("127.0.0.1:0".parse().unwrap())
.danger_accept_invalid_certs(true)
.build();
let mut response = client
.get(&url)
.unwrap()
.header("upgrade", "echo")
.header("connection", "Upgrade")
.send()
.await
.unwrap();
assert_eq!(response.status().as_u16(), 101);
let ns = response.network_stream().expect("tls upgrade stream");
let meta = ns.metadata();
assert_eq!(meta.transport_kind, TransportKind::Tls);
assert!(meta.local_addr.is_some());
assert!(meta.peer_addr.is_some());
let tls = meta.tls_info.as_ref().expect("tls info captured");
assert!(tls.tls_version.is_some(), "tls version observed");
assert!(tls.cipher_suite.is_some(), "cipher observed");
assert_eq!(tls.alpn_protocol.as_deref(), Some("http/1.1"));
}