Clean up imports, import ServerName directly

Author: djc

examples/client.rs

@@ -6,6 +6,7 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use argh::FromArgs;
+use pki_types::ServerName;
 use tokio::io::{copy, split, stdin as tokio_stdin, stdout as tokio_stdout, AsyncWriteExt};
 use tokio::net::TcpStream;
 use tokio_rustls::{rustls, TlsConnector};
@@ -60,7 +61,7 @@ async fn main() -> io::Result<()> {
 
     let (mut stdin, mut stdout) = (tokio_stdin(), tokio_stdout());
 
-    let domain = pki_types::ServerName::try_from(domain.as_str())
+    let domain = ServerName::try_from(domain.as_str())
         .map_err(|_| io::Error::new(io::ErrorKind::InvalidInput, "invalid dnsname"))?
         .to_owned();
 

src/common/test_stream.rs

@@ -5,6 +5,7 @@ use std::task::{Context, Poll};
 
 use futures_util::future::poll_fn;
 use futures_util::task::noop_waker_ref;
+use pki_types::ServerName;
 use rustls::{ClientConnection, Connection, ServerConnection};
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
 
@@ -294,7 +295,7 @@ fn make_pair() -> (ServerConnection, ClientConnection) {
     let (sconfig, cconfig) = utils::make_configs();
     let server = ServerConnection::new(Arc::new(sconfig)).unwrap();
 
-    let domain = pki_types::ServerName::try_from("foobar.com").unwrap();
+    let domain = ServerName::try_from("foobar.com").unwrap();
     let client = ClientConnection::new(Arc::new(cconfig), domain).unwrap();
 
     (server, client)

src/lib.rs

@@ -47,6 +47,8 @@ use std::sync::Arc;
 use std::task::{Context, Poll};
 
 pub use rustls;
+
+use pki_types::ServerName;
 use rustls::server::AcceptedAlert;
 use rustls::{ClientConfig, ClientConnection, CommonState, ServerConfig, ServerConnection};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
@@ -107,19 +109,14 @@ impl TlsConnector {
     }
 
     #[inline]
-    pub fn connect<IO>(&self, domain: pki_types::ServerName<'static>, stream: IO) -> Connect<IO>
+    pub fn connect<IO>(&self, domain: ServerName<'static>, stream: IO) -> Connect<IO>
     where
         IO: AsyncRead + AsyncWrite + Unpin,
     {
         self.connect_with(domain, stream, |_| ())
     }
 
-    pub fn connect_with<IO, F>(
-        &self,
-        domain: pki_types::ServerName<'static>,
-        stream: IO,
-        f: F,
-    ) -> Connect<IO>
+    pub fn connect_with<IO, F>(&self, domain: ServerName<'static>, stream: IO, f: F) -> Connect<IO>
     where
         IO: AsyncRead + AsyncWrite + Unpin,
         F: FnOnce(&mut ClientConnection),

tests/badssl.rs

@@ -2,13 +2,12 @@ use std::io;
 use std::net::ToSocketAddrs;
 use std::sync::Arc;
 
+use pki_types::ServerName;
+use rustls::ClientConfig;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
-use tokio_rustls::{
-    client::TlsStream,
-    rustls::{self, ClientConfig},
-    TlsConnector,
-};
+use tokio_rustls::client::TlsStream;
+use tokio_rustls::TlsConnector;
 
 async fn get(
     config: Arc<ClientConfig>,
@@ -20,7 +19,7 @@ async fn get(
     let input = format!("GET / HTTP/1.0\r\nHost: {}\r\n\r\n", domain);
 
     let addr = (domain, port).to_socket_addrs()?.next().unwrap();
-    let domain = pki_types::ServerName::try_from(domain).unwrap().to_owned();
+    let domain = ServerName::try_from(domain).unwrap().to_owned();
     let mut buf = Vec::new();
 
     let stream = TcpStream::connect(&addr).await?;

tests/early-data.rs

@@ -8,10 +8,12 @@ use std::task::{Context, Poll};
 use std::thread;
 
 use futures_util::{future::Future, ready};
+use pki_types::ServerName;
 use rustls::{self, ClientConfig, ServerConnection, Stream};
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWriteExt, ReadBuf};
 use tokio::net::TcpStream;
-use tokio_rustls::{client::TlsStream, TlsConnector};
+use tokio_rustls::client::TlsStream;
+use tokio_rustls::TlsConnector;
 
 struct Read1<T>(T);
 
@@ -41,7 +43,7 @@ async fn send(
 ) -> io::Result<(TlsStream<TcpStream>, Vec<u8>)> {
     let connector = TlsConnector::from(config).early_data(true);
     let stream = TcpStream::connect(&addr).await?;
-    let domain = pki_types::ServerName::try_from("foobar.com").unwrap();
+    let domain = ServerName::try_from("foobar.com").unwrap();
 
     let mut stream = connector.connect(domain, stream).await?;
     utils::write(&mut stream, data, vectored).await?;

tests/test.rs

@@ -7,6 +7,7 @@ use std::{io, thread};
 
 use futures_util::future::TryFutureExt;
 use lazy_static::lazy_static;
+use pki_types::ServerName;
 use rustls::ClientConfig;
 use tokio::io::{copy, split, AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
@@ -64,7 +65,7 @@ lazy_static! {
 async fn start_client(addr: SocketAddr, domain: &str, config: Arc<ClientConfig>) -> io::Result<()> {
     const FILE: &[u8] = include_bytes!("../README.md");
 
-    let domain = pki_types::ServerName::try_from(domain).unwrap().to_owned();
+    let domain = ServerName::try_from(domain).unwrap().to_owned();
     let config = TlsConnector::from(config);
     let mut buf = vec![0; FILE.len()];
 
@@ -112,9 +113,7 @@ async fn test_lazy_config_acceptor() -> io::Result<()> {
     let (sconfig, cconfig) = utils::make_configs();
 
     let (cstream, sstream) = tokio::io::duplex(1200);
-    let domain = pki_types::ServerName::try_from("foobar.com")
-        .unwrap()
-        .to_owned();
+    let domain = ServerName::try_from("foobar.com").unwrap().to_owned();
     tokio::spawn(async move {
         let connector = crate::TlsConnector::from(Arc::new(cconfig));
         let mut client = connector.connect(domain, cstream).await.unwrap();