use super::*;
use super::tcp::{CapturingBlockingConnector, wait_for_quic_pending, write_quic_data_hello};
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_session_multiplexes_isolated_data_streams_for_two_services() {
let (cert, key) = certificate();
let server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: SecretToken::new(b"quic-test-secret".to_vec()).unwrap(),
allow_public_service_binds: false,
})
.await
.unwrap();
let echo = TcpListener::bind("127.0.0.1:0").await.unwrap();
let echo_addr = echo.local_addr().unwrap();
let echo_task = tokio::spawn(async move {
while let Ok((stream, _)) = echo.accept().await {
tokio::spawn(async move {
let (mut read, mut write) = tokio::io::split(stream);
let _ = tokio::io::copy(&mut read, &mut write).await;
let _ = write.shutdown().await;
});
}
});
let client = Client::start_quic_insecure_for_test(ClientConfig {
server_addr: server.local_addr().to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: SecretToken::new(b"quic-test-secret".to_vec()).unwrap(),
services: vec![
ClientService::new(
ServiceId(1),
ServiceName::new("quic-one").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new(echo_addr.ip().to_string(), echo_addr.port()).unwrap(),
),
ClientService::new(
ServiceId(2),
ServiceName::new("quic-two").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new(echo_addr.ip().to_string(), echo_addr.port()).unwrap(),
),
],
})
.await
.unwrap();
let binds = tokio::time::timeout(Duration::from_secs(10), async {
loop {
let binds = server.handle().snapshot().effective_binds;
if binds.len() == 2 {
break binds
.into_iter()
.map(|(_, _, bind)| {
SocketAddr::V6(std::net::SocketAddrV6::new(
std::net::Ipv6Addr::from(bind.address),
bind.port,
0,
0,
))
})
.collect::<Vec<_>>();
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let (one, two) = tokio::join!(
roundtrip(binds[0], b"quic-stream-one"),
roundtrip(binds[1], b"quic-stream-two")
);
assert_eq!(one, b"quic-stream-one");
assert_eq!(two, b"quic-stream-two");
let mut reset_stream = TcpStream::connect(binds[0]).await.unwrap();
reset_stream.write_all(b"reset-this-stream").await.unwrap();
drop(reset_stream);
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(
roundtrip(binds[1], b"stream-after-reset").await,
b"stream-after-reset"
);
client.shutdown().await;
server.shutdown().await;
echo_task.abort();
}
#[cfg(feature = "quic")]
#[tokio::test]
#[ignore = "bounded QUIC stream-churn qualification"]
async fn qualification_quic_stream_churn_soak() {
use std::time::Instant;
const CONNECTIONS: usize = 200;
const CONCURRENCY: usize = 4;
static SMALL: [u8; 64] = [0x3c; 64];
static MEDIUM: [u8; 64 * 1024] = [0xc3; 64 * 1024];
let (cert, key) = certificate();
let token = SecretToken::new(b"quic-stream-churn-qualification".to_vec()).unwrap();
let server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: token.clone(),
allow_public_service_binds: false,
})
.await
.unwrap();
let echo = TcpListener::bind("127.0.0.1:0").await.unwrap();
let echo_addr = echo.local_addr().unwrap();
let echo_task = tokio::spawn(async move {
while let Ok((stream, _)) = echo.accept().await {
tokio::spawn(async move {
let (mut read, mut write) = tokio::io::split(stream);
let _ = tokio::io::copy(&mut read, &mut write).await;
let _ = write.shutdown().await;
});
}
});
let client = Client::start_quic_insecure_for_test(ClientConfig {
server_addr: server.local_addr().to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token,
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("quic-churn").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new(echo_addr.ip().to_string(), echo_addr.port()).unwrap(),
)],
})
.await
.unwrap();
let client_handle = client.handle();
let bind = tokio::time::timeout(Duration::from_secs(10), async {
loop {
if let Some((_, _, bind)) = server.handle().snapshot().effective_binds.first() {
break bind.clone();
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let address = SocketAddr::V6(std::net::SocketAddrV6::new(
std::net::Ipv6Addr::from(bind.address),
bind.port,
0,
0,
));
let started = Instant::now();
let mut bytes_each_direction = 0usize;
let mut completed = 0usize;
for first in (0..CONNECTIONS).step_by(CONCURRENCY) {
let mut streams = tokio::task::JoinSet::new();
for connection in first..(first + CONCURRENCY).min(CONNECTIONS) {
let payload: &'static [u8] = if connection % 2 == 0 { &SMALL } else { &MEDIUM };
streams.spawn(async move {
let received = tokio::time::timeout(
Duration::from_secs(10),
roundtrip(address, payload),
)
.await
.unwrap();
(payload.len(), received == payload)
});
}
while let Some(result) = streams.join_next().await {
let (bytes, matched) = result.unwrap();
assert!(matched);
bytes_each_direction += bytes;
completed += 1;
}
}
let elapsed = started.elapsed();
client.shutdown().await;
let server_handle = server.handle();
server.shutdown().await;
echo_task.abort();
let client_final = client_handle.snapshot();
let server_final = server_handle.snapshot();
assert_eq!(client_final.active_sessions, 0);
assert_eq!(client_final.registered_services, 0);
assert_eq!(client_final.active_client_open_tasks, 0);
assert_eq!(client_final.active_handshakes, 0);
assert_eq!(client_final.task_panics, 0);
assert_eq!(server_final.active_sessions, 0);
assert_eq!(server_final.active_connections, 0);
assert_eq!(server_final.pending_connections, 0);
assert_eq!(server_final.task_panics, 0);
eprintln!(
"quic stream churn: os={} arch={} connections={} concurrency={} bytes_each_direction={} elapsed_ms={} streams_per_second={:.2} aggregate_mib_per_second={:.2} client_open_high_water={} server_sessions_high_water={}",
std::env::consts::OS,
std::env::consts::ARCH,
completed,
CONCURRENCY,
bytes_each_direction,
elapsed.as_millis(),
completed as f64 / elapsed.as_secs_f64(),
bytes_each_direction as f64 * 2.0 / elapsed.as_secs_f64() / (1024.0 * 1024.0),
client_final.high_water_client_open_tasks,
server_final.high_water_sessions,
);
}
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_connection_replacement_creates_new_session_and_reregisters_services() {
let (cert, key) = certificate();
let token = SecretToken::new(b"quic-reconnect-secret".to_vec()).unwrap();
let first_server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: token.clone(),
allow_public_service_binds: false,
})
.await
.unwrap();
let endpoint = first_server.local_addr();
let first_handle = first_server.handle();
let client = Client::start_quic_insecure_for_test(ClientConfig {
server_addr: endpoint.to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: token.clone(),
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("quic-restored").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new("127.0.0.1", 9).unwrap(),
)],
})
.await
.unwrap();
tokio::time::timeout(Duration::from_secs(10), async {
loop {
if first_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let first_session = first_handle.snapshot().effective_binds[0].0;
first_server.shutdown().await;
let second_server = Server::bind_quic(ServerConfig {
listen_addr: endpoint,
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token,
allow_public_service_binds: false,
})
.await
.unwrap();
tokio::time::timeout(Duration::from_secs(10), async {
loop {
if second_server.handle().snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let second_session = second_server.handle().snapshot().effective_binds[0].0;
assert_ne!(first_session, second_session);
let client_handle = client.handle();
assert!(client_handle.snapshot().reconnects > 0);
client.shutdown().await;
let client_final = client_handle.snapshot();
assert!(!client_final.connected);
assert_eq!(client_final.active_sessions, 0);
assert_eq!(client_final.registered_services, 0);
second_server.shutdown().await;
}
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_wrong_session_data_hello_is_rejected_and_pending_entry_survives() {
let (cert, key) = certificate();
let server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: SecretToken::new(b"quic-wrong-session-secret".to_vec()).unwrap(),
allow_public_service_binds: false,
})
.await
.unwrap();
let server_handle = server.handle();
let captured: std::sync::Arc<std::sync::Mutex<Option<eggtunnel_proto::ConnectionId>>> =
std::sync::Arc::new(std::sync::Mutex::new(None));
let client = Client::start_quic_insecure_with_connector_for_test(
ClientConfig {
server_addr: server.local_addr().to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: SecretToken::new(b"quic-wrong-session-secret".to_vec()).unwrap(),
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("wrong-session-svc").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new("127.0.0.1", 9).unwrap(),
)],
},
std::sync::Arc::new(CapturingBlockingConnector {
captured: captured.clone(),
}),
)
.await
.unwrap();
let client_handle = client.handle();
tokio::time::timeout(Duration::from_secs(5), async {
loop {
if server_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let bind = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let Some((_, _, bind)) = server_handle.snapshot().effective_binds.first() {
break bind.clone();
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let addr = SocketAddr::V6(std::net::SocketAddrV6::new(
std::net::Ipv6Addr::from(bind.address),
bind.port,
0,
0,
));
let external = TcpStream::connect(addr).await.unwrap();
wait_for_quic_pending(&server_handle, 1).await;
let captured_id = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let Some(id) = *captured.lock().unwrap_or_else(|p| p.into_inner()) {
break id;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let quic = client_handle
.quic_client_for_test()
.expect("client must have an established QUIC client");
let mut wrong_stream = quic.open_stream().await.unwrap();
write_quic_data_hello(
&mut wrong_stream,
eggtunnel_proto::DataHello {
session_id: SessionId([9; 16]),
service_id: ServiceId(1),
connection_id: captured_id,
},
)
.await;
let mut buf = [0u8; 64];
let read_result = tokio::time::timeout(
Duration::from_secs(2),
tokio::io::AsyncReadExt::read(&mut wrong_stream, &mut buf),
)
.await;
assert!(
read_result.is_err() || matches!(read_result, Ok(Ok(0)) | Ok(Err(_))),
"wrong-session DataHello should not produce server-side data, got {read_result:?}"
);
assert_eq!(
server_handle.snapshot().rejected_connections,
1,
"wrong-session DataHello must increment rejected_connections"
);
assert_eq!(
server_handle.snapshot().pending_connections,
1,
"wrong-session DataHello must not consume the pending entry"
);
drop(external);
client.shutdown().await;
server.shutdown().await;
}
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_replay_data_hello_on_second_stream_is_rejected() {
let (cert, key) = certificate();
let echo = TcpListener::bind("127.0.0.1:0").await.unwrap();
let echo_addr = echo.local_addr().unwrap();
let echo_task = tokio::spawn(async move {
while let Ok((stream, _)) = echo.accept().await {
tokio::spawn(async move {
let (mut read, mut write) = stream.into_split();
let _ = tokio::io::copy(&mut read, &mut write).await;
});
}
});
let server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: SecretToken::new(b"quic-replay-secret".to_vec()).unwrap(),
allow_public_service_binds: false,
})
.await
.unwrap();
let server_handle = server.handle();
let client = Client::start_quic_insecure_for_test(ClientConfig {
server_addr: server.local_addr().to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: SecretToken::new(b"quic-replay-secret".to_vec()).unwrap(),
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("quic-replay-svc").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new(echo_addr.ip().to_string(), echo_addr.port()).unwrap(),
)],
})
.await
.unwrap();
let client_handle = client.handle();
tokio::time::timeout(Duration::from_secs(5), async {
loop {
if server_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let bind = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let Some((_, _, bind)) = server_handle.snapshot().effective_binds.first() {
break bind.clone();
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let addr = SocketAddr::V6(std::net::SocketAddrV6::new(
std::net::Ipv6Addr::from(bind.address),
bind.port,
0,
0,
));
let mut first = TcpStream::connect(addr).await.unwrap();
first.write_all(b"first").await.unwrap();
let mut response = [0u8; 5];
tokio::time::timeout(Duration::from_secs(5), first.read_exact(&mut response))
.await
.unwrap()
.unwrap();
assert_eq!(&response, b"first");
drop(first);
tokio::time::timeout(Duration::from_secs(5), async {
loop {
let snapshot = server_handle.snapshot();
if snapshot.pending_connections == 0 && snapshot.active_connections == 0 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let legitimate_session_id = server_handle.snapshot().effective_binds[0].0;
let quic = client_handle
.quic_client_for_test()
.expect("client must have an established QUIC client");
let mut replay_stream = quic.open_stream().await.unwrap();
write_quic_data_hello(
&mut replay_stream,
eggtunnel_proto::DataHello {
session_id: legitimate_session_id,
service_id: ServiceId(1),
connection_id: eggtunnel_proto::ConnectionId([42; 16]),
},
)
.await;
let mut buf = [0u8; 64];
let read_result = tokio::time::timeout(
Duration::from_secs(2),
tokio::io::AsyncReadExt::read(&mut replay_stream, &mut buf),
)
.await;
assert!(
read_result.is_err() || matches!(read_result, Ok(Ok(0)) | Ok(Err(_))),
"replay DataHello should not produce server-side data, got {read_result:?}"
);
assert!(
server_handle.snapshot().rejected_connections >= 1,
"replay DataHello must increment rejected_connections"
);
client.shutdown().await;
server.shutdown().await;
echo_task.abort();
}
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_stale_old_generation_data_hello_is_rejected_after_reconnect() {
let (cert, key) = certificate();
let token = SecretToken::new(b"quic-stale-secret".to_vec()).unwrap();
let first_server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: token.clone(),
allow_public_service_binds: false,
})
.await
.unwrap();
let endpoint = first_server.local_addr();
let first_handle = first_server.handle();
let client = Client::start_quic_insecure_for_test(ClientConfig {
server_addr: endpoint.to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: token.clone(),
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("quic-stale-svc").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new("127.0.0.1", 9).unwrap(),
)],
})
.await
.unwrap();
let client_handle = client.handle();
tokio::time::timeout(Duration::from_secs(10), async {
loop {
if first_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let old_session_id = first_handle.snapshot().effective_binds[0].0;
let rejected_before = first_handle.snapshot().rejected_connections;
first_server.shutdown().await;
let second_server = Server::bind_quic(ServerConfig {
listen_addr: endpoint,
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: token.clone(),
allow_public_service_binds: false,
})
.await
.unwrap();
let second_handle = second_server.handle();
tokio::time::timeout(Duration::from_secs(10), async {
loop {
if second_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let new_session_id = second_handle.snapshot().effective_binds[0].0;
assert_ne!(old_session_id, new_session_id);
let quic = tokio::time::timeout(Duration::from_secs(10), async {
loop {
if let Some(client) = client_handle.quic_client_for_test()
&& client.get_connection().await.map(|_| true).unwrap_or(false)
{
break client;
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
})
.await
.unwrap();
let mut stale_stream = quic.open_stream().await.unwrap();
write_quic_data_hello(
&mut stale_stream,
eggtunnel_proto::DataHello {
session_id: old_session_id,
service_id: ServiceId(1),
connection_id: eggtunnel_proto::ConnectionId([7; 16]),
},
)
.await;
let mut buf = [0u8; 64];
let read_result = tokio::time::timeout(
Duration::from_secs(2),
tokio::io::AsyncReadExt::read(&mut stale_stream, &mut buf),
)
.await;
assert!(
read_result.is_err() || matches!(read_result, Ok(Ok(0)) | Ok(Err(_))),
"stale DataHello should not produce server-side data, got {read_result:?}"
);
assert!(
second_handle.snapshot().rejected_connections > rejected_before,
"stale DataHello must be rejected by the new server"
);
client.shutdown().await;
second_server.shutdown().await;
}
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_stream_saturation_recovers_capacity_and_keeps_unrelated_streams_alive() {
let (cert, key) = certificate();
let ceiling = 2;
let server = Server::bind_quic_with_admission_for_test(
ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: SecretToken::new(b"quic-saturation-secret".to_vec()).unwrap(),
allow_public_service_binds: false,
},
ceiling,
)
.await
.unwrap();
let server_handle = server.handle();
let client = Client::start_quic_insecure_for_test(ClientConfig {
server_addr: server.local_addr().to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: SecretToken::new(b"quic-saturation-secret".to_vec()).unwrap(),
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("quic-saturation-svc").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new("127.0.0.1", 9).unwrap(),
)],
})
.await
.unwrap();
let client_handle = client.handle();
tokio::time::timeout(Duration::from_secs(5), async {
loop {
if server_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let quic = client_handle
.quic_client_for_test()
.expect("client must have an established QUIC client");
let mut admitted = Vec::new();
for _ in 0..ceiling {
let mut stream = quic.open_stream().await.unwrap();
write_quic_data_hello(
&mut stream,
eggtunnel_proto::DataHello {
session_id: SessionId([0; 16]),
service_id: ServiceId(1),
connection_id: eggtunnel_proto::ConnectionId([0; 16]),
},
)
.await;
admitted.push(stream);
}
tokio::time::timeout(Duration::from_secs(5), async {
loop {
if server_handle.snapshot().rejected_connections >= ceiling as u64 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let mut extra = quic.open_stream().await.unwrap();
write_quic_data_hello(
&mut extra,
eggtunnel_proto::DataHello {
session_id: SessionId([0; 16]),
service_id: ServiceId(1),
connection_id: eggtunnel_proto::ConnectionId([0; 16]),
},
)
.await;
let rejected_after_extra = tokio::time::timeout(Duration::from_secs(5), async {
loop {
let snapshot = server_handle.snapshot();
if snapshot.rejected_connections > ceiling as u64 {
break snapshot.rejected_connections;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
assert!(
rejected_after_extra > ceiling as u64,
"extra QUIC stream must be rejected once the ceiling is full, got {rejected_after_extra}"
);
admitted.remove(0);
tokio::time::sleep(Duration::from_millis(50)).await;
let rejected_after_release = server_handle.snapshot().rejected_connections;
let mut follow_up = quic.open_stream().await.unwrap();
write_quic_data_hello(
&mut follow_up,
eggtunnel_proto::DataHello {
session_id: SessionId([0; 16]),
service_id: ServiceId(1),
connection_id: eggtunnel_proto::ConnectionId([0; 16]),
},
)
.await;
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(
server_handle.snapshot().registered_services,
1,
"unrelated admitted stream path must remain operational"
);
assert!(
server_handle.snapshot().rejected_connections >= rejected_after_release,
"follow-up stream must not stall"
);
client.shutdown().await;
server.shutdown().await;
}
#[cfg(feature = "quic")]
struct HalfCloseTarget {
reply: Vec<u8>,
}
#[cfg(feature = "quic")]
impl TargetConnector for HalfCloseTarget {
fn connect(&self, _service: ClientService, _context: TargetContext) -> TargetFuture {
let reply = self.reply.clone();
Box::pin(async move {
let (application, _peer) = tokio::io::duplex(8 * 1024);
let reply_clone = reply.clone();
tokio::spawn(async move {
let (mut read, mut write) = tokio::io::split(application);
let mut request = Vec::new();
let _ = tokio::io::copy(&mut read, &mut request).await;
drop(read);
let _ = write.write_all(&reply_clone).await;
let _ = write.shutdown().await;
});
Ok(Box::new(_peer) as TargetStream)
})
}
}
#[cfg(feature = "quic")]
#[tokio::test]
async fn quic_half_close_preserves_response_after_request_eof() {
let (cert, key) = certificate();
let server = Server::bind_quic(ServerConfig {
listen_addr: "127.0.0.1:0".parse().unwrap(),
certificate_pem: cert.as_bytes().to_vec(),
private_key_pem: key.as_bytes().to_vec(),
token: SecretToken::new(b"quic-half-close-secret".to_vec()).unwrap(),
allow_public_service_binds: false,
})
.await
.unwrap();
let server_handle = server.handle();
let reply = b"response-after-eof".to_vec();
let connector = std::sync::Arc::new(HalfCloseTarget {
reply: reply.clone(),
});
let client = Client::start_quic_insecure_with_connector_for_test(
ClientConfig {
server_addr: server.local_addr().to_string(),
tls_server_name: "localhost".into(),
ca_pem: None,
token: SecretToken::new(b"quic-half-close-secret".to_vec()).unwrap(),
services: vec![ClientService::new(
ServiceId(1),
ServiceName::new("quic-half-close-svc").unwrap(),
RequestedBind::Loopback { port: 0 },
TcpTarget::new("127.0.0.1", 9).unwrap(),
)],
},
connector,
)
.await
.unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
loop {
if server_handle.snapshot().registered_services == 1 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let bind = tokio::time::timeout(Duration::from_secs(5), async {
loop {
if let Some((_, _, bind)) = server_handle.snapshot().effective_binds.first() {
break bind.clone();
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
let addr = SocketAddr::V6(std::net::SocketAddrV6::new(
std::net::Ipv6Addr::from(bind.address),
bind.port,
0,
0,
));
let mut external = TcpStream::connect(addr).await.unwrap();
external.write_all(b"request").await.unwrap();
external.shutdown().await.unwrap();
let mut received = Vec::new();
tokio::time::timeout(Duration::from_secs(5), external.read_to_end(&mut received))
.await
.unwrap()
.unwrap();
assert_eq!(
received, reply,
"QUIC half-close must deliver the target response after request EOF"
);
client.shutdown().await;
server.shutdown().await;
}