gio/auto/
tls_database.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
5use crate::{
6    ffi, AsyncResult, Cancellable, SocketConnectable, TlsCertificate, TlsCertificateFlags,
7    TlsDatabaseLookupFlags, TlsDatabaseVerifyFlags, TlsInteraction,
8};
9use glib::{prelude::*, translate::*};
10use std::{boxed::Box as Box_, pin::Pin};
11
12glib::wrapper! {
13    #[doc(alias = "GTlsDatabase")]
14    pub struct TlsDatabase(Object<ffi::GTlsDatabase, ffi::GTlsDatabaseClass>);
15
16    match fn {
17        type_ => || ffi::g_tls_database_get_type(),
18    }
19}
20
21impl TlsDatabase {
22    pub const NONE: Option<&'static TlsDatabase> = None;
23}
24
25mod sealed {
26    pub trait Sealed {}
27    impl<T: super::IsA<super::TlsDatabase>> Sealed for T {}
28}
29
30pub trait TlsDatabaseExt: IsA<TlsDatabase> + sealed::Sealed + 'static {
31    #[doc(alias = "g_tls_database_create_certificate_handle")]
32    fn create_certificate_handle(
33        &self,
34        certificate: &impl IsA<TlsCertificate>,
35    ) -> Option<glib::GString> {
36        unsafe {
37            from_glib_full(ffi::g_tls_database_create_certificate_handle(
38                self.as_ref().to_glib_none().0,
39                certificate.as_ref().to_glib_none().0,
40            ))
41        }
42    }
43
44    #[doc(alias = "g_tls_database_lookup_certificate_for_handle")]
45    fn lookup_certificate_for_handle(
46        &self,
47        handle: &str,
48        interaction: Option<&impl IsA<TlsInteraction>>,
49        flags: TlsDatabaseLookupFlags,
50        cancellable: Option<&impl IsA<Cancellable>>,
51    ) -> Result<Option<TlsCertificate>, glib::Error> {
52        unsafe {
53            let mut error = std::ptr::null_mut();
54            let ret = ffi::g_tls_database_lookup_certificate_for_handle(
55                self.as_ref().to_glib_none().0,
56                handle.to_glib_none().0,
57                interaction.map(|p| p.as_ref()).to_glib_none().0,
58                flags.into_glib(),
59                cancellable.map(|p| p.as_ref()).to_glib_none().0,
60                &mut error,
61            );
62            if error.is_null() {
63                Ok(from_glib_full(ret))
64            } else {
65                Err(from_glib_full(error))
66            }
67        }
68    }
69
70    #[doc(alias = "g_tls_database_lookup_certificate_for_handle_async")]
71    fn lookup_certificate_for_handle_async<
72        P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
73    >(
74        &self,
75        handle: &str,
76        interaction: Option<&impl IsA<TlsInteraction>>,
77        flags: TlsDatabaseLookupFlags,
78        cancellable: Option<&impl IsA<Cancellable>>,
79        callback: P,
80    ) {
81        let main_context = glib::MainContext::ref_thread_default();
82        let is_main_context_owner = main_context.is_owner();
83        let has_acquired_main_context = (!is_main_context_owner)
84            .then(|| main_context.acquire().ok())
85            .flatten();
86        assert!(
87            is_main_context_owner || has_acquired_main_context.is_some(),
88            "Async operations only allowed if the thread is owning the MainContext"
89        );
90
91        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
92            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
93        unsafe extern "C" fn lookup_certificate_for_handle_async_trampoline<
94            P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
95        >(
96            _source_object: *mut glib::gobject_ffi::GObject,
97            res: *mut crate::ffi::GAsyncResult,
98            user_data: glib::ffi::gpointer,
99        ) {
100            let mut error = std::ptr::null_mut();
101            let ret = ffi::g_tls_database_lookup_certificate_for_handle_finish(
102                _source_object as *mut _,
103                res,
104                &mut error,
105            );
106            let result = if error.is_null() {
107                Ok(from_glib_full(ret))
108            } else {
109                Err(from_glib_full(error))
110            };
111            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
112                Box_::from_raw(user_data as *mut _);
113            let callback: P = callback.into_inner();
114            callback(result);
115        }
116        let callback = lookup_certificate_for_handle_async_trampoline::<P>;
117        unsafe {
118            ffi::g_tls_database_lookup_certificate_for_handle_async(
119                self.as_ref().to_glib_none().0,
120                handle.to_glib_none().0,
121                interaction.map(|p| p.as_ref()).to_glib_none().0,
122                flags.into_glib(),
123                cancellable.map(|p| p.as_ref()).to_glib_none().0,
124                Some(callback),
125                Box_::into_raw(user_data) as *mut _,
126            );
127        }
128    }
129
130    fn lookup_certificate_for_handle_future(
131        &self,
132        handle: &str,
133        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
134        flags: TlsDatabaseLookupFlags,
135    ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>
136    {
137        let handle = String::from(handle);
138        let interaction = interaction.map(ToOwned::to_owned);
139        Box_::pin(crate::GioFuture::new(
140            self,
141            move |obj, cancellable, send| {
142                obj.lookup_certificate_for_handle_async(
143                    &handle,
144                    interaction.as_ref().map(::std::borrow::Borrow::borrow),
145                    flags,
146                    Some(cancellable),
147                    move |res| {
148                        send.resolve(res);
149                    },
150                );
151            },
152        ))
153    }
154
155    #[doc(alias = "g_tls_database_lookup_certificate_issuer")]
156    fn lookup_certificate_issuer(
157        &self,
158        certificate: &impl IsA<TlsCertificate>,
159        interaction: Option<&impl IsA<TlsInteraction>>,
160        flags: TlsDatabaseLookupFlags,
161        cancellable: Option<&impl IsA<Cancellable>>,
162    ) -> Result<TlsCertificate, glib::Error> {
163        unsafe {
164            let mut error = std::ptr::null_mut();
165            let ret = ffi::g_tls_database_lookup_certificate_issuer(
166                self.as_ref().to_glib_none().0,
167                certificate.as_ref().to_glib_none().0,
168                interaction.map(|p| p.as_ref()).to_glib_none().0,
169                flags.into_glib(),
170                cancellable.map(|p| p.as_ref()).to_glib_none().0,
171                &mut error,
172            );
173            if error.is_null() {
174                Ok(from_glib_full(ret))
175            } else {
176                Err(from_glib_full(error))
177            }
178        }
179    }
180
181    #[doc(alias = "g_tls_database_lookup_certificate_issuer_async")]
182    fn lookup_certificate_issuer_async<P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static>(
183        &self,
184        certificate: &impl IsA<TlsCertificate>,
185        interaction: Option<&impl IsA<TlsInteraction>>,
186        flags: TlsDatabaseLookupFlags,
187        cancellable: Option<&impl IsA<Cancellable>>,
188        callback: P,
189    ) {
190        let main_context = glib::MainContext::ref_thread_default();
191        let is_main_context_owner = main_context.is_owner();
192        let has_acquired_main_context = (!is_main_context_owner)
193            .then(|| main_context.acquire().ok())
194            .flatten();
195        assert!(
196            is_main_context_owner || has_acquired_main_context.is_some(),
197            "Async operations only allowed if the thread is owning the MainContext"
198        );
199
200        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
201            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
202        unsafe extern "C" fn lookup_certificate_issuer_async_trampoline<
203            P: FnOnce(Result<TlsCertificate, glib::Error>) + 'static,
204        >(
205            _source_object: *mut glib::gobject_ffi::GObject,
206            res: *mut crate::ffi::GAsyncResult,
207            user_data: glib::ffi::gpointer,
208        ) {
209            let mut error = std::ptr::null_mut();
210            let ret = ffi::g_tls_database_lookup_certificate_issuer_finish(
211                _source_object as *mut _,
212                res,
213                &mut error,
214            );
215            let result = if error.is_null() {
216                Ok(from_glib_full(ret))
217            } else {
218                Err(from_glib_full(error))
219            };
220            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
221                Box_::from_raw(user_data as *mut _);
222            let callback: P = callback.into_inner();
223            callback(result);
224        }
225        let callback = lookup_certificate_issuer_async_trampoline::<P>;
226        unsafe {
227            ffi::g_tls_database_lookup_certificate_issuer_async(
228                self.as_ref().to_glib_none().0,
229                certificate.as_ref().to_glib_none().0,
230                interaction.map(|p| p.as_ref()).to_glib_none().0,
231                flags.into_glib(),
232                cancellable.map(|p| p.as_ref()).to_glib_none().0,
233                Some(callback),
234                Box_::into_raw(user_data) as *mut _,
235            );
236        }
237    }
238
239    fn lookup_certificate_issuer_future(
240        &self,
241        certificate: &(impl IsA<TlsCertificate> + Clone + 'static),
242        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
243        flags: TlsDatabaseLookupFlags,
244    ) -> Pin<Box_<dyn std::future::Future<Output = Result<TlsCertificate, glib::Error>> + 'static>>
245    {
246        let certificate = certificate.clone();
247        let interaction = interaction.map(ToOwned::to_owned);
248        Box_::pin(crate::GioFuture::new(
249            self,
250            move |obj, cancellable, send| {
251                obj.lookup_certificate_issuer_async(
252                    &certificate,
253                    interaction.as_ref().map(::std::borrow::Borrow::borrow),
254                    flags,
255                    Some(cancellable),
256                    move |res| {
257                        send.resolve(res);
258                    },
259                );
260            },
261        ))
262    }
263
264    #[doc(alias = "g_tls_database_lookup_certificates_issued_by")]
265    fn lookup_certificates_issued_by(
266        &self,
267        issuer_raw_dn: &glib::ByteArray,
268        interaction: Option<&impl IsA<TlsInteraction>>,
269        flags: TlsDatabaseLookupFlags,
270        cancellable: Option<&impl IsA<Cancellable>>,
271    ) -> Result<Vec<TlsCertificate>, glib::Error> {
272        unsafe {
273            let mut error = std::ptr::null_mut();
274            let ret = ffi::g_tls_database_lookup_certificates_issued_by(
275                self.as_ref().to_glib_none().0,
276                issuer_raw_dn.to_glib_none().0,
277                interaction.map(|p| p.as_ref()).to_glib_none().0,
278                flags.into_glib(),
279                cancellable.map(|p| p.as_ref()).to_glib_none().0,
280                &mut error,
281            );
282            if error.is_null() {
283                Ok(FromGlibPtrContainer::from_glib_full(ret))
284            } else {
285                Err(from_glib_full(error))
286            }
287        }
288    }
289
290    #[doc(alias = "g_tls_database_lookup_certificates_issued_by_async")]
291    fn lookup_certificates_issued_by_async<
292        P: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + 'static,
293    >(
294        &self,
295        issuer_raw_dn: &glib::ByteArray,
296        interaction: Option<&impl IsA<TlsInteraction>>,
297        flags: TlsDatabaseLookupFlags,
298        cancellable: Option<&impl IsA<Cancellable>>,
299        callback: P,
300    ) {
301        let main_context = glib::MainContext::ref_thread_default();
302        let is_main_context_owner = main_context.is_owner();
303        let has_acquired_main_context = (!is_main_context_owner)
304            .then(|| main_context.acquire().ok())
305            .flatten();
306        assert!(
307            is_main_context_owner || has_acquired_main_context.is_some(),
308            "Async operations only allowed if the thread is owning the MainContext"
309        );
310
311        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
312            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
313        unsafe extern "C" fn lookup_certificates_issued_by_async_trampoline<
314            P: FnOnce(Result<Vec<TlsCertificate>, glib::Error>) + 'static,
315        >(
316            _source_object: *mut glib::gobject_ffi::GObject,
317            res: *mut crate::ffi::GAsyncResult,
318            user_data: glib::ffi::gpointer,
319        ) {
320            let mut error = std::ptr::null_mut();
321            let ret = ffi::g_tls_database_lookup_certificates_issued_by_finish(
322                _source_object as *mut _,
323                res,
324                &mut error,
325            );
326            let result = if error.is_null() {
327                Ok(FromGlibPtrContainer::from_glib_full(ret))
328            } else {
329                Err(from_glib_full(error))
330            };
331            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
332                Box_::from_raw(user_data as *mut _);
333            let callback: P = callback.into_inner();
334            callback(result);
335        }
336        let callback = lookup_certificates_issued_by_async_trampoline::<P>;
337        unsafe {
338            ffi::g_tls_database_lookup_certificates_issued_by_async(
339                self.as_ref().to_glib_none().0,
340                issuer_raw_dn.to_glib_none().0,
341                interaction.map(|p| p.as_ref()).to_glib_none().0,
342                flags.into_glib(),
343                cancellable.map(|p| p.as_ref()).to_glib_none().0,
344                Some(callback),
345                Box_::into_raw(user_data) as *mut _,
346            );
347        }
348    }
349
350    fn lookup_certificates_issued_by_future(
351        &self,
352        issuer_raw_dn: &glib::ByteArray,
353        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
354        flags: TlsDatabaseLookupFlags,
355    ) -> Pin<
356        Box_<dyn std::future::Future<Output = Result<Vec<TlsCertificate>, glib::Error>> + 'static>,
357    > {
358        let issuer_raw_dn = issuer_raw_dn.clone();
359        let interaction = interaction.map(ToOwned::to_owned);
360        Box_::pin(crate::GioFuture::new(
361            self,
362            move |obj, cancellable, send| {
363                obj.lookup_certificates_issued_by_async(
364                    &issuer_raw_dn,
365                    interaction.as_ref().map(::std::borrow::Borrow::borrow),
366                    flags,
367                    Some(cancellable),
368                    move |res| {
369                        send.resolve(res);
370                    },
371                );
372            },
373        ))
374    }
375
376    #[doc(alias = "g_tls_database_verify_chain")]
377    fn verify_chain(
378        &self,
379        chain: &impl IsA<TlsCertificate>,
380        purpose: &str,
381        identity: Option<&impl IsA<SocketConnectable>>,
382        interaction: Option<&impl IsA<TlsInteraction>>,
383        flags: TlsDatabaseVerifyFlags,
384        cancellable: Option<&impl IsA<Cancellable>>,
385    ) -> Result<TlsCertificateFlags, glib::Error> {
386        unsafe {
387            let mut error = std::ptr::null_mut();
388            let ret = ffi::g_tls_database_verify_chain(
389                self.as_ref().to_glib_none().0,
390                chain.as_ref().to_glib_none().0,
391                purpose.to_glib_none().0,
392                identity.map(|p| p.as_ref()).to_glib_none().0,
393                interaction.map(|p| p.as_ref()).to_glib_none().0,
394                flags.into_glib(),
395                cancellable.map(|p| p.as_ref()).to_glib_none().0,
396                &mut error,
397            );
398            if error.is_null() {
399                Ok(from_glib(ret))
400            } else {
401                Err(from_glib_full(error))
402            }
403        }
404    }
405
406    #[doc(alias = "g_tls_database_verify_chain_async")]
407    fn verify_chain_async<P: FnOnce(Result<TlsCertificateFlags, glib::Error>) + 'static>(
408        &self,
409        chain: &impl IsA<TlsCertificate>,
410        purpose: &str,
411        identity: Option<&impl IsA<SocketConnectable>>,
412        interaction: Option<&impl IsA<TlsInteraction>>,
413        flags: TlsDatabaseVerifyFlags,
414        cancellable: Option<&impl IsA<Cancellable>>,
415        callback: P,
416    ) {
417        let main_context = glib::MainContext::ref_thread_default();
418        let is_main_context_owner = main_context.is_owner();
419        let has_acquired_main_context = (!is_main_context_owner)
420            .then(|| main_context.acquire().ok())
421            .flatten();
422        assert!(
423            is_main_context_owner || has_acquired_main_context.is_some(),
424            "Async operations only allowed if the thread is owning the MainContext"
425        );
426
427        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
428            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
429        unsafe extern "C" fn verify_chain_async_trampoline<
430            P: FnOnce(Result<TlsCertificateFlags, glib::Error>) + 'static,
431        >(
432            _source_object: *mut glib::gobject_ffi::GObject,
433            res: *mut crate::ffi::GAsyncResult,
434            user_data: glib::ffi::gpointer,
435        ) {
436            let mut error = std::ptr::null_mut();
437            let ret =
438                ffi::g_tls_database_verify_chain_finish(_source_object as *mut _, res, &mut error);
439            let result = if error.is_null() {
440                Ok(from_glib(ret))
441            } else {
442                Err(from_glib_full(error))
443            };
444            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
445                Box_::from_raw(user_data as *mut _);
446            let callback: P = callback.into_inner();
447            callback(result);
448        }
449        let callback = verify_chain_async_trampoline::<P>;
450        unsafe {
451            ffi::g_tls_database_verify_chain_async(
452                self.as_ref().to_glib_none().0,
453                chain.as_ref().to_glib_none().0,
454                purpose.to_glib_none().0,
455                identity.map(|p| p.as_ref()).to_glib_none().0,
456                interaction.map(|p| p.as_ref()).to_glib_none().0,
457                flags.into_glib(),
458                cancellable.map(|p| p.as_ref()).to_glib_none().0,
459                Some(callback),
460                Box_::into_raw(user_data) as *mut _,
461            );
462        }
463    }
464
465    fn verify_chain_future(
466        &self,
467        chain: &(impl IsA<TlsCertificate> + Clone + 'static),
468        purpose: &str,
469        identity: Option<&(impl IsA<SocketConnectable> + Clone + 'static)>,
470        interaction: Option<&(impl IsA<TlsInteraction> + Clone + 'static)>,
471        flags: TlsDatabaseVerifyFlags,
472    ) -> Pin<
473        Box_<dyn std::future::Future<Output = Result<TlsCertificateFlags, glib::Error>> + 'static>,
474    > {
475        let chain = chain.clone();
476        let purpose = String::from(purpose);
477        let identity = identity.map(ToOwned::to_owned);
478        let interaction = interaction.map(ToOwned::to_owned);
479        Box_::pin(crate::GioFuture::new(
480            self,
481            move |obj, cancellable, send| {
482                obj.verify_chain_async(
483                    &chain,
484                    &purpose,
485                    identity.as_ref().map(::std::borrow::Borrow::borrow),
486                    interaction.as_ref().map(::std::borrow::Borrow::borrow),
487                    flags,
488                    Some(cancellable),
489                    move |res| {
490                        send.resolve(res);
491                    },
492                );
493            },
494        ))
495    }
496}
497
498impl<O: IsA<TlsDatabase>> TlsDatabaseExt for O {}
gio/auto/tls_database.rs

gio/auto/
tls_database.rs
