From e7e6ef5da2f96f231fabe746eafdf681224f5bc9 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Fri, 5 Sep 2014 21:52:44 -0700 Subject: [PATCH] Remove failing constructor wrappers --- src/ssl/mod.rs | 29 ++++++----------------------- src/ssl/tests.rs | 44 ++++++++++++++++++++++---------------------- 2 files changed, 28 insertions(+), 45 deletions(-) diff --git a/src/ssl/mod.rs b/src/ssl/mod.rs index 8bdfe416..85503704 100644 --- a/src/ssl/mod.rs +++ b/src/ssl/mod.rs @@ -127,8 +127,8 @@ impl Drop for SslContext { } impl SslContext { - /// Attempts to create a new SSL context. - pub fn try_new(method: SslMethod) -> Result { + /// Creates a new SSL context. + pub fn new(method: SslMethod) -> Result { init(); let ctx = unsafe { ffi::SSL_CTX_new(method.to_raw()) }; @@ -139,14 +139,6 @@ impl SslContext { Ok(SslContext { ctx: ctx }) } - /// A convenience wrapper around `try_new`. - pub fn new(method: SslMethod) -> SslContext { - match SslContext::try_new(method) { - Ok(ctx) => ctx, - Err(err) => fail!("Error creating SSL context: {}", err) - } - } - /// Configures the certificate verification method for new connections. pub fn set_verify(&mut self, mode: SslVerifyMode, verify: Option) { @@ -302,7 +294,7 @@ impl Drop for Ssl { } impl Ssl { - pub fn try_new(ctx: &SslContext) -> Result { + pub fn new(ctx: &SslContext) -> Result { let ssl = unsafe { ffi::SSL_new(ctx.ctx) }; if ssl == ptr::mut_null() { return Err(SslError::get()); @@ -480,10 +472,9 @@ impl SslStream { } } - /// Attempts to create a new SSL stream - pub fn try_new(ctx: &SslContext, stream: S) -> Result, - SslError> { - let ssl = match Ssl::try_new(ctx) { + /// Creates a new SSL stream + pub fn new(ctx: &SslContext, stream: S) -> Result, SslError> { + let ssl = match Ssl::new(ctx) { Ok(ssl) => ssl, Err(err) => return Err(err) }; @@ -491,14 +482,6 @@ impl SslStream { SslStream::new_from(ssl, stream) } - /// A convenience wrapper around `try_new`. - pub fn new(ctx: &SslContext, stream: S) -> SslStream { - match SslStream::try_new(ctx, stream) { - Ok(stream) => stream, - Err(err) => fail!("Error creating SSL stream: {}", err) - } - } - fn in_retry_wrapper(&mut self, blk: |&Ssl| -> c_int) -> Result { loop { diff --git a/src/ssl/tests.rs b/src/ssl/tests.rs index 3b10e878..99241719 100644 --- a/src/ssl/tests.rs +++ b/src/ssl/tests.rs @@ -6,21 +6,21 @@ use ssl::{Sslv23, SslContext, SslStream, SslVerifyPeer, X509StoreContext}; #[test] fn test_new_ctx() { - SslContext::new(Sslv23); + SslContext::new(Sslv23).unwrap(); } #[test] fn test_new_sslstream() { let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - SslStream::new(&SslContext::new(Sslv23), stream); + SslStream::new(&SslContext::new(Sslv23).unwrap(), stream).unwrap(); } #[test] fn test_verify_untrusted() { let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, None); - match SslStream::try_new(&ctx, stream) { + match SslStream::new(&ctx, stream) { Ok(_) => fail!("expected failure"), Err(err) => println!("error {}", err) } @@ -29,13 +29,13 @@ fn test_verify_untrusted() { #[test] fn test_verify_trusted() { let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, None); match ctx.set_CA_file("test/cert.pem") { None => {} Some(err) => fail!("Unexpected error {}", err) } - match SslStream::try_new(&ctx, stream) { + match SslStream::new(&ctx, stream) { Ok(_) => (), Err(err) => fail!("Expected success, got {}", err) } @@ -47,9 +47,9 @@ fn test_verify_untrusted_callback_override_ok() { true } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); - match SslStream::try_new(&ctx, stream) { + match SslStream::new(&ctx, stream) { Ok(_) => (), Err(err) => fail!("Expected success, got {}", err) } @@ -61,9 +61,9 @@ fn test_verify_untrusted_callback_override_bad() { false } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); - assert!(SslStream::try_new(&ctx, stream).is_err()); + assert!(SslStream::new(&ctx, stream).is_err()); } #[test] @@ -72,13 +72,13 @@ fn test_verify_trusted_callback_override_ok() { true } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); match ctx.set_CA_file("test/cert.pem") { None => {} Some(err) => fail!("Unexpected error {}", err) } - match SslStream::try_new(&ctx, stream) { + match SslStream::new(&ctx, stream) { Ok(_) => (), Err(err) => fail!("Expected success, got {}", err) } @@ -90,13 +90,13 @@ fn test_verify_trusted_callback_override_bad() { false } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); match ctx.set_CA_file("test/cert.pem") { None => {} Some(err) => fail!("Unexpected error {}", err) } - assert!(SslStream::try_new(&ctx, stream).is_err()); + assert!(SslStream::new(&ctx, stream).is_err()); } #[test] @@ -106,9 +106,9 @@ fn test_verify_callback_load_certs() { true } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); - assert!(SslStream::try_new(&ctx, stream).is_ok()); + assert!(SslStream::new(&ctx, stream).is_ok()); } #[test] @@ -118,13 +118,13 @@ fn test_verify_trusted_get_error_ok() { true } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); match ctx.set_CA_file("test/cert.pem") { None => {} Some(err) => fail!("Unexpected error {}", err) } - assert!(SslStream::try_new(&ctx, stream).is_ok()); + assert!(SslStream::new(&ctx, stream).is_ok()); } #[test] @@ -134,15 +134,15 @@ fn test_verify_trusted_get_error_err() { false } let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut ctx = SslContext::new(Sslv23); + let mut ctx = SslContext::new(Sslv23).unwrap(); ctx.set_verify(SslVerifyPeer, Some(callback)); - assert!(SslStream::try_new(&ctx, stream).is_err()); + assert!(SslStream::new(&ctx, stream).is_err()); } #[test] fn test_write() { let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut stream = SslStream::new(&SslContext::new(Sslv23), stream); + let mut stream = SslStream::new(&SslContext::new(Sslv23).unwrap(), stream).unwrap(); stream.write("hello".as_bytes()).unwrap(); stream.flush().unwrap(); stream.write(" there".as_bytes()).unwrap(); @@ -152,7 +152,7 @@ fn test_write() { #[test] fn test_read() { let stream = TcpStream::connect("127.0.0.1", 15418).unwrap(); - let mut stream = SslStream::new(&SslContext::new(Sslv23), stream); + let mut stream = SslStream::new(&SslContext::new(Sslv23).unwrap(), stream).unwrap(); stream.write("GET /\r\n\r\n".as_bytes()).unwrap(); stream.flush().unwrap(); let buf = stream.read_to_end().ok().expect("read error");