Rename ssl stuff

Author: sfackler

src/io/mod.rs

@@ -1,4 +1,4 @@
-//! Types and traits for SSL adaptors.
+//! Types and traits for TLS adaptors.
 pub use priv_io::Stream;
 
 use std::error::Error;
@@ -13,24 +13,24 @@ pub mod security_framework;
 #[cfg(all(feature = "openssl", not(feature = "with-openssl")))]
 const _CHECK: OpensslFeatureRenamedSeeDocs = "";
 
-/// A trait implemented by SSL adaptors.
-pub trait StreamWrapper: fmt::Debug + Read + Write + Send {
+/// A trait implemented by TLS adaptors.
+pub trait TlsStream: fmt::Debug + Read + Write + Send {
     /// Returns a reference to the underlying `Stream`.
     fn get_ref(&self) -> &Stream;
 
     /// Returns a mutable reference to the underlying `Stream`.
     fn get_mut(&mut self) -> &mut Stream;
 }
 
-/// A trait implemented by types that can negotiate SSL over a Postgres stream.
-pub trait NegotiateSsl: fmt::Debug {
-    /// Negotiates an SSL session, returning a wrapper around the provided
-    /// stream.
+/// A trait implemented by types that can negotiate TLS over a Postgres stream.
+pub trait TlsHandshake: fmt::Debug {
+    /// Performs a client-side TLS handshake, returning a wrapper around the
+    /// provided stream.
     ///
     /// The host portion of the connection parameters is provided for hostname
     /// verification.
-    fn negotiate_ssl(&self,
+    fn tls_handshake(&self,
                      host: &str,
                      stream: Stream)
-                     -> Result<Box<StreamWrapper>, Box<Error + Sync + Send>>;
+                     -> Result<Box<TlsStream>, Box<Error + Sync + Send>>;
 }

src/io/openssl.rs

@@ -8,9 +8,9 @@ use self::openssl::ssl::{IntoSsl, SslContext, SslStream, SslMethod, SSL_VERIFY_P
                          SSL_OP_NO_SSLV2, SSL_OP_NO_SSLV3, SSL_OP_NO_COMPRESSION};
 use self::openssl::ssl::error::SslError;
 use self::openssl_verify::verify_callback;
-use io::{StreamWrapper, Stream, NegotiateSsl};
+use io::{TlsStream, Stream, TlsHandshake};
 
-impl StreamWrapper for SslStream<Stream> {
+impl TlsStream for SslStream<Stream> {
     fn get_ref(&self) -> &Stream {
         self.get_ref()
     }
@@ -20,17 +20,17 @@ impl StreamWrapper for SslStream<Stream> {
     }
 }
 
-/// A `NegotiateSsl` implementation that uses OpenSSL.
+/// A `TlsHandshake` implementation that uses OpenSSL.
 ///
 /// Requires the `with-openssl` feature.
 #[derive(Debug)]
-pub struct Negotiator(SslContext);
+pub struct OpenSsl(SslContext);
 
-impl Negotiator {
-    /// Creates a `Negotiator` with a reasonable default configuration.
+impl OpenSsl {
+    /// Creates a `OpenSsl` with a reasonable default configuration.
     ///
     /// The configuration is modeled after libcurl's and is subject to change.
-    pub fn new() -> Result<Negotiator, SslError> {
+    pub fn new() -> Result<OpenSsl, SslError> {
         let mut ctx = try!(SslContext::new(SslMethod::Sslv23));
         try!(ctx.set_default_verify_paths());
         ctx.set_options(SSL_OP_NO_SSLV2 | SSL_OP_NO_SSLV3 | SSL_OP_NO_COMPRESSION);
@@ -49,17 +49,17 @@ impl Negotiator {
     }
 }
 
-impl From<SslContext> for Negotiator {
-    fn from(ctx: SslContext) -> Negotiator {
-        Negotiator(ctx)
+impl From<SslContext> for OpenSsl {
+    fn from(ctx: SslContext) -> OpenSsl {
+        OpenSsl(ctx)
     }
 }
 
-impl NegotiateSsl for Negotiator {
-    fn negotiate_ssl(&self,
+impl TlsHandshake for OpenSsl {
+    fn tls_handshake(&self,
                      domain: &str,
                      stream: Stream)
-                     -> Result<Box<StreamWrapper>, Box<Error + Send + Sync>> {
+                     -> Result<Box<TlsStream>, Box<Error + Send + Sync>> {
         let domain = domain.to_owned();
         let mut ssl = try!(self.0.into_ssl());
         ssl.set_verify_callback(SSL_VERIFY_PEER, move |p, x| verify_callback(&domain, p, x));

src/io/security_framework.rs

@@ -2,10 +2,10 @@
 extern crate security_framework;
 
 use self::security_framework::secure_transport::{SslStream, ClientBuilder};
-use io::{Stream, StreamWrapper, NegotiateSsl};
+use io::{Stream, TlsStream, TlsHandshake};
 use std::error::Error;
 
-impl StreamWrapper for SslStream<Stream> {
+impl TlsStream for SslStream<Stream> {
     fn get_ref(&self) -> &Stream {
         self.get_ref()
     }
@@ -15,15 +15,15 @@ impl StreamWrapper for SslStream<Stream> {
     }
 }
 
-/// A `NegotiateSsl` implementation that uses Security Framework.
+/// A `TlsHandshake` implementation that uses the Security Framework.
 ///
 /// Requires the `security-framework` feature.
 #[derive(Debug)]
-pub struct Negotiator(ClientBuilder);
+pub struct SecurityFramework(ClientBuilder);
 
-impl Negotiator {
-    /// Returns a new `Negotiator` with default settings.
-    pub fn new() -> Negotiator {
+impl SecurityFramework {
+    /// Returns a new `SecurityFramework` with default settings.
+    pub fn new() -> SecurityFramework {
         ClientBuilder::new().into()
     }
 
@@ -38,17 +38,17 @@ impl Negotiator {
     }
 }
 
-impl From<ClientBuilder> for Negotiator {
-    fn from(b: ClientBuilder) -> Negotiator {
-        Negotiator(b)
+impl From<ClientBuilder> for SecurityFramework {
+    fn from(b: ClientBuilder) -> SecurityFramework {
+        SecurityFramework(b)
     }
 }
 
-impl NegotiateSsl for Negotiator {
-    fn negotiate_ssl(&self,
+impl TlsHandshake for SecurityFramework {
+    fn tls_handshake(&self,
                      domain: &str,
                      stream: Stream)
-                     -> Result<Box<StreamWrapper>, Box<Error + Send + Sync>> {
+                     -> Result<Box<TlsStream>, Box<Error + Send + Sync>> {
         let stream = try!(self.0.handshake(domain, stream));
         Ok(Box::new(stream))
     }

src/lib.rs

@@ -68,7 +68,7 @@ use std::time::Duration;
 use std::path::PathBuf;
 
 use error::{Error, ConnectError, SqlState, DbError};
-use io::{StreamWrapper, NegotiateSsl};
+use io::{TlsStream, TlsHandshake};
 use message::{Frontend, Backend, RowDescriptionEntry};
 use message::{WriteMessage, ReadMessage};
 use notification::{Notifications, Notification};
@@ -305,9 +305,9 @@ pub enum SslMode<'a> {
     /// The connection will not use SSL.
     None,
     /// The connection will use SSL if the backend supports it.
-    Prefer(&'a NegotiateSsl),
+    Prefer(&'a TlsHandshake),
     /// The connection must use SSL.
-    Require(&'a NegotiateSsl),
+    Require(&'a TlsHandshake),
 }
 
 struct StatementInfo {
@@ -317,7 +317,7 @@ struct StatementInfo {
 }
 
 struct InnerConnection {
-    stream: BufStream<Box<StreamWrapper>>,
+    stream: BufStream<Box<TlsStream>>,
     notice_handler: Box<HandleNotice>,
     notifications: VecDeque<Notification>,
     cancel_data: CancelData,

src/priv_io.rs

@@ -17,7 +17,7 @@ use std::os::windows::io::{AsRawSocket, RawSocket};
 
 use {SslMode, ConnectParams, ConnectTarget};
 use error::ConnectError;
-use io::StreamWrapper;
+use io::TlsStream;
 use message::{self, WriteMessage};
 use message::Frontend;
 
@@ -29,7 +29,7 @@ pub trait StreamOptions {
     fn set_nonblocking(&self, nonblock: bool) -> io::Result<()>;
 }
 
-impl StreamOptions for BufStream<Box<StreamWrapper>> {
+impl StreamOptions for BufStream<Box<TlsStream>> {
     fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
         match self.get_ref().get_ref().0 {
             InternalStream::Tcp(ref s) => s.set_read_timeout(timeout),
@@ -49,7 +49,7 @@ impl StreamOptions for BufStream<Box<StreamWrapper>> {
 
 /// A connection to the Postgres server.
 ///
-/// It implements `Read`, `Write` and `StreamWrapper`, as well as `AsRawFd` on
+/// It implements `Read`, `Write` and `TlsStream`, as well as `AsRawFd` on
 /// Unix platforms and `AsRawSocket` on Windows platforms.
 pub struct Stream(InternalStream);
 
@@ -79,7 +79,7 @@ impl Write for Stream {
     }
 }
 
-impl StreamWrapper for Stream {
+impl TlsStream for Stream {
     fn get_ref(&self) -> &Stream {
         self
     }
@@ -160,7 +160,7 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
 
 pub fn initialize_stream(params: &ConnectParams,
                          ssl: SslMode)
-                         -> Result<Box<StreamWrapper>, ConnectError> {
+                         -> Result<Box<TlsStream>, ConnectError> {
     let mut socket = Stream(try!(open_socket(params)));
 
     let (ssl_required, negotiator) = match ssl {
@@ -188,5 +188,5 @@ pub fn initialize_stream(params: &ConnectParams,
         ConnectTarget::Unix(_) => return Err(ConnectError::Io(::bad_response())),
     };
 
-    negotiator.negotiate_ssl(host, socket).map_err(ConnectError::Ssl)
+    negotiator.tls_handshake(host, socket).map_err(ConnectError::Ssl)
 }

tests/test.rs

@@ -663,9 +663,9 @@ fn test_cancel_query() {
 #[test]
 #[cfg(feature = "with-openssl")]
 fn test_require_ssl_conn() {
-    use postgres::io::openssl::Negotiator;
+    use postgres::io::openssl::OpenSsl;
 
-    let mut negotiator = Negotiator::new().unwrap();
+    let mut negotiator = OpenSsl::new().unwrap();
     negotiator.context_mut().set_CA_file(".travis/server.crt").unwrap();
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
                                              SslMode::Require(&negotiator)));
@@ -675,9 +675,9 @@ fn test_require_ssl_conn() {
 #[test]
 #[cfg(feature = "with-openssl")]
 fn test_prefer_ssl_conn() {
-    use postgres::io::openssl::Negotiator;
+    use postgres::io::openssl::OpenSsl;
 
-    let mut negotiator = Negotiator::new().unwrap();
+    let mut negotiator = OpenSsl::new().unwrap();
     negotiator.context_mut().set_CA_file(".travis/server.crt").unwrap();
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
                                              SslMode::Require(&negotiator)));
@@ -687,12 +687,12 @@ fn test_prefer_ssl_conn() {
 #[test]
 #[cfg(feature = "security-framework")]
 fn security_framework_ssl() {
-    use postgres::io::security_framework::Negotiator;
+    use postgres::io::security_framework::SecurityFramework;
     use security_framework::certificate::SecCertificate;
 
     let certificate = include_bytes!("../.travis/server.der");
     let certificate = or_panic!(SecCertificate::from_der(certificate));
-    let mut negotiator = Negotiator::new();
+    let mut negotiator = SecurityFramework::new();
     negotiator.builder_mut().anchor_certificates(&[certificate]);
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
                                              SslMode::Require(&negotiator)));