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 use crate::AsyncResult;
6 use crate::Cancellable;
7 use crate::SocketConnectable;
8 use crate::TlsCertificate;
9 use crate::TlsCertificateFlags;
10 use crate::TlsDatabaseLookupFlags;
11 use crate::TlsDatabaseVerifyFlags;
12 use crate::TlsInteraction;
13 use glib::object::IsA;
14 use glib::translate::*;
15 use std::boxed::Box as Box_;
16 use std::fmt;
17 use std::pin::Pin;
18 use std::ptr;
19 
20 glib::wrapper! {
21     #[doc(alias = "GTlsDatabase")]
22     pub struct TlsDatabase(Object<ffi::GTlsDatabase, ffi::GTlsDatabaseClass>);
23 
24     match fn {
25         type_ => || ffi::g_tls_database_get_type(),
26     }
27 }
28 
29 pub const NONE_TLS_DATABASE: Option<&TlsDatabase> = None;
30 
31 pub trait TlsDatabaseExt: 'static {
32     #[doc(alias = "g_tls_database_create_certificate_handle")]
create_certificate_handle<P: IsA<TlsCertificate>>( &self, certificate: &P, ) -> Option<glib::GString>33     fn create_certificate_handle<P: IsA<TlsCertificate>>(
34         &self,
35         certificate: &P,
36     ) -> Option<glib::GString>;
37 
38     #[doc(alias = "g_tls_database_lookup_certificate_for_handle")]
lookup_certificate_for_handle<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>( &self, handle: &str, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, ) -> Result<Option<TlsCertificate>, glib::Error>39     fn lookup_certificate_for_handle<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
40         &self,
41         handle: &str,
42         interaction: Option<&P>,
43         flags: TlsDatabaseLookupFlags,
44         cancellable: Option<&Q>,
45     ) -> Result<Option<TlsCertificate>, glib::Error>;
46 
47     #[doc(alias = "g_tls_database_lookup_certificate_for_handle_async")]
lookup_certificate_for_handle_async< P: IsA<TlsInteraction>, Q: IsA<Cancellable>, R: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static, >( &self, handle: &str, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, callback: R, )48     fn lookup_certificate_for_handle_async<
49         P: IsA<TlsInteraction>,
50         Q: IsA<Cancellable>,
51         R: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static,
52     >(
53         &self,
54         handle: &str,
55         interaction: Option<&P>,
56         flags: TlsDatabaseLookupFlags,
57         cancellable: Option<&Q>,
58         callback: R,
59     );
60 
lookup_certificate_for_handle_async_future<P: IsA<TlsInteraction> + Clone + 'static>( &self, handle: &str, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>61     fn lookup_certificate_for_handle_async_future<P: IsA<TlsInteraction> + Clone + 'static>(
62         &self,
63         handle: &str,
64         interaction: Option<&P>,
65         flags: TlsDatabaseLookupFlags,
66     ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>;
67 
68     #[doc(alias = "g_tls_database_lookup_certificate_issuer")]
lookup_certificate_issuer< P: IsA<TlsCertificate>, Q: IsA<TlsInteraction>, R: IsA<Cancellable>, >( &self, certificate: &P, interaction: Option<&Q>, flags: TlsDatabaseLookupFlags, cancellable: Option<&R>, ) -> Result<TlsCertificate, glib::Error>69     fn lookup_certificate_issuer<
70         P: IsA<TlsCertificate>,
71         Q: IsA<TlsInteraction>,
72         R: IsA<Cancellable>,
73     >(
74         &self,
75         certificate: &P,
76         interaction: Option<&Q>,
77         flags: TlsDatabaseLookupFlags,
78         cancellable: Option<&R>,
79     ) -> Result<TlsCertificate, glib::Error>;
80 
81     #[doc(alias = "g_tls_database_lookup_certificate_issuer_async")]
lookup_certificate_issuer_async< P: IsA<TlsCertificate>, Q: IsA<TlsInteraction>, R: IsA<Cancellable>, S: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static, >( &self, certificate: &P, interaction: Option<&Q>, flags: TlsDatabaseLookupFlags, cancellable: Option<&R>, callback: S, )82     fn lookup_certificate_issuer_async<
83         P: IsA<TlsCertificate>,
84         Q: IsA<TlsInteraction>,
85         R: IsA<Cancellable>,
86         S: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static,
87     >(
88         &self,
89         certificate: &P,
90         interaction: Option<&Q>,
91         flags: TlsDatabaseLookupFlags,
92         cancellable: Option<&R>,
93         callback: S,
94     );
95 
lookup_certificate_issuer_async_future< P: IsA<TlsCertificate> + Clone + 'static, Q: IsA<TlsInteraction> + Clone + 'static, >( &self, certificate: &P, interaction: Option<&Q>, flags: TlsDatabaseLookupFlags, ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>96     fn lookup_certificate_issuer_async_future<
97         P: IsA<TlsCertificate> + Clone + 'static,
98         Q: IsA<TlsInteraction> + Clone + 'static,
99     >(
100         &self,
101         certificate: &P,
102         interaction: Option<&Q>,
103         flags: TlsDatabaseLookupFlags,
104     ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>;
105 
106     #[doc(alias = "g_tls_database_lookup_certificates_issued_by")]
lookup_certificates_issued_by<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>( &self, issuer_raw_dn: &glib::ByteArray, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, ) -> Result<Vec<TlsCertificate>, glib::Error>107     fn lookup_certificates_issued_by<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
108         &self,
109         issuer_raw_dn: &glib::ByteArray,
110         interaction: Option<&P>,
111         flags: TlsDatabaseLookupFlags,
112         cancellable: Option<&Q>,
113     ) -> Result<Vec<TlsCertificate>, glib::Error>;
114 
115     #[doc(alias = "g_tls_database_lookup_certificates_issued_by_async")]
lookup_certificates_issued_by_async< P: IsA<TlsInteraction>, Q: IsA<Cancellable>, R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + Send + 'static, >( &self, issuer_raw_dn: &glib::ByteArray, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, callback: R, )116     fn lookup_certificates_issued_by_async<
117         P: IsA<TlsInteraction>,
118         Q: IsA<Cancellable>,
119         R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + Send + 'static,
120     >(
121         &self,
122         issuer_raw_dn: &glib::ByteArray,
123         interaction: Option<&P>,
124         flags: TlsDatabaseLookupFlags,
125         cancellable: Option<&Q>,
126         callback: R,
127     );
128 
lookup_certificates_issued_by_async_future<P: IsA<TlsInteraction> + Clone + 'static>( &self, issuer_raw_dn: &glib::ByteArray, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, ) -> Pin< Box_<dyn std::future::Future<Output = Result<Vec<TlsCertificate>, glib::Error>> + 'static>, >129     fn lookup_certificates_issued_by_async_future<P: IsA<TlsInteraction> + Clone + 'static>(
130         &self,
131         issuer_raw_dn: &glib::ByteArray,
132         interaction: Option<&P>,
133         flags: TlsDatabaseLookupFlags,
134     ) -> Pin<
135         Box_<dyn std::future::Future<Output = Result<Vec<TlsCertificate>, glib::Error>> + 'static>,
136     >;
137 
138     #[doc(alias = "g_tls_database_verify_chain")]
verify_chain< P: IsA<TlsCertificate>, Q: IsA<SocketConnectable>, R: IsA<TlsInteraction>, S: IsA<Cancellable>, >( &self, chain: &P, purpose: &str, identity: Option<&Q>, interaction: Option<&R>, flags: TlsDatabaseVerifyFlags, cancellable: Option<&S>, ) -> Result<TlsCertificateFlags, glib::Error>139     fn verify_chain<
140         P: IsA<TlsCertificate>,
141         Q: IsA<SocketConnectable>,
142         R: IsA<TlsInteraction>,
143         S: IsA<Cancellable>,
144     >(
145         &self,
146         chain: &P,
147         purpose: &str,
148         identity: Option<&Q>,
149         interaction: Option<&R>,
150         flags: TlsDatabaseVerifyFlags,
151         cancellable: Option<&S>,
152     ) -> Result<TlsCertificateFlags, glib::Error>;
153 
154     #[doc(alias = "g_tls_database_verify_chain_async")]
verify_chain_async< P: IsA<TlsCertificate>, Q: IsA<SocketConnectable>, R: IsA<TlsInteraction>, S: IsA<Cancellable>, T: FnOnce(Result<TlsCertificateFlags, glib::Error>) + Send + 'static, >( &self, chain: &P, purpose: &str, identity: Option<&Q>, interaction: Option<&R>, flags: TlsDatabaseVerifyFlags, cancellable: Option<&S>, callback: T, )155     fn verify_chain_async<
156         P: IsA<TlsCertificate>,
157         Q: IsA<SocketConnectable>,
158         R: IsA<TlsInteraction>,
159         S: IsA<Cancellable>,
160         T: FnOnce(Result<TlsCertificateFlags, glib::Error>) + Send + 'static,
161     >(
162         &self,
163         chain: &P,
164         purpose: &str,
165         identity: Option<&Q>,
166         interaction: Option<&R>,
167         flags: TlsDatabaseVerifyFlags,
168         cancellable: Option<&S>,
169         callback: T,
170     );
171 
verify_chain_async_future< P: IsA<TlsCertificate> + Clone + 'static, Q: IsA<SocketConnectable> + Clone + 'static, R: IsA<TlsInteraction> + Clone + 'static, >( &self, chain: &P, purpose: &str, identity: Option<&Q>, interaction: Option<&R>, flags: TlsDatabaseVerifyFlags, ) -> Pin< Box_<dyn std::future::Future<Output = Result<TlsCertificateFlags, glib::Error>> + 'static>, >172     fn verify_chain_async_future<
173         P: IsA<TlsCertificate> + Clone + 'static,
174         Q: IsA<SocketConnectable> + Clone + 'static,
175         R: IsA<TlsInteraction> + Clone + 'static,
176     >(
177         &self,
178         chain: &P,
179         purpose: &str,
180         identity: Option<&Q>,
181         interaction: Option<&R>,
182         flags: TlsDatabaseVerifyFlags,
183     ) -> Pin<
184         Box_<dyn std::future::Future<Output = Result<TlsCertificateFlags, glib::Error>> + 'static>,
185     >;
186 }
187 
188 impl<O: IsA<TlsDatabase>> TlsDatabaseExt for O {
create_certificate_handle<P: IsA<TlsCertificate>>( &self, certificate: &P, ) -> Option<glib::GString>189     fn create_certificate_handle<P: IsA<TlsCertificate>>(
190         &self,
191         certificate: &P,
192     ) -> Option<glib::GString> {
193         unsafe {
194             from_glib_full(ffi::g_tls_database_create_certificate_handle(
195                 self.as_ref().to_glib_none().0,
196                 certificate.as_ref().to_glib_none().0,
197             ))
198         }
199     }
200 
lookup_certificate_for_handle<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>( &self, handle: &str, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, ) -> Result<Option<TlsCertificate>, glib::Error>201     fn lookup_certificate_for_handle<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
202         &self,
203         handle: &str,
204         interaction: Option<&P>,
205         flags: TlsDatabaseLookupFlags,
206         cancellable: Option<&Q>,
207     ) -> Result<Option<TlsCertificate>, glib::Error> {
208         unsafe {
209             let mut error = ptr::null_mut();
210             let ret = ffi::g_tls_database_lookup_certificate_for_handle(
211                 self.as_ref().to_glib_none().0,
212                 handle.to_glib_none().0,
213                 interaction.map(|p| p.as_ref()).to_glib_none().0,
214                 flags.into_glib(),
215                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
216                 &mut error,
217             );
218             if error.is_null() {
219                 Ok(from_glib_full(ret))
220             } else {
221                 Err(from_glib_full(error))
222             }
223         }
224     }
225 
lookup_certificate_for_handle_async< P: IsA<TlsInteraction>, Q: IsA<Cancellable>, R: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static, >( &self, handle: &str, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, callback: R, )226     fn lookup_certificate_for_handle_async<
227         P: IsA<TlsInteraction>,
228         Q: IsA<Cancellable>,
229         R: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static,
230     >(
231         &self,
232         handle: &str,
233         interaction: Option<&P>,
234         flags: TlsDatabaseLookupFlags,
235         cancellable: Option<&Q>,
236         callback: R,
237     ) {
238         let user_data: Box_<R> = Box_::new(callback);
239         unsafe extern "C" fn lookup_certificate_for_handle_async_trampoline<
240             R: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static,
241         >(
242             _source_object: *mut glib::gobject_ffi::GObject,
243             res: *mut crate::ffi::GAsyncResult,
244             user_data: glib::ffi::gpointer,
245         ) {
246             let mut error = ptr::null_mut();
247             let ret = ffi::g_tls_database_lookup_certificate_for_handle_finish(
248                 _source_object as *mut _,
249                 res,
250                 &mut error,
251             );
252             let result = if error.is_null() {
253                 Ok(from_glib_full(ret))
254             } else {
255                 Err(from_glib_full(error))
256             };
257             let callback: Box_<R> = Box_::from_raw(user_data as *mut _);
258             callback(result);
259         }
260         let callback = lookup_certificate_for_handle_async_trampoline::<R>;
261         unsafe {
262             ffi::g_tls_database_lookup_certificate_for_handle_async(
263                 self.as_ref().to_glib_none().0,
264                 handle.to_glib_none().0,
265                 interaction.map(|p| p.as_ref()).to_glib_none().0,
266                 flags.into_glib(),
267                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
268                 Some(callback),
269                 Box_::into_raw(user_data) as *mut _,
270             );
271         }
272     }
273 
lookup_certificate_for_handle_async_future<P: IsA<TlsInteraction> + Clone + 'static>( &self, handle: &str, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>274     fn lookup_certificate_for_handle_async_future<P: IsA<TlsInteraction> + Clone + 'static>(
275         &self,
276         handle: &str,
277         interaction: Option<&P>,
278         flags: TlsDatabaseLookupFlags,
279     ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>
280     {
281         let handle = String::from(handle);
282         let interaction = interaction.map(ToOwned::to_owned);
283         Box_::pin(crate::GioFuture::new(
284             self,
285             move |obj, cancellable, send| {
286                 obj.lookup_certificate_for_handle_async(
287                     &handle,
288                     interaction.as_ref().map(::std::borrow::Borrow::borrow),
289                     flags,
290                     Some(cancellable),
291                     move |res| {
292                         send.resolve(res);
293                     },
294                 );
295             },
296         ))
297     }
298 
lookup_certificate_issuer< P: IsA<TlsCertificate>, Q: IsA<TlsInteraction>, R: IsA<Cancellable>, >( &self, certificate: &P, interaction: Option<&Q>, flags: TlsDatabaseLookupFlags, cancellable: Option<&R>, ) -> Result<TlsCertificate, glib::Error>299     fn lookup_certificate_issuer<
300         P: IsA<TlsCertificate>,
301         Q: IsA<TlsInteraction>,
302         R: IsA<Cancellable>,
303     >(
304         &self,
305         certificate: &P,
306         interaction: Option<&Q>,
307         flags: TlsDatabaseLookupFlags,
308         cancellable: Option<&R>,
309     ) -> Result<TlsCertificate, glib::Error> {
310         unsafe {
311             let mut error = ptr::null_mut();
312             let ret = ffi::g_tls_database_lookup_certificate_issuer(
313                 self.as_ref().to_glib_none().0,
314                 certificate.as_ref().to_glib_none().0,
315                 interaction.map(|p| p.as_ref()).to_glib_none().0,
316                 flags.into_glib(),
317                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
318                 &mut error,
319             );
320             if error.is_null() {
321                 Ok(from_glib_full(ret))
322             } else {
323                 Err(from_glib_full(error))
324             }
325         }
326     }
327 
lookup_certificate_issuer_async< P: IsA<TlsCertificate>, Q: IsA<TlsInteraction>, R: IsA<Cancellable>, S: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static, >( &self, certificate: &P, interaction: Option<&Q>, flags: TlsDatabaseLookupFlags, cancellable: Option<&R>, callback: S, )328     fn lookup_certificate_issuer_async<
329         P: IsA<TlsCertificate>,
330         Q: IsA<TlsInteraction>,
331         R: IsA<Cancellable>,
332         S: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static,
333     >(
334         &self,
335         certificate: &P,
336         interaction: Option<&Q>,
337         flags: TlsDatabaseLookupFlags,
338         cancellable: Option<&R>,
339         callback: S,
340     ) {
341         let user_data: Box_<S> = Box_::new(callback);
342         unsafe extern "C" fn lookup_certificate_issuer_async_trampoline<
343             S: FnOnce(Result<TlsCertificate, glib::Error>) + Send + 'static,
344         >(
345             _source_object: *mut glib::gobject_ffi::GObject,
346             res: *mut crate::ffi::GAsyncResult,
347             user_data: glib::ffi::gpointer,
348         ) {
349             let mut error = ptr::null_mut();
350             let ret = ffi::g_tls_database_lookup_certificate_issuer_finish(
351                 _source_object as *mut _,
352                 res,
353                 &mut error,
354             );
355             let result = if error.is_null() {
356                 Ok(from_glib_full(ret))
357             } else {
358                 Err(from_glib_full(error))
359             };
360             let callback: Box_<S> = Box_::from_raw(user_data as *mut _);
361             callback(result);
362         }
363         let callback = lookup_certificate_issuer_async_trampoline::<S>;
364         unsafe {
365             ffi::g_tls_database_lookup_certificate_issuer_async(
366                 self.as_ref().to_glib_none().0,
367                 certificate.as_ref().to_glib_none().0,
368                 interaction.map(|p| p.as_ref()).to_glib_none().0,
369                 flags.into_glib(),
370                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
371                 Some(callback),
372                 Box_::into_raw(user_data) as *mut _,
373             );
374         }
375     }
376 
lookup_certificate_issuer_async_future< P: IsA<TlsCertificate> + Clone + 'static, Q: IsA<TlsInteraction> + Clone + 'static, >( &self, certificate: &P, interaction: Option<&Q>, flags: TlsDatabaseLookupFlags, ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>377     fn lookup_certificate_issuer_async_future<
378         P: IsA<TlsCertificate> + Clone + 'static,
379         Q: IsA<TlsInteraction> + Clone + 'static,
380     >(
381         &self,
382         certificate: &P,
383         interaction: Option<&Q>,
384         flags: TlsDatabaseLookupFlags,
385     ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>
386     {
387         let certificate = certificate.clone();
388         let interaction = interaction.map(ToOwned::to_owned);
389         Box_::pin(crate::GioFuture::new(
390             self,
391             move |obj, cancellable, send| {
392                 obj.lookup_certificate_issuer_async(
393                     &certificate,
394                     interaction.as_ref().map(::std::borrow::Borrow::borrow),
395                     flags,
396                     Some(cancellable),
397                     move |res| {
398                         send.resolve(res);
399                     },
400                 );
401             },
402         ))
403     }
404 
lookup_certificates_issued_by<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>( &self, issuer_raw_dn: &glib::ByteArray, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, ) -> Result<Vec<TlsCertificate>, glib::Error>405     fn lookup_certificates_issued_by<P: IsA<TlsInteraction>, Q: IsA<Cancellable>>(
406         &self,
407         issuer_raw_dn: &glib::ByteArray,
408         interaction: Option<&P>,
409         flags: TlsDatabaseLookupFlags,
410         cancellable: Option<&Q>,
411     ) -> Result<Vec<TlsCertificate>, glib::Error> {
412         unsafe {
413             let mut error = ptr::null_mut();
414             let ret = ffi::g_tls_database_lookup_certificates_issued_by(
415                 self.as_ref().to_glib_none().0,
416                 issuer_raw_dn.to_glib_none().0,
417                 interaction.map(|p| p.as_ref()).to_glib_none().0,
418                 flags.into_glib(),
419                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
420                 &mut error,
421             );
422             if error.is_null() {
423                 Ok(FromGlibPtrContainer::from_glib_full(ret))
424             } else {
425                 Err(from_glib_full(error))
426             }
427         }
428     }
429 
lookup_certificates_issued_by_async< P: IsA<TlsInteraction>, Q: IsA<Cancellable>, R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + Send + 'static, >( &self, issuer_raw_dn: &glib::ByteArray, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, cancellable: Option<&Q>, callback: R, )430     fn lookup_certificates_issued_by_async<
431         P: IsA<TlsInteraction>,
432         Q: IsA<Cancellable>,
433         R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + Send + 'static,
434     >(
435         &self,
436         issuer_raw_dn: &glib::ByteArray,
437         interaction: Option<&P>,
438         flags: TlsDatabaseLookupFlags,
439         cancellable: Option<&Q>,
440         callback: R,
441     ) {
442         let user_data: Box_<R> = Box_::new(callback);
443         unsafe extern "C" fn lookup_certificates_issued_by_async_trampoline<
444             R: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + Send + 'static,
445         >(
446             _source_object: *mut glib::gobject_ffi::GObject,
447             res: *mut crate::ffi::GAsyncResult,
448             user_data: glib::ffi::gpointer,
449         ) {
450             let mut error = ptr::null_mut();
451             let ret = ffi::g_tls_database_lookup_certificates_issued_by_finish(
452                 _source_object as *mut _,
453                 res,
454                 &mut error,
455             );
456             let result = if error.is_null() {
457                 Ok(FromGlibPtrContainer::from_glib_full(ret))
458             } else {
459                 Err(from_glib_full(error))
460             };
461             let callback: Box_<R> = Box_::from_raw(user_data as *mut _);
462             callback(result);
463         }
464         let callback = lookup_certificates_issued_by_async_trampoline::<R>;
465         unsafe {
466             ffi::g_tls_database_lookup_certificates_issued_by_async(
467                 self.as_ref().to_glib_none().0,
468                 issuer_raw_dn.to_glib_none().0,
469                 interaction.map(|p| p.as_ref()).to_glib_none().0,
470                 flags.into_glib(),
471                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
472                 Some(callback),
473                 Box_::into_raw(user_data) as *mut _,
474             );
475         }
476     }
477 
lookup_certificates_issued_by_async_future<P: IsA<TlsInteraction> + Clone + 'static>( &self, issuer_raw_dn: &glib::ByteArray, interaction: Option<&P>, flags: TlsDatabaseLookupFlags, ) -> Pin< Box_<dyn std::future::Future<Output = Result<Vec<TlsCertificate>, glib::Error>> + 'static>, >478     fn lookup_certificates_issued_by_async_future<P: IsA<TlsInteraction> + Clone + 'static>(
479         &self,
480         issuer_raw_dn: &glib::ByteArray,
481         interaction: Option<&P>,
482         flags: TlsDatabaseLookupFlags,
483     ) -> Pin<
484         Box_<dyn std::future::Future<Output = Result<Vec<TlsCertificate>, glib::Error>> + 'static>,
485     > {
486         let issuer_raw_dn = issuer_raw_dn.clone();
487         let interaction = interaction.map(ToOwned::to_owned);
488         Box_::pin(crate::GioFuture::new(
489             self,
490             move |obj, cancellable, send| {
491                 obj.lookup_certificates_issued_by_async(
492                     &issuer_raw_dn,
493                     interaction.as_ref().map(::std::borrow::Borrow::borrow),
494                     flags,
495                     Some(cancellable),
496                     move |res| {
497                         send.resolve(res);
498                     },
499                 );
500             },
501         ))
502     }
503 
verify_chain< P: IsA<TlsCertificate>, Q: IsA<SocketConnectable>, R: IsA<TlsInteraction>, S: IsA<Cancellable>, >( &self, chain: &P, purpose: &str, identity: Option<&Q>, interaction: Option<&R>, flags: TlsDatabaseVerifyFlags, cancellable: Option<&S>, ) -> Result<TlsCertificateFlags, glib::Error>504     fn verify_chain<
505         P: IsA<TlsCertificate>,
506         Q: IsA<SocketConnectable>,
507         R: IsA<TlsInteraction>,
508         S: IsA<Cancellable>,
509     >(
510         &self,
511         chain: &P,
512         purpose: &str,
513         identity: Option<&Q>,
514         interaction: Option<&R>,
515         flags: TlsDatabaseVerifyFlags,
516         cancellable: Option<&S>,
517     ) -> Result<TlsCertificateFlags, glib::Error> {
518         unsafe {
519             let mut error = ptr::null_mut();
520             let ret = ffi::g_tls_database_verify_chain(
521                 self.as_ref().to_glib_none().0,
522                 chain.as_ref().to_glib_none().0,
523                 purpose.to_glib_none().0,
524                 identity.map(|p| p.as_ref()).to_glib_none().0,
525                 interaction.map(|p| p.as_ref()).to_glib_none().0,
526                 flags.into_glib(),
527                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
528                 &mut error,
529             );
530             if error.is_null() {
531                 Ok(from_glib(ret))
532             } else {
533                 Err(from_glib_full(error))
534             }
535         }
536     }
537 
verify_chain_async< P: IsA<TlsCertificate>, Q: IsA<SocketConnectable>, R: IsA<TlsInteraction>, S: IsA<Cancellable>, T: FnOnce(Result<TlsCertificateFlags, glib::Error>) + Send + 'static, >( &self, chain: &P, purpose: &str, identity: Option<&Q>, interaction: Option<&R>, flags: TlsDatabaseVerifyFlags, cancellable: Option<&S>, callback: T, )538     fn verify_chain_async<
539         P: IsA<TlsCertificate>,
540         Q: IsA<SocketConnectable>,
541         R: IsA<TlsInteraction>,
542         S: IsA<Cancellable>,
543         T: FnOnce(Result<TlsCertificateFlags, glib::Error>) + Send + 'static,
544     >(
545         &self,
546         chain: &P,
547         purpose: &str,
548         identity: Option<&Q>,
549         interaction: Option<&R>,
550         flags: TlsDatabaseVerifyFlags,
551         cancellable: Option<&S>,
552         callback: T,
553     ) {
554         let user_data: Box_<T> = Box_::new(callback);
555         unsafe extern "C" fn verify_chain_async_trampoline<
556             T: FnOnce(Result<TlsCertificateFlags, glib::Error>) + Send + 'static,
557         >(
558             _source_object: *mut glib::gobject_ffi::GObject,
559             res: *mut crate::ffi::GAsyncResult,
560             user_data: glib::ffi::gpointer,
561         ) {
562             let mut error = ptr::null_mut();
563             let ret =
564                 ffi::g_tls_database_verify_chain_finish(_source_object as *mut _, res, &mut error);
565             let result = if error.is_null() {
566                 Ok(from_glib(ret))
567             } else {
568                 Err(from_glib_full(error))
569             };
570             let callback: Box_<T> = Box_::from_raw(user_data as *mut _);
571             callback(result);
572         }
573         let callback = verify_chain_async_trampoline::<T>;
574         unsafe {
575             ffi::g_tls_database_verify_chain_async(
576                 self.as_ref().to_glib_none().0,
577                 chain.as_ref().to_glib_none().0,
578                 purpose.to_glib_none().0,
579                 identity.map(|p| p.as_ref()).to_glib_none().0,
580                 interaction.map(|p| p.as_ref()).to_glib_none().0,
581                 flags.into_glib(),
582                 cancellable.map(|p| p.as_ref()).to_glib_none().0,
583                 Some(callback),
584                 Box_::into_raw(user_data) as *mut _,
585             );
586         }
587     }
588 
verify_chain_async_future< P: IsA<TlsCertificate> + Clone + 'static, Q: IsA<SocketConnectable> + Clone + 'static, R: IsA<TlsInteraction> + Clone + 'static, >( &self, chain: &P, purpose: &str, identity: Option<&Q>, interaction: Option<&R>, flags: TlsDatabaseVerifyFlags, ) -> Pin< Box_<dyn std::future::Future<Output = Result<TlsCertificateFlags, glib::Error>> + 'static>, >589     fn verify_chain_async_future<
590         P: IsA<TlsCertificate> + Clone + 'static,
591         Q: IsA<SocketConnectable> + Clone + 'static,
592         R: IsA<TlsInteraction> + Clone + 'static,
593     >(
594         &self,
595         chain: &P,
596         purpose: &str,
597         identity: Option<&Q>,
598         interaction: Option<&R>,
599         flags: TlsDatabaseVerifyFlags,
600     ) -> Pin<
601         Box_<dyn std::future::Future<Output = Result<TlsCertificateFlags, glib::Error>> + 'static>,
602     > {
603         let chain = chain.clone();
604         let purpose = String::from(purpose);
605         let identity = identity.map(ToOwned::to_owned);
606         let interaction = interaction.map(ToOwned::to_owned);
607         Box_::pin(crate::GioFuture::new(
608             self,
609             move |obj, cancellable, send| {
610                 obj.verify_chain_async(
611                     &chain,
612                     &purpose,
613                     identity.as_ref().map(::std::borrow::Borrow::borrow),
614                     interaction.as_ref().map(::std::borrow::Borrow::borrow),
615                     flags,
616                     Some(cancellable),
617                     move |res| {
618                         send.resolve(res);
619                     },
620                 );
621             },
622         ))
623     }
624 }
625 
626 impl fmt::Display for TlsDatabase {
fmt(&self, f: &mut fmt::Formatter) -> fmt::Result627     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
628         f.write_str("TlsDatabase")
629     }
630 }
631