diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index c853db4b..3cd45742 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -17,7 +17,7 @@ jobs: - stable - beta - nightly - - 1.50.0 + - 1.51.0 os: [ubuntu-18.04] # but only stable on macos/windows (slower platforms) include: diff --git a/Cargo.toml b/Cargo.toml index 0b88c3db..69404756 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -20,7 +20,6 @@ tokio-rustls = { version = "0.23", default-features = false } webpki-roots = { version = "0.22", optional = true } [dev-dependencies] -async-stream = "0.3.0" futures-util = { version = "0.3.1", default-features = false } hyper = { version = "0.14", features = ["full"] } rustls = { version = "0.20.1", default-features = false, features = ["tls12"] } diff --git a/examples/server.rs b/examples/server.rs index 9b835b0d..8e381321 100644 --- a/examples/server.rs +++ b/examples/server.rs @@ -4,15 +4,19 @@ //! Certificate and private key are hardcoded to sample files. //! hyper will automatically use HTTP/2 if a client starts talking HTTP/2, //! otherwise HTTP/1.1 will be used. -use std::{env, fs, io, sync}; - -use async_stream::stream; -use futures_util::future::TryFutureExt; -use hyper::server::accept; +use core::task::{Context, Poll}; +use futures_util::ready; +use hyper::server::accept::Accept; +use hyper::server::conn::{AddrIncoming, AddrStream}; use hyper::service::{make_service_fn, service_fn}; use hyper::{Body, Method, Request, Response, Server, StatusCode}; -use tokio::net::TcpListener; -use tokio_rustls::TlsAcceptor; +use std::future::Future; +use std::pin::Pin; +use std::sync::Arc; +use std::vec::Vec; +use std::{env, fs, io, sync}; +use tokio::io::{AsyncRead, AsyncWrite, ReadBuf}; +use tokio_rustls::rustls::ServerConfig; fn main() { // Serve an echo service over HTTPS, with proper error handling. @@ -33,7 +37,7 @@ async fn run_server() -> Result<(), Box> { Some(ref p) => p.to_owned(), None => "1337".to_owned(), }; - let addr = format!("127.0.0.1:{}", port); + let addr = format!("127.0.0.1:{}", port).parse()?; // Build TLS configuration. let tls_cfg = { @@ -53,24 +57,9 @@ async fn run_server() -> Result<(), Box> { }; // Create a TCP listener via tokio. - let tcp = TcpListener::bind(&addr).await?; - let tls_acceptor = TlsAcceptor::from(tls_cfg); - // Prepare a long-running future stream to accept and serve clients. - let incoming_tls_stream = stream! { - loop { - let (socket, _) = tcp.accept().await?; - let stream = tls_acceptor.accept(socket).map_err(|e| { - println!("[!] Voluntary server halt due to client-connection error..."); - // Errors could be handled here, instead of server aborting. - // Ok(None) - error(format!("TLS Error: {:?}", e)) - }); - yield stream.await; - } - }; - let acceptor = accept::from_stream(incoming_tls_stream); + let incoming = AddrIncoming::bind(&addr)?; let service = make_service_fn(|_| async { Ok::<_, io::Error>(service_fn(echo)) }); - let server = Server::builder(acceptor).serve(service); + let server = Server::builder(TlsAcceptor::new(tls_cfg, incoming)).serve(service); // Run the future, keep going until an error occurs. println!("Starting to serve on https://{}.", addr); @@ -78,6 +67,111 @@ async fn run_server() -> Result<(), Box> { Ok(()) } +enum State { + Handshaking(tokio_rustls::Accept), + Streaming(tokio_rustls::server::TlsStream), +} + +// tokio_rustls::server::TlsStream doesn't expose constructor methods, +// so we have to TlsAcceptor::accept and handshake to have access to it +// TlsStream implements AsyncRead/AsyncWrite handshaking tokio_rustls::Accept first +pub struct TlsStream { + state: State, +} + +impl TlsStream { + fn new(stream: AddrStream, config: Arc) -> TlsStream { + let accept = tokio_rustls::TlsAcceptor::from(config).accept(stream); + TlsStream { + state: State::Handshaking(accept), + } + } +} + +impl AsyncRead for TlsStream { + fn poll_read( + self: Pin<&mut Self>, + cx: &mut Context, + buf: &mut ReadBuf, + ) -> Poll> { + let pin = self.get_mut(); + match pin.state { + State::Handshaking(ref mut accept) => match ready!(Pin::new(accept).poll(cx)) { + Ok(mut stream) => { + let result = Pin::new(&mut stream).poll_read(cx, buf); + pin.state = State::Streaming(stream); + result + } + Err(err) => Poll::Ready(Err(err)), + }, + State::Streaming(ref mut stream) => Pin::new(stream).poll_read(cx, buf), + } + } +} + +impl AsyncWrite for TlsStream { + fn poll_write( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + buf: &[u8], + ) -> Poll> { + let pin = self.get_mut(); + match pin.state { + State::Handshaking(ref mut accept) => match ready!(Pin::new(accept).poll(cx)) { + Ok(mut stream) => { + let result = Pin::new(&mut stream).poll_write(cx, buf); + pin.state = State::Streaming(stream); + result + } + Err(err) => Poll::Ready(Err(err)), + }, + State::Streaming(ref mut stream) => Pin::new(stream).poll_write(cx, buf), + } + } + + fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + match self.state { + State::Handshaking(_) => Poll::Ready(Ok(())), + State::Streaming(ref mut stream) => Pin::new(stream).poll_flush(cx), + } + } + + fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + match self.state { + State::Handshaking(_) => Poll::Ready(Ok(())), + State::Streaming(ref mut stream) => Pin::new(stream).poll_shutdown(cx), + } + } +} + +pub struct TlsAcceptor { + config: Arc, + incoming: AddrIncoming, +} + +impl TlsAcceptor { + pub fn new(config: Arc, incoming: AddrIncoming) -> TlsAcceptor { + TlsAcceptor { config, incoming } + } +} + +impl Accept for TlsAcceptor { + type Conn = TlsStream; + type Error = io::Error; + + fn poll_accept( + self: Pin<&mut Self>, + cx: &mut Context<'_>, + ) -> Poll>> { + let pin = self.get_mut(); + match ready!(Pin::new(&mut pin.incoming).poll_accept(cx)) { + Some(Ok(sock)) => Poll::Ready(Some(Ok(TlsStream::new(sock, pin.config.clone())))), + Some(Err(e)) => Poll::Ready(Some(Err(e))), + None => Poll::Ready(None), + } + } +} + // Custom echo service, handling two different routes and a // catch-all 404 responder. async fn echo(req: Request) -> Result, hyper::Error> {