Use 2018 edition

Cargo.toml

@@ -6,6 +6,7 @@ license = "MIT/Apache-2.0"
 description = "A wrapper over a platform's native TLS implementation"
 repository = "https://github.com/sfackler/rust-native-tls"
 readme = "README.md"
+edition = "2018"
 
 [package.metadata.docs.rs]
 features = ["alpn"]

README.md

@@ -25,8 +25,6 @@ native-tls = "0.2"
 An example client looks like:
 
 ```rust,ignore
-extern crate native_tls;
-
 use native_tls::TlsConnector;
 use std::io::{Read, Write};
 use std::net::TcpStream;
@@ -47,8 +45,6 @@ fn main() {
 To accept connections as a server from remote clients:
 
 ```rust,ignore
-extern crate native_tls;
-
 use native_tls::{Identity, TlsAcceptor, TlsStream};
 use std::fs::File;
 use std::io::{Read};

examples/google-connect.rs

@@ -1,5 +1,3 @@
-extern crate native_tls;
-
 use native_tls::TlsConnector;
 use std::io::{Read, Write};
 use std::net::TcpStream;

examples/simple-server-pkcs8.rs

@@ -1,5 +1,3 @@
-extern crate native_tls;
-
 use native_tls::{Identity, TlsAcceptor, TlsStream};
 use std::fs::File;
 use std::io::{Read, Write};

examples/simple-server.rs

@@ -1,5 +1,3 @@
-extern crate native_tls;
-
 use native_tls::{Identity, TlsAcceptor, TlsStream};
 use std::fs::File;
 use std::io::Read;

src/imp/openssl.rs

@@ -1,30 +1,28 @@
-extern crate openssl;
-extern crate openssl_probe;
-
-use self::openssl::error::ErrorStack;
-use self::openssl::hash::MessageDigest;
-use self::openssl::nid::Nid;
-use self::openssl::pkcs12::Pkcs12;
-use self::openssl::pkey::{PKey, Private};
-use self::openssl::ssl::{
+use log::debug;
+use openssl::error::ErrorStack;
+use openssl::hash::MessageDigest;
+use openssl::nid::Nid;
+use openssl::pkcs12::Pkcs12;
+use openssl::pkey::{PKey, Private};
+use openssl::ssl::{
     self, MidHandshakeSslStream, SslAcceptor, SslConnector, SslContextBuilder, SslMethod,
     SslVerifyMode,
 };
-use self::openssl::x509::{store::X509StoreBuilder, X509VerifyResult, X509};
+use openssl::x509::{store::X509StoreBuilder, X509VerifyResult, X509};
 use std::error;
 use std::fmt;
 use std::io;
 use std::sync::Once;
 
-use {Protocol, TlsAcceptorBuilder, TlsConnectorBuilder};
+use crate::{Protocol, TlsAcceptorBuilder, TlsConnectorBuilder};
 
 #[cfg(have_min_max_version)]
 fn supported_protocols(
     min: Option<Protocol>,
     max: Option<Protocol>,
     ctx: &mut SslContextBuilder,
 ) -> Result<(), ErrorStack> {
-    use self::openssl::ssl::SslVersion;
+    use openssl::ssl::SslVersion;
 
     fn cvt(p: Protocol) -> SslVersion {
         match p {
@@ -48,7 +46,7 @@ fn supported_protocols(
     max: Option<Protocol>,
     ctx: &mut SslContextBuilder,
 ) -> Result<(), ErrorStack> {
-    use self::openssl::ssl::SslOptions;
+    use openssl::ssl::SslOptions;
 
     let no_ssl_mask = SslOptions::NO_SSLV2
         | SslOptions::NO_SSLV3
@@ -132,7 +130,7 @@ impl error::Error for Error {
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Error::Normal(ref e) => fmt::Display::fmt(e, fmt),
             Error::Ssl(ref e, X509VerifyResult::OK) => fmt::Display::fmt(e, fmt),
@@ -212,7 +210,7 @@ impl<S> fmt::Debug for MidHandshakeTlsStream<S>
 where
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }
@@ -350,7 +348,7 @@ impl TlsConnector {
 }
 
 impl fmt::Debug for TlsConnector {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt.debug_struct("TlsConnector")
             // n.b. SslConnector is a newtype on SslContext which implements a noop Debug so it's omitted
             .field("use_sni", &self.use_sni)
@@ -391,7 +389,7 @@ impl TlsAcceptor {
 pub struct TlsStream<S>(ssl::SslStream<S>);
 
 impl<S: fmt::Debug> fmt::Debug for TlsStream<S> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }

src/imp/schannel.rs

@@ -1,16 +1,14 @@
-extern crate schannel;
-
-use self::schannel::cert_context::{CertContext, HashAlgorithm, KeySpec};
-use self::schannel::cert_store::{CertAdd, CertStore, Memory, PfxImportOptions};
-use self::schannel::crypt_prov::{AcquireOptions, ProviderType};
-use self::schannel::schannel_cred::{Direction, Protocol, SchannelCred};
-use self::schannel::tls_stream;
+use schannel::cert_context::{CertContext, HashAlgorithm, KeySpec};
+use schannel::cert_store::{CertAdd, CertStore, Memory, PfxImportOptions};
+use schannel::crypt_prov::{AcquireOptions, ProviderType};
+use schannel::schannel_cred::{Direction, Protocol, SchannelCred};
+use schannel::tls_stream;
 use std::error;
 use std::fmt;
 use std::io;
 use std::str;
 
-use {TlsAcceptorBuilder, TlsConnectorBuilder};
+use crate::{TlsAcceptorBuilder, TlsConnectorBuilder};
 
 const SEC_E_NO_CREDENTIALS: u32 = 0x8009030E;
 
@@ -21,7 +19,10 @@ static PROTOCOLS: &'static [Protocol] = &[
     Protocol::Tls12,
 ];
 
-fn convert_protocols(min: Option<::Protocol>, max: Option<::Protocol>) -> &'static [Protocol] {
+fn convert_protocols(
+    min: Option<crate::Protocol>,
+    max: Option<crate::Protocol>,
+) -> &'static [Protocol] {
     let mut protocols = PROTOCOLS;
     if let Some(p) = max.and_then(|max| protocols.get(..=max as usize)) {
         protocols = p;
@@ -41,13 +42,13 @@ impl error::Error for Error {
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.0, fmt)
     }
 }
 
 impl fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }
@@ -183,7 +184,7 @@ impl<S> fmt::Debug for MidHandshakeTlsStream<S>
 where
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }
@@ -236,8 +237,8 @@ impl<S> From<io::Error> for HandshakeError<S> {
 pub struct TlsConnector {
     cert: Option<CertContext>,
     roots: CertStore,
-    min_protocol: Option<::Protocol>,
-    max_protocol: Option<::Protocol>,
+    min_protocol: Option<crate::Protocol>,
+    max_protocol: Option<crate::Protocol>,
     use_sni: bool,
     accept_invalid_hostnames: bool,
     accept_invalid_certs: bool,
@@ -327,8 +328,8 @@ impl TlsConnector {
 #[derive(Clone)]
 pub struct TlsAcceptor {
     cert: CertContext,
-    min_protocol: Option<::Protocol>,
-    max_protocol: Option<::Protocol>,
+    min_protocol: Option<crate::Protocol>,
+    max_protocol: Option<crate::Protocol>,
 }
 
 impl TlsAcceptor {
@@ -359,7 +360,7 @@ impl TlsAcceptor {
 pub struct TlsStream<S>(tls_stream::TlsStream<S>);
 
 impl<S: fmt::Debug> fmt::Debug for TlsStream<S> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }

src/imp/security_framework.rs

@@ -1,39 +1,36 @@
-extern crate libc;
-extern crate security_framework;
-extern crate security_framework_sys;
-extern crate tempfile;
-
-use self::security_framework::base;
-use self::security_framework::certificate::SecCertificate;
-use self::security_framework::identity::SecIdentity;
-use self::security_framework::import_export::{ImportedIdentity, Pkcs12ImportOptions};
-use self::security_framework::random::SecRandom;
-use self::security_framework::secure_transport::{
+use security_framework::base;
+use security_framework::certificate::SecCertificate;
+use security_framework::identity::SecIdentity;
+use security_framework::import_export::{ImportedIdentity, Pkcs12ImportOptions};
+use security_framework::random::SecRandom;
+use security_framework::secure_transport::{
     self, ClientBuilder, SslConnectionType, SslContext, SslProtocol, SslProtocolSide,
 };
-use self::security_framework_sys::base::{errSecIO, errSecParam};
-use self::tempfile::TempDir;
+use security_framework_sys::base::{errSecIO, errSecParam};
 use std::error;
 use std::fmt;
 use std::io;
 use std::str;
 use std::sync::Mutex;
 use std::sync::Once;
+use tempfile::TempDir;
 
 #[cfg(not(target_os = "ios"))]
-use self::security_framework::os::macos::certificate::{PropertyType, SecCertificateExt};
+use lazy_static::lazy_static;
 #[cfg(not(target_os = "ios"))]
-use self::security_framework::os::macos::certificate_oids::CertificateOid;
+use security_framework::os::macos::certificate::{PropertyType, SecCertificateExt};
 #[cfg(not(target_os = "ios"))]
-use self::security_framework::os::macos::identity::SecIdentityExt;
+use security_framework::os::macos::certificate_oids::CertificateOid;
 #[cfg(not(target_os = "ios"))]
-use self::security_framework::os::macos::import_export::{
+use security_framework::os::macos::identity::SecIdentityExt;
+#[cfg(not(target_os = "ios"))]
+use security_framework::os::macos::import_export::{
     ImportOptions, Pkcs12ImportOptionsExt, SecItems,
 };
 #[cfg(not(target_os = "ios"))]
-use self::security_framework::os::macos::keychain::{self, KeychainSettings, SecKeychain};
+use security_framework::os::macos::keychain::{self, KeychainSettings, SecKeychain};
 
-use {Protocol, TlsAcceptorBuilder, TlsConnectorBuilder};
+use crate::{Protocol, TlsAcceptorBuilder, TlsConnectorBuilder};
 
 static SET_AT_EXIT: Once = Once::new();
 
@@ -61,13 +58,13 @@ impl error::Error for Error {
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.0, fmt)
     }
 }
 
 impl fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }
@@ -264,7 +261,7 @@ impl<S> fmt::Debug for MidHandshakeTlsStream<S>
 where
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             MidHandshakeTlsStream::Server(ref s, _) => s.fmt(fmt),
             MidHandshakeTlsStream::Client(ref s) => s.fmt(fmt),
@@ -427,7 +424,7 @@ pub struct TlsStream<S> {
 }
 
 impl<S: fmt::Debug> fmt::Debug for TlsStream<S> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.stream, fmt)
     }
 }

src/lib.rs

@@ -98,19 +98,12 @@
 #![warn(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
-#[macro_use]
-#[cfg(any(target_os = "macos", target_os = "ios"))]
-extern crate lazy_static;
-
 use std::any::Any;
 use std::error;
 use std::fmt;
 use std::io;
 use std::result;
 
-#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-#[macro_use]
-extern crate log;
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[path = "imp/security_framework.rs"]
 mod imp;
@@ -137,13 +130,13 @@ impl error::Error for Error {
 }
 
 impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(&self.0, fmt)
     }
 }
 
 impl fmt::Debug for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }
@@ -223,7 +216,7 @@ impl<S> fmt::Debug for MidHandshakeTlsStream<S>
 where
     S: fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }
@@ -290,7 +283,7 @@ impl<S> fmt::Display for HandshakeError<S>
 where
     S: Any + fmt::Debug,
 {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             HandshakeError::Failure(ref e) => fmt::Display::fmt(e, fmt),
             HandshakeError::WouldBlock(_) => fmt.write_str("the handshake process was interrupted"),
@@ -633,7 +626,7 @@ impl TlsAcceptor {
 pub struct TlsStream<S>(imp::TlsStream<S>);
 
 impl<S: fmt::Debug> fmt::Debug for TlsStream<S> {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.0, fmt)
     }
 }