yaahc/eyre - Change 4SNDY6U7TDCVRCARTEQ7JLATJFDMUMEFV2GSLKMQJY7RFNPU5HDQC

Fix UB when accessing errors with large alignment

Created by John Schug on October 9, 2019

4SNDY6U7TDCVRCARTEQ7JLATJFDMUMEFV2GSLKMQJY7RFNPU5HDQC

Dependencies

In channels

main

Change contents

Replacement in src/error.rs at line 94 [7.3238]
B:BD[6.941] → [6.941:960]
```
            error,
```
[6.941]
[6.960]
```
            _error: error,
```

Replacement in src/error.rs at line 236 [7.3238]

B:BD[7.6676] → [3.134:218]

                let error = ptr::read(&outer.inner.error as *const () as *const E);

[7.6676]

[3.218]

                let error = ptr::read(outer.inner.error() as *const _ as *const E);

Replacement in src/error.rs at line 288 [7.3238]

B:BD[7.7064] → [2.0:76]

            Some(unsafe { &*(&self.inner.error as *const () as *const E) })

[7.7064]

[8.1380]

            Some(unsafe { &*(self.inner.error() as *const _ as *const E) })

Replacement in src/error.rs at line 300 [7.3238]

B:BD[7.7360] → [2.77:157]

            Some(unsafe { &mut *(&mut self.inner.error as *mut () as *mut E) })

[7.7360]

[8.1425]

            Some(unsafe { &mut *(self.inner.error_mut() as *mut _ as *mut E) })

Replacement in src/error.rs at line 359 [7.3238]

∅:D[3.447] → [9.91:251]

∅:D[10.519] → [9.91:251]

B:BD[11.195] → [9.91:251]

    object_raw: fn(*const ()) -> *const (dyn StdError + Send + Sync + 'static),
    object_mut_raw: fn(*mut ()) -> *mut (dyn StdError + Send + Sync + 'static),

[3.447]

[12.210]

    object_raw: unsafe fn(&ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static),
    object_mut_raw: unsafe fn(&mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static),

Replacement in src/error.rs at line 379 [7.3238]

B:BD[11.364] → [13.153:233]

fn object_raw<E>(e: *const ()) -> *const (dyn StdError + Send + Sync + 'static)

[11.364]

[11.451]

unsafe fn object_raw<E>(e: &ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static)

Replacement in src/error.rs at line 383 [7.3238]
B:BD[11.500] → [11.500:518]
```
    e as *const E
```
[11.500]
[7.9174]
```
    &(*(e as *const ErrorImpl<()> as *const ErrorImpl<E>))._error
```

Replacement in src/error.rs at line 386 [7.3238]

B:BD[7.9177] → [13.234:314]

fn object_mut_raw<E>(e: *mut ()) -> *mut (dyn StdError + Send + Sync + 'static)

[7.9177]

[11.606]

unsafe fn object_mut_raw<E>(e: &mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static)

Replacement in src/error.rs at line 390 [7.3238]
B:BD[11.655] → [11.655:671]
```
    e as *mut E
```
[11.655]
[12.305]
```
    &mut (*(e as *mut ErrorImpl<()> as *mut ErrorImpl<E>))._error
```

Replacement in src/error.rs at line 406 [7.3238]

B:BD[7.9352] → [7.9352:9366]

    error: E,

[7.9352]

[7.9366]

    // NOTE: Don't use directly. Use only through vtable. Erased type may have different alignment.
    _error: E,

Replacement in src/error.rs at line 464 [7.3238]

B:BD[14.1693] → [9.252:311]

        unsafe { &*(self.vtable.object_raw)(&self.error) }

[14.1693]

[7.10195]

        unsafe { &*(self.vtable.object_raw)(self) }

Replacement in src/error.rs at line 468 [7.3238]

B:BD[14.1771] → [9.312:383]

        unsafe { &mut *(self.vtable.object_mut_raw)(&mut self.error) }

[14.1771]

[12.515]

        unsafe { &mut *(self.vtable.object_mut_raw)(self) }

Replacement in src/error.rs at line 536 [7.3238]
B:BD[5.383] → [5.383:411]
```
        self.error.source()
```
[5.383]
[5.411]
```
        self.erase().error().source()
```

Replacement in src/error.rs at line 554 [7.3238]

B:BD[12.2589] → [12.2589:2634]

        Display::fmt(&self.error, formatter)

[12.2589]

[12.2634]

        Display::fmt(&self.erase().error(), formatter)

Insertion in tests/test_downcast.rs at line 7 [15.311]
[4.58]
[15.346]
```
use std::error::Error as StdError;
use std::fmt::{self, Display};
```

Insertion in tests/test_downcast.rs at line 80 [15.311]

[4.389]

[15.772]

}
#[test]
fn test_large_alignment() {
    #[repr(align(64))]
    #[derive(Debug)]
    struct LargeAlignedError(&'static str);
    impl Display for LargeAlignedError {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.write_str(self.0)
        }
    }
    impl StdError for LargeAlignedError {}
    let error = Error::new(LargeAlignedError("oh no!"));
    assert_eq!("oh no!", error.downcast_ref::<LargeAlignedError>().unwrap().0);