1#[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 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 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}