Merge pull request #2 from dignifiedquire/master

fix test_0rtt, examples and cargo fmt

Author: skade

examples/client/src/main.rs

@@ -1,6 +1,6 @@
 use async_std::io;
-use async_std::io::Write;
 use async_std::net::TcpStream;
+use async_std::prelude::*;
 use async_std::task;
 use async_tls::TlsConnector;
 

examples/server/src/main.rs

@@ -1,7 +1,6 @@
 use async_std::io;
-use async_std::io::Write;
 use async_std::net::{TcpListener, TcpStream};
-use async_std::stream::Stream;
+use async_std::prelude::*;
 use async_std::task;
 use async_tls::TlsAcceptor;
 use rustls::internal::pemfile::{certs, rsa_private_keys};
@@ -41,7 +40,7 @@ fn load_keys(path: &Path) -> io::Result<Vec<PrivateKey>> {
 
 /// Configure the server using rusttls
 /// See https://docs.rs/rustls/0.16.0/rustls/struct.ServerConfig.html for details
-/// 
+///
 /// A TLS server needs a certificate and a fitting private key
 fn load_config(options: &Options) -> io::Result<ServerConfig> {
     let certs = load_certs(&options.cert)?;

src/acceptor.rs

@@ -4,10 +4,10 @@ use crate::server;
 use futures::io::{AsyncRead, AsyncWrite};
 use rustls::{ServerConfig, ServerSession};
 use std::future::Future;
+use std::io;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::io;
 
 /// The TLS accepting part. The acceptor drives
 /// the server side of the TLS handshake process. It works
@@ -73,4 +73,4 @@ impl From<Arc<ServerConfig>> for TlsAcceptor {
     fn from(inner: Arc<ServerConfig>) -> TlsAcceptor {
         TlsAcceptor { inner }
     }
-}
+}

src/client.rs

@@ -1,5 +1,5 @@
-use crate::rusttls::stream::Stream;
 use crate::common::tls_state::TlsState;
+use crate::rusttls::stream::Stream;
 use futures::io::{AsyncRead, AsyncWrite};
 use rustls::ClientSession;
 use std::future::Future;

src/common/tls_state.rs

@@ -36,4 +36,4 @@ impl TlsState {
             _ => true,
         }
     }
-}
+}

src/connector.rs

@@ -3,27 +3,27 @@ use crate::common::tls_state::TlsState;
 use crate::client;
 
 use futures::io::{AsyncRead, AsyncWrite};
-use rustls::{ClientConfig,ClientSession};
+use rustls::{ClientConfig, ClientSession};
 use std::future::Future;
+use std::io;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::io;
 use webpki::DNSNameRef;
 
 /// The TLS connecting part. The acceptor drives
 /// the client side of the TLS handshake process. It works
 /// on any asynchronous stream.
-/// 
+///
 /// It provides a simple interface (`connect`), returning a future
 /// that will resolve when the handshake process completed. On
 /// success, it will hand you an async `TlsStream`.
-/// 
+///
 /// To create a `TlsConnector` with a non-default configuation, create
 /// a `rusttls::ClientConfig` and call `.into()` on it.
 ///
 /// ## Example
-/// 
+///
 /// ```rust
 /// #![feature(async_await)]
 ///
@@ -67,7 +67,7 @@ impl Default for TlsConnector {
 
 impl TlsConnector {
     /// Create a new TlsConnector with default configuration.
-    /// 
+    ///
     /// This is the same as calling `TlsConnector::default()`.
     pub fn new() -> Self {
         Default::default()
@@ -157,7 +157,3 @@ impl<IO: AsyncRead + AsyncWrite + Unpin> Future for Connect<IO> {
         Pin::new(&mut self.0).poll(cx)
     }
 }
-
-#[cfg(feature = "early-data")]
-#[cfg(test)]
-mod test_0rtt;

src/lib.rs

@@ -2,12 +2,16 @@
 
 #![deny(unsafe_code)]
 
+mod acceptor;
 pub mod client;
-pub mod server;
 mod common;
-mod rusttls;
 mod connector;
-mod acceptor;
+mod rusttls;
+pub mod server;
+
+pub use acceptor::TlsAcceptor;
+pub use connector::TlsConnector;
 
-pub use acceptor::TlsAcceptor as TlsAcceptor;
-pub use connector::TlsConnector as TlsConnector;
+#[cfg(feature = "early-data")]
+#[cfg(test)]
+mod test_0rtt;

src/rusttls/mod.rs

@@ -1 +1 @@
-pub(crate) mod stream;
+pub(crate) mod stream;

src/rusttls/stream.rs

@@ -258,5 +258,5 @@ impl<'a, IO: AsyncRead + AsyncWrite + Unpin, S: Session> AsyncWrite for Stream<'
 }
 
 #[cfg(test)]
-#[path="test_stream.rs"]
+#[path = "test_stream.rs"]
 mod test_stream;

src/server.rs

@@ -1,5 +1,5 @@
-use crate::rusttls::stream::Stream;
 use crate::common::tls_state::TlsState;
+use crate::rusttls::stream::Stream;
 
 use futures::io::{AsyncRead, AsyncWrite};
 use rustls::ServerSession;