From 0fceadf79919723564ef9033bb6b502fec28d8c1 Mon Sep 17 00:00:00 2001 From: quininer Date: Sun, 11 Aug 2019 00:00:49 +0800 Subject: [PATCH] publish 0.12.0-alpha.1 --- .travis.yml | 4 +- Cargo.toml | 2 +- src/common/test_stream.rs | 198 ++++++++++++++++++-------------------- src/test_0rtt.rs | 15 +-- 4 files changed, 102 insertions(+), 117 deletions(-) diff --git a/.travis.yml b/.travis.yml index cab8ded..b0b0082 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,8 +15,8 @@ matrix: - rust: stable script: - - cargo test --test test - # - cargo test --features early-data + - cargo test + - cargo test --features early-data # - cd examples/server # - cargo check # - cd ../../examples/client diff --git a/Cargo.toml b/Cargo.toml index cb318ff..96e1c79 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "tokio-rustls" -version = "0.12.0-alpha" +version = "0.12.0-alpha.1" authors = ["quininer kel "] license = "MIT/Apache-2.0" repository = "https://github.com/quininer/tokio-rustls" diff --git a/src/common/test_stream.rs b/src/common/test_stream.rs index 335c67d..d109369 100644 --- a/src/common/test_stream.rs +++ b/src/common/test_stream.rs @@ -1,7 +1,9 @@ use std::pin::Pin; use std::sync::Arc; use std::task::{ Poll, Context }; +use futures_core::ready; use futures_util::future::poll_fn; +use futures_util::task::noop_waker_ref; use tokio_io::{ AsyncRead, AsyncWrite, AsyncReadExt, AsyncWriteExt }; use std::io::{ self, Read, Write, BufReader, Cursor }; use webpki::DNSNameRef; @@ -14,7 +16,7 @@ use rustls::{ use super::Stream; -struct Good<'a>(&'a mut Session); +struct Good<'a>(&'a mut dyn Session); impl<'a> AsyncRead for Good<'a> { fn poll_read(mut self: Pin<&mut Self>, _cx: &mut Context<'_>, mut buf: &mut [u8]) -> Poll> { @@ -34,7 +36,7 @@ impl<'a> AsyncWrite for Good<'a> { Poll::Ready(Ok(())) } - fn poll_close(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { + fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { Poll::Ready(Ok(())) } } @@ -60,122 +62,104 @@ impl AsyncWrite for Bad { Poll::Ready(Ok(())) } - fn poll_close(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { + fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll> { Poll::Ready(Ok(())) } } -#[test] -fn stream_good() -> io::Result<()> { +#[tokio::test] +async fn stream_good() -> io::Result<()> { const FILE: &'static [u8] = include_bytes!("../../README.md"); - let fut = async { - let (mut server, mut client) = make_pair(); - poll_fn(|cx| do_handshake(&mut client, &mut server, cx)).await?; - io::copy(&mut Cursor::new(FILE), &mut server)?; - - { - let mut good = Good(&mut server); - let mut stream = Stream::new(&mut good, &mut client); - - let mut buf = Vec::new(); - stream.read_to_end(&mut buf).await?; - assert_eq!(buf, FILE); - stream.write_all(b"Hello World!").await?; - } - - let mut buf = String::new(); - server.read_to_string(&mut buf)?; - assert_eq!(buf, "Hello World!"); - - Ok(()) as io::Result<()> - }; - - executor::block_on(fut) -} - -#[test] -fn stream_bad() -> io::Result<()> { - let fut = async { - let (mut server, mut client) = make_pair(); - poll_fn(|cx| do_handshake(&mut client, &mut server, cx)).await?; - client.set_buffer_limit(1024); - - let mut bad = Bad(true); - let mut stream = Stream::new(&mut bad, &mut client); - assert_eq!(poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x42; 8])).await?, 8); - assert_eq!(poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x42; 8])).await?, 8); - let r = poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x00; 1024])).await?; // fill buffer - assert!(r < 1024); - - let ret = poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x01])); - assert!(ret.is_pending()); - - Ok(()) as io::Result<()> - }; - - executor::block_on(fut) -} - -#[test] -fn stream_handshake() -> io::Result<()> { - let fut = async { - let (mut server, mut client) = make_pair(); - - { - let mut good = Good(&mut server); - let mut stream = Stream::new(&mut good, &mut client); - let (r, w) = poll_fn(|cx| stream.complete_io(cx)).await?; - - assert!(r > 0); - assert!(w > 0); - - poll_fn(|cx| stream.complete_io(cx)).await?; // finish server handshake - } - - assert!(!server.is_handshaking()); - assert!(!client.is_handshaking()); - - Ok(()) as io::Result<()> - }; - - executor::block_on(fut) -} - -#[test] -fn stream_handshake_eof() -> io::Result<()> { - let fut = async { - let (_, mut client) = make_pair(); - - let mut bad = Bad(false); - let mut stream = Stream::new(&mut bad, &mut client); - - let r = poll_fn(|cx| stream.complete_io(&mut cx)).await?; - assert_eq!(r.map_err(|err| err.kind()), Poll::Ready(Err(io::ErrorKind::UnexpectedEof))); - - Ok(()) as io::Result<()> - }; - - executor::block_on(fut) -} - -#[test] -fn stream_eof() -> io::Result<()> { - let fut = async { - let (mut server, mut client) = make_pair(); - poll_fn(|cx| do_handshake(&mut client, &mut server, cx)).await?; + let (mut server, mut client) = make_pair(); + poll_fn(|cx| do_handshake(&mut client, &mut server, cx)).await?; + io::copy(&mut Cursor::new(FILE), &mut server)?; + { let mut good = Good(&mut server); - let mut stream = Stream::new(&mut good, &mut client).set_eof(true); + let mut stream = Stream::new(&mut good, &mut client); let mut buf = Vec::new(); stream.read_to_end(&mut buf).await?; - assert_eq!(buf.len(), 0); + assert_eq!(buf, FILE); + stream.write_all(b"Hello World!").await?; + } - Ok(()) as io::Result<()> - }; + let mut buf = String::new(); + server.read_to_string(&mut buf)?; + assert_eq!(buf, "Hello World!"); - executor::block_on(fut) + Ok(()) as io::Result<()> +} + +#[tokio::test] +async fn stream_bad() -> io::Result<()> { + let (mut server, mut client) = make_pair(); + poll_fn(|cx| do_handshake(&mut client, &mut server, cx)).await?; + client.set_buffer_limit(1024); + + let mut bad = Bad(true); + let mut stream = Stream::new(&mut bad, &mut client); + assert_eq!(poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x42; 8])).await?, 8); + assert_eq!(poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x42; 8])).await?, 8); + let r = poll_fn(|cx| stream.as_mut_pin().poll_write(cx, &[0x00; 1024])).await?; // fill buffer + assert!(r < 1024); + + let mut cx = Context::from_waker(noop_waker_ref()); + let ret = stream.as_mut_pin().poll_write(&mut cx, &[0x01]); + assert!(ret.is_pending()); + + Ok(()) as io::Result<()> +} + +#[tokio::test] +async fn stream_handshake() -> io::Result<()> { + let (mut server, mut client) = make_pair(); + + { + let mut good = Good(&mut server); + let mut stream = Stream::new(&mut good, &mut client); + let (r, w) = poll_fn(|cx| stream.complete_io(cx)).await?; + + assert!(r > 0); + assert!(w > 0); + + poll_fn(|cx| stream.complete_io(cx)).await?; // finish server handshake + } + + assert!(!server.is_handshaking()); + assert!(!client.is_handshaking()); + + Ok(()) as io::Result<()> +} + +#[tokio::test] +async fn stream_handshake_eof() -> io::Result<()> { + let (_, mut client) = make_pair(); + + let mut bad = Bad(false); + let mut stream = Stream::new(&mut bad, &mut client); + + let mut cx = Context::from_waker(noop_waker_ref()); + let r = stream.complete_io(&mut cx); + assert_eq!(r.map_err(|err| err.kind()), Poll::Ready(Err(io::ErrorKind::UnexpectedEof))); + + Ok(()) as io::Result<()> +} + +#[tokio::test] +async fn stream_eof() -> io::Result<()> { + let (mut server, mut client) = make_pair(); + poll_fn(|cx| do_handshake(&mut client, &mut server, cx)).await?; + + let mut good = Good(&mut server); + let mut stream = Stream::new(&mut good, &mut client).set_eof(true); + + let mut buf = Vec::new(); + stream.read_to_end(&mut buf).await?; + assert_eq!(buf.len(), 0); + + Ok(()) as io::Result<()> } fn make_pair() -> (ServerSession, ClientSession) { @@ -203,11 +187,11 @@ fn do_handshake(client: &mut ClientSession, server: &mut ServerSession, cx: &mut let mut stream = Stream::new(&mut good, client); if stream.session.is_handshaking() { - futures::ready!(stream.complete_io(cx))?; + ready!(stream.complete_io(cx))?; } if stream.session.wants_write() { - futures::ready!(stream.complete_io(cx))?; + ready!(stream.complete_io(cx))?; } Poll::Ready(Ok(())) diff --git a/src/test_0rtt.rs b/src/test_0rtt.rs index 8c8db6c..cb3e94b 100644 --- a/src/test_0rtt.rs +++ b/src/test_0rtt.rs @@ -1,9 +1,8 @@ use std::io; use std::sync::Arc; use std::net::ToSocketAddrs; -use futures::executor; -use futures::prelude::*; -use romio::tcp::TcpStream; +use tokio::prelude::*; +use tokio::net::TcpStream; use rustls::ClientConfig; use crate::{ TlsConnector, client::TlsStream }; @@ -28,19 +27,21 @@ async fn get(config: Arc, domain: &str, rtt0: bool) Ok((stream, String::from_utf8(buf).unwrap())) } -#[test] -fn test_0rtt() { +#[tokio::test] +async fn test_0rtt() -> io::Result<()> { let mut config = ClientConfig::new(); config.root_store.add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); config.enable_early_data = true; let config = Arc::new(config); let domain = "mozilla-modern.badssl.com"; - let (_, output) = executor::block_on(get(config.clone(), domain, false)).unwrap(); + let (_, output) = get(config.clone(), domain, false).await?; assert!(output.contains("mozilla-modern.badssl.com")); - let (io, output) = executor::block_on(get(config.clone(), domain, true)).unwrap(); + let (io, output) = get(config.clone(), domain, true).await?; assert!(output.contains("mozilla-modern.badssl.com")); assert_eq!(io.early_data.0, 0); + + Ok(()) }