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

Rename new_client to connect and new_server to accept

parent 1373a76c

openssl/src/ssl/mod.rs

+22 −17
Original line number Diff line number Diff line
@@ -777,13 +777,13 @@ impl<S: Read+Write> IndirectStream<S> { 
        })

    }



    fn new_client<T: IntoSsl>(ssl: T, stream: S) -> Result<IndirectStream<S>, SslError> {

    fn connect<T: IntoSsl>(ssl: T, stream: S) -> Result<IndirectStream<S>, SslError> {

        let mut ssl = try!(IndirectStream::new_base(ssl, stream));

        try!(ssl.in_retry_wrapper(|ssl| ssl.connect()));

        Ok(ssl)

    }



    fn new_server<T: IntoSsl>(ssl: T, stream: S) -> Result<IndirectStream<S>, SslError> {

    fn accept<T: IntoSsl>(ssl: T, stream: S) -> Result<IndirectStream<S>, SslError> {

        let mut ssl = try!(IndirectStream::new_base(ssl, stream));

        try!(ssl.in_retry_wrapper(|ssl| ssl.accept()));

        Ok(ssl)
@@ -884,7 +884,7 @@ impl<S> DirectStream<S> { 
        })

    }



    fn new_client(ssl: Ssl, stream: S, sock: c_int) -> Result<DirectStream<S>, SslError> {

    fn connect(ssl: Ssl, stream: S, sock: c_int) -> Result<DirectStream<S>, SslError> {

        let ssl = try!(DirectStream::new_base(ssl, stream, sock));

        let ret = ssl.ssl.connect();

        if ret > 0 {
@@ -894,7 +894,7 @@ impl<S> DirectStream<S> { 
        }

    }



    fn new_server(ssl: Ssl, stream: S, sock: c_int) -> Result<DirectStream<S>, SslError> {

    fn accept(ssl: Ssl, stream: S, sock: c_int) -> Result<DirectStream<S>, SslError> {

        let ssl = try!(DirectStream::new_base(ssl, stream, sock));

        let ret = ssl.ssl.accept();

        if ret > 0 {
@@ -1017,19 +1017,19 @@ impl<S> fmt::Debug for SslStream<S> where S: fmt::Debug { 


#[cfg(unix)]

impl<S: ::std::os::unix::io::AsRawFd> SslStream<S> {

    pub fn new_client_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

    pub fn connect_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let ssl = try!(ssl.into_ssl());

        let fd = stream.as_raw_fd() as c_int;

        let stream = try!(DirectStream::new_client(ssl, stream, fd));

        let stream = try!(DirectStream::connect(ssl, stream, fd));

        Ok(SslStream {

            kind: StreamKind::Direct(stream)

        })

    }



    pub fn new_server_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

    pub fn accept_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let ssl = try!(ssl.into_ssl());

        let fd = stream.as_raw_fd() as c_int;

        let stream = try!(DirectStream::new_server(ssl, stream, fd));

        let stream = try!(DirectStream::accept(ssl, stream, fd));

        Ok(SslStream {

            kind: StreamKind::Direct(stream)

        })
@@ -1040,7 +1040,7 @@ impl<S: ::std::os::unix::io::AsRawFd> SslStream<S> { 
impl<S: ::std::os::windows::io::AsRawSocket> SslStream<S> {

    pub fn new_client_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let fd = stream.as_raw_socket() as c_int;

        let stream = try!(DirectStream::new_client(ssl, stream, fd));

        let stream = try!(DirectStream::connect(ssl, stream, fd));

        Ok(SslStream {

            kind: StreamKind::Direct(stream)

        })
@@ -1048,7 +1048,7 @@ impl<S: ::std::os::windows::io::AsRawSocket> SslStream<S> { 


    pub fn new_server_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let fd = stream.as_raw_socket() as c_int;

        let stream = try!(DirectStream::new_server(ssl, stream, fd));

        let stream = try!(DirectStream::accept(ssl, stream, fd));

        Ok(SslStream {

            kind: StreamKind::Direct(stream)

        })
@@ -1056,33 +1056,38 @@ impl<S: ::std::os::windows::io::AsRawSocket> SslStream<S> { 
}



impl<S: Read+Write> SslStream<S> {

    pub fn new_client<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let stream = try!(IndirectStream::new_client(ssl, stream));

    pub fn connect<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let stream = try!(IndirectStream::connect(ssl, stream));

        Ok(SslStream {

            kind: StreamKind::Indirect(stream)

        })

    }



    pub fn new_server<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let stream = try!(IndirectStream::new_server(ssl, stream));

    pub fn accept<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {

        let stream = try!(IndirectStream::accept(ssl, stream));

        Ok(SslStream {

            kind: StreamKind::Indirect(stream)

        })

    }



    /// # Deprecated

    pub fn new_server(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> {

        SslStream::accept(ssl, stream)

    }



    /// # Deprecated

    pub fn new_server_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> {

        SslStream::new_server(ssl, stream)

        SslStream::accept(ssl, stream)

    }



    /// # Deprecated

    pub fn new_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> {

        SslStream::new_client(ssl, stream)

        SslStream::connect(ssl, stream)

    }



    /// # Deprecated

    pub fn new(ctx: &SslContext, stream: S) -> Result<SslStream<S>, SslError> {

        SslStream::new_client(ctx, stream)

        SslStream::connect(ctx, stream)

    }



    /// # Deprecated

openssl/src/ssl/tests.rs

+27 −27
Original line number Diff line number Diff line
@@ -83,14 +83,14 @@ run_test!(new_ctx, |method, _| { 
});



run_test!(new_sslstream, |method, stream| {

    SslStream::new_client(&SslContext::new(method).unwrap(), stream).unwrap();

    SslStream::connect(&SslContext::new(method).unwrap(), stream).unwrap();

});



run_test!(verify_untrusted, |method, stream| {

    let mut ctx = SslContext::new(method).unwrap();

    ctx.set_verify(SSL_VERIFY_PEER, None);



    match SslStream::new_client(&ctx, stream) {

    match SslStream::connect(&ctx, stream) {

        Ok(_) => panic!("expected failure"),

        Err(err) => println!("error {:?}", err)

    }
@@ -104,7 +104,7 @@ run_test!(verify_trusted, |method, stream| { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    match SslStream::new_client(&ctx, stream) {

    match SslStream::connect(&ctx, stream) {

        Ok(_) => (),

        Err(err) => panic!("Expected success, got {:?}", err)

    }
@@ -118,7 +118,7 @@ run_test!(verify_untrusted_callback_override_ok, |method, stream| { 
    let mut ctx = SslContext::new(method).unwrap();

    ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));



    match SslStream::new_client(&ctx, stream) {

    match SslStream::connect(&ctx, stream) {

        Ok(_) => (),

        Err(err) => panic!("Expected success, got {:?}", err)

    }
@@ -132,7 +132,7 @@ run_test!(verify_untrusted_callback_override_bad, |method, stream| { 
    let mut ctx = SslContext::new(method).unwrap();

    ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));



    assert!(SslStream::new_client(&ctx, stream).is_err());

    assert!(SslStream::connect(&ctx, stream).is_err());

});



run_test!(verify_trusted_callback_override_ok, |method, stream| {
@@ -147,7 +147,7 @@ run_test!(verify_trusted_callback_override_ok, |method, stream| { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    match SslStream::new_client(&ctx, stream) {

    match SslStream::connect(&ctx, stream) {

        Ok(_) => (),

        Err(err) => panic!("Expected success, got {:?}", err)

    }
@@ -165,7 +165,7 @@ run_test!(verify_trusted_callback_override_bad, |method, stream| { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    assert!(SslStream::new_client(&ctx, stream).is_err());

    assert!(SslStream::connect(&ctx, stream).is_err());

});



run_test!(verify_callback_load_certs, |method, stream| {
@@ -177,7 +177,7 @@ run_test!(verify_callback_load_certs, |method, stream| { 
    let mut ctx = SslContext::new(method).unwrap();

    ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));



    assert!(SslStream::new_client(&ctx, stream).is_ok());

    assert!(SslStream::connect(&ctx, stream).is_ok());

});



run_test!(verify_trusted_get_error_ok, |method, stream| {
@@ -193,7 +193,7 @@ run_test!(verify_trusted_get_error_ok, |method, stream| { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    assert!(SslStream::new_client(&ctx, stream).is_ok());

    assert!(SslStream::connect(&ctx, stream).is_ok());

});



run_test!(verify_trusted_get_error_err, |method, stream| {
@@ -205,7 +205,7 @@ run_test!(verify_trusted_get_error_err, |method, stream| { 
    let mut ctx = SslContext::new(method).unwrap();

    ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));



    assert!(SslStream::new_client(&ctx, stream).is_err());

    assert!(SslStream::connect(&ctx, stream).is_err());

});



run_test!(verify_callback_data, |method, stream| {
@@ -230,7 +230,7 @@ run_test!(verify_callback_data, |method, stream| { 
    ctx.set_verify_with_data(SSL_VERIFY_PEER, callback, node_id);

    ctx.set_verify_depth(1);



    match SslStream::new_client(&ctx, stream) {

    match SslStream::connect(&ctx, stream) {

        Ok(_) => (),

        Err(err) => panic!("Expected success, got {:?}", err)

    }
@@ -245,7 +245,7 @@ fn test_write_hits_stream() { 
    let guard = thread::spawn(move || {

        let ctx = SslContext::new(Sslv23).unwrap();

        let stream = TcpStream::connect(addr).unwrap();

        let mut stream = SslStream::new_client(&ctx, stream).unwrap();

        let mut stream = SslStream::connect(&ctx, stream).unwrap();



        stream.write_all(b"hello").unwrap();

        stream
@@ -256,7 +256,7 @@ fn test_write_hits_stream() { 
    ctx.set_certificate_file(&Path::new("test/cert.pem"), X509FileType::PEM).unwrap();

    ctx.set_private_key_file(&Path::new("test/key.pem"), X509FileType::PEM).unwrap();

    let stream = listener.accept().unwrap().0;

    let mut stream = SslStream::new_server(&ctx, stream).unwrap();

    let mut stream = SslStream::accept(&ctx, stream).unwrap();



    let mut buf = [0; 5];

    assert_eq!(5, stream.read(&mut buf).unwrap());
@@ -310,7 +310,7 @@ run_test!(clear_ctx_options, |method, _| { 
#[test]

fn test_write() {

    let stream = TcpStream::connect("127.0.0.1:15418").unwrap();

    let mut stream = SslStream::new_client(&SslContext::new(Sslv23).unwrap(), stream).unwrap();

    let mut stream = SslStream::connect(&SslContext::new(Sslv23).unwrap(), stream).unwrap();

    stream.write_all("hello".as_bytes()).unwrap();

    stream.flush().unwrap();

    stream.write_all(" there".as_bytes()).unwrap();
@@ -320,7 +320,7 @@ fn test_write() { 
#[test]

fn test_write_direct() {

    let stream = TcpStream::connect("127.0.0.1:15418").unwrap();

    let mut stream = SslStream::new_client_direct(&SslContext::new(Sslv23).unwrap(), stream).unwrap();

    let mut stream = SslStream::connect_direct(&SslContext::new(Sslv23).unwrap(), stream).unwrap();

    stream.write_all("hello".as_bytes()).unwrap();

    stream.flush().unwrap();

    stream.write_all(" there".as_bytes()).unwrap();
@@ -328,7 +328,7 @@ fn test_write_direct() { 
}



run_test!(get_peer_certificate, |method, stream| {

    let stream = SslStream::new_client(&SslContext::new(method).unwrap(), stream).unwrap();

    let stream = SslStream::connect(&SslContext::new(method).unwrap(), stream).unwrap();

    let cert = stream.get_peer_certificate().unwrap();

    let fingerprint = cert.fingerprint(SHA256).unwrap();

    let node_hash_str = "db400bb62f1b1f29c3b8f323b8f7d9dea724fdcd67104ef549c772ae3749655b";
@@ -342,7 +342,7 @@ fn test_write_dtlsv1() { 
    let sock = UdpSocket::bind("127.0.0.1:0").unwrap();

    let stream = sock.connect("127.0.0.1:15410").unwrap();



    let mut stream = SslStream::new_client(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap();

    let mut stream = SslStream::connect(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap();

    stream.write_all("hello".as_bytes()).unwrap();

    stream.flush().unwrap();

    stream.write_all(" there".as_bytes()).unwrap();
@@ -352,7 +352,7 @@ fn test_write_dtlsv1() { 
#[test]

fn test_read() {

    let tcp = TcpStream::connect("127.0.0.1:15418").unwrap();

    let mut stream = SslStream::new_client(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();

    let mut stream = SslStream::connect(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();

    stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap();

    stream.flush().unwrap();

    io::copy(&mut stream, &mut io::sink()).ok().expect("read error");
@@ -361,7 +361,7 @@ fn test_read() { 
#[test]

fn test_read_direct() {

    let tcp = TcpStream::connect("127.0.0.1:15418").unwrap();

    let mut stream = SslStream::new_client_direct(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();

    let mut stream = SslStream::connect_direct(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();

    stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap();

    stream.flush().unwrap();

    io::copy(&mut stream, &mut io::sink()).ok().expect("read error");
@@ -370,7 +370,7 @@ fn test_read_direct() { 
#[test]

fn test_pending() {

    let tcp = TcpStream::connect("127.0.0.1:15418").unwrap();

    let mut stream = SslStream::new_client(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();

    let mut stream = SslStream::connect(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();

    stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap();

    stream.flush().unwrap();
@@ -403,7 +403,7 @@ fn test_connect_with_unilateral_npn() { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    let stream = match SslStream::new_client(&ctx, stream) {

    let stream = match SslStream::connect(&ctx, stream) {

        Ok(stream) => stream,

        Err(err) => panic!("Expected success, got {:?}", err)

    };
@@ -427,7 +427,7 @@ fn test_connect_with_npn_successful_multiple_matching() { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    let stream = match SslStream::new_client(&ctx, stream) {

    let stream = match SslStream::connect(&ctx, stream) {

        Ok(stream) => stream,

        Err(err) => panic!("Expected success, got {:?}", err)

    };
@@ -452,7 +452,7 @@ fn test_connect_with_npn_successful_single_match() { 
        Ok(_) => {}

        Err(err) => panic!("Unexpected error {:?}", err)

    }

    let stream = match SslStream::new_client(&ctx, stream) {

    let stream = match SslStream::connect(&ctx, stream) {

        Ok(stream) => stream,

        Err(err) => panic!("Expected success, got {:?}", err)

    };
@@ -482,7 +482,7 @@ fn test_npn_server_advertise_multiple() { 
    // Have the listener wait on the connection in a different thread.

    thread::spawn(move || {

        let (stream, _) = listener.accept().unwrap();

        let _ = SslStream::new_server(&listener_ctx, stream).unwrap();

        let _ = SslStream::accept(&listener_ctx, stream).unwrap();

    });



    let mut ctx = SslContext::new(Sslv23).unwrap();
@@ -494,7 +494,7 @@ fn test_npn_server_advertise_multiple() { 
    }

    // Now connect to the socket and make sure the protocol negotiation works...

    let stream = TcpStream::connect(localhost).unwrap();

    let stream = match SslStream::new_client(&ctx, stream) {

    let stream = match SslStream::connect(&ctx, stream) {

        Ok(stream) => stream,

        Err(err) => panic!("Expected success, got {:?}", err)

    };
@@ -531,7 +531,7 @@ fn test_read_dtlsv1() { 
    let server = udp::next_server();

    let stream = sock.connect(&server[..]).unwrap();



    let mut stream = SslStream::new_client(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap();

    let mut stream = SslStream::connect(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap();

    let mut buf = [0u8;100];

    assert!(stream.read(&mut buf).is_ok());

}
@@ -540,5 +540,5 @@ fn test_read_dtlsv1() { 
#[cfg(feature = "sslv2")]

fn test_sslv2_connect_failure() {

    let tcp = TcpStream::connect("127.0.0.1:15420").unwrap();

    SslStream::new_client(&SslContext::new(Sslv2).unwrap(), tcp).err().unwrap();

    SslStream::connect(&SslContext::new(Sslv2).unwrap(), tcp).err().unwrap();

}