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

Make the direct constructors the defaults

This commit is contained in:
Steven Fackler 2015-06-28 10:06:42 -07:00
parent 797488dd09
commit 3325e6b474
2 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
openssl/src/ssl/mod.rs
View File

@ -1022,7 +1022,7 @@ impl<S: ::std::os::unix::io::AsRawFd> SslStream<S> {
/// `connect_direct` creates a more efficient `SslStream` than `connect` /// `connect_direct` creates a more efficient `SslStream` than `connect`
/// does, but requires that the stream implement `AsRawFd` on Unix and /// does, but requires that the stream implement `AsRawFd` on Unix and
/// `AsRawSocket` on Windows. /// `AsRawSocket` on Windows.
pub fn connect_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> { pub fn connect<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {
let ssl = try!(ssl.into_ssl()); let ssl = try!(ssl.into_ssl());
let fd = stream.as_raw_fd() as c_int; let fd = stream.as_raw_fd() as c_int;
let stream = try!(DirectStream::connect(ssl, stream, fd)); let stream = try!(DirectStream::connect(ssl, stream, fd));
@ -1036,7 +1036,7 @@ impl<S: ::std::os::unix::io::AsRawFd> SslStream<S> {
/// `accept_direct` creates a more efficient `SslStream` than `accept` /// `accept_direct` creates a more efficient `SslStream` than `accept`
/// does, but requires that the stream implement `AsRawFd` on Unix and /// does, but requires that the stream implement `AsRawFd` on Unix and
/// `AsRawSocket` on Windows. /// `AsRawSocket` on Windows.
pub fn accept_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> { pub fn accept<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {
let ssl = try!(ssl.into_ssl()); let ssl = try!(ssl.into_ssl());
let fd = stream.as_raw_fd() as c_int; let fd = stream.as_raw_fd() as c_int;
let stream = try!(DirectStream::accept(ssl, stream, fd)); let stream = try!(DirectStream::accept(ssl, stream, fd));
@ -1053,7 +1053,7 @@ impl<S: ::std::os::windows::io::AsRawSocket> SslStream<S> {
/// `connect_direct` creates a more efficient `SslStream` than `connect` /// `connect_direct` creates a more efficient `SslStream` than `connect`
/// does, but requires that the stream implement `AsRawFd` on Unix and /// does, but requires that the stream implement `AsRawFd` on Unix and
/// `AsRawSocket` on Windows. /// `AsRawSocket` on Windows.
pub fn new_client_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> { pub fn connect<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {
let fd = stream.as_raw_socket() as c_int; let fd = stream.as_raw_socket() as c_int;
let stream = try!(DirectStream::connect(ssl, stream, fd)); let stream = try!(DirectStream::connect(ssl, stream, fd));
Ok(SslStream { Ok(SslStream {
@ -1066,7 +1066,7 @@ impl<S: ::std::os::windows::io::AsRawSocket> SslStream<S> {
/// `accept_direct` creates a more efficient `SslStream` than `accept` /// `accept_direct` creates a more efficient `SslStream` than `accept`
/// does, but requires that the stream implement `AsRawFd` on Unix and /// does, but requires that the stream implement `AsRawFd` on Unix and
/// `AsRawSocket` on Windows. /// `AsRawSocket` on Windows.
pub fn new_server_direct<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> { pub fn accept<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {
let fd = stream.as_raw_socket() as c_int; let fd = stream.as_raw_socket() as c_int;
let stream = try!(DirectStream::accept(ssl, stream, fd)); let stream = try!(DirectStream::accept(ssl, stream, fd));
Ok(SslStream { Ok(SslStream {
@ -1077,7 +1077,7 @@ impl<S: ::std::os::windows::io::AsRawSocket> SslStream<S> {
impl<S: Read+Write> SslStream<S> { impl<S: Read+Write> SslStream<S> {
/// Creates an SSL/TLS client operating over the provided stream. /// Creates an SSL/TLS client operating over the provided stream.
pub fn connect<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> { pub fn connect_generic<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {
let stream = try!(IndirectStream::connect(ssl, stream)); let stream = try!(IndirectStream::connect(ssl, stream));
Ok(SslStream { Ok(SslStream {
kind: StreamKind::Indirect(stream) kind: StreamKind::Indirect(stream)
@ -1085,7 +1085,7 @@ impl<S: Read+Write> SslStream<S> {
} }
/// Creates an SSL/TLS server operating over the provided stream. /// Creates an SSL/TLS server operating over the provided stream.
pub fn accept<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> { pub fn accept_generic<T: IntoSsl>(ssl: T, stream: S) -> Result<SslStream<S>, SslError> {
let stream = try!(IndirectStream::accept(ssl, stream)); let stream = try!(IndirectStream::accept(ssl, stream));
Ok(SslStream { Ok(SslStream {
kind: StreamKind::Indirect(stream) kind: StreamKind::Indirect(stream)
@ -1094,22 +1094,22 @@ impl<S: Read+Write> SslStream<S> {
/// # Deprecated /// # Deprecated
pub fn new_server(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> { pub fn new_server(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> {
SslStream::accept(ssl, stream) SslStream::accept_generic(ssl, stream)
} }
/// # Deprecated /// # Deprecated
pub fn new_server_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> { pub fn new_server_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> {
SslStream::accept(ssl, stream) SslStream::accept_generic(ssl, stream)
} }
/// # Deprecated /// # Deprecated
pub fn new_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> { pub fn new_from(ssl: Ssl, stream: S) -> Result<SslStream<S>, SslError> {
SslStream::connect(ssl, stream) SslStream::connect_generic(ssl, stream)
} }
/// # Deprecated /// # Deprecated
pub fn new(ctx: &SslContext, stream: S) -> Result<SslStream<S>, SslError> { pub fn new(ctx: &SslContext, stream: S) -> Result<SslStream<S>, SslError> {
SslStream::connect(ctx, stream) SslStream::connect_generic(ctx, stream)
} }
/// # Deprecated /// # Deprecated

50
openssl/src/ssl/tests.rs
View File

@ -83,14 +83,14 @@ run_test!(new_ctx, |method, _| {
}); });
run_test!(new_sslstream, |method, stream| { run_test!(new_sslstream, |method, stream| {
SslStream::connect(&SslContext::new(method).unwrap(), stream).unwrap(); SslStream::connect_generic(&SslContext::new(method).unwrap(), stream).unwrap();
}); });
run_test!(verify_untrusted, |method, stream| { run_test!(verify_untrusted, |method, stream| {
let mut ctx = SslContext::new(method).unwrap(); let mut ctx = SslContext::new(method).unwrap();
ctx.set_verify(SSL_VERIFY_PEER, None); ctx.set_verify(SSL_VERIFY_PEER, None);
match SslStream::connect(&ctx, stream) { match SslStream::connect_generic(&ctx, stream) {
Ok(_) => panic!("expected failure"), Ok(_) => panic!("expected failure"),
Err(err) => println!("error {:?}", err) Err(err) => println!("error {:?}", err)
} }
@ -104,7 +104,7 @@ run_test!(verify_trusted, |method, stream| {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
match SslStream::connect(&ctx, stream) { match SslStream::connect_generic(&ctx, stream) {
Ok(_) => (), Ok(_) => (),
Err(err) => panic!("Expected success, got {:?}", err) 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(); let mut ctx = SslContext::new(method).unwrap();
ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback)); ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));
match SslStream::connect(&ctx, stream) { match SslStream::connect_generic(&ctx, stream) {
Ok(_) => (), Ok(_) => (),
Err(err) => panic!("Expected success, got {:?}", err) 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(); let mut ctx = SslContext::new(method).unwrap();
ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback)); ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));
assert!(SslStream::connect(&ctx, stream).is_err()); assert!(SslStream::connect_generic(&ctx, stream).is_err());
}); });
run_test!(verify_trusted_callback_override_ok, |method, stream| { run_test!(verify_trusted_callback_override_ok, |method, stream| {
@ -147,7 +147,7 @@ run_test!(verify_trusted_callback_override_ok, |method, stream| {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
match SslStream::connect(&ctx, stream) { match SslStream::connect_generic(&ctx, stream) {
Ok(_) => (), Ok(_) => (),
Err(err) => panic!("Expected success, got {:?}", err) Err(err) => panic!("Expected success, got {:?}", err)
} }
@ -165,7 +165,7 @@ run_test!(verify_trusted_callback_override_bad, |method, stream| {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
assert!(SslStream::connect(&ctx, stream).is_err()); assert!(SslStream::connect_generic(&ctx, stream).is_err());
}); });
run_test!(verify_callback_load_certs, |method, stream| { 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(); let mut ctx = SslContext::new(method).unwrap();
ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback)); ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));
assert!(SslStream::connect(&ctx, stream).is_ok()); assert!(SslStream::connect_generic(&ctx, stream).is_ok());
}); });
run_test!(verify_trusted_get_error_ok, |method, stream| { run_test!(verify_trusted_get_error_ok, |method, stream| {
@ -193,7 +193,7 @@ run_test!(verify_trusted_get_error_ok, |method, stream| {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
assert!(SslStream::connect(&ctx, stream).is_ok()); assert!(SslStream::connect_generic(&ctx, stream).is_ok());
}); });
run_test!(verify_trusted_get_error_err, |method, stream| { 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(); let mut ctx = SslContext::new(method).unwrap();
ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback)); ctx.set_verify(SSL_VERIFY_PEER, Some(callback as VerifyCallback));
assert!(SslStream::connect(&ctx, stream).is_err()); assert!(SslStream::connect_generic(&ctx, stream).is_err());
}); });
run_test!(verify_callback_data, |method, stream| { 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_with_data(SSL_VERIFY_PEER, callback, node_id);
ctx.set_verify_depth(1); ctx.set_verify_depth(1);
match SslStream::connect(&ctx, stream) { match SslStream::connect_generic(&ctx, stream) {
Ok(_) => (), Ok(_) => (),
Err(err) => panic!("Expected success, got {:?}", err) Err(err) => panic!("Expected success, got {:?}", err)
} }
@ -245,7 +245,7 @@ fn test_write_hits_stream() {
let guard = thread::spawn(move || { let guard = thread::spawn(move || {
let ctx = SslContext::new(Sslv23).unwrap(); let ctx = SslContext::new(Sslv23).unwrap();
let stream = TcpStream::connect(addr).unwrap(); let stream = TcpStream::connect(addr).unwrap();
let mut stream = SslStream::connect(&ctx, stream).unwrap(); let mut stream = SslStream::connect_generic(&ctx, stream).unwrap();
stream.write_all(b"hello").unwrap(); stream.write_all(b"hello").unwrap();
stream stream
@ -310,7 +310,7 @@ run_test!(clear_ctx_options, |method, _| {
#[test] #[test]
fn test_write() { fn test_write() {
let stream = TcpStream::connect("127.0.0.1:15418").unwrap(); let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
let mut stream = SslStream::connect(&SslContext::new(Sslv23).unwrap(), stream).unwrap(); let mut stream = SslStream::connect_generic(&SslContext::new(Sslv23).unwrap(), stream).unwrap();
stream.write_all("hello".as_bytes()).unwrap(); stream.write_all("hello".as_bytes()).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
stream.write_all(" there".as_bytes()).unwrap(); stream.write_all(" there".as_bytes()).unwrap();
@ -320,7 +320,7 @@ fn test_write() {
#[test] #[test]
fn test_write_direct() { fn test_write_direct() {
let stream = TcpStream::connect("127.0.0.1:15418").unwrap(); let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
let mut stream = SslStream::connect_direct(&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.write_all("hello".as_bytes()).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
stream.write_all(" there".as_bytes()).unwrap(); stream.write_all(" there".as_bytes()).unwrap();
@ -328,7 +328,7 @@ fn test_write_direct() {
} }
run_test!(get_peer_certificate, |method, stream| { run_test!(get_peer_certificate, |method, stream| {
let stream = SslStream::connect(&SslContext::new(method).unwrap(), stream).unwrap(); let stream = SslStream::connect_generic(&SslContext::new(method).unwrap(), stream).unwrap();
let cert = stream.get_peer_certificate().unwrap(); let cert = stream.get_peer_certificate().unwrap();
let fingerprint = cert.fingerprint(SHA256).unwrap(); let fingerprint = cert.fingerprint(SHA256).unwrap();
let node_hash_str = "db400bb62f1b1f29c3b8f323b8f7d9dea724fdcd67104ef549c772ae3749655b"; let node_hash_str = "db400bb62f1b1f29c3b8f323b8f7d9dea724fdcd67104ef549c772ae3749655b";
@ -342,7 +342,7 @@ fn test_write_dtlsv1() {
let sock = UdpSocket::bind("127.0.0.1:0").unwrap(); let sock = UdpSocket::bind("127.0.0.1:0").unwrap();
let stream = sock.connect("127.0.0.1:15410").unwrap(); let stream = sock.connect("127.0.0.1:15410").unwrap();
let mut stream = SslStream::connect(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap(); let mut stream = SslStream::connect_generic(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap();
stream.write_all("hello".as_bytes()).unwrap(); stream.write_all("hello".as_bytes()).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
stream.write_all(" there".as_bytes()).unwrap(); stream.write_all(" there".as_bytes()).unwrap();
@ -352,7 +352,7 @@ fn test_write_dtlsv1() {
#[test] #[test]
fn test_read() { fn test_read() {
let tcp = TcpStream::connect("127.0.0.1:15418").unwrap(); let tcp = TcpStream::connect("127.0.0.1:15418").unwrap();
let mut stream = SslStream::connect(&SslContext::new(Sslv23).unwrap(), tcp).unwrap(); let mut stream = SslStream::connect_generic(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();
stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap(); stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
io::copy(&mut stream, &mut io::sink()).ok().expect("read error"); io::copy(&mut stream, &mut io::sink()).ok().expect("read error");
@ -361,7 +361,7 @@ fn test_read() {
#[test] #[test]
fn test_read_direct() { fn test_read_direct() {
let tcp = TcpStream::connect("127.0.0.1:15418").unwrap(); let tcp = TcpStream::connect("127.0.0.1:15418").unwrap();
let mut stream = SslStream::connect_direct(&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.write_all("GET /\r\n\r\n".as_bytes()).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
io::copy(&mut stream, &mut io::sink()).ok().expect("read error"); io::copy(&mut stream, &mut io::sink()).ok().expect("read error");
@ -370,7 +370,7 @@ fn test_read_direct() {
#[test] #[test]
fn test_pending() { fn test_pending() {
let tcp = TcpStream::connect("127.0.0.1:15418").unwrap(); let tcp = TcpStream::connect("127.0.0.1:15418").unwrap();
let mut stream = SslStream::connect(&SslContext::new(Sslv23).unwrap(), tcp).unwrap(); let mut stream = SslStream::connect_generic(&SslContext::new(Sslv23).unwrap(), tcp).unwrap();
stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap(); stream.write_all("GET /\r\n\r\n".as_bytes()).unwrap();
stream.flush().unwrap(); stream.flush().unwrap();
@ -403,7 +403,7 @@ fn test_connect_with_unilateral_npn() {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
let stream = match SslStream::connect(&ctx, stream) { let stream = match SslStream::connect_generic(&ctx, stream) {
Ok(stream) => stream, Ok(stream) => stream,
Err(err) => panic!("Expected success, got {:?}", err) Err(err) => panic!("Expected success, got {:?}", err)
}; };
@ -427,7 +427,7 @@ fn test_connect_with_npn_successful_multiple_matching() {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
let stream = match SslStream::connect(&ctx, stream) { let stream = match SslStream::connect_generic(&ctx, stream) {
Ok(stream) => stream, Ok(stream) => stream,
Err(err) => panic!("Expected success, got {:?}", err) Err(err) => panic!("Expected success, got {:?}", err)
}; };
@ -452,7 +452,7 @@ fn test_connect_with_npn_successful_single_match() {
Ok(_) => {} Ok(_) => {}
Err(err) => panic!("Unexpected error {:?}", err) Err(err) => panic!("Unexpected error {:?}", err)
} }
let stream = match SslStream::connect(&ctx, stream) { let stream = match SslStream::connect_generic(&ctx, stream) {
Ok(stream) => stream, Ok(stream) => stream,
Err(err) => panic!("Expected success, got {:?}", err) Err(err) => panic!("Expected success, got {:?}", err)
}; };
@ -494,7 +494,7 @@ fn test_npn_server_advertise_multiple() {
} }
// Now connect to the socket and make sure the protocol negotiation works... // Now connect to the socket and make sure the protocol negotiation works...
let stream = TcpStream::connect(localhost).unwrap(); let stream = TcpStream::connect(localhost).unwrap();
let stream = match SslStream::connect(&ctx, stream) { let stream = match SslStream::connect_generic(&ctx, stream) {
Ok(stream) => stream, Ok(stream) => stream,
Err(err) => panic!("Expected success, got {:?}", err) Err(err) => panic!("Expected success, got {:?}", err)
}; };
@ -531,7 +531,7 @@ fn test_read_dtlsv1() {
let server = udp::next_server(); let server = udp::next_server();
let stream = sock.connect(&server[..]).unwrap(); let stream = sock.connect(&server[..]).unwrap();
let mut stream = SslStream::connect(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap(); let mut stream = SslStream::connect_generic(&SslContext::new(Dtlsv1).unwrap(), stream).unwrap();
let mut buf = [0u8;100]; let mut buf = [0u8;100];
assert!(stream.read(&mut buf).is_ok()); assert!(stream.read(&mut buf).is_ok());
} }
@ -540,5 +540,5 @@ fn test_read_dtlsv1() {
#[cfg(feature = "sslv2")] #[cfg(feature = "sslv2")]
fn test_sslv2_connect_failure() { fn test_sslv2_connect_failure() {
let tcp = TcpStream::connect("127.0.0.1:15420").unwrap(); let tcp = TcpStream::connect("127.0.0.1:15420").unwrap();
SslStream::connect(&SslContext::new(Sslv2).unwrap(), tcp).err().unwrap(); SslStream::connect_generic(&SslContext::new(Sslv2).unwrap(), tcp).err().unwrap();
} }