GI.Gio.Objects.Resolver

Resolver provides cancellable synchronous and asynchronous DNS resolution, for hostnames (resolverLookupByAddress, resolverLookupByName and their async variants) and SRV (service) records (resolverLookupService).

NetworkAddress and NetworkService provide wrappers around Resolver functionality that also implement SocketConnectable, making it easy to connect to a remote host/service.

Exported types

newtype Resolver

Constructors

Resolver (ManagedPtr Resolver)

Instances

GObject Resolver

Methods

gobjectType :: Resolver -> IO GType

IsObject Resolver

IsResolver Resolver

((~) * info (ResolveResolverMethod t Resolver), MethodInfo * info Resolver p) => IsLabel t (Resolver -> p)

Methods

fromLabel :: Proxy# Symbol t -> Resolver -> p

((~) * info (ResolveResolverMethod t Resolver), MethodInfo * info Resolver p) => IsLabelProxy t (Resolver -> p)

Methods

fromLabelProxy :: Proxy Symbol t -> Resolver -> p

HasAttributeList * Resolver

type AttributeList Resolver

type AttributeList Resolver

type SignalList Resolver

type SignalList Resolver

class GObject o => IsResolver o

Instances

(GObject a, UnknownAncestorError Constraint Resolver a) => IsResolver a

IsResolver Resolver

toResolver :: IsResolver o => o -> IO Resolver

noResolver :: Maybe Resolver

Methods

getDefault

resolverGetDefault

Arguments

:: (HasCallStack, MonadIO m)

=> m Resolver

Returns: the default Resolver.

Gets the default Resolver. You should unref it when you are done with it. Resolver may use its reference count as a hint about how many threads it should allocate for concurrent DNS resolutions.

Since: 2.22

lookupByAddress

data ResolverLookupByAddressMethodInfo

Instances

((~) * signature (b -> Maybe c -> m Text), MonadIO m, IsResolver a, IsInetAddress b, IsCancellable c) => MethodInfo * ResolverLookupByAddressMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupByAddressMethodInfo a -> signature -> s

resolverLookupByAddress

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsInetAddress b, IsCancellable c)

=> a

resolver: a Resolver

-> b

address: the address to reverse-resolve

-> Maybe c

cancellable: a Cancellable, or Nothing

-> m Text

Returns: a hostname (either ASCII-only, or in ASCII-encoded form), or Nothing on error. (Can throw GError)

Synchronously reverse-resolves address to determine its associated hostname.

If the DNS resolution fails, error (if non-Nothing) will be set to a value from ResolverError.

If cancellable is non-Nothing, it can be used to cancel the operation, in which case error (if non-Nothing) will be set to IOErrorEnumCancelled.

Since: 2.22

lookupByAddressAsync

data ResolverLookupByAddressAsyncMethodInfo

Instances

((~) * signature (b -> Maybe c -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsResolver a, IsInetAddress b, IsCancellable c) => MethodInfo * ResolverLookupByAddressAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupByAddressAsyncMethodInfo a -> signature -> s

resolverLookupByAddressAsync

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsInetAddress b, IsCancellable c)

=> a

resolver: a Resolver

-> b

address: the address to reverse-resolve

-> Maybe c

cancellable: a Cancellable, or Nothing

-> Maybe AsyncReadyCallback

callback: callback to call after resolution completes

-> m ()

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

Since: 2.22

lookupByAddressFinish

data ResolverLookupByAddressFinishMethodInfo

Instances

((~) * signature (b -> m Text), MonadIO m, IsResolver a, IsAsyncResult b) => MethodInfo * ResolverLookupByAddressFinishMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupByAddressFinishMethodInfo a -> signature -> s

resolverLookupByAddressFinish

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsAsyncResult b)

=> a

resolver: a Resolver

-> b

result: the result passed to your AsyncReadyCallback

-> m Text

Returns: a hostname (either ASCII-only, or in ASCII-encoded form), or Nothing on error. (Can throw GError)

Retrieves the result of a previous call to resolverLookupByAddressAsync.

If the DNS resolution failed, error (if non-Nothing) will be set to a value from ResolverError. If the operation was cancelled, error will be set to IOErrorEnumCancelled.

Since: 2.22

lookupByName

data ResolverLookupByNameMethodInfo

Instances

((~) * signature (Text -> Maybe b -> m [InetAddress]), MonadIO m, IsResolver a, IsCancellable b) => MethodInfo * ResolverLookupByNameMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupByNameMethodInfo a -> signature -> s

resolverLookupByName

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsCancellable b)

=> a

resolver: a Resolver

-> Text

hostname: the hostname to look up

-> Maybe b

cancellable: a Cancellable, or Nothing

-> m [InetAddress]

Returns: a non-empty List of InetAddress, or Nothing 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.) (Can throw GError)

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 inetAddressNewFromString).

On success, resolverLookupByName will return a non-empty List of InetAddress, 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. socketListenerAddAddress.

If the DNS resolution fails, error (if non-Nothing) will be set to a value from ResolverError and Nothing will be returned.

If cancellable is non-Nothing, it can be used to cancel the operation, in which case error (if non-Nothing) will be set to IOErrorEnumCancelled.

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

Since: 2.22

lookupByNameAsync

data ResolverLookupByNameAsyncMethodInfo

Instances

((~) * signature (Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsResolver a, IsCancellable b) => MethodInfo * ResolverLookupByNameAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupByNameAsyncMethodInfo a -> signature -> s

resolverLookupByNameAsync

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsCancellable b)

=> a

resolver: a Resolver

-> Text

hostname: the hostname to look up the address of

-> Maybe b

cancellable: a Cancellable, or Nothing

-> Maybe AsyncReadyCallback

callback: callback to call after resolution completes

-> m ()

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

Since: 2.22

lookupByNameFinish

data ResolverLookupByNameFinishMethodInfo

Instances

((~) * signature (b -> m [InetAddress]), MonadIO m, IsResolver a, IsAsyncResult b) => MethodInfo * ResolverLookupByNameFinishMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupByNameFinishMethodInfo a -> signature -> s

resolverLookupByNameFinish

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsAsyncResult b)

=> a

resolver: a Resolver

-> b

result: the result passed to your AsyncReadyCallback

-> m [InetAddress]

Returns: a List of InetAddress, or Nothing on error. See resolverLookupByName for more details. (Can throw GError)

Retrieves the result of a call to resolverLookupByNameAsync.

If the DNS resolution failed, error (if non-Nothing) will be set to a value from ResolverError. If the operation was cancelled, error will be set to IOErrorEnumCancelled.

Since: 2.22

lookupRecords

data ResolverLookupRecordsMethodInfo

Instances

((~) * signature (Text -> ResolverRecordType -> Maybe b -> m [GVariant]), MonadIO m, IsResolver a, IsCancellable b) => MethodInfo * ResolverLookupRecordsMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupRecordsMethodInfo a -> signature -> s

resolverLookupRecords

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsCancellable b)

=> a

resolver: a Resolver

-> Text

rrname: the DNS name to lookup the record for

-> ResolverRecordType

recordType: the type of DNS record to lookup

-> Maybe b

cancellable: a Cancellable, or Nothing

-> m [GVariant]

Returns: a non-empty List of GVariant, or Nothing 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 variantUnref to do this.) (Can throw GError)

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

If the DNS resolution fails, error (if non-Nothing) will be set to a value from ResolverError and Nothing will be returned.

If cancellable is non-Nothing, it can be used to cancel the operation, in which case error (if non-Nothing) will be set to IOErrorEnumCancelled.

Since: 2.34

lookupRecordsAsync

data ResolverLookupRecordsAsyncMethodInfo

Instances

((~) * signature (Text -> ResolverRecordType -> Maybe b -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsResolver a, IsCancellable b) => MethodInfo * ResolverLookupRecordsAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupRecordsAsyncMethodInfo a -> signature -> s

resolverLookupRecordsAsync

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsCancellable b)

=> a

resolver: a Resolver

-> Text

rrname: the DNS name to lookup the record for

-> ResolverRecordType

recordType: the type of DNS record to lookup

-> Maybe b

cancellable: a Cancellable, or Nothing

-> Maybe AsyncReadyCallback

callback: callback to call after resolution completes

-> m ()

Begins asynchronously performing a DNS lookup for the given rrname, and eventually calls callback, which must call resolverLookupRecordsFinish to get the final result. See resolverLookupRecords for more details.

Since: 2.34

lookupRecordsFinish

data ResolverLookupRecordsFinishMethodInfo

Instances

((~) * signature (b -> m [GVariant]), MonadIO m, IsResolver a, IsAsyncResult b) => MethodInfo * ResolverLookupRecordsFinishMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupRecordsFinishMethodInfo a -> signature -> s

resolverLookupRecordsFinish

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsAsyncResult b)

=> a

resolver: a Resolver

-> b

result: the result passed to your AsyncReadyCallback

-> m [GVariant]

Returns: a non-empty List of GVariant, or Nothing 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 variantUnref to do this.) (Can throw GError)

Retrieves the result of a previous call to resolverLookupRecordsAsync. Returns a non-empty list of records as GVariant tuples. See ResolverRecordType for information on what the records contain.

If the DNS resolution failed, error (if non-Nothing) will be set to a value from ResolverError. If the operation was cancelled, error will be set to IOErrorEnumCancelled.

Since: 2.34

lookupService

data ResolverLookupServiceMethodInfo

Instances

((~) * signature (Text -> Text -> Text -> Maybe b -> m [SrvTarget]), MonadIO m, IsResolver a, IsCancellable b) => MethodInfo * ResolverLookupServiceMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupServiceMethodInfo a -> signature -> s

resolverLookupService

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsCancellable b)

=> a

resolver: a Resolver

-> Text

service: the service type to look up (eg, "ldap")

-> Text

protocol: the networking protocol to use for service (eg, "tcp")

-> Text

domain: the DNS domain to look up the service in

-> Maybe b

cancellable: a Cancellable, or Nothing

-> m [SrvTarget]

Returns: a non-empty List of SrvTarget, or Nothing 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.) (Can throw GError)

Synchronously performs a DNS SRV lookup for the given service and protocol in the given domain and returns an array of SrvTarget. 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, resolverLookupService will return a non-empty List of SrvTarget, 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-Nothing) will be set to a value from ResolverError and Nothing will be returned.

If cancellable is non-Nothing, it can be used to cancel the operation, in which case error (if non-Nothing) will be set to IOErrorEnumCancelled.

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

Since: 2.22

lookupServiceAsync

data ResolverLookupServiceAsyncMethodInfo

Instances

((~) * signature (Text -> Text -> Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsResolver a, IsCancellable b) => MethodInfo * ResolverLookupServiceAsyncMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupServiceAsyncMethodInfo a -> signature -> s

resolverLookupServiceAsync

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsCancellable b)

=> a

resolver: a Resolver

-> Text

service: the service type to look up (eg, "ldap")

-> Text

protocol: the networking protocol to use for service (eg, "tcp")

-> Text

domain: the DNS domain to look up the service in

-> Maybe b

cancellable: a Cancellable, or Nothing

-> Maybe AsyncReadyCallback

callback: callback to call after resolution completes

-> m ()

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

Since: 2.22

lookupServiceFinish

data ResolverLookupServiceFinishMethodInfo

Instances

((~) * signature (b -> m [SrvTarget]), MonadIO m, IsResolver a, IsAsyncResult b) => MethodInfo * ResolverLookupServiceFinishMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverLookupServiceFinishMethodInfo a -> signature -> s

resolverLookupServiceFinish

Arguments

:: (HasCallStack, MonadIO m, IsResolver a, IsAsyncResult b)

=> a

resolver: a Resolver

-> b

result: the result passed to your AsyncReadyCallback

-> m [SrvTarget]

Returns: a non-empty List of SrvTarget, or Nothing on error. See resolverLookupService for more details. (Can throw GError)

Retrieves the result of a previous call to resolverLookupServiceAsync.

If the DNS resolution failed, error (if non-Nothing) will be set to a value from ResolverError. If the operation was cancelled, error will be set to IOErrorEnumCancelled.

Since: 2.22

setDefault

data ResolverSetDefaultMethodInfo

Instances

((~) * signature (m ()), MonadIO m, IsResolver a) => MethodInfo * ResolverSetDefaultMethodInfo a signature

Methods

overloadedMethod :: MethodProxy ResolverSetDefaultMethodInfo a -> signature -> s

resolverSetDefault

Arguments

:: (HasCallStack, MonadIO m, IsResolver a)

=> a

resolver: the new default Resolver

-> m ()

Sets resolver to be the application's default resolver (reffing resolver, and unreffing the previous default resolver, if any). Future calls to resolverGetDefault 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 Resolver 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.

Since: 2.22

Signals

reload

type C_ResolverReloadCallback = Ptr () -> Ptr () -> IO ()

type ResolverReloadCallback = IO ()

data ResolverReloadSignalInfo

Instances

SignalInfo ResolverReloadSignalInfo

Associated Types

type HaskellCallbackType ResolverReloadSignalInfo :: *

Methods

connectSignal :: GObject o => SignalProxy o ResolverReloadSignalInfo -> o -> HaskellCallbackType ResolverReloadSignalInfo -> SignalConnectMode -> IO SignalHandlerId

type HaskellCallbackType ResolverReloadSignalInfo

type HaskellCallbackType ResolverReloadSignalInfo = ResolverReloadCallback

afterResolverReload :: (GObject a, MonadIO m) => a -> ResolverReloadCallback -> m SignalHandlerId

genClosure_ResolverReload :: ResolverReloadCallback -> IO Closure

mk_ResolverReloadCallback :: C_ResolverReloadCallback -> IO (FunPtr C_ResolverReloadCallback)

noResolverReloadCallback :: Maybe ResolverReloadCallback

onResolverReload :: (GObject a, MonadIO m) => a -> ResolverReloadCallback -> m SignalHandlerId

wrap_ResolverReloadCallback :: ResolverReloadCallback -> Ptr () -> Ptr () -> IO ()