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

Add stream panic propagation behind a nightly feature gate

parent b32a5079

openssl/Cargo.toml

+2 −0
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ rfc5114 = ["openssl-sys/rfc5114"] 
ecdh_auto = ["openssl-sys-extras/ecdh_auto"]

pkcs5_pbkdf2_hmac = ["openssl-sys/pkcs5_pbkdf2_hmac"]



nightly = []



[dependencies]

bitflags = ">= 0.2, < 0.4"

lazy_static = "0.1"

openssl/src/lib.rs

+1 −0
Original line number Diff line number Diff line 
#![doc(html_root_url="https://sfackler.github.io/rust-openssl/doc/v0.7.4")]

#![cfg_attr(feature = "nightly", feature(const_fn, recover, panic_propagate))]



#[macro_use]

extern crate bitflags;

openssl/src/ssl/bio.rs

+88 −10
Original line number Diff line number Diff line 
use libc::{c_char, c_int, c_long, c_void, strlen};

use ffi::{BIO, BIO_METHOD, BIO_CTRL_FLUSH, BIO_TYPE_NONE, BIO_new};

use ffi_extras::{BIO_clear_retry_flags, BIO_set_retry_read, BIO_set_retry_write};

use std::any::Any;

use std::io;

use std::io::prelude::*;

use std::mem;

use std::slice;

use std::ptr;

use std::slice;

use std::sync::Arc;



use ssl::error::SslError;
@@ -16,6 +17,7 @@ const NAME: [c_char; 5] = [114, 117, 115, 116, 0]; 
pub struct StreamState<S> {

    pub stream: S,

    pub error: Option<io::Error>,

    pub panic: Option<Box<Any + Send>>,

}



pub fn new<S: Read + Write>(stream: S) -> Result<(*mut BIO, Arc<BIO_METHOD>), SslError> {
@@ -35,6 +37,7 @@ pub fn new<S: Read + Write>(stream: S) -> Result<(*mut BIO, Arc<BIO_METHOD>), Ss 
    let state = Box::new(StreamState {

        stream: stream,

        error: None,

        panic: None,

    });



    unsafe {
@@ -51,6 +54,12 @@ pub unsafe fn take_error<S>(bio: *mut BIO) -> Option<io::Error> { 
    state.error.take()

}



#[cfg_attr(not(feature = "nightly"), allow(dead_code))]

pub unsafe fn take_panic<S>(bio: *mut BIO) -> Option<Box<Any + Send>> {

    let state = state::<S>(bio);

    state.panic.take()

}



pub unsafe fn get_ref<'a, S: 'a>(bio: *mut BIO) -> &'a S {

    let state: &'a StreamState<S> = mem::transmute((*bio).ptr);

    &state.stream
@@ -64,20 +73,69 @@ unsafe fn state<'a, S: 'a>(bio: *mut BIO) -> &'a mut StreamState<S> { 
    mem::transmute((*bio).ptr)

}



#[cfg(feature = "nightly")]

fn recover<F, T>(f: F) -> Result<T, Box<Any + Send>> where F: FnOnce() -> T + ::std::panic::RecoverSafe {

    ::std::panic::recover(f)

}



#[cfg(not(feature = "nightly"))]

fn recover<F, T>(f: F) -> Result<T, Box<Any + Send>> where F: FnOnce() -> T {

    Ok(f())

}



#[cfg(feature = "nightly")]

use std::panic::AssertRecoverSafe;



#[cfg(not(feature = "nightly"))]

struct AssertRecoverSafe<T>(T);



#[cfg(not(feature = "nightly"))]

impl<T> AssertRecoverSafe<T> {

    fn new(t: T) -> Self {

        AssertRecoverSafe(t)

    }

}



#[cfg(not(feature = "nightly"))]

impl<T> ::std::ops::Deref for AssertRecoverSafe<T> {

    type Target = T;



    fn deref(&self) -> &T {

        &self.0

    }

}



#[cfg(not(feature = "nightly"))]

impl<T> ::std::ops::DerefMut for AssertRecoverSafe<T> {

    fn deref_mut(&mut self) -> &mut T {

        &mut self.0

    }

}



unsafe extern "C" fn bwrite<S: Write>(bio: *mut BIO, buf: *const c_char, len: c_int) -> c_int {

    BIO_clear_retry_flags(bio);



    let state = state::<S>(bio);

    let buf = slice::from_raw_parts(buf as *const _, len as usize);

    match state.stream.write(buf) {

        Ok(len) => len as c_int,

        Err(err) => {



    let result = {

        let mut youre_not_my_supervisor = AssertRecoverSafe::new(&mut *state);

        recover(move || youre_not_my_supervisor.stream.write(buf))

    };



    match result {

        Ok(Ok(len)) => len as c_int,

        Ok(Err(err)) => {

            if retriable_error(&err) {

                BIO_set_retry_write(bio);

            }

            state.error = Some(err);

            -1

        }

        Err(err) => {

            state.panic = Some(err);

            -1

        }

    }

}
@@ -86,15 +144,26 @@ unsafe extern "C" fn bread<S: Read>(bio: *mut BIO, buf: *mut c_char, len: c_int) 


    let state = state::<S>(bio);

    let buf = slice::from_raw_parts_mut(buf as *mut _, len as usize);

    match state.stream.read(buf) {

        Ok(len) => len as c_int,

        Err(err) => {



    let result = {

        let mut youre_not_my_supervisor = AssertRecoverSafe::new(&mut *state);

        let mut fuuuu = AssertRecoverSafe::new(buf);

        recover(move || youre_not_my_supervisor.stream.read(&mut *fuuuu))

    };



    match result {

        Ok(Ok(len)) => len as c_int,

        Ok(Err(err)) => {

            if retriable_error(&err) {

                BIO_set_retry_read(bio);

            }

            state.error = Some(err);

            -1

        }

        Err(err) => {

            state.panic = Some(err);

            -1

        }

    }

}
@@ -116,12 +185,21 @@ unsafe extern "C" fn ctrl<S: Write>(bio: *mut BIO, 
                                    -> c_long {

    if cmd == BIO_CTRL_FLUSH {

        let state = state::<S>(bio);

        match state.stream.flush() {

            Ok(()) => 1,

            Err(err) => {

        let result = {

            let mut youre_not_my_supervisor = AssertRecoverSafe::new(&mut *state);

            recover(move || youre_not_my_supervisor.stream.flush())

        };



        match result {

            Ok(Ok(())) => 1,

            Ok(Err(err)) => {

                state.error = Some(err);

                0

            }

            Err(err) => {

                state.panic = Some(err);

                0

            }

        }

    } else {

        0

openssl/src/ssl/mod.rs

+16 −2
Original line number Diff line number Diff line
@@ -26,8 +26,7 @@ use std::os::windows::io::{AsRawSocket, RawSocket}; 
use ffi;

use ffi_extras;

use dh::DH;

use ssl::error::{NonblockingSslError, SslError, StreamError, OpenSslErrors, OpenSslError,

                 OpensslError};

use ssl::error::{NonblockingSslError, SslError, OpenSslError, OpensslError};

use x509::{X509StoreContext, X509FileType, X509};

use crypto::pkey::PKey;
@@ -1137,6 +1136,8 @@ impl<S: Read + Write> SslStream<S> { 


impl<S> SslStream<S> {

    fn make_error(&mut self, ret: c_int) -> Error {

        self.check_panic();



        match self.ssl.get_error(ret) {

            LibSslError::ErrorSsl => Error::Ssl(OpenSslError::get_stack()),

            LibSslError::ErrorSyscall => {
@@ -1163,6 +1164,8 @@ impl<S> SslStream<S> { 
    }



    fn make_old_error(&mut self, ret: c_int) -> SslError {

        self.check_panic();



        match self.ssl.get_error(ret) {

            LibSslError::ErrorSsl => SslError::get(),

            LibSslError::ErrorSyscall => {
@@ -1193,6 +1196,17 @@ impl<S> SslStream<S> { 
        }

    }



    #[cfg(feature = "nightly")]

    fn check_panic(&mut self) {

        if let Some(err) = unsafe { bio::take_panic::<S>(self.ssl.get_raw_rbio()) } {

            ::std::panic::propagate(err)

        }

    }



    #[cfg(not(feature = "nightly"))]

    fn check_panic(&mut self) {

    }



    fn get_bio_error(&mut self) -> io::Error {

        let error = unsafe { bio::take_error::<S>(self.ssl.get_raw_rbio()) };

        match error {

openssl/src/ssl/tests/mod.rs

+88 −0
Original line number Diff line number Diff line
@@ -957,3 +957,91 @@ fn broken_try_clone_doesnt_crash() { 
    let stream1 = SslStream::connect(&context, inner).unwrap();

    let _stream2 = stream1.try_clone().unwrap();

}



#[test]

#[should_panic(message = "blammo")]

#[cfg(feature = "nightly")]

fn write_panic() {

    struct ExplodingStream(TcpStream);



    impl Read for ExplodingStream {

        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {

            self.0.read(buf)

        }

    }



    impl Write for ExplodingStream {

        fn write(&mut self, _: &[u8]) -> io::Result<usize> {

            panic!("blammo");

        }



        fn flush(&mut self) -> io::Result<()> {

            self.0.flush()

        }

    }



    let (_s, stream) = Server::new();

    let stream = ExplodingStream(stream);



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

    let _ = SslStream::connect(&ctx, stream);

}



#[test]

#[should_panic(message = "blammo")]

#[cfg(feature = "nightly")]

fn read_panic() {

    struct ExplodingStream(TcpStream);



    impl Read for ExplodingStream {

        fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {

            panic!("blammo");

        }

    }



    impl Write for ExplodingStream {

        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {

            self.0.write(buf)

        }



        fn flush(&mut self) -> io::Result<()> {

            self.0.flush()

        }

    }



    let (_s, stream) = Server::new();

    let stream = ExplodingStream(stream);



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

    let _ = SslStream::connect(&ctx, stream);

}



#[test]

#[should_panic(message = "blammo")]

#[cfg(feature = "nightly")]

fn flush_panic() {

    struct ExplodingStream(TcpStream);



    impl Read for ExplodingStream {

        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {

            self.0.read(buf)

        }

    }



    impl Write for ExplodingStream {

        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {

            self.0.write(buf)

        }



        fn flush(&mut self) -> io::Result<()> {

            panic!("blammo");

        }

    }



    let (_s, stream) = Server::new();

    let stream = ExplodingStream(stream);



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

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

    let _ = stream.flush();

}