use std::{
convert::Infallible,
future::Future,
io::{Read as _, Write as _},
net::TcpListener,
thread,
time::Duration,
};
use bytes::Bytes;
use futures_util::{AsyncReadExt as _, AsyncWriteExt as _};
use http_body::Frame;
use http_body_util::{Full, StreamBody};
use hyper::service::service_fn;
use hyper_util::rt::TokioIo;
use tez::{
Client, Method, StatusCode, Timeouts, Version,
connection::{Http2, Settings},
header, proxy,
};
fn upgrade_peer() -> (String, thread::JoinHandle<()>) {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let peer = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
read_headers(&mut stream);
stream
.write_all(
b"HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nUpgrade: test\r\n\r\nhello",
)
.unwrap();
let mut request = [0; 4];
stream.read_exact(&mut request).unwrap();
assert_eq!(&request, b"ping");
stream.write_all(b"pong").unwrap();
});
(format!("http://{address}/upgrade"), peer)
}
#[tokio::test]
async fn an_http_upgrade_returns_the_connection_with_prefetched_bytes() {
let (url, peer) = upgrade_peer();
let response = Client::new()
.unwrap()
.get(url)
.header(header::CONNECTION, "upgrade")
.header(header::UPGRADE, "test")
.send()
.await
.unwrap();
assert_eq!(response.status(), StatusCode::SWITCHING_PROTOCOLS);
assert_eq!(response.info().attempts(), 1);
assert_eq!(response.info().redirects(), 0);
let mut stream = response.upgrade().await.unwrap();
let mut greeting = [0; 5];
stream.read_exact(&mut greeting).await.unwrap();
assert_eq!(&greeting, b"hello");
stream.write_all(b"ping").await.unwrap();
stream.flush().await.unwrap();
let mut reply = [0; 4];
stream.read_exact(&mut reply).await.unwrap();
assert_eq!(&reply, b"pong");
peer.join().unwrap();
}
#[test]
fn a_blocking_http_upgrade_returns_a_readable_and_writable_connection() {
let (url, peer) = upgrade_peer();
let response = tez::blocking::Client::new()
.unwrap()
.get(url)
.header(header::CONNECTION, "upgrade")
.header(header::UPGRADE, "test")
.send()
.unwrap();
let mut stream = response.upgrade().unwrap();
let mut greeting = [0; 5];
stream.read_exact(&mut greeting).unwrap();
assert_eq!(&greeting, b"hello");
stream.write_all(b"ping").unwrap();
stream.flush().unwrap();
let mut reply = [0; 4];
stream.read_exact(&mut reply).unwrap();
assert_eq!(&reply, b"pong");
peer.join().unwrap();
}
#[derive(Clone)]
struct Spawn;
impl<F> hyper::rt::Executor<F> for Spawn
where
F: Future<Output = ()> + Send + 'static,
{
fn execute(&self, future: F) {
tokio::spawn(future);
}
}
async fn http2_connect_peer() -> (String, tokio::task::JoinHandle<()>) {
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
.await
.unwrap();
let address = listener.local_addr().unwrap();
let peer = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
hyper::server::conn::http2::Builder::new(Spawn)
.serve_connection(
TokioIo::new(stream),
service_fn(|mut request| async move {
assert_eq!(request.version(), Version::HTTP_2);
if request.method() == Method::CONNECT {
let upgrade = hyper::upgrade::on(&mut request);
tokio::spawn(async move {
use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};
let mut tunnel = TokioIo::new(upgrade.await.unwrap());
let mut message = [0; 4];
tunnel.read_exact(&mut message).await.unwrap();
assert_eq!(&message, b"ping");
tunnel.write_all(b"pong").await.unwrap();
});
Ok::<_, Infallible>(hyper::Response::new(Full::new(Bytes::new())))
} else {
assert_eq!(request.method(), Method::GET);
Ok(hyper::Response::new(Full::new(Bytes::from_static(
b"pooled",
))))
}
}),
)
.await
.unwrap();
});
(format!("http://{address}"), peer)
}
#[tokio::test]
async fn an_http2_connect_returns_a_duplex_stream_and_keeps_the_connection_reusable() {
let (base_url, peer) = http2_connect_peer().await;
let client = Client::builder()
.connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
.timeouts(Timeouts::default().total(Duration::from_secs(1)))
.build()
.unwrap();
let response = client
.connect(format!("{base_url}/tunnel"))
.send()
.await
.unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.version(), Version::HTTP_2);
let mut tunnel = response.upgrade().await.unwrap();
tunnel.write_all(b"ping").await.unwrap();
tunnel.flush().await.unwrap();
let mut reply = [0; 4];
tunnel.read_exact(&mut reply).await.unwrap();
assert_eq!(&reply, b"pong");
let response = client
.get(format!("{base_url}/pooled"))
.send()
.await
.unwrap();
assert_eq!(response.version(), Version::HTTP_2);
assert_eq!(response.bytes().await.unwrap(), "pooled");
drop(tunnel);
drop(client);
peer.await.unwrap();
}
#[tokio::test(flavor = "multi_thread")]
async fn a_blocking_http2_connect_returns_a_readable_and_writable_stream() {
let (base_url, peer) = http2_connect_peer().await;
tokio::task::spawn_blocking(move || {
let client = tez::blocking::Client::builder()
.connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
.timeout(Duration::from_secs(1))
.build()
.unwrap();
let response = client.connect(format!("{base_url}/tunnel")).send().unwrap();
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.version(), Version::HTTP_2);
let mut tunnel = response.upgrade().unwrap();
tunnel.write_all(b"ping").unwrap();
tunnel.flush().unwrap();
let mut reply = [0; 4];
tunnel.read_exact(&mut reply).unwrap();
assert_eq!(&reply, b"pong");
let response = client.get(format!("{base_url}/pooled")).send().unwrap();
assert_eq!(response.version(), Version::HTTP_2);
assert_eq!(response.bytes().unwrap(), "pooled");
})
.await
.unwrap();
peer.await.unwrap();
}
#[tokio::test]
async fn cleartext_http2_prior_knowledge_uses_http2_without_an_upgrade() {
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
.await
.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
hyper::server::conn::http2::Builder::new(Spawn)
.serve_connection(
TokioIo::new(stream),
service_fn(|request| async move {
assert_eq!(request.version(), Version::HTTP_2);
Ok::<_, Infallible>(hyper::Response::new(Full::new(Bytes::from_static(b"h2"))))
}),
)
.await
.unwrap();
});
let client = Client::builder()
.connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
.build()
.unwrap();
let response = client
.get(format!("http://{address}/h2"))
.send()
.await
.unwrap();
assert_eq!(response.version(), Version::HTTP_2);
assert_eq!(response.bytes().await.unwrap(), "h2");
drop(client);
server.await.unwrap();
}
#[tokio::test]
async fn slow_http2_response_bodies_report_timeouts() {
let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
.await
.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
let _ = hyper::server::conn::http2::Builder::new(Spawn)
.serve_connection(
TokioIo::new(stream),
service_fn(|_| async move {
let frames = futures_util::stream::once(async {
tokio::time::sleep(Duration::from_millis(100)).await;
Ok::<_, Infallible>(Frame::data(Bytes::from_static(b"late")))
});
Ok::<_, Infallible>(hyper::Response::new(StreamBody::new(frames)))
}),
)
.await;
});
let client = Client::builder()
.connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
.timeouts(
Timeouts::default()
.total(Duration::from_secs(1))
.read(Duration::from_millis(20)),
)
.build()
.unwrap();
let response = client
.get(format!("http://{address}/slow"))
.send()
.await
.unwrap();
assert_eq!(response.version(), Version::HTTP_2);
assert!(response.bytes().await.unwrap_err().is_timeout());
drop(client);
server.await.unwrap();
}
#[tokio::test]
async fn a_socks5h_proxy_resolves_the_destination_and_authenticates() {
let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
let address = listener.local_addr().unwrap();
let proxy_peer = thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
let mut greeting = [0; 3];
stream.read_exact(&mut greeting).unwrap();
assert_eq!(greeting, [5, 1, 2]);
stream.write_all(&[5, 2]).unwrap();
let mut auth_header = [0; 2];
stream.read_exact(&mut auth_header).unwrap();
assert_eq!(auth_header, [1, 4]);
let mut username = [0; 4];
stream.read_exact(&mut username).unwrap();
assert_eq!(&username, b"user");
let mut password_length = [0; 1];
stream.read_exact(&mut password_length).unwrap();
let mut password = vec![0; usize::from(password_length[0])];
stream.read_exact(&mut password).unwrap();
assert_eq!(&password, b"secret");
stream.write_all(&[1, 0]).unwrap();
let mut connect = [0; 5];
stream.read_exact(&mut connect).unwrap();
assert_eq!(&connect[..4], &[5, 1, 0, 3]);
let mut host = vec![0; usize::from(connect[4])];
stream.read_exact(&mut host).unwrap();
assert_eq!(&host, b"origin.invalid");
let mut port = [0; 2];
stream.read_exact(&mut port).unwrap();
assert_eq!(u16::from_be_bytes(port), 80);
stream
.write_all(&[5, 0, 0, 1, 127, 0, 0, 1, 0, 80])
.unwrap();
read_headers(&mut stream);
stream
.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\nConnection: close\r\n\r\nsocks")
.unwrap();
});
let client = Client::builder()
.proxy(proxy::Policy::all(format!(
"socks5h://user:secret@{address}"
)))
.build()
.unwrap();
let response = client
.get("http://origin.invalid/proxied")
.send()
.await
.unwrap();
assert_eq!(response.bytes().await.unwrap(), "socks");
proxy_peer.join().unwrap();
}
fn read_headers(stream: &mut std::net::TcpStream) {
let mut request = Vec::new();
let mut byte = [0; 1];
while !request.ends_with(b"\r\n\r\n") {
stream.read_exact(&mut byte).unwrap();
request.push(byte[0]);
}
}