Trait ResolverExt

pub trait ResolverExt: IsA<Resolver> + 'static {
    // Provided methods
    fn timeout(&self) -> u32 { ... }
    fn lookup_by_address(
        &self,
        address: &impl IsA<InetAddress>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<GString, Error> { ... }
    fn lookup_by_address_async<P: FnOnce(Result<GString, Error>) + 'static>(
        &self,
        address: &impl IsA<InetAddress>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) { ... }
    fn lookup_by_address_future(
        &self,
        address: &(impl IsA<InetAddress> + Clone + 'static),
    ) -> Pin<Box_<dyn Future<Output = Result<GString, Error>> + 'static>> { ... }
    fn lookup_by_name(
        &self,
        hostname: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Vec<InetAddress>, Error> { ... }
    fn lookup_by_name_async<P: FnOnce(Result<Vec<InetAddress>, Error>) + 'static>(
        &self,
        hostname: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) { ... }
    fn lookup_by_name_future(
        &self,
        hostname: &str,
    ) -> Pin<Box_<dyn Future<Output = Result<Vec<InetAddress>, Error>> + 'static>> { ... }
    fn lookup_by_name_with_flags(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Vec<InetAddress>, Error> { ... }
    fn lookup_by_name_with_flags_async<P: FnOnce(Result<Vec<InetAddress>, Error>) + 'static>(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) { ... }
    fn lookup_by_name_with_flags_future(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
    ) -> Pin<Box_<dyn Future<Output = Result<Vec<InetAddress>, Error>> + 'static>> { ... }
    fn lookup_records(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Vec<Variant>, Error> { ... }
    fn lookup_records_async<P: FnOnce(Result<Vec<Variant>, Error>) + 'static>(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) { ... }
    fn lookup_records_future(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
    ) -> Pin<Box_<dyn Future<Output = Result<Vec<Variant>, Error>> + 'static>> { ... }
    fn lookup_service(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<Vec<SrvTarget>, Error> { ... }
    fn lookup_service_async<P: FnOnce(Result<Vec<SrvTarget>, Error>) + 'static>(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) { ... }
    fn lookup_service_future(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
    ) -> Pin<Box_<dyn Future<Output = Result<Vec<SrvTarget>, Error>> + 'static>> { ... }
    fn set_default(&self) { ... }
    fn set_timeout(&self, timeout_ms: u32) { ... }
    fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { ... }
    fn connect_timeout_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId { ... }
}

Trait containing all Resolver methods.

Implementors

Resolver

Provided Methods

fn timeout(&self) -> u32

Available on crate feature v2_78 only.

Get the timeout applied to all resolver lookups. See #GResolver:timeout.

Returns

the resolver timeout, in milliseconds, or 0 for no timeout

fn lookup_by_address( &self, address: &impl IsA<InetAddress>, cancellable: Option<&impl IsA<Cancellable>>, ) -> Result<GString, Error>

Synchronously reverse-resolves @address to determine its associated hostname.

If the DNS resolution fails, @error (if non-None) will be set to a value from #GResolverError.

If @cancellable is non-None, it can be used to cancel the operation, in which case @error (if non-None) will be set to IOErrorEnum::Cancelled.

address

the address to reverse-resolve

cancellable

a #GCancellable, or None

Returns

a hostname (either ASCII-only, or in ASCII-encoded form), or None on error.

fn lookup_by_address_async<P: FnOnce(Result<GString, Error>) + 'static>( &self, address: &impl IsA<InetAddress>, cancellable: Option<&impl IsA<Cancellable>>, callback: P, )

Begins asynchronously reverse-resolving @address to determine its associated hostname, and eventually calls @callback, which must call g_resolver_lookup_by_address_finish() to get the final result.

address

the address to reverse-resolve

cancellable

a #GCancellable, or None

callback

callback to call after resolution completes

fn lookup_by_address_future( &self, address: &(impl IsA<InetAddress> + Clone + 'static), ) -> Pin<Box_<dyn Future<Output = Result<GString, Error>> + 'static>>

fn lookup_by_name( &self, hostname: &str, cancellable: Option<&impl IsA<Cancellable>>, ) -> Result<Vec<InetAddress>, Error>

Synchronously resolves @hostname to determine its associated IP address(es). @hostname may be an ASCII-only or UTF-8 hostname, or the textual form of an IP address (in which case this just becomes a wrapper around g_inet_address_new_from_string()).

On success, g_resolver_lookup_by_name() will return a non-empty #GList of #GInetAddress, sorted in order of preference and guaranteed to not contain duplicates. That is, if using the result to connect to @hostname, you should attempt to connect to the first address first, then the second if the first fails, etc. If you are using the result to listen on a socket, it is appropriate to add each result using e.g. g_socket_listener_add_address().

If the DNS resolution fails, @error (if non-None) will be set to a value from #GResolverError and None will be returned.

If @cancellable is non-None, it can be used to cancel the operation, in which case @error (if non-None) will be set to IOErrorEnum::Cancelled.

If you are planning to connect to a socket on the resolved IP address, it may be easier to create a #GNetworkAddress and use its #GSocketConnectable interface.

hostname

the hostname to look up

cancellable

a #GCancellable, or None

Returns

a non-empty #GList of #GInetAddress, or None on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.)

fn lookup_by_name_async<P: FnOnce(Result<Vec<InetAddress>, Error>) + 'static>( &self, hostname: &str, cancellable: Option<&impl IsA<Cancellable>>, callback: P, )

Begins asynchronously resolving @hostname to determine its associated IP address(es), and eventually calls @callback, which must call g_resolver_lookup_by_name_finish() to get the result. See g_resolver_lookup_by_name() for more details.

hostname

the hostname to look up the address of

cancellable

a #GCancellable, or None

callback

callback to call after resolution completes

fn lookup_by_name_future( &self, hostname: &str, ) -> Pin<Box_<dyn Future<Output = Result<Vec<InetAddress>, Error>> + 'static>>

fn lookup_by_name_with_flags( &self, hostname: &str, flags: ResolverNameLookupFlags, cancellable: Option<&impl IsA<Cancellable>>, ) -> Result<Vec<InetAddress>, Error>

Available on crate feature v2_60 only.

This differs from g_resolver_lookup_by_name() in that you can modify the lookup behavior with @flags. For example this can be used to limit results with ResolverNameLookupFlags::IPV4_ONLY.

hostname

the hostname to look up

flags

extra #GResolverNameLookupFlags for the lookup

cancellable

a #GCancellable, or None

Returns

a non-empty #GList of #GInetAddress, or None on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.)

fn lookup_by_name_with_flags_async<P: FnOnce(Result<Vec<InetAddress>, Error>) + 'static>( &self, hostname: &str, flags: ResolverNameLookupFlags, cancellable: Option<&impl IsA<Cancellable>>, callback: P, )

Available on crate feature v2_60 only.

Begins asynchronously resolving @hostname to determine its associated IP address(es), and eventually calls @callback, which must call g_resolver_lookup_by_name_with_flags_finish() to get the result. See g_resolver_lookup_by_name() for more details.

hostname

the hostname to look up the address of

flags

extra #GResolverNameLookupFlags for the lookup

cancellable

a #GCancellable, or None

callback

callback to call after resolution completes

fn lookup_by_name_with_flags_future( &self, hostname: &str, flags: ResolverNameLookupFlags, ) -> Pin<Box_<dyn Future<Output = Result<Vec<InetAddress>, Error>> + 'static>>

Available on crate feature v2_60 only.

fn lookup_records( &self, rrname: &str, record_type: ResolverRecordType, cancellable: Option<&impl IsA<Cancellable>>, ) -> Result<Vec<Variant>, Error>

Synchronously performs a DNS record lookup for the given @rrname and returns a list of records as #GVariant tuples. See #GResolverRecordType for information on what the records contain for each @record_type.

If the DNS resolution fails, @error (if non-None) will be set to a value from #GResolverError and None will be returned.

If @cancellable is non-None, it can be used to cancel the operation, in which case @error (if non-None) will be set to IOErrorEnum::Cancelled.

rrname

the DNS name to look up the record for

record_type

the type of DNS record to look up

cancellable

a #GCancellable, or None

Returns

a non-empty #GList of #GVariant, or None on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.)

fn lookup_records_async<P: FnOnce(Result<Vec<Variant>, Error>) + 'static>( &self, rrname: &str, record_type: ResolverRecordType, cancellable: Option<&impl IsA<Cancellable>>, callback: P, )

Begins asynchronously performing a DNS lookup for the given @rrname, and eventually calls @callback, which must call g_resolver_lookup_records_finish() to get the final result. See g_resolver_lookup_records() for more details.

rrname

the DNS name to look up the record for

record_type

the type of DNS record to look up

cancellable

a #GCancellable, or None

callback

callback to call after resolution completes

fn lookup_records_future( &self, rrname: &str, record_type: ResolverRecordType, ) -> Pin<Box_<dyn Future<Output = Result<Vec<Variant>, Error>> + 'static>>

fn lookup_service( &self, service: &str, protocol: &str, domain: &str, cancellable: Option<&impl IsA<Cancellable>>, ) -> Result<Vec<SrvTarget>, Error>

Synchronously performs a DNS SRV lookup for the given @service and @protocol in the given @domain and returns an array of #GSrvTarget. @domain may be an ASCII-only or UTF-8 hostname. Note also that the @service and @protocol arguments do not include the leading underscore that appears in the actual DNS entry.

On success, g_resolver_lookup_service() will return a non-empty #GList of #GSrvTarget, sorted in order of preference. (That is, you should attempt to connect to the first target first, then the second if the first fails, etc.)

If the DNS resolution fails, @error (if non-None) will be set to a value from #GResolverError and None will be returned.

If @cancellable is non-None, it can be used to cancel the operation, in which case @error (if non-None) will be set to IOErrorEnum::Cancelled.

If you are planning to connect to the service, it is usually easier to create a #GNetworkService and use its #GSocketConnectable interface.

service

the service type to look up (eg, “ldap”)

protocol

the networking protocol to use for @service (eg, “tcp”)

domain

the DNS domain to look up the service in

cancellable

a #GCancellable, or None

Returns

a non-empty #GList of #GSrvTarget, or None on error. You must free each of the targets and the list when you are done with it. (You can use g_resolver_free_targets() to do this.)

fn lookup_service_async<P: FnOnce(Result<Vec<SrvTarget>, Error>) + 'static>( &self, service: &str, protocol: &str, domain: &str, cancellable: Option<&impl IsA<Cancellable>>, callback: P, )

Begins asynchronously performing a DNS SRV lookup for the given @service and @protocol in the given @domain, and eventually calls @callback, which must call g_resolver_lookup_service_finish() to get the final result. See g_resolver_lookup_service() for more details.

service

the service type to look up (eg, “ldap”)

protocol

the networking protocol to use for @service (eg, “tcp”)

domain

the DNS domain to look up the service in

cancellable

a #GCancellable, or None

callback

callback to call after resolution completes

fn lookup_service_future( &self, service: &str, protocol: &str, domain: &str, ) -> Pin<Box_<dyn Future<Output = Result<Vec<SrvTarget>, Error>> + 'static>>

fn set_default(&self)

Sets @self to be the application’s default resolver (reffing @self, and unreffing the previous default resolver, if any). Future calls to g_resolver_get_default() will return this resolver.

This can be used if an application wants to perform any sort of DNS caching or “pinning”; it can implement its own #GResolver that calls the original default resolver for DNS operations, and implements its own cache policies on top of that, and then set itself as the default resolver for all later code to use.

fn set_timeout(&self, timeout_ms: u32)

Available on crate feature v2_78 only.

Set the timeout applied to all resolver lookups. See #GResolver:timeout.

timeout_ms

timeout in milliseconds, or 0 for no timeouts

fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId

Emitted when the resolver notices that the system resolver configuration has changed.

fn connect_timeout_notify<F: Fn(&Self) + 'static>( &self, f: F, ) -> SignalHandlerId

Available on crate feature v2_78 only.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<O: IsA<Resolver>> ResolverExt for O