1#[cfg(feature = "v2_60")]
6#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
7use crate::ResolverNameLookupFlags;
8use crate::{ffi, AsyncResult, Cancellable, InetAddress, ResolverRecordType, SrvTarget};
9use glib::{
10 object::ObjectType as _,
11 prelude::*,
12 signal::{connect_raw, SignalHandlerId},
13 translate::*,
14};
15use std::{boxed::Box as Box_, pin::Pin};
16
17glib::wrapper! {
18 #[doc(alias = "GResolver")]
70 pub struct Resolver(Object<ffi::GResolver, ffi::GResolverClass>);
71
72 match fn {
73 type_ => || ffi::g_resolver_get_type(),
74 }
75}
76
77impl Resolver {
78 pub const NONE: Option<&'static Resolver> = None;
79
80 #[doc(alias = "g_resolver_get_default")]
98 #[doc(alias = "get_default")]
99 #[allow(clippy::should_implement_trait)]
100 pub fn default() -> Resolver {
101 unsafe { from_glib_full(ffi::g_resolver_get_default()) }
102 }
103}
104
105mod sealed {
106 pub trait Sealed {}
107 impl<T: super::IsA<super::Resolver>> Sealed for T {}
108}
109
110pub trait ResolverExt: IsA<Resolver> + sealed::Sealed + 'static {
116 #[cfg(feature = "v2_78")]
122 #[cfg_attr(docsrs, doc(cfg(feature = "v2_78")))]
123 #[doc(alias = "g_resolver_get_timeout")]
124 #[doc(alias = "get_timeout")]
125 fn timeout(&self) -> u32 {
126 unsafe { ffi::g_resolver_get_timeout(self.as_ref().to_glib_none().0) }
127 }
128
129 #[doc(alias = "g_resolver_lookup_by_address")]
148 fn lookup_by_address(
149 &self,
150 address: &impl IsA<InetAddress>,
151 cancellable: Option<&impl IsA<Cancellable>>,
152 ) -> Result<glib::GString, glib::Error> {
153 unsafe {
154 let mut error = std::ptr::null_mut();
155 let ret = ffi::g_resolver_lookup_by_address(
156 self.as_ref().to_glib_none().0,
157 address.as_ref().to_glib_none().0,
158 cancellable.map(|p| p.as_ref()).to_glib_none().0,
159 &mut error,
160 );
161 if error.is_null() {
162 Ok(from_glib_full(ret))
163 } else {
164 Err(from_glib_full(error))
165 }
166 }
167 }
168
169 #[doc(alias = "g_resolver_lookup_by_address_async")]
179 fn lookup_by_address_async<P: FnOnce(Result<glib::GString, glib::Error>) + 'static>(
180 &self,
181 address: &impl IsA<InetAddress>,
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_by_address_async_trampoline<
198 P: FnOnce(Result<glib::GString, 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 =
206 ffi::g_resolver_lookup_by_address_finish(_source_object as *mut _, res, &mut error);
207 let result = if error.is_null() {
208 Ok(from_glib_full(ret))
209 } else {
210 Err(from_glib_full(error))
211 };
212 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
213 Box_::from_raw(user_data as *mut _);
214 let callback: P = callback.into_inner();
215 callback(result);
216 }
217 let callback = lookup_by_address_async_trampoline::<P>;
218 unsafe {
219 ffi::g_resolver_lookup_by_address_async(
220 self.as_ref().to_glib_none().0,
221 address.as_ref().to_glib_none().0,
222 cancellable.map(|p| p.as_ref()).to_glib_none().0,
223 Some(callback),
224 Box_::into_raw(user_data) as *mut _,
225 );
226 }
227 }
228
229 fn lookup_by_address_future(
230 &self,
231 address: &(impl IsA<InetAddress> + Clone + 'static),
232 ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>>
233 {
234 let address = address.clone();
235 Box_::pin(crate::GioFuture::new(
236 self,
237 move |obj, cancellable, send| {
238 obj.lookup_by_address_async(&address, Some(cancellable), move |res| {
239 send.resolve(res);
240 });
241 },
242 ))
243 }
244
245 #[doc(alias = "g_resolver_lookup_by_name")]
280 fn lookup_by_name(
281 &self,
282 hostname: &str,
283 cancellable: Option<&impl IsA<Cancellable>>,
284 ) -> Result<Vec<InetAddress>, glib::Error> {
285 unsafe {
286 let mut error = std::ptr::null_mut();
287 let ret = ffi::g_resolver_lookup_by_name(
288 self.as_ref().to_glib_none().0,
289 hostname.to_glib_none().0,
290 cancellable.map(|p| p.as_ref()).to_glib_none().0,
291 &mut error,
292 );
293 if error.is_null() {
294 Ok(FromGlibPtrContainer::from_glib_full(ret))
295 } else {
296 Err(from_glib_full(error))
297 }
298 }
299 }
300
301 #[doc(alias = "g_resolver_lookup_by_name_async")]
312 fn lookup_by_name_async<P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static>(
313 &self,
314 hostname: &str,
315 cancellable: Option<&impl IsA<Cancellable>>,
316 callback: P,
317 ) {
318 let main_context = glib::MainContext::ref_thread_default();
319 let is_main_context_owner = main_context.is_owner();
320 let has_acquired_main_context = (!is_main_context_owner)
321 .then(|| main_context.acquire().ok())
322 .flatten();
323 assert!(
324 is_main_context_owner || has_acquired_main_context.is_some(),
325 "Async operations only allowed if the thread is owning the MainContext"
326 );
327
328 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
329 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
330 unsafe extern "C" fn lookup_by_name_async_trampoline<
331 P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
332 >(
333 _source_object: *mut glib::gobject_ffi::GObject,
334 res: *mut crate::ffi::GAsyncResult,
335 user_data: glib::ffi::gpointer,
336 ) {
337 let mut error = std::ptr::null_mut();
338 let ret =
339 ffi::g_resolver_lookup_by_name_finish(_source_object as *mut _, res, &mut error);
340 let result = if error.is_null() {
341 Ok(FromGlibPtrContainer::from_glib_full(ret))
342 } else {
343 Err(from_glib_full(error))
344 };
345 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
346 Box_::from_raw(user_data as *mut _);
347 let callback: P = callback.into_inner();
348 callback(result);
349 }
350 let callback = lookup_by_name_async_trampoline::<P>;
351 unsafe {
352 ffi::g_resolver_lookup_by_name_async(
353 self.as_ref().to_glib_none().0,
354 hostname.to_glib_none().0,
355 cancellable.map(|p| p.as_ref()).to_glib_none().0,
356 Some(callback),
357 Box_::into_raw(user_data) as *mut _,
358 );
359 }
360 }
361
362 fn lookup_by_name_future(
363 &self,
364 hostname: &str,
365 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>
366 {
367 let hostname = String::from(hostname);
368 Box_::pin(crate::GioFuture::new(
369 self,
370 move |obj, cancellable, send| {
371 obj.lookup_by_name_async(&hostname, Some(cancellable), move |res| {
372 send.resolve(res);
373 });
374 },
375 ))
376 }
377
378 #[cfg(feature = "v2_60")]
395 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
396 #[doc(alias = "g_resolver_lookup_by_name_with_flags")]
397 fn lookup_by_name_with_flags(
398 &self,
399 hostname: &str,
400 flags: ResolverNameLookupFlags,
401 cancellable: Option<&impl IsA<Cancellable>>,
402 ) -> Result<Vec<InetAddress>, glib::Error> {
403 unsafe {
404 let mut error = std::ptr::null_mut();
405 let ret = ffi::g_resolver_lookup_by_name_with_flags(
406 self.as_ref().to_glib_none().0,
407 hostname.to_glib_none().0,
408 flags.into_glib(),
409 cancellable.map(|p| p.as_ref()).to_glib_none().0,
410 &mut error,
411 );
412 if error.is_null() {
413 Ok(FromGlibPtrContainer::from_glib_full(ret))
414 } else {
415 Err(from_glib_full(error))
416 }
417 }
418 }
419
420 #[cfg(feature = "v2_60")]
433 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
434 #[doc(alias = "g_resolver_lookup_by_name_with_flags_async")]
435 fn lookup_by_name_with_flags_async<
436 P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
437 >(
438 &self,
439 hostname: &str,
440 flags: ResolverNameLookupFlags,
441 cancellable: Option<&impl IsA<Cancellable>>,
442 callback: P,
443 ) {
444 let main_context = glib::MainContext::ref_thread_default();
445 let is_main_context_owner = main_context.is_owner();
446 let has_acquired_main_context = (!is_main_context_owner)
447 .then(|| main_context.acquire().ok())
448 .flatten();
449 assert!(
450 is_main_context_owner || has_acquired_main_context.is_some(),
451 "Async operations only allowed if the thread is owning the MainContext"
452 );
453
454 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
455 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
456 unsafe extern "C" fn lookup_by_name_with_flags_async_trampoline<
457 P: FnOnce(Result<Vec<InetAddress>, glib::Error>) + 'static,
458 >(
459 _source_object: *mut glib::gobject_ffi::GObject,
460 res: *mut crate::ffi::GAsyncResult,
461 user_data: glib::ffi::gpointer,
462 ) {
463 let mut error = std::ptr::null_mut();
464 let ret = ffi::g_resolver_lookup_by_name_with_flags_finish(
465 _source_object as *mut _,
466 res,
467 &mut error,
468 );
469 let result = if error.is_null() {
470 Ok(FromGlibPtrContainer::from_glib_full(ret))
471 } else {
472 Err(from_glib_full(error))
473 };
474 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
475 Box_::from_raw(user_data as *mut _);
476 let callback: P = callback.into_inner();
477 callback(result);
478 }
479 let callback = lookup_by_name_with_flags_async_trampoline::<P>;
480 unsafe {
481 ffi::g_resolver_lookup_by_name_with_flags_async(
482 self.as_ref().to_glib_none().0,
483 hostname.to_glib_none().0,
484 flags.into_glib(),
485 cancellable.map(|p| p.as_ref()).to_glib_none().0,
486 Some(callback),
487 Box_::into_raw(user_data) as *mut _,
488 );
489 }
490 }
491
492 #[cfg(feature = "v2_60")]
493 #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
494 fn lookup_by_name_with_flags_future(
495 &self,
496 hostname: &str,
497 flags: ResolverNameLookupFlags,
498 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>
499 {
500 let hostname = String::from(hostname);
501 Box_::pin(crate::GioFuture::new(
502 self,
503 move |obj, cancellable, send| {
504 obj.lookup_by_name_with_flags_async(
505 &hostname,
506 flags,
507 Some(cancellable),
508 move |res| {
509 send.resolve(res);
510 },
511 );
512 },
513 ))
514 }
515
516 #[doc(alias = "g_resolver_lookup_records")]
540 fn lookup_records(
541 &self,
542 rrname: &str,
543 record_type: ResolverRecordType,
544 cancellable: Option<&impl IsA<Cancellable>>,
545 ) -> Result<Vec<glib::Variant>, glib::Error> {
546 unsafe {
547 let mut error = std::ptr::null_mut();
548 let ret = ffi::g_resolver_lookup_records(
549 self.as_ref().to_glib_none().0,
550 rrname.to_glib_none().0,
551 record_type.into_glib(),
552 cancellable.map(|p| p.as_ref()).to_glib_none().0,
553 &mut error,
554 );
555 if error.is_null() {
556 Ok(FromGlibPtrContainer::from_glib_full(ret))
557 } else {
558 Err(from_glib_full(error))
559 }
560 }
561 }
562
563 #[doc(alias = "g_resolver_lookup_records_async")]
576 fn lookup_records_async<P: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + 'static>(
577 &self,
578 rrname: &str,
579 record_type: ResolverRecordType,
580 cancellable: Option<&impl IsA<Cancellable>>,
581 callback: P,
582 ) {
583 let main_context = glib::MainContext::ref_thread_default();
584 let is_main_context_owner = main_context.is_owner();
585 let has_acquired_main_context = (!is_main_context_owner)
586 .then(|| main_context.acquire().ok())
587 .flatten();
588 assert!(
589 is_main_context_owner || has_acquired_main_context.is_some(),
590 "Async operations only allowed if the thread is owning the MainContext"
591 );
592
593 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
594 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
595 unsafe extern "C" fn lookup_records_async_trampoline<
596 P: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + 'static,
597 >(
598 _source_object: *mut glib::gobject_ffi::GObject,
599 res: *mut crate::ffi::GAsyncResult,
600 user_data: glib::ffi::gpointer,
601 ) {
602 let mut error = std::ptr::null_mut();
603 let ret =
604 ffi::g_resolver_lookup_records_finish(_source_object as *mut _, res, &mut error);
605 let result = if error.is_null() {
606 Ok(FromGlibPtrContainer::from_glib_full(ret))
607 } else {
608 Err(from_glib_full(error))
609 };
610 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
611 Box_::from_raw(user_data as *mut _);
612 let callback: P = callback.into_inner();
613 callback(result);
614 }
615 let callback = lookup_records_async_trampoline::<P>;
616 unsafe {
617 ffi::g_resolver_lookup_records_async(
618 self.as_ref().to_glib_none().0,
619 rrname.to_glib_none().0,
620 record_type.into_glib(),
621 cancellable.map(|p| p.as_ref()).to_glib_none().0,
622 Some(callback),
623 Box_::into_raw(user_data) as *mut _,
624 );
625 }
626 }
627
628 fn lookup_records_future(
629 &self,
630 rrname: &str,
631 record_type: ResolverRecordType,
632 ) -> Pin<
633 Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>,
634 > {
635 let rrname = String::from(rrname);
636 Box_::pin(crate::GioFuture::new(
637 self,
638 move |obj, cancellable, send| {
639 obj.lookup_records_async(&rrname, record_type, Some(cancellable), move |res| {
640 send.resolve(res);
641 });
642 },
643 ))
644 }
645
646 #[doc(alias = "g_resolver_lookup_service")]
683 fn lookup_service(
684 &self,
685 service: &str,
686 protocol: &str,
687 domain: &str,
688 cancellable: Option<&impl IsA<Cancellable>>,
689 ) -> Result<Vec<SrvTarget>, glib::Error> {
690 unsafe {
691 let mut error = std::ptr::null_mut();
692 let ret = ffi::g_resolver_lookup_service(
693 self.as_ref().to_glib_none().0,
694 service.to_glib_none().0,
695 protocol.to_glib_none().0,
696 domain.to_glib_none().0,
697 cancellable.map(|p| p.as_ref()).to_glib_none().0,
698 &mut error,
699 );
700 if error.is_null() {
701 Ok(FromGlibPtrContainer::from_glib_full(ret))
702 } else {
703 Err(from_glib_full(error))
704 }
705 }
706 }
707
708 #[doc(alias = "g_resolver_lookup_service_async")]
724 fn lookup_service_async<P: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + 'static>(
725 &self,
726 service: &str,
727 protocol: &str,
728 domain: &str,
729 cancellable: Option<&impl IsA<Cancellable>>,
730 callback: P,
731 ) {
732 let main_context = glib::MainContext::ref_thread_default();
733 let is_main_context_owner = main_context.is_owner();
734 let has_acquired_main_context = (!is_main_context_owner)
735 .then(|| main_context.acquire().ok())
736 .flatten();
737 assert!(
738 is_main_context_owner || has_acquired_main_context.is_some(),
739 "Async operations only allowed if the thread is owning the MainContext"
740 );
741
742 let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
743 Box_::new(glib::thread_guard::ThreadGuard::new(callback));
744 unsafe extern "C" fn lookup_service_async_trampoline<
745 P: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + 'static,
746 >(
747 _source_object: *mut glib::gobject_ffi::GObject,
748 res: *mut crate::ffi::GAsyncResult,
749 user_data: glib::ffi::gpointer,
750 ) {
751 let mut error = std::ptr::null_mut();
752 let ret =
753 ffi::g_resolver_lookup_service_finish(_source_object as *mut _, res, &mut error);
754 let result = if error.is_null() {
755 Ok(FromGlibPtrContainer::from_glib_full(ret))
756 } else {
757 Err(from_glib_full(error))
758 };
759 let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
760 Box_::from_raw(user_data as *mut _);
761 let callback: P = callback.into_inner();
762 callback(result);
763 }
764 let callback = lookup_service_async_trampoline::<P>;
765 unsafe {
766 ffi::g_resolver_lookup_service_async(
767 self.as_ref().to_glib_none().0,
768 service.to_glib_none().0,
769 protocol.to_glib_none().0,
770 domain.to_glib_none().0,
771 cancellable.map(|p| p.as_ref()).to_glib_none().0,
772 Some(callback),
773 Box_::into_raw(user_data) as *mut _,
774 );
775 }
776 }
777
778 fn lookup_service_future(
779 &self,
780 service: &str,
781 protocol: &str,
782 domain: &str,
783 ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>>
784 {
785 let service = String::from(service);
786 let protocol = String::from(protocol);
787 let domain = String::from(domain);
788 Box_::pin(crate::GioFuture::new(
789 self,
790 move |obj, cancellable, send| {
791 obj.lookup_service_async(
792 &service,
793 &protocol,
794 &domain,
795 Some(cancellable),
796 move |res| {
797 send.resolve(res);
798 },
799 );
800 },
801 ))
802 }
803
804 #[doc(alias = "g_resolver_set_default")]
814 fn set_default(&self) {
815 unsafe {
816 ffi::g_resolver_set_default(self.as_ref().to_glib_none().0);
817 }
818 }
819
820 #[cfg(feature = "v2_78")]
824 #[cfg_attr(docsrs, doc(cfg(feature = "v2_78")))]
825 #[doc(alias = "g_resolver_set_timeout")]
826 #[doc(alias = "timeout")]
827 fn set_timeout(&self, timeout_ms: u32) {
828 unsafe {
829 ffi::g_resolver_set_timeout(self.as_ref().to_glib_none().0, timeout_ms);
830 }
831 }
832
833 #[doc(alias = "reload")]
836 fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
837 unsafe extern "C" fn reload_trampoline<P: IsA<Resolver>, F: Fn(&P) + 'static>(
838 this: *mut ffi::GResolver,
839 f: glib::ffi::gpointer,
840 ) {
841 let f: &F = &*(f as *const F);
842 f(Resolver::from_glib_borrow(this).unsafe_cast_ref())
843 }
844 unsafe {
845 let f: Box_<F> = Box_::new(f);
846 connect_raw(
847 self.as_ptr() as *mut _,
848 b"reload\0".as_ptr() as *const _,
849 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
850 reload_trampoline::<Self, F> as *const (),
851 )),
852 Box_::into_raw(f),
853 )
854 }
855 }
856
857 #[cfg(feature = "v2_78")]
858 #[cfg_attr(docsrs, doc(cfg(feature = "v2_78")))]
859 #[doc(alias = "timeout")]
860 fn connect_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
861 unsafe extern "C" fn notify_timeout_trampoline<P: IsA<Resolver>, F: Fn(&P) + 'static>(
862 this: *mut ffi::GResolver,
863 _param_spec: glib::ffi::gpointer,
864 f: glib::ffi::gpointer,
865 ) {
866 let f: &F = &*(f as *const F);
867 f(Resolver::from_glib_borrow(this).unsafe_cast_ref())
868 }
869 unsafe {
870 let f: Box_<F> = Box_::new(f);
871 connect_raw(
872 self.as_ptr() as *mut _,
873 b"notify::timeout\0".as_ptr() as *const _,
874 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
875 notify_timeout_trampoline::<Self, F> as *const (),
876 )),
877 Box_::into_raw(f),
878 )
879 }
880 }
881}
882
883impl<O: IsA<Resolver>> ResolverExt for O {}