use std::io;
use std::net::{Ipv4Addr, SocketAddr};
use std::ops::ControlFlow;
use std::time::{Duration, Instant};
use quietquic_proto::endpoint::Endpoint as Core;
use quietquic_proto::freshness::now_minutes;
use quietquic_proto::outcome::ConnectionHandle;
use quietquic_proto::outcome::Event as CoreEvent;
use tokio::net::UdpSocket;
use tokio::sync::{mpsc, oneshot, watch};
use crate::config::{ClientConfigFile, ConfigError};
use crate::conn::{CmdSender, Connection, Parked, Tagged};
const MAX_DATAGRAM: usize = 65_535;
const CMD_CHANNEL_CAP: usize = 256;
const IDLE_SLEEP: Duration = Duration::from_secs(3600);
const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
#[derive(Debug, thiserror::Error)]
pub enum ClientError {
#[error("io: {0}")]
Io(#[from] io::Error),
#[error("tls config: {0}")]
Tls(String),
#[error("connect: {0}")]
Connect(#[from] quinn_proto::ConnectError),
#[error("connection lost during handshake: {0}")]
ConnectionLost(#[from] quinn_proto::ConnectionError),
#[error("handshake ended without connecting")]
HandshakeIncomplete,
#[error("connect timed out")]
TimedOut,
}
fn client_error(err: ConfigError) -> ClientError {
match err {
ConfigError::Io(io) => ClientError::Io(io),
ConfigError::Parse(parse) => ClientError::Io(io::Error::other(parse.to_string())),
ConfigError::Invalid(message) => {
ClientError::Io(io::Error::new(io::ErrorKind::InvalidInput, message))
}
}
}
pub struct Client {
_private: (),
}
impl Client {
pub async fn connect(cfg: ClientConfigFile) -> Result<Connection, ClientError> {
connect(cfg).await
}
}
pub async fn connect(cfg: ClientConfigFile) -> Result<Connection, ClientError> {
connect_with_timeout(cfg, DEFAULT_CONNECT_TIMEOUT).await
}
async fn connect_with_timeout(
cfg: ClientConfigFile,
connect_timeout: Duration,
) -> Result<Connection, ClientError> {
let server_addr = cfg.server;
let bind_addr: SocketAddr = match cfg.bind {
Some(explicit) => {
if explicit.is_ipv4() != server_addr.is_ipv4() {
return Err(ClientError::Io(io::Error::new(
io::ErrorKind::InvalidInput,
format!(
"bind address {explicit} and server address {server_addr} are \
different IP versions"
),
)));
}
explicit
}
None if server_addr.is_ipv4() => (Ipv4Addr::UNSPECIFIED, 0).into(),
None => (std::net::Ipv6Addr::UNSPECIFIED, 0).into(),
};
let socket = UdpSocket::bind(bind_addr).await?;
let now = Instant::now();
let freshness_minute = now_minutes();
let (core, handle) = Core::new_client(now, freshness_minute, cfg).map_err(client_error)?;
let (connected_tx, connected_rx) = oneshot::channel();
let driver = ClientDriver::new(socket, core, handle, connected_tx);
let driver_task = tokio::spawn(driver.run());
match tokio::time::timeout(connect_timeout, connected_rx).await {
Ok(Ok(result)) => result,
Ok(Err(_recv)) => {
Err(ClientError::HandshakeIncomplete)
}
Err(_elapsed) => {
driver_task.abort();
Err(ClientError::TimedOut)
}
}
}
struct ClientDriver {
socket: UdpSocket,
core: Core,
handle: ConnectionHandle,
parked: Parked,
cmd_tx: mpsc::Sender<Tagged>,
cmd_rx: mpsc::Receiver<Tagged>,
connected: Option<oneshot::Sender<Result<Connection, ClientError>>>,
}
impl ClientDriver {
fn new(
socket: UdpSocket,
core: Core,
handle: ConnectionHandle,
connected: oneshot::Sender<Result<Connection, ClientError>>,
) -> Self {
let (cmd_tx, cmd_rx) = mpsc::channel(CMD_CHANNEL_CAP);
let (closed_tx, _closed_rx) = watch::channel(None);
Self {
socket,
core,
handle,
parked: Parked::new(closed_tx),
cmd_tx,
cmd_rx,
connected: Some(connected),
}
}
async fn run(mut self) {
let mut recv_buf = vec![0u8; MAX_DATAGRAM];
loop {
if self.pump().await.is_break() {
return;
}
let sleep = match self.core.next_timeout() {
Some(at) => tokio::time::sleep_until(tokio::time::Instant::from_std(at)),
None => tokio::time::sleep(IDLE_SLEEP),
};
tokio::pin!(sleep);
tokio::select! {
res = self.socket.recv_from(&mut recv_buf) => {
match res {
Ok((len, from)) => {
let _ = self.core.handle_datagram(
Instant::now(), from, &recv_buf[..len],
);
}
Err(_e) => continue, }
}
Some(tagged) = self.cmd_rx.recv() => {
self.on_command(tagged);
}
_ = &mut sleep => {
self.core.handle_timeout(Instant::now());
}
}
}
}
async fn pump(&mut self) -> ControlFlow<()> {
loop {
let now = Instant::now();
let mut progressed = false;
let mut lost = false;
while let Some(event) = self.core.poll_event() {
if self.on_event(event) {
lost = true;
}
progressed = true;
}
while let Some(transmit) = self.core.poll_transmit(now) {
let _ = self
.socket
.send_to(&transmit.contents, transmit.destination)
.await;
progressed = true;
}
if lost {
return ControlFlow::Break(());
}
if !progressed {
return ControlFlow::Continue(());
}
}
}
fn on_event(&mut self, event: CoreEvent) -> bool {
match event {
CoreEvent::Connected(ch) if ch == self.handle => {
self.surface();
false
}
CoreEvent::StreamOpened { conn, .. } if conn == self.handle => {
if let Some(state) = self.core.conn_mut(conn) {
self.parked.on_stream_opened(state);
}
false
}
CoreEvent::StreamReadable { conn, id } if conn == self.handle => {
if let Some(state) = self.core.conn_mut(conn) {
self.parked.on_readable(state, id);
}
false
}
CoreEvent::StreamWritable { conn, id } if conn == self.handle => {
if let Some(state) = self.core.conn_mut(conn) {
self.parked.on_writable(state, id);
}
false
}
CoreEvent::StreamFinAcked { conn, id } if conn == self.handle => {
self.parked.on_fin_acked(id);
false
}
CoreEvent::StreamStopped {
conn,
id,
error_code,
} if conn == self.handle => {
if let Some(state) = self.core.conn_mut(conn) {
self.parked.on_stopped(state, id, error_code);
}
false
}
CoreEvent::ConnectionLost { conn, reason } if conn == self.handle => {
self.parked.mark_closed(reason);
self.parked.fail_all();
if let Some(tx) = self.connected.take() {
let _ = tx.send(Err(ClientError::HandshakeIncomplete));
}
true
}
_ => false,
}
}
fn surface(&mut self) {
let Some(tx) = self.connected.take() else {
return;
};
let Some(state) = self.core.conn_mut(self.handle) else {
return;
};
let remote = state.conn().remote_address();
let cmds = CmdSender::new(self.handle, self.cmd_tx.clone());
let closed = self.parked.subscribe_closed();
let _ = tx.send(Ok(Connection::new(self.handle, remote, None, cmds, closed)));
}
fn on_command(&mut self, tagged: Tagged) {
if tagged.handle != self.handle {
return;
}
if let Some(state) = self.core.conn_mut(self.handle) {
self.parked.apply_cmd(state, tagged.cmd, Instant::now());
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::ClientConfigFile;
fn test_bind_addr() -> SocketAddr {
let ip = std::env::var("QUIETQUIC_TEST_ADDR").unwrap_or_else(|_| "127.0.0.1".into());
let port = std::env::var("QUIETQUIC_TEST_PORT_BASE")
.ok()
.and_then(|base| base.parse::<u16>().ok())
.and_then(|base| base.checked_add(2000))
.unwrap_or(0);
SocketAddr::new(
ip.parse()
.expect("QUIETQUIC_TEST_ADDR must be an IP address"),
port,
)
}
#[tokio::test]
async fn connect_times_out_when_nothing_answers() {
let silent_addr = {
let socket = UdpSocket::bind(test_bind_addr()).await.unwrap();
let addr = socket.local_addr().unwrap();
drop(socket);
addr
};
let psk_hex = "0000000000000000000000000000000000000000000000000000000000000009";
let cfg: ClientConfigFile = toml::from_str(&format!(
"client_id=\"a\"\npsk=\"{psk_hex}\"\nserver=\"{silent_addr}\"\n"
))
.unwrap();
let start = std::time::Instant::now();
let result = tokio::time::timeout(
Duration::from_secs(12),
connect_with_timeout(cfg, Duration::from_millis(500)),
)
.await
.expect("connect_with_timeout itself must not hang past the outer test guard");
match result {
Err(ClientError::TimedOut) => {}
Err(other) => panic!("expected ClientError::TimedOut, got a different error: {other}"),
Ok(_) => panic!("expected ClientError::TimedOut, but connect unexpectedly succeeded"),
}
assert!(
start.elapsed() < Duration::from_secs(2),
"connect should have returned promptly after its short internal timeout, took {:?}",
start.elapsed()
);
}
}