Tokio 0.3 (#29)
* Remove futures-core * Upgrade Tokio 0.3 * clean code * Fix ci * Fix lint
This commit is contained in:
parent
c3bf063eb6
commit
e6ef54641b
@ -5,7 +5,7 @@
|
||||
rust_2018_idioms,
|
||||
unreachable_pub
|
||||
)]
|
||||
#![deny(intra_doc_link_resolution_failure)]
|
||||
#![deny(broken_intra_doc_links)]
|
||||
#![doc(test(
|
||||
no_crate_inject,
|
||||
attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
|
||||
|
@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "tokio-rustls"
|
||||
version = "0.14.1"
|
||||
version = "0.20.0"
|
||||
authors = ["quininer kel <quininer@live.com>"]
|
||||
license = "MIT/Apache-2.0"
|
||||
repository = "https://github.com/tokio-rs/tls"
|
||||
@ -12,20 +12,16 @@ categories = ["asynchronous", "cryptography", "network-programming"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
tokio = "0.2.0"
|
||||
futures-core = "0.3.1"
|
||||
tokio = "0.3"
|
||||
rustls = "0.18"
|
||||
webpki = "0.21"
|
||||
|
||||
bytes = { version = "0.5", optional = true }
|
||||
|
||||
[features]
|
||||
early-data = []
|
||||
dangerous_configuration = ["rustls/dangerous_configuration"]
|
||||
unstable = ["bytes"]
|
||||
|
||||
[dev-dependencies]
|
||||
tokio = { version = "0.2.0", features = ["macros", "net", "io-util", "rt-core", "time"] }
|
||||
tokio = { version = "0.3", features = ["full"] }
|
||||
futures-util = "0.3.1"
|
||||
lazy_static = "1"
|
||||
webpki-roots = "0.20"
|
||||
|
@ -5,7 +5,7 @@ authors = ["quininer <quininer@live.com>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
tokio = { version = "0.2", features = [ "full" ] }
|
||||
tokio = { version = "0.3", features = [ "full" ] }
|
||||
argh = "0.1"
|
||||
tokio-rustls = { path = "../.." }
|
||||
webpki-roots = "0.20"
|
||||
|
@ -5,6 +5,6 @@ authors = ["quininer <quininer@live.com>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
tokio = { version = "0.2", features = [ "full" ] }
|
||||
tokio = { version = "0.3", features = [ "full" ] }
|
||||
argh = "0.1"
|
||||
tokio-rustls = { path = "../.." }
|
||||
|
@ -59,7 +59,7 @@ async fn main() -> io::Result<()> {
|
||||
.map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
|
||||
let acceptor = TlsAcceptor::from(Arc::new(config));
|
||||
|
||||
let mut listener = TcpListener::bind(&addr).await?;
|
||||
let listener = TcpListener::bind(&addr).await?;
|
||||
|
||||
loop {
|
||||
let (stream, peer_addr) = listener.accept().await?;
|
||||
|
@ -52,16 +52,11 @@ impl<IO> AsyncRead for TlsStream<IO>
|
||||
where
|
||||
IO: AsyncRead + AsyncWrite + Unpin,
|
||||
{
|
||||
#[cfg(feature = "unstable")]
|
||||
unsafe fn prepare_uninitialized_buffer(&self, _buf: &mut [std::mem::MaybeUninit<u8>]) -> bool {
|
||||
false
|
||||
}
|
||||
|
||||
fn poll_read(
|
||||
self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
buf: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
buf: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
match self.state {
|
||||
#[cfg(feature = "early-data")]
|
||||
TlsState::EarlyData(..) => Poll::Pending,
|
||||
@ -69,21 +64,24 @@ where
|
||||
let this = self.get_mut();
|
||||
let mut stream =
|
||||
Stream::new(&mut this.io, &mut this.session).set_eof(!this.state.readable());
|
||||
let prev = buf.remaining();
|
||||
|
||||
match stream.as_mut_pin().poll_read(cx, buf) {
|
||||
Poll::Ready(Ok(0)) => {
|
||||
this.state.shutdown_read();
|
||||
Poll::Ready(Ok(0))
|
||||
Poll::Ready(Ok(())) => {
|
||||
if prev == buf.remaining() {
|
||||
this.state.shutdown_read();
|
||||
}
|
||||
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
Poll::Ready(Ok(n)) => Poll::Ready(Ok(n)),
|
||||
Poll::Ready(Err(ref e)) if e.kind() == io::ErrorKind::ConnectionAborted => {
|
||||
this.state.shutdown_read();
|
||||
Poll::Ready(Ok(0))
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
output => output,
|
||||
}
|
||||
}
|
||||
TlsState::ReadShutdown | TlsState::FullyShutdown => Poll::Ready(Ok(0)),
|
||||
TlsState::ReadShutdown | TlsState::FullyShutdown => Poll::Ready(Ok(())),
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -107,7 +105,6 @@ where
|
||||
match this.state {
|
||||
#[cfg(feature = "early-data")]
|
||||
TlsState::EarlyData(ref mut pos, ref mut data) => {
|
||||
use futures_core::ready;
|
||||
use std::io::Write;
|
||||
|
||||
// write early data
|
||||
@ -153,8 +150,6 @@ where
|
||||
|
||||
#[cfg(feature = "early-data")]
|
||||
{
|
||||
use futures_core::ready;
|
||||
|
||||
if let TlsState::EarlyData(ref mut pos, ref mut data) = this.state {
|
||||
// complete handshake
|
||||
while stream.session.is_handshaking() {
|
||||
|
@ -1,5 +1,4 @@
|
||||
use crate::common::{Stream, TlsState};
|
||||
use futures_core::future::FusedFuture;
|
||||
use rustls::Session;
|
||||
use std::future::Future;
|
||||
use std::pin::Pin;
|
||||
@ -21,21 +20,6 @@ pub(crate) enum MidHandshake<IS> {
|
||||
End,
|
||||
}
|
||||
|
||||
impl<IS> FusedFuture for MidHandshake<IS>
|
||||
where
|
||||
IS: IoSession + Unpin,
|
||||
IS::Io: AsyncRead + AsyncWrite + Unpin,
|
||||
IS::Session: Session + Unpin,
|
||||
{
|
||||
fn is_terminated(&self) -> bool {
|
||||
if let MidHandshake::End = self {
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<IS> Future for MidHandshake<IS>
|
||||
where
|
||||
IS: IoSession + Unpin,
|
||||
|
@ -1,15 +1,11 @@
|
||||
mod handshake;
|
||||
|
||||
#[cfg(feature = "unstable")]
|
||||
mod vecbuf;
|
||||
|
||||
use futures_core as futures;
|
||||
pub(crate) use handshake::{IoSession, MidHandshake};
|
||||
use rustls::Session;
|
||||
use std::io::{self, Read, Write};
|
||||
use std::pin::Pin;
|
||||
use std::task::{Context, Poll};
|
||||
use tokio::io::{AsyncRead, AsyncWrite};
|
||||
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum TlsState {
|
||||
@ -40,27 +36,18 @@ impl TlsState {
|
||||
|
||||
#[inline]
|
||||
pub fn writeable(&self) -> bool {
|
||||
match *self {
|
||||
TlsState::WriteShutdown | TlsState::FullyShutdown => false,
|
||||
_ => true,
|
||||
}
|
||||
!matches!(*self, TlsState::WriteShutdown | TlsState::FullyShutdown)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn readable(&self) -> bool {
|
||||
match self {
|
||||
TlsState::ReadShutdown | TlsState::FullyShutdown => false,
|
||||
_ => true,
|
||||
}
|
||||
!matches!(*self, TlsState::ReadShutdown | TlsState::FullyShutdown)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[cfg(feature = "early-data")]
|
||||
pub fn is_early_data(&self) -> bool {
|
||||
match self {
|
||||
TlsState::EarlyData(..) => true,
|
||||
_ => false,
|
||||
}
|
||||
matches!(self, TlsState::EarlyData(..))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
@ -105,8 +92,10 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> Stream<'a, IO, S> {
|
||||
impl<'a, 'b, T: AsyncRead + Unpin> Read for Reader<'a, 'b, T> {
|
||||
#[inline]
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
match Pin::new(&mut self.io).poll_read(self.cx, buf) {
|
||||
Poll::Ready(result) => result,
|
||||
let mut buf = ReadBuf::new(buf);
|
||||
match Pin::new(&mut self.io).poll_read(self.cx, &mut buf) {
|
||||
Poll::Ready(Ok(())) => Ok(buf.filled().len()),
|
||||
Poll::Ready(Err(err)) => Err(err),
|
||||
Poll::Pending => Err(io::ErrorKind::WouldBlock.into()),
|
||||
}
|
||||
}
|
||||
@ -133,9 +122,6 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> Stream<'a, IO, S> {
|
||||
}
|
||||
|
||||
pub fn write_io(&mut self, cx: &mut Context) -> Poll<io::Result<usize>> {
|
||||
#[cfg(feature = "unstable")]
|
||||
use std::io::IoSlice;
|
||||
|
||||
struct Writer<'a, 'b, T> {
|
||||
io: &'a mut T,
|
||||
cx: &'a mut Context<'b>,
|
||||
@ -150,19 +136,6 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> Stream<'a, IO, S> {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "unstable")]
|
||||
#[inline]
|
||||
fn write_vectored(&mut self, bufs: &[IoSlice]) -> io::Result<usize> {
|
||||
use vecbuf::VecBuf;
|
||||
|
||||
let mut vbuf = VecBuf::new(bufs);
|
||||
|
||||
match Pin::new(&mut self.io).poll_write_buf(self.cx, &mut vbuf) {
|
||||
Poll::Ready(result) => result,
|
||||
Poll::Pending => Err(io::ErrorKind::WouldBlock.into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
match Pin::new(&mut self.io).poll_flush(self.cx) {
|
||||
Poll::Ready(result) => result,
|
||||
@ -232,12 +205,12 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> Stream<'a, IO, S> {
|
||||
impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> AsyncRead for Stream<'a, IO, S> {
|
||||
fn poll_read(
|
||||
mut self: Pin<&mut Self>,
|
||||
cx: &mut Context,
|
||||
buf: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
let mut pos = 0;
|
||||
cx: &mut Context<'_>,
|
||||
buf: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
let prev = buf.remaining();
|
||||
|
||||
while pos != buf.len() {
|
||||
while buf.remaining() != 0 {
|
||||
let mut would_block = false;
|
||||
|
||||
// read a packet
|
||||
@ -256,22 +229,28 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> AsyncRead for Stream<'a
|
||||
}
|
||||
}
|
||||
|
||||
return match self.session.read(&mut buf[pos..]) {
|
||||
Ok(0) if pos == 0 && would_block => Poll::Pending,
|
||||
Ok(n) if self.eof || would_block => Poll::Ready(Ok(pos + n)),
|
||||
return match self.session.read(buf.initialize_unfilled()) {
|
||||
Ok(0) if prev == buf.remaining() && would_block => Poll::Pending,
|
||||
Ok(n) => {
|
||||
pos += n;
|
||||
continue;
|
||||
buf.advance(n);
|
||||
|
||||
if self.eof || would_block {
|
||||
break;
|
||||
} else {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => Poll::Pending,
|
||||
Err(ref err) if err.kind() == io::ErrorKind::ConnectionAborted && pos != 0 => {
|
||||
Poll::Ready(Ok(pos))
|
||||
Err(ref err)
|
||||
if err.kind() == io::ErrorKind::ConnectionAborted
|
||||
&& prev != buf.remaining() =>
|
||||
{
|
||||
break
|
||||
}
|
||||
Err(err) => Poll::Ready(Err(err)),
|
||||
};
|
||||
}
|
||||
|
||||
Poll::Ready(Ok(pos))
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
}
|
||||
|
||||
@ -288,7 +267,6 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> AsyncWrite for Stream<'
|
||||
|
||||
match self.session.write(&buf[pos..]) {
|
||||
Ok(n) => pos += n,
|
||||
Err(ref err) if err.kind() == io::ErrorKind::WouldBlock => (),
|
||||
Err(err) => return Poll::Ready(Err(err)),
|
||||
};
|
||||
|
||||
@ -316,14 +294,14 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> AsyncWrite for Stream<'
|
||||
fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<io::Result<()>> {
|
||||
self.session.flush()?;
|
||||
while self.session.wants_write() {
|
||||
futures::ready!(self.write_io(cx))?;
|
||||
ready!(self.write_io(cx))?;
|
||||
}
|
||||
Pin::new(&mut self.io).poll_flush(cx)
|
||||
}
|
||||
|
||||
fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
|
||||
while self.session.wants_write() {
|
||||
futures::ready!(self.write_io(cx))?;
|
||||
ready!(self.write_io(cx))?;
|
||||
}
|
||||
Pin::new(&mut self.io).poll_shutdown(cx)
|
||||
}
|
||||
|
@ -1,5 +1,4 @@
|
||||
use super::Stream;
|
||||
use futures_core::ready;
|
||||
use futures_util::future::poll_fn;
|
||||
use futures_util::task::noop_waker_ref;
|
||||
use rustls::internal::pemfile::{certs, rsa_private_keys};
|
||||
@ -8,7 +7,7 @@ use std::io::{self, BufReader, Cursor, Read, Write};
|
||||
use std::pin::Pin;
|
||||
use std::sync::Arc;
|
||||
use std::task::{Context, Poll};
|
||||
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
|
||||
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
|
||||
use webpki::DNSNameRef;
|
||||
|
||||
struct Good<'a>(&'a mut dyn Session);
|
||||
@ -17,9 +16,17 @@ impl<'a> AsyncRead for Good<'a> {
|
||||
fn poll_read(
|
||||
mut self: Pin<&mut Self>,
|
||||
_cx: &mut Context<'_>,
|
||||
mut buf: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
Poll::Ready(self.0.write_tls(buf.by_ref()))
|
||||
buf: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
let mut buf2 = buf.initialize_unfilled();
|
||||
|
||||
Poll::Ready(match self.0.write_tls(buf2.by_ref()) {
|
||||
Ok(n) => {
|
||||
buf.advance(n);
|
||||
Ok(())
|
||||
}
|
||||
Err(err) => Err(err),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@ -55,8 +62,8 @@ impl AsyncRead for Pending {
|
||||
fn poll_read(
|
||||
self: Pin<&mut Self>,
|
||||
_cx: &mut Context<'_>,
|
||||
_: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
_: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
Poll::Pending
|
||||
}
|
||||
}
|
||||
@ -85,9 +92,9 @@ impl AsyncRead for Eof {
|
||||
fn poll_read(
|
||||
self: Pin<&mut Self>,
|
||||
_cx: &mut Context<'_>,
|
||||
_: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
Poll::Ready(Ok(0))
|
||||
_: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,140 +0,0 @@
|
||||
use bytes::Buf;
|
||||
use std::cmp::{self, Ordering};
|
||||
use std::io::IoSlice;
|
||||
|
||||
pub struct VecBuf<'a> {
|
||||
pos: usize,
|
||||
cur: usize,
|
||||
inner: &'a [IoSlice<'a>],
|
||||
}
|
||||
|
||||
impl<'a> VecBuf<'a> {
|
||||
pub fn new(vbytes: &'a [IoSlice<'a>]) -> Self {
|
||||
VecBuf {
|
||||
pos: 0,
|
||||
cur: 0,
|
||||
inner: vbytes,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> Buf for VecBuf<'a> {
|
||||
fn remaining(&self) -> usize {
|
||||
let sum = self
|
||||
.inner
|
||||
.iter()
|
||||
.skip(self.pos)
|
||||
.map(|bytes| bytes.len())
|
||||
.sum::<usize>();
|
||||
sum - self.cur
|
||||
}
|
||||
|
||||
fn bytes(&self) -> &[u8] {
|
||||
&self.inner[self.pos][self.cur..]
|
||||
}
|
||||
|
||||
fn advance(&mut self, cnt: usize) {
|
||||
let current = self.inner[self.pos].len();
|
||||
match (self.cur + cnt).cmp(¤t) {
|
||||
Ordering::Equal => {
|
||||
if self.pos + 1 < self.inner.len() {
|
||||
self.pos += 1;
|
||||
self.cur = 0;
|
||||
} else {
|
||||
self.cur += cnt;
|
||||
}
|
||||
}
|
||||
Ordering::Greater => {
|
||||
if self.pos + 1 < self.inner.len() {
|
||||
self.pos += 1;
|
||||
}
|
||||
let remaining = self.cur + cnt - current;
|
||||
self.advance(remaining);
|
||||
}
|
||||
Ordering::Less => self.cur += cnt,
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::needless_range_loop)]
|
||||
#[inline]
|
||||
fn bytes_vectored<'c>(&'c self, dst: &mut [IoSlice<'c>]) -> usize {
|
||||
let len = cmp::min(self.inner.len() - self.pos, dst.len());
|
||||
|
||||
if len > 0 {
|
||||
dst[0] = IoSlice::new(self.bytes());
|
||||
}
|
||||
|
||||
for i in 1..len {
|
||||
dst[i] = self.inner[self.pos + i];
|
||||
}
|
||||
|
||||
len
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test_vecbuf {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_fresh_cursor_vec() {
|
||||
let buf = [IoSlice::new(b"he"), IoSlice::new(b"llo")];
|
||||
let mut buf = VecBuf::new(&buf);
|
||||
|
||||
assert_eq!(buf.remaining(), 5);
|
||||
assert_eq!(buf.bytes(), b"he");
|
||||
|
||||
buf.advance(1);
|
||||
|
||||
assert_eq!(buf.remaining(), 4);
|
||||
assert_eq!(buf.bytes(), b"e");
|
||||
|
||||
buf.advance(1);
|
||||
|
||||
assert_eq!(buf.remaining(), 3);
|
||||
assert_eq!(buf.bytes(), b"llo");
|
||||
|
||||
buf.advance(3);
|
||||
|
||||
assert_eq!(buf.remaining(), 0);
|
||||
assert_eq!(buf.bytes(), b"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_get_u8() {
|
||||
let buf = [IoSlice::new(b"\x21z"), IoSlice::new(b"omg")];
|
||||
let mut buf = VecBuf::new(&buf);
|
||||
assert_eq!(0x21, buf.get_u8());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_get_u16() {
|
||||
let buf = [IoSlice::new(b"\x21\x54z"), IoSlice::new(b"omg")];
|
||||
let mut buf = VecBuf::new(&buf);
|
||||
assert_eq!(0x2154, buf.get_u16());
|
||||
let buf = [IoSlice::new(b"\x21\x54z"), IoSlice::new(b"omg")];
|
||||
let mut buf = VecBuf::new(&buf);
|
||||
assert_eq!(0x5421, buf.get_u16_le());
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn test_get_u16_buffer_underflow() {
|
||||
let buf = [IoSlice::new(b"\x21")];
|
||||
let mut buf = VecBuf::new(&buf);
|
||||
buf.get_u16();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bufs_vec() {
|
||||
let buf = [IoSlice::new(b"he"), IoSlice::new(b"llo")];
|
||||
let buf = VecBuf::new(&buf);
|
||||
|
||||
let b1: &[u8] = &mut [0];
|
||||
let b2: &[u8] = &mut [0];
|
||||
|
||||
let mut dst: [IoSlice; 2] = [IoSlice::new(b1), IoSlice::new(b2)];
|
||||
|
||||
assert_eq!(2, buf.bytes_vectored(&mut dst[..]));
|
||||
}
|
||||
}
|
@ -1,18 +1,26 @@
|
||||
//! Asynchronous TLS/SSL streams for Tokio using [Rustls](https://github.com/ctz/rustls).
|
||||
|
||||
macro_rules! ready {
|
||||
( $e:expr ) => {
|
||||
match $e {
|
||||
std::task::Poll::Ready(t) => t,
|
||||
std::task::Poll::Pending => return std::task::Poll::Pending,
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
pub mod client;
|
||||
mod common;
|
||||
pub mod server;
|
||||
|
||||
use common::{MidHandshake, Stream, TlsState};
|
||||
use futures_core::future::FusedFuture;
|
||||
use rustls::{ClientConfig, ClientSession, ServerConfig, ServerSession, Session};
|
||||
use std::future::Future;
|
||||
use std::io;
|
||||
use std::pin::Pin;
|
||||
use std::sync::Arc;
|
||||
use std::task::{Context, Poll};
|
||||
use tokio::io::{AsyncRead, AsyncWrite};
|
||||
use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
|
||||
use webpki::DNSNameRef;
|
||||
|
||||
pub use rustls;
|
||||
@ -155,13 +163,6 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Connect<IO> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> FusedFuture for Connect<IO> {
|
||||
#[inline]
|
||||
fn is_terminated(&self) -> bool {
|
||||
self.0.is_terminated()
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Accept<IO> {
|
||||
type Output = io::Result<server::TlsStream<IO>>;
|
||||
|
||||
@ -171,13 +172,6 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Accept<IO> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> FusedFuture for Accept<IO> {
|
||||
#[inline]
|
||||
fn is_terminated(&self) -> bool {
|
||||
self.0.is_terminated()
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FailableConnect<IO> {
|
||||
type Output = Result<client::TlsStream<IO>, (io::Error, IO)>;
|
||||
|
||||
@ -187,13 +181,6 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FailableConnect<IO> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> FusedFuture for FailableConnect<IO> {
|
||||
#[inline]
|
||||
fn is_terminated(&self) -> bool {
|
||||
self.0.is_terminated()
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FailableAccept<IO> {
|
||||
type Output = Result<server::TlsStream<IO>, (io::Error, IO)>;
|
||||
|
||||
@ -203,13 +190,6 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for FailableAccept<IO> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<IO: AsyncRead + AsyncWrite + Unpin> FusedFuture for FailableAccept<IO> {
|
||||
#[inline]
|
||||
fn is_terminated(&self) -> bool {
|
||||
self.0.is_terminated()
|
||||
}
|
||||
}
|
||||
|
||||
/// Unified TLS stream type
|
||||
///
|
||||
/// This abstracts over the inner `client::TlsStream` and `server::TlsStream`, so you can use
|
||||
@ -269,8 +249,8 @@ where
|
||||
fn poll_read(
|
||||
self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
buf: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
buf: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
match self.get_mut() {
|
||||
TlsStream::Client(x) => Pin::new(x).poll_read(cx, buf),
|
||||
TlsStream::Server(x) => Pin::new(x).poll_read(cx, buf),
|
||||
|
@ -52,40 +52,36 @@ impl<IO> AsyncRead for TlsStream<IO>
|
||||
where
|
||||
IO: AsyncRead + AsyncWrite + Unpin,
|
||||
{
|
||||
#[cfg(feature = "unstable")]
|
||||
unsafe fn prepare_uninitialized_buffer(&self, _buf: &mut [std::mem::MaybeUninit<u8>]) -> bool {
|
||||
// TODO
|
||||
//
|
||||
// https://doc.rust-lang.org/nightly/std/io/trait.Read.html#method.initializer
|
||||
false
|
||||
}
|
||||
|
||||
fn poll_read(
|
||||
self: Pin<&mut Self>,
|
||||
cx: &mut Context<'_>,
|
||||
buf: &mut [u8],
|
||||
) -> Poll<io::Result<usize>> {
|
||||
buf: &mut ReadBuf<'_>,
|
||||
) -> Poll<io::Result<()>> {
|
||||
let this = self.get_mut();
|
||||
let mut stream =
|
||||
Stream::new(&mut this.io, &mut this.session).set_eof(!this.state.readable());
|
||||
|
||||
match &this.state {
|
||||
TlsState::Stream | TlsState::WriteShutdown => {
|
||||
let prev = buf.remaining();
|
||||
|
||||
match stream.as_mut_pin().poll_read(cx, buf) {
|
||||
Poll::Ready(Ok(0)) => {
|
||||
this.state.shutdown_read();
|
||||
Poll::Ready(Ok(0))
|
||||
Poll::Ready(Ok(())) => {
|
||||
if prev == buf.remaining() {
|
||||
this.state.shutdown_read();
|
||||
}
|
||||
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
Poll::Ready(Ok(n)) => Poll::Ready(Ok(n)),
|
||||
Poll::Ready(Err(ref err)) if err.kind() == io::ErrorKind::ConnectionAborted => {
|
||||
this.state.shutdown_read();
|
||||
Poll::Ready(Ok(0))
|
||||
Poll::Ready(Ok(()))
|
||||
}
|
||||
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
|
||||
Poll::Pending => Poll::Pending,
|
||||
}
|
||||
}
|
||||
TlsState::ReadShutdown | TlsState::FullyShutdown => Poll::Ready(Ok(0)),
|
||||
TlsState::ReadShutdown | TlsState::FullyShutdown => Poll::Ready(Ok(())),
|
||||
#[cfg(feature = "early-data")]
|
||||
s => unreachable!("server TLS can not hit this state: {:?}", s),
|
||||
}
|
||||
|
@ -9,9 +9,10 @@ use std::process::{Child, Command, Stdio};
|
||||
use std::sync::Arc;
|
||||
use std::task::{Context, Poll};
|
||||
use std::time::Duration;
|
||||
use tokio::io::ReadBuf;
|
||||
use tokio::net::TcpStream;
|
||||
use tokio::prelude::*;
|
||||
use tokio::time::delay_for;
|
||||
use tokio::time::sleep;
|
||||
use tokio_rustls::{client::TlsStream, TlsConnector};
|
||||
|
||||
struct Read1<T>(T);
|
||||
@ -21,6 +22,7 @@ impl<T: AsyncRead + Unpin> Future for Read1<T> {
|
||||
|
||||
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
let mut buf = [0];
|
||||
let mut buf = &mut ReadBuf::new(&mut buf);
|
||||
ready!(Pin::new(&mut self.0).poll_read(cx, &mut buf))?;
|
||||
Poll::Pending
|
||||
}
|
||||
@ -42,7 +44,7 @@ async fn send(
|
||||
// sleep 1s
|
||||
//
|
||||
// see https://www.mail-archive.com/openssl-users@openssl.org/msg84451.html
|
||||
let sleep1 = delay_for(Duration::from_secs(1));
|
||||
let sleep1 = sleep(Duration::from_secs(1));
|
||||
let mut stream = match future::select(Read1(stream), sleep1).await {
|
||||
future::Either::Right((_, Read1(stream))) => stream,
|
||||
future::Either::Left((Err(err), _)) => return Err(err),
|
||||
@ -77,7 +79,7 @@ async fn test_0rtt() -> io::Result<()> {
|
||||
.map(DropKill)?;
|
||||
|
||||
// wait openssl server
|
||||
delay_for(Duration::from_secs(1)).await;
|
||||
sleep(Duration::from_secs(1)).await;
|
||||
|
||||
let mut config = ClientConfig::new();
|
||||
let mut chain = BufReader::new(Cursor::new(include_str!("end.chain")));
|
||||
|
@ -31,17 +31,16 @@ lazy_static! {
|
||||
let (send, recv) = channel();
|
||||
|
||||
thread::spawn(move || {
|
||||
let mut runtime = runtime::Builder::new()
|
||||
.basic_scheduler()
|
||||
let runtime = runtime::Builder::new_current_thread()
|
||||
.enable_io()
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
let handle = runtime.handle().clone();
|
||||
let runtime = Arc::new(runtime);
|
||||
let runtime2 = runtime.clone();
|
||||
|
||||
let done = async move {
|
||||
let addr = SocketAddr::from(([127, 0, 0, 1], 0));
|
||||
let mut listener = TcpListener::bind(&addr).await?;
|
||||
let listener = TcpListener::bind(&addr).await?;
|
||||
|
||||
send.send(listener.local_addr()?).unwrap();
|
||||
|
||||
@ -59,7 +58,7 @@ lazy_static! {
|
||||
}
|
||||
.unwrap_or_else(|err| eprintln!("server: {:?}", err));
|
||||
|
||||
handle.spawn(fut);
|
||||
runtime2.spawn(fut);
|
||||
}
|
||||
}
|
||||
.unwrap_or_else(|err: io::Error| eprintln!("server: {:?}", err));
|
||||
@ -102,7 +101,7 @@ async fn pass() -> io::Result<()> {
|
||||
// TcpStream::bind now returns a future it creates a race
|
||||
// condition until its ready sometimes.
|
||||
use std::time::*;
|
||||
tokio::time::delay_for(Duration::from_secs(1)).await;
|
||||
tokio::time::sleep(Duration::from_secs(1)).await;
|
||||
|
||||
let mut config = ClientConfig::new();
|
||||
let mut chain = BufReader::new(Cursor::new(chain));
|
||||
|
Loading…
Reference in New Issue
Block a user