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

gio/auto/
tls_database.rs
