gio/auto/
tls_interaction.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5#[cfg(feature = "futures")]
6use futures::future;
7use gio_sys;
8use glib::object::IsA;
9use glib::translate::*;
10use glib_sys;
11use gobject_sys;
12#[cfg(feature = "futures")]
13use std::boxed::Box as Box_;
14use std::fmt;
15use std::ptr;
16use Cancellable;
17use Error;
18use TlsCertificateRequestFlags;
19use TlsConnection;
20use TlsInteractionResult;
21use TlsPassword;
22
23glib_wrapper! {
24    pub struct TlsInteraction(Object<gio_sys::GTlsInteraction, gio_sys::GTlsInteractionClass, TlsInteractionClass>);
25
26    match fn {
27        get_type => || gio_sys::g_tls_interaction_get_type(),
28    }
29}
30
31pub const NONE_TLS_INTERACTION: Option<&TlsInteraction> = None;
32
33pub trait TlsInteractionExt: 'static {
34    fn ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
35        &self,
36        password: &P,
37        cancellable: Option<&Q>,
38    ) -> Result<TlsInteractionResult, Error>;
39
40    fn ask_password_async<
41        P: IsA<TlsPassword>,
42        Q: IsA<Cancellable>,
43        R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
44    >(
45        &self,
46        password: &P,
47        cancellable: Option<&Q>,
48        callback: R,
49    );
50
51    #[cfg(feature = "futures")]
52    fn ask_password_async_future<P: IsA<TlsPassword> + Clone + 'static>(
53        &self,
54        password: &P,
55    ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>;
56
57    fn invoke_ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
58        &self,
59        password: &P,
60        cancellable: Option<&Q>,
61    ) -> Result<TlsInteractionResult, Error>;
62
63    fn invoke_request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
64        &self,
65        connection: &P,
66        flags: TlsCertificateRequestFlags,
67        cancellable: Option<&Q>,
68    ) -> Result<TlsInteractionResult, Error>;
69
70    fn request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
71        &self,
72        connection: &P,
73        flags: TlsCertificateRequestFlags,
74        cancellable: Option<&Q>,
75    ) -> Result<TlsInteractionResult, Error>;
76
77    fn request_certificate_async<
78        P: IsA<TlsConnection>,
79        Q: IsA<Cancellable>,
80        R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
81    >(
82        &self,
83        connection: &P,
84        flags: TlsCertificateRequestFlags,
85        cancellable: Option<&Q>,
86        callback: R,
87    );
88
89    #[cfg(feature = "futures")]
90    fn request_certificate_async_future<P: IsA<TlsConnection> + Clone + 'static>(
91        &self,
92        connection: &P,
93        flags: TlsCertificateRequestFlags,
94    ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>;
95}
96
97impl<O: IsA<TlsInteraction>> TlsInteractionExt for O {
98    fn ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
99        &self,
100        password: &P,
101        cancellable: Option<&Q>,
102    ) -> Result<TlsInteractionResult, Error> {
103        unsafe {
104            let mut error = ptr::null_mut();
105            let ret = gio_sys::g_tls_interaction_ask_password(
106                self.as_ref().to_glib_none().0,
107                password.as_ref().to_glib_none().0,
108                cancellable.map(|p| p.as_ref()).to_glib_none().0,
109                &mut error,
110            );
111            if error.is_null() {
112                Ok(from_glib(ret))
113            } else {
114                Err(from_glib_full(error))
115            }
116        }
117    }
118
119    fn ask_password_async<
120        P: IsA<TlsPassword>,
121        Q: IsA<Cancellable>,
122        R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
123    >(
124        &self,
125        password: &P,
126        cancellable: Option<&Q>,
127        callback: R,
128    ) {
129        let user_data: Box<R> = Box::new(callback);
130        unsafe extern "C" fn ask_password_async_trampoline<
131            R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
132        >(
133            _source_object: *mut gobject_sys::GObject,
134            res: *mut gio_sys::GAsyncResult,
135            user_data: glib_sys::gpointer,
136        ) {
137            let mut error = ptr::null_mut();
138            let ret = gio_sys::g_tls_interaction_ask_password_finish(
139                _source_object as *mut _,
140                res,
141                &mut error,
142            );
143            let result = if error.is_null() {
144                Ok(from_glib(ret))
145            } else {
146                Err(from_glib_full(error))
147            };
148            let callback: Box<R> = Box::from_raw(user_data as *mut _);
149            callback(result);
150        }
151        let callback = ask_password_async_trampoline::<R>;
152        unsafe {
153            gio_sys::g_tls_interaction_ask_password_async(
154                self.as_ref().to_glib_none().0,
155                password.as_ref().to_glib_none().0,
156                cancellable.map(|p| p.as_ref()).to_glib_none().0,
157                Some(callback),
158                Box::into_raw(user_data) as *mut _,
159            );
160        }
161    }
162
163    #[cfg(feature = "futures")]
164    fn ask_password_async_future<P: IsA<TlsPassword> + Clone + 'static>(
165        &self,
166        password: &P,
167    ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>
168    {
169        use fragile::Fragile;
170        use GioFuture;
171
172        let password = password.clone();
173        GioFuture::new(self, move |obj, send| {
174            let cancellable = Cancellable::new();
175            let send = Fragile::new(send);
176            obj.ask_password_async(&password, Some(&cancellable), move |res| {
177                let _ = send.into_inner().send(res);
178            });
179
180            cancellable
181        })
182    }
183
184    fn invoke_ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
185        &self,
186        password: &P,
187        cancellable: Option<&Q>,
188    ) -> Result<TlsInteractionResult, Error> {
189        unsafe {
190            let mut error = ptr::null_mut();
191            let ret = gio_sys::g_tls_interaction_invoke_ask_password(
192                self.as_ref().to_glib_none().0,
193                password.as_ref().to_glib_none().0,
194                cancellable.map(|p| p.as_ref()).to_glib_none().0,
195                &mut error,
196            );
197            if error.is_null() {
198                Ok(from_glib(ret))
199            } else {
200                Err(from_glib_full(error))
201            }
202        }
203    }
204
205    fn invoke_request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
206        &self,
207        connection: &P,
208        flags: TlsCertificateRequestFlags,
209        cancellable: Option<&Q>,
210    ) -> Result<TlsInteractionResult, Error> {
211        unsafe {
212            let mut error = ptr::null_mut();
213            let ret = gio_sys::g_tls_interaction_invoke_request_certificate(
214                self.as_ref().to_glib_none().0,
215                connection.as_ref().to_glib_none().0,
216                flags.to_glib(),
217                cancellable.map(|p| p.as_ref()).to_glib_none().0,
218                &mut error,
219            );
220            if error.is_null() {
221                Ok(from_glib(ret))
222            } else {
223                Err(from_glib_full(error))
224            }
225        }
226    }
227
228    fn request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
229        &self,
230        connection: &P,
231        flags: TlsCertificateRequestFlags,
232        cancellable: Option<&Q>,
233    ) -> Result<TlsInteractionResult, Error> {
234        unsafe {
235            let mut error = ptr::null_mut();
236            let ret = gio_sys::g_tls_interaction_request_certificate(
237                self.as_ref().to_glib_none().0,
238                connection.as_ref().to_glib_none().0,
239                flags.to_glib(),
240                cancellable.map(|p| p.as_ref()).to_glib_none().0,
241                &mut error,
242            );
243            if error.is_null() {
244                Ok(from_glib(ret))
245            } else {
246                Err(from_glib_full(error))
247            }
248        }
249    }
250
251    fn request_certificate_async<
252        P: IsA<TlsConnection>,
253        Q: IsA<Cancellable>,
254        R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
255    >(
256        &self,
257        connection: &P,
258        flags: TlsCertificateRequestFlags,
259        cancellable: Option<&Q>,
260        callback: R,
261    ) {
262        let user_data: Box<R> = Box::new(callback);
263        unsafe extern "C" fn request_certificate_async_trampoline<
264            R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
265        >(
266            _source_object: *mut gobject_sys::GObject,
267            res: *mut gio_sys::GAsyncResult,
268            user_data: glib_sys::gpointer,
269        ) {
270            let mut error = ptr::null_mut();
271            let ret = gio_sys::g_tls_interaction_request_certificate_finish(
272                _source_object as *mut _,
273                res,
274                &mut error,
275            );
276            let result = if error.is_null() {
277                Ok(from_glib(ret))
278            } else {
279                Err(from_glib_full(error))
280            };
281            let callback: Box<R> = Box::from_raw(user_data as *mut _);
282            callback(result);
283        }
284        let callback = request_certificate_async_trampoline::<R>;
285        unsafe {
286            gio_sys::g_tls_interaction_request_certificate_async(
287                self.as_ref().to_glib_none().0,
288                connection.as_ref().to_glib_none().0,
289                flags.to_glib(),
290                cancellable.map(|p| p.as_ref()).to_glib_none().0,
291                Some(callback),
292                Box::into_raw(user_data) as *mut _,
293            );
294        }
295    }
296
297    #[cfg(feature = "futures")]
298    fn request_certificate_async_future<P: IsA<TlsConnection> + Clone + 'static>(
299        &self,
300        connection: &P,
301        flags: TlsCertificateRequestFlags,
302    ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>
303    {
304        use fragile::Fragile;
305        use GioFuture;
306
307        let connection = connection.clone();
308        GioFuture::new(self, move |obj, send| {
309            let cancellable = Cancellable::new();
310            let send = Fragile::new(send);
311            obj.request_certificate_async(&connection, flags, Some(&cancellable), move |res| {
312                let _ = send.into_inner().send(res);
313            });
314
315            cancellable
316        })
317    }
318}
319
320impl fmt::Display for TlsInteraction {
321    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
322        write!(f, "TlsInteraction")
323    }
324}