From aa619c81c08eac2fccc23f6403d2cab378286c8a Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Fri, 27 Apr 2018 15:39:04 -0700 Subject: [PATCH] Some misc cleanup --- openssl-sys/build.rs | 21 +++-- openssl/src/ssl/test.rs | 165 ++++++++++++++++++++++------------------ 2 files changed, 102 insertions(+), 84 deletions(-) diff --git a/openssl-sys/build.rs b/openssl-sys/build.rs index a5a6c744..786609cc 100644 --- a/openssl-sys/build.rs +++ b/openssl-sys/build.rs @@ -29,9 +29,8 @@ const DEFINES: &'static [&'static str] = &[ ]; enum Version { - Openssl110, - Openssl102, - Openssl101, + Openssl11x, + Openssl10x, Libressl, } @@ -89,10 +88,8 @@ fn main() { let libs = match libs_env.as_ref().and_then(|s| s.to_str()) { Some(ref v) => v.split(":").collect(), None => match version { - Version::Openssl101 | Version::Openssl102 if target.contains("windows") => { - vec!["ssleay32", "libeay32"] - } - Version::Openssl110 if target.contains("windows") => vec!["libssl", "libcrypto"], + Version::Openssl10x if target.contains("windows") => vec!["ssleay32", "libeay32"], + Version::Openssl11x if target.contains("windows") => vec!["libssl", "libcrypto"], _ => vec!["ssl", "crypto"], }, }; @@ -446,25 +443,25 @@ See rust-openssl README for more information: println!("cargo:rustc-cfg=ossl111"); println!("cargo:rustc-cfg=ossl110"); println!("cargo:version=111"); - Version::Openssl110 + Version::Openssl11x } else if openssl_version >= 0x1_01_00_06_0 { println!("cargo:rustc-cfg=ossl110"); println!("cargo:rustc-cfg=ossl110f"); println!("cargo:version=110"); println!("cargo:patch=f"); - Version::Openssl110 + Version::Openssl11x } else if openssl_version >= 0x1_01_00_00_0 { println!("cargo:rustc-cfg=ossl110"); println!("cargo:version=110"); - Version::Openssl110 + Version::Openssl11x } else if openssl_version >= 0x1_00_02_00_0 { println!("cargo:rustc-cfg=ossl102"); println!("cargo:version=102"); - Version::Openssl102 + Version::Openssl10x } else if openssl_version >= 0x1_00_01_00_0 { println!("cargo:rustc-cfg=ossl101"); println!("cargo:version=101"); - Version::Openssl101 + Version::Openssl10x } else { version_error() } diff --git a/openssl/src/ssl/test.rs b/openssl/src/ssl/test.rs index ddcb49ff..150b4cdc 100644 --- a/openssl/src/ssl/test.rs +++ b/openssl/src/ssl/test.rs @@ -17,16 +17,16 @@ use tempdir::TempDir; use dh::Dh; use hash::MessageDigest; use ocsp::{OcspResponse, OcspResponseStatus}; +use pkey::PKey; use ssl; -use ssl::{Error, HandshakeError, ShutdownResult, Ssl, SslAcceptor, SslConnector, SslContext, - SslFiletype, SslMethod, SslSessionCacheMode, SslStream, MidHandshakeSslStream, - SslVerifyMode, StatusType}; #[cfg(any(ossl110, ossl111))] use ssl::SslVersion; -use x509::{X509, X509Name, X509StoreContext, X509VerifyResult}; +use ssl::{Error, HandshakeError, MidHandshakeSslStream, ShutdownResult, Ssl, SslAcceptor, + SslConnector, SslContext, SslFiletype, SslMethod, SslSessionCacheMode, SslStream, + SslVerifyMode, StatusType}; #[cfg(any(ossl102, ossl110))] use x509::verify::X509CheckFlags; -use pkey::PKey; +use x509::{X509, X509Name, X509StoreContext, X509VerifyResult}; use std::net::UdpSocket; @@ -1391,74 +1391,89 @@ fn _check_kinds() { is_sync::>(); } -#[derive(Debug)] -struct MemoryStream { - incoming: io::Cursor>, - outgoing: Vec, -} - -impl MemoryStream { - pub fn new() -> Self { Self { - incoming: io::Cursor::new(Vec::new()), - outgoing: Vec::new(), - }} - - pub fn extend_incoming(&mut self, data: &[u8]) { - self.incoming.get_mut().extend_from_slice(data); - } - - pub fn take_outgoing(&mut self) -> Outgoing { Outgoing(&mut self.outgoing) } -} - -impl Read for MemoryStream { - fn read(&mut self, buf: &mut [u8]) -> io::Result { - let n = self.incoming.read(buf)?; - if self.incoming.position() == self.incoming.get_ref().len() as u64 { - self.incoming.set_position(0); - self.incoming.get_mut().clear(); - } - if n == 0 { - return Err(io::Error::new(io::ErrorKind::WouldBlock, "no data available")); - } - Ok(n) - } -} - -impl Write for MemoryStream { - fn write(&mut self, buf: &[u8]) -> io::Result { - self.outgoing.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { Ok(()) } -} - -pub struct Outgoing<'a>(&'a mut Vec); - -impl<'a> Drop for Outgoing<'a> { - fn drop(&mut self) { - self.0.clear(); - } -} - -impl<'a> ::std::ops::Deref for Outgoing<'a> { - type Target = [u8]; - fn deref(&self) -> &[u8] { &self.0 } -} - -impl<'a> AsRef<[u8]> for Outgoing<'a> { - fn as_ref(&self) -> &[u8] { &self.0 } -} - -fn send(from: &mut MemoryStream, to: &mut MemoryStream) { - to.extend_incoming(&from.take_outgoing()); -} - #[test] #[cfg(ossl111)] fn stateless() { use super::SslOptions; - fn hs(stream: Result, HandshakeError>) -> Result, MidHandshakeSslStream> { + #[derive(Debug)] + struct MemoryStream { + incoming: io::Cursor>, + outgoing: Vec, + } + + impl MemoryStream { + pub fn new() -> Self { + Self { + incoming: io::Cursor::new(Vec::new()), + outgoing: Vec::new(), + } + } + + pub fn extend_incoming(&mut self, data: &[u8]) { + self.incoming.get_mut().extend_from_slice(data); + } + + pub fn take_outgoing(&mut self) -> Outgoing { + Outgoing(&mut self.outgoing) + } + } + + impl Read for MemoryStream { + fn read(&mut self, buf: &mut [u8]) -> io::Result { + let n = self.incoming.read(buf)?; + if self.incoming.position() == self.incoming.get_ref().len() as u64 { + self.incoming.set_position(0); + self.incoming.get_mut().clear(); + } + if n == 0 { + return Err(io::Error::new( + io::ErrorKind::WouldBlock, + "no data available", + )); + } + Ok(n) + } + } + + impl Write for MemoryStream { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.outgoing.write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + + pub struct Outgoing<'a>(&'a mut Vec); + + impl<'a> Drop for Outgoing<'a> { + fn drop(&mut self) { + self.0.clear(); + } + } + + impl<'a> ::std::ops::Deref for Outgoing<'a> { + type Target = [u8]; + fn deref(&self) -> &[u8] { + &self.0 + } + } + + impl<'a> AsRef<[u8]> for Outgoing<'a> { + fn as_ref(&self) -> &[u8] { + &self.0 + } + } + + fn send(from: &mut MemoryStream, to: &mut MemoryStream) { + to.extend_incoming(&from.take_outgoing()); + } + + fn hs( + stream: Result, HandshakeError>, + ) -> Result, MidHandshakeSslStream> { match stream { Ok(stream) => Ok(stream), Err(HandshakeError::WouldBlock(stream)) => Err(stream), @@ -1475,14 +1490,20 @@ fn stateless() { let client_stream = Ssl::new(&client_ctx.build()).unwrap(); let mut server_ctx = SslContext::builder(SslMethod::tls()).unwrap(); - server_ctx.set_certificate_file(&Path::new("test/cert.pem"), SslFiletype::PEM) + server_ctx + .set_certificate_file(&Path::new("test/cert.pem"), SslFiletype::PEM) .unwrap(); - server_ctx.set_private_key_file(&Path::new("test/key.pem"), SslFiletype::PEM) + server_ctx + .set_private_key_file(&Path::new("test/key.pem"), SslFiletype::PEM) .unwrap(); const COOKIE: &[u8] = b"chocolate chip"; - server_ctx.set_stateless_cookie_generate_cb(|_tls, buf| { buf[0..COOKIE.len()].copy_from_slice(COOKIE); Ok(COOKIE.len()) }); + server_ctx.set_stateless_cookie_generate_cb(|_tls, buf| { + buf[0..COOKIE.len()].copy_from_slice(COOKIE); + Ok(COOKIE.len()) + }); server_ctx.set_stateless_cookie_verify_cb(|_tls, buf| buf == COOKIE); - let mut server_stream = ssl::SslStreamBuilder::new(Ssl::new(&server_ctx.build()).unwrap(), MemoryStream::new()); + let mut server_stream = + ssl::SslStreamBuilder::new(Ssl::new(&server_ctx.build()).unwrap(), MemoryStream::new()); // // Handshake