libsignal-protocol 0.1.0

An idiomatic high-level interface to the libsignal-protocol-c crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

macro_rules! impl_serializable {
    ($name:ty, $serialize:ident, $deserialize:ident) => {
        impl $crate::Serializable for $name {
            fn deserialize(_data: &[u8]) -> Result<Self, failure::Error>
            where
                Self: Sized,
            {
                unimplemented!()
            }

            fn serialize(&self) -> Result<$crate::Buffer, failure::Error> {
                #[allow(unused_imports)]
                use $crate::errors::FromInternalErrorCode;

                unsafe {
                    let mut buffer = std::ptr::null_mut();
                    sys::$serialize(&mut buffer, self.raw.as_const_ptr())
                        .into_result()?;
                    Ok($crate::Buffer::from_raw(buffer))
                }
            }
        }
    };
}

macro_rules! impl_is_a {
    ($child:ty => $parent:ty) => {
        unsafe impl $crate::raw_ptr::IsA<$parent> for $child {
            unsafe fn upcast(this: *mut Self) -> *mut $parent {
                this as *mut $parent
            }
        }
    };
    ($($child:ty => $parent:ty),* $(,)*) => {
        $(
            impl_is_a!($child => $parent);
        )*
    };
}

/// An an alternative to [`assert!()`] for functions called from C.
macro_rules! signal_assert {
    ($condition:expr) => {
        signal_assert!($condition, $crate::InternalError::InvalidArgument);
    };
    ($condition:expr, $ret:expr) => {
        if !$condition {
            ::log::error!(
                "Assertion failed at {}#{}: {}",
                file!(),
                line!(),
                stringify!($condition),
            );
            let bt = ::failure::Backtrace::new().to_string();
            if !bt.is_empty() {
                ::log::error!("{}", bt);
            }

            return $ret.into();
        }
    };
}

macro_rules! signal_catch_unwind {
    ($operation:expr) => {
        match ::std::panic::catch_unwind(|| $operation) {
            Ok(got) => got,
            Err(panic_error) => {
                let msg = if let Some(m) = panic_error.downcast_ref::<&str>() {
                    m
                } else if let Some(m) = panic_error.downcast_ref::<String>() {
                    m.as_str()
                } else {
                    "Unknown panic"
                };

                ::log::error!(
                    "The expression `{}` panicked at {}#{}: {}",
                    stringify!($operation),
                    file!(),
                    line!(),
                    msg
                );

                return $crate::InternalError::Unknown.into();
            },
        }
    };
}