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