1#[cfg(feature = "futures")]
6use futures::future;
7use gio_sys;
8use glib::object::IsA;
9use glib::translate::*;
10use glib_sys;
11use gobject_sys;
12#[cfg(feature = "futures")]
13use std::boxed::Box as Box_;
14use std::fmt;
15use std::ptr;
16use Cancellable;
17use Error;
18use TlsCertificateRequestFlags;
19use TlsConnection;
20use TlsInteractionResult;
21use TlsPassword;
22
23glib_wrapper! {
24 pub struct TlsInteraction(Object<gio_sys::GTlsInteraction, gio_sys::GTlsInteractionClass, TlsInteractionClass>);
25
26 match fn {
27 get_type => || gio_sys::g_tls_interaction_get_type(),
28 }
29}
30
31pub const NONE_TLS_INTERACTION: Option<&TlsInteraction> = None;
32
33pub trait TlsInteractionExt: 'static {
34 fn ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
35 &self,
36 password: &P,
37 cancellable: Option<&Q>,
38 ) -> Result<TlsInteractionResult, Error>;
39
40 fn ask_password_async<
41 P: IsA<TlsPassword>,
42 Q: IsA<Cancellable>,
43 R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
44 >(
45 &self,
46 password: &P,
47 cancellable: Option<&Q>,
48 callback: R,
49 );
50
51 #[cfg(feature = "futures")]
52 fn ask_password_async_future<P: IsA<TlsPassword> + Clone + 'static>(
53 &self,
54 password: &P,
55 ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>;
56
57 fn invoke_ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
58 &self,
59 password: &P,
60 cancellable: Option<&Q>,
61 ) -> Result<TlsInteractionResult, Error>;
62
63 fn invoke_request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
64 &self,
65 connection: &P,
66 flags: TlsCertificateRequestFlags,
67 cancellable: Option<&Q>,
68 ) -> Result<TlsInteractionResult, Error>;
69
70 fn request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
71 &self,
72 connection: &P,
73 flags: TlsCertificateRequestFlags,
74 cancellable: Option<&Q>,
75 ) -> Result<TlsInteractionResult, Error>;
76
77 fn request_certificate_async<
78 P: IsA<TlsConnection>,
79 Q: IsA<Cancellable>,
80 R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
81 >(
82 &self,
83 connection: &P,
84 flags: TlsCertificateRequestFlags,
85 cancellable: Option<&Q>,
86 callback: R,
87 );
88
89 #[cfg(feature = "futures")]
90 fn request_certificate_async_future<P: IsA<TlsConnection> + Clone + 'static>(
91 &self,
92 connection: &P,
93 flags: TlsCertificateRequestFlags,
94 ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>;
95}
96
97impl<O: IsA<TlsInteraction>> TlsInteractionExt for O {
98 fn ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
99 &self,
100 password: &P,
101 cancellable: Option<&Q>,
102 ) -> Result<TlsInteractionResult, Error> {
103 unsafe {
104 let mut error = ptr::null_mut();
105 let ret = gio_sys::g_tls_interaction_ask_password(
106 self.as_ref().to_glib_none().0,
107 password.as_ref().to_glib_none().0,
108 cancellable.map(|p| p.as_ref()).to_glib_none().0,
109 &mut error,
110 );
111 if error.is_null() {
112 Ok(from_glib(ret))
113 } else {
114 Err(from_glib_full(error))
115 }
116 }
117 }
118
119 fn ask_password_async<
120 P: IsA<TlsPassword>,
121 Q: IsA<Cancellable>,
122 R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
123 >(
124 &self,
125 password: &P,
126 cancellable: Option<&Q>,
127 callback: R,
128 ) {
129 let user_data: Box<R> = Box::new(callback);
130 unsafe extern "C" fn ask_password_async_trampoline<
131 R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
132 >(
133 _source_object: *mut gobject_sys::GObject,
134 res: *mut gio_sys::GAsyncResult,
135 user_data: glib_sys::gpointer,
136 ) {
137 let mut error = ptr::null_mut();
138 let ret = gio_sys::g_tls_interaction_ask_password_finish(
139 _source_object as *mut _,
140 res,
141 &mut error,
142 );
143 let result = if error.is_null() {
144 Ok(from_glib(ret))
145 } else {
146 Err(from_glib_full(error))
147 };
148 let callback: Box<R> = Box::from_raw(user_data as *mut _);
149 callback(result);
150 }
151 let callback = ask_password_async_trampoline::<R>;
152 unsafe {
153 gio_sys::g_tls_interaction_ask_password_async(
154 self.as_ref().to_glib_none().0,
155 password.as_ref().to_glib_none().0,
156 cancellable.map(|p| p.as_ref()).to_glib_none().0,
157 Some(callback),
158 Box::into_raw(user_data) as *mut _,
159 );
160 }
161 }
162
163 #[cfg(feature = "futures")]
164 fn ask_password_async_future<P: IsA<TlsPassword> + Clone + 'static>(
165 &self,
166 password: &P,
167 ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>
168 {
169 use fragile::Fragile;
170 use GioFuture;
171
172 let password = password.clone();
173 GioFuture::new(self, move |obj, send| {
174 let cancellable = Cancellable::new();
175 let send = Fragile::new(send);
176 obj.ask_password_async(&password, Some(&cancellable), move |res| {
177 let _ = send.into_inner().send(res);
178 });
179
180 cancellable
181 })
182 }
183
184 fn invoke_ask_password<P: IsA<TlsPassword>, Q: IsA<Cancellable>>(
185 &self,
186 password: &P,
187 cancellable: Option<&Q>,
188 ) -> Result<TlsInteractionResult, Error> {
189 unsafe {
190 let mut error = ptr::null_mut();
191 let ret = gio_sys::g_tls_interaction_invoke_ask_password(
192 self.as_ref().to_glib_none().0,
193 password.as_ref().to_glib_none().0,
194 cancellable.map(|p| p.as_ref()).to_glib_none().0,
195 &mut error,
196 );
197 if error.is_null() {
198 Ok(from_glib(ret))
199 } else {
200 Err(from_glib_full(error))
201 }
202 }
203 }
204
205 fn invoke_request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
206 &self,
207 connection: &P,
208 flags: TlsCertificateRequestFlags,
209 cancellable: Option<&Q>,
210 ) -> Result<TlsInteractionResult, Error> {
211 unsafe {
212 let mut error = ptr::null_mut();
213 let ret = gio_sys::g_tls_interaction_invoke_request_certificate(
214 self.as_ref().to_glib_none().0,
215 connection.as_ref().to_glib_none().0,
216 flags.to_glib(),
217 cancellable.map(|p| p.as_ref()).to_glib_none().0,
218 &mut error,
219 );
220 if error.is_null() {
221 Ok(from_glib(ret))
222 } else {
223 Err(from_glib_full(error))
224 }
225 }
226 }
227
228 fn request_certificate<P: IsA<TlsConnection>, Q: IsA<Cancellable>>(
229 &self,
230 connection: &P,
231 flags: TlsCertificateRequestFlags,
232 cancellable: Option<&Q>,
233 ) -> Result<TlsInteractionResult, Error> {
234 unsafe {
235 let mut error = ptr::null_mut();
236 let ret = gio_sys::g_tls_interaction_request_certificate(
237 self.as_ref().to_glib_none().0,
238 connection.as_ref().to_glib_none().0,
239 flags.to_glib(),
240 cancellable.map(|p| p.as_ref()).to_glib_none().0,
241 &mut error,
242 );
243 if error.is_null() {
244 Ok(from_glib(ret))
245 } else {
246 Err(from_glib_full(error))
247 }
248 }
249 }
250
251 fn request_certificate_async<
252 P: IsA<TlsConnection>,
253 Q: IsA<Cancellable>,
254 R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
255 >(
256 &self,
257 connection: &P,
258 flags: TlsCertificateRequestFlags,
259 cancellable: Option<&Q>,
260 callback: R,
261 ) {
262 let user_data: Box<R> = Box::new(callback);
263 unsafe extern "C" fn request_certificate_async_trampoline<
264 R: FnOnce(Result<TlsInteractionResult, Error>) + Send + 'static,
265 >(
266 _source_object: *mut gobject_sys::GObject,
267 res: *mut gio_sys::GAsyncResult,
268 user_data: glib_sys::gpointer,
269 ) {
270 let mut error = ptr::null_mut();
271 let ret = gio_sys::g_tls_interaction_request_certificate_finish(
272 _source_object as *mut _,
273 res,
274 &mut error,
275 );
276 let result = if error.is_null() {
277 Ok(from_glib(ret))
278 } else {
279 Err(from_glib_full(error))
280 };
281 let callback: Box<R> = Box::from_raw(user_data as *mut _);
282 callback(result);
283 }
284 let callback = request_certificate_async_trampoline::<R>;
285 unsafe {
286 gio_sys::g_tls_interaction_request_certificate_async(
287 self.as_ref().to_glib_none().0,
288 connection.as_ref().to_glib_none().0,
289 flags.to_glib(),
290 cancellable.map(|p| p.as_ref()).to_glib_none().0,
291 Some(callback),
292 Box::into_raw(user_data) as *mut _,
293 );
294 }
295 }
296
297 #[cfg(feature = "futures")]
298 fn request_certificate_async_future<P: IsA<TlsConnection> + Clone + 'static>(
299 &self,
300 connection: &P,
301 flags: TlsCertificateRequestFlags,
302 ) -> Box_<dyn future::Future<Output = Result<TlsInteractionResult, Error>> + std::marker::Unpin>
303 {
304 use fragile::Fragile;
305 use GioFuture;
306
307 let connection = connection.clone();
308 GioFuture::new(self, move |obj, send| {
309 let cancellable = Cancellable::new();
310 let send = Fragile::new(send);
311 obj.request_certificate_async(&connection, flags, Some(&cancellable), move |res| {
312 let _ = send.into_inner().send(res);
313 });
314
315 cancellable
316 })
317 }
318}
319
320impl fmt::Display for TlsInteraction {
321 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
322 write!(f, "TlsInteraction")
323 }
324}