Commit e7e6ef5d authored by Steven Fackler's avatar Steven Fackler
Browse files

Remove failing constructor wrappers

parent 0a18409c

src/ssl/mod.rs

+6 −23
Original line number Diff line number Diff line
@@ -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 {

src/ssl/tests.rs

+22 −22
Original line number Diff line number Diff line
@@ -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");