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

Simplify panic safety logic for new nightly

parent dfce15be

openssl/src/ssl/bio.rs

+5 −44
Original line number Diff line number Diff line
@@ -74,8 +74,8 @@ unsafe fn state<'a, S: 'a>(bio: *mut BIO) -> &'a mut StreamState<S> { 
}



#[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)

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

    ::std::panic::recover(::std::panic::AssertRecoverSafe::new(f))

}



#[cfg(not(feature = "nightly"))]
@@ -83,45 +83,13 @@ 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);



    let result = {

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

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

    };

    let result = recover(|| state.stream.write(buf));



    match result {

        Ok(Ok(len)) => len as c_int,
@@ -145,11 +113,7 @@ 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);



    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))

    };

    let result = recover(|| state.stream.read(buf));



    match result {

        Ok(Ok(len)) => len as c_int,
@@ -185,10 +149,7 @@ unsafe extern "C" fn ctrl<S: Write>(bio: *mut BIO, 
                                    -> c_long {

    if cmd == BIO_CTRL_FLUSH {

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

        let result = {

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

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

        };

        let result = recover(|| state.stream.flush());



        match result {

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