## GProxyResolver

GProxyResolver — Asynchronous and cancellable network proxy resolver

## Synopsis

    #include <gio/gio.h>

                        GProxyResolver;
    #define             G_PROXY_RESOLVER_EXTENSION_POINT_NAME
    GProxyResolver *    g_proxy_resolver_get_default        (void);
    gboolean            g_proxy_resolver_is_supported       (GProxyResolver *resolver);
    gchar **            g_proxy_resolver_lookup             (GProxyResolver *resolver,
                                                             const gchar *uri,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                g_proxy_resolver_lookup_async       (GProxyResolver *resolver,
                                                             const gchar *uri,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gchar **            g_proxy_resolver_lookup_finish      (GProxyResolver *resolver,
                                                             GAsyncResult *result,
                                                             GError **error);

## Object Hierarchy

      GInterface
       +----GProxyResolver

## Prerequisites

GProxyResolver requires GObject.

## Description

GProxyResolver provides synchronous and asynchronous network proxy resolution. GProxyResolver is used within GClientSocket through the method `g_socket_connectable_proxy_enumerate()`.

## Details

### GProxyResolver

    typedef struct _GProxyResolver GProxyResolver;

Interface that can be used to resolve proxy address.

Since 2.26

### G_PROXY_RESOLVER_EXTENSION_POINT_NAME

    #define G_PROXY_RESOLVER_EXTENSION_POINT_NAME "gio-proxy-resolver"

Extension point for proxy resolving functionality. See Extending GIO.

### g_proxy_resolver_get_default ()

    GProxyResolver *    g_proxy_resolver_get_default        (void);

Gets the default GProxyResolver for the system.

Returns : | the default GProxyResolver.

Since 2.26

### g_proxy_resolver_is_supported ()

    gboolean            g_proxy_resolver_is_supported       (GProxyResolver *resolver);

Checks if `resolver` can be used on this system. (This is used internally; `g_proxy_resolver_get_default()` will only return a proxy resolver that returns `TRUE` for this method.)

`resolver` : | a GProxyResolver
Returns : | `TRUE` if `resolver` is supported.

Since 2.26

### g_proxy_resolver_lookup ()

    gchar **            g_proxy_resolver_lookup             (GProxyResolver *resolver,
                                                             const gchar *uri,
                                                             GCancellable *cancellable,
                                                             GError **error);

Looks into the system proxy configuration to determine what proxy, if any, to use to connect to `uri`. The returned proxy URIs are of the form `<protocol>://[user[:password]@]host:port` or `direct://`, where <protocol> could be http, rtsp, socks or other proxying protocol.

If you don't know what network protocol is being used on the socket, you should use `none` as the URI protocol. In this case, the resolver might still return a generic proxy type (such as SOCKS), but would not return protocol-specific proxy types (such as http).

`direct://` is used when no proxy is needed. Direct connection should not be attempted unless it is part of the returned array of proxies.

`resolver` : | a GProxyResolver
`uri` : | a URI representing the destination to connect to
`cancellable` : | a GCancellable, or `NULL`
`error` : | return location for a GError, or `NULL`
Returns : | A NULL-terminated array of proxy URIs. Must be freed with `g_strfreev()`.

Since 2.26

### g_proxy_resolver_lookup_async ()

    void                g_proxy_resolver_lookup_async       (GProxyResolver *resolver,
                                                             const gchar *uri,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronous lookup of proxy. See `g_proxy_resolver_lookup()` for more details.

`resolver` : | a GProxyResolver
`uri` : | a URI representing the destination to connect to
`cancellable` : | a GCancellable, or `NULL`
`callback` : | callback to call after resolution completes
`user_data` : | data for `callback`

Since 2.26

### g_proxy_resolver_lookup_finish ()

    gchar **            g_proxy_resolver_lookup_finish      (GProxyResolver *resolver,
                                                             GAsyncResult *result,
                                                             GError **error);

Call this function to obtain the array of proxy URIs when `g_proxy_resolver_lookup_async()` is complete. See `g_proxy_resolver_lookup()` for more details.

`resolver` : | a GProxyResolver
`result` : | the result passed to your GAsyncReadyCallback
`error` : | return location for a GError, or `NULL`
Returns : | A NULL-terminated array of proxy URIs. Must be freed with `g_strfreev()`.

Since 2.26