openssl/
macros.rs

Help
1macro_rules! private_key_from_pem {
2    ($(#[$m:meta])* $n:ident, $(#[$m2:meta])* $n2:ident, $(#[$m3:meta])* $n3:ident, $t:ty, $f:path) => {
3        from_pem!($(#[$m])* $n, $t, $f);
4
5        $(#[$m2])*
6        pub fn $n2(pem: &[u8], passphrase: &[u8]) -> Result<$t, crate::error::ErrorStack> {
7            unsafe {
8                ffi::init();
9                let bio = crate::bio::MemBioSlice::new(pem)?;
10                let passphrase = ::std::ffi::CString::new(passphrase).unwrap();
11                cvt_p($f(bio.as_ptr(),
12                         ptr::null_mut(),
13                         None,
14                         passphrase.as_ptr() as *const _ as *mut _))
15                    .map(|p| ::foreign_types::ForeignType::from_ptr(p))
16            }
17        }
18
19        $(#[$m3])*
20        pub fn $n3<F>(pem: &[u8], callback: F) -> Result<$t, crate::error::ErrorStack>
21            where F: FnOnce(&mut [u8]) -> Result<usize, crate::error::ErrorStack>
22        {
23            unsafe {
24                ffi::init();
25                let mut cb = crate::util::CallbackState::new(callback);
26                let bio = crate::bio::MemBioSlice::new(pem)?;
27                cvt_p($f(bio.as_ptr(),
28                         ptr::null_mut(),
29                         Some(crate::util::invoke_passwd_cb::<F>),
30                         &mut cb as *mut _ as *mut _))
31                    .map(|p| ::foreign_types::ForeignType::from_ptr(p))
32            }
33        }
34    }
35}
36
37macro_rules! private_key_to_pem {
38    ($(#[$m:meta])* $n:ident, $(#[$m2:meta])* $n2:ident, $f:path) => {
39        $(#[$m])*
40        pub fn $n(&self) -> Result<Vec<u8>, crate::error::ErrorStack> {
41            unsafe {
42                let bio = crate::bio::MemBio::new()?;
43                cvt($f(bio.as_ptr(),
44                        self.as_ptr(),
45                        ptr::null(),
46                        ptr::null_mut(),
47                        -1,
48                        None,
49                        ptr::null_mut()))?;
50                Ok(bio.get_buf().to_owned())
51            }
52        }
53
54        $(#[$m2])*
55        pub fn $n2(
56            &self,
57            cipher: crate::symm::Cipher,
58            passphrase: &[u8]
59        ) -> Result<Vec<u8>, crate::error::ErrorStack> {
60            unsafe {
61                let bio = crate::bio::MemBio::new()?;
62                assert!(passphrase.len() <= ::libc::c_int::MAX as usize);
63                cvt($f(bio.as_ptr(),
64                        self.as_ptr(),
65                        cipher.as_ptr(),
66                        passphrase.as_ptr() as *const _ as *mut _,
67                        passphrase.len() as ::libc::c_int,
68                        None,
69                        ptr::null_mut()))?;
70                Ok(bio.get_buf().to_owned())
71            }
72        }
73    }
74}
75
76macro_rules! to_pem {
77    ($(#[$m:meta])* $n:ident, $f:path) => {
78        $(#[$m])*
79        pub fn $n(&self) -> Result<Vec<u8>, crate::error::ErrorStack> {
80            unsafe {
81                let bio = crate::bio::MemBio::new()?;
82                cvt($f(bio.as_ptr(), self.as_ptr()))?;
83                Ok(bio.get_buf().to_owned())
84            }
85        }
86    }
87}
88
89macro_rules! to_der {
90    ($(#[$m:meta])* $n:ident, $f:path) => {
91        $(#[$m])*
92        pub fn $n(&self) -> Result<Vec<u8>, crate::error::ErrorStack> {
93            unsafe {
94                let len = crate::cvt($f(::foreign_types::ForeignTypeRef::as_ptr(self),
95                                        ptr::null_mut()))?;
96                let mut buf = vec![0; len as usize];
97                crate::cvt($f(::foreign_types::ForeignTypeRef::as_ptr(self),
98                              &mut buf.as_mut_ptr()))?;
99                Ok(buf)
100            }
101        }
102    };
103}
104
105macro_rules! from_der {
106    ($(#[$m:meta])* $n:ident, $t:ty, $f:path) => {
107        $(#[$m])*
108        pub fn $n(der: &[u8]) -> Result<$t, crate::error::ErrorStack> {
109            use std::convert::TryInto;
110            unsafe {
111                ffi::init();
112                let len = ::std::cmp::min(der.len(), ::libc::c_long::MAX as usize) as ::libc::c_long;
113                crate::cvt_p($f(::std::ptr::null_mut(), &mut der.as_ptr(), len.try_into().unwrap()))
114                    .map(|p| ::foreign_types::ForeignType::from_ptr(p))
115            }
116        }
117    }
118}
119
120macro_rules! from_pem {
121    ($(#[$m:meta])* $n:ident, $t:ty, $f:path) => {
122        $(#[$m])*
123        pub fn $n(pem: &[u8]) -> Result<$t, crate::error::ErrorStack> {
124            unsafe {
125                crate::init();
126                let bio = crate::bio::MemBioSlice::new(pem)?;
127                cvt_p($f(bio.as_ptr(), ::std::ptr::null_mut(), None, ::std::ptr::null_mut()))
128                    .map(|p| ::foreign_types::ForeignType::from_ptr(p))
129            }
130        }
131    }
132}
133
134macro_rules! foreign_type_and_impl_send_sync {
135    (
136        $(#[$impl_attr:meta])*
137        type CType = $ctype:ty;
138        fn drop = $drop:expr;
139        $(fn clone = $clone:expr;)*
140
141        $(#[$owned_attr:meta])*
142        pub struct $owned:ident;
143        $(#[$borrowed_attr:meta])*
144        pub struct $borrowed:ident;
145    )
146        => {
147            ::foreign_types::foreign_type! {
148                $(#[$impl_attr])*
149                type CType = $ctype;
150                fn drop = $drop;
151                $(fn clone = $clone;)*
152                $(#[$owned_attr])*
153                pub struct $owned;
154                $(#[$borrowed_attr])*
155                pub struct $borrowed;
156            }
157
158            unsafe impl Send for $owned{}
159            unsafe impl Send for $borrowed{}
160            unsafe impl Sync for $owned{}
161            unsafe impl Sync for $borrowed{}
162        };
163}
164
165macro_rules! generic_foreign_type_and_impl_send_sync {
166    (
167        $(#[$impl_attr:meta])*
168        type CType = $ctype:ty;
169        fn drop = $drop:expr;
170        $(fn clone = $clone:expr;)*
171
172        $(#[$owned_attr:meta])*
173        pub struct $owned:ident<T>;
174        $(#[$borrowed_attr:meta])*
175        pub struct $borrowed:ident<T>;
176    ) => {
177        $(#[$owned_attr])*
178        pub struct $owned<T>(*mut $ctype, ::std::marker::PhantomData<T>);
179
180        $(#[$impl_attr])*
181        impl<T> ::foreign_types::ForeignType for $owned<T> {
182            type CType = $ctype;
183            type Ref = $borrowed<T>;
184
185            #[inline]
186            unsafe fn from_ptr(ptr: *mut $ctype) -> $owned<T> {
187                $owned(ptr, ::std::marker::PhantomData)
188            }
189
190            #[inline]
191            fn as_ptr(&self) -> *mut $ctype {
192                self.0
193            }
194        }
195
196        impl<T> Drop for $owned<T> {
197            #[inline]
198            fn drop(&mut self) {
199                unsafe { $drop(self.0) }
200            }
201        }
202
203        $(
204            impl<T> Clone for $owned<T> {
205                #[inline]
206                fn clone(&self) -> $owned<T> {
207                    unsafe {
208                        let handle: *mut $ctype = $clone(self.0);
209                        ::foreign_types::ForeignType::from_ptr(handle)
210                    }
211                }
212            }
213
214            impl<T> ::std::borrow::ToOwned for $borrowed<T> {
215                type Owned = $owned<T>;
216                #[inline]
217                fn to_owned(&self) -> $owned<T> {
218                    unsafe {
219                        let handle: *mut $ctype =
220                            $clone(::foreign_types::ForeignTypeRef::as_ptr(self));
221                        $crate::ForeignType::from_ptr(handle)
222                    }
223                }
224            }
225        )*
226
227        impl<T> ::std::ops::Deref for $owned<T> {
228            type Target = $borrowed<T>;
229
230            #[inline]
231            fn deref(&self) -> &$borrowed<T> {
232                unsafe { ::foreign_types::ForeignTypeRef::from_ptr(self.0) }
233            }
234        }
235
236        impl<T> ::std::ops::DerefMut for $owned<T> {
237            #[inline]
238            fn deref_mut(&mut self) -> &mut $borrowed<T> {
239                unsafe { ::foreign_types::ForeignTypeRef::from_ptr_mut(self.0) }
240            }
241        }
242
243        impl<T> ::std::borrow::Borrow<$borrowed<T>> for $owned<T> {
244            #[inline]
245            fn borrow(&self) -> &$borrowed<T> {
246                &**self
247            }
248        }
249
250        impl<T> ::std::convert::AsRef<$borrowed<T>> for $owned<T> {
251            #[inline]
252            fn as_ref(&self) -> &$borrowed<T> {
253                &**self
254            }
255        }
256
257        $(#[$borrowed_attr])*
258        pub struct $borrowed<T>(::foreign_types::Opaque, ::std::marker::PhantomData<T>);
259
260        $(#[$impl_attr])*
261        impl<T> ::foreign_types::ForeignTypeRef for $borrowed<T> {
262            type CType = $ctype;
263        }
264
265        unsafe impl<T> Send for $owned<T>{}
266        unsafe impl<T> Send for $borrowed<T>{}
267        unsafe impl<T> Sync for $owned<T>{}
268        unsafe impl<T> Sync for $borrowed<T>{}
269    };
270}
openssl/macros.rs

openssl/
macros.rs
