min
/
boring2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove failing constructor wrappers

This commit is contained in:
Steven Fackler 2014-09-05 21:52:44 -07:00
parent 0a18409cdb
commit e7e6ef5da2
2 changed files with 28 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/ssl/mod.rs
View File

@ -127,8 +127,8 @@ impl Drop for SslContext {
}
impl SslContext {
/// Attempts to create a new SSL context.
pub fn try_new(method: SslMethod) -> Result<SslContext, SslError> {
/// Creates a new SSL context.
pub fn new(method: SslMethod) -> Result<SslContext, SslError> {
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<VerifyCallback>) {
@ -302,7 +294,7 @@ impl Drop for Ssl {
}
impl Ssl {
pub fn try_new(ctx: &SslContext) -> Result<Ssl, SslError> {
pub fn new(ctx: &SslContext) -> Result<Ssl, SslError> {
let ssl = unsafe { ffi::SSL_new(ctx.ctx) };
if ssl == ptr::mut_null() {
return Err(SslError::get());
@ -480,10 +472,9 @@ impl<S: Stream> SslStream<S> {
}
}
/// Attempts to create a new SSL stream
pub fn try_new(ctx: &SslContext, stream: S) -> Result<SslStream<S>,
SslError> {
let ssl = match Ssl::try_new(ctx) {
/// Creates a new SSL stream
pub fn new(ctx: &SslContext, stream: S) -> Result<SslStream<S>, SslError> {
let ssl = match Ssl::new(ctx) {
Ok(ssl) => ssl,
Err(err) => return Err(err)
};
@ -491,14 +482,6 @@ impl<S: Stream> SslStream<S> {
SslStream::new_from(ssl, stream)
}
/// A convenience wrapper around `try_new`.
pub fn new(ctx: &SslContext, stream: S) -> SslStream<S> {
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<c_int, SslError> {
loop {

44
src/ssl/tests.rs
View File

@ -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");