## GProxyResolver GProxyResolver — Asynchronous and cancellable network proxy resolver |

## Synopsis

    #include <gio/gio.h>

                        GProxyResolver;
    struct              GProxyResolverInterface;
    #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.

## Known Implementations

GProxyResolver is implemented by GSimpleProxyResolver.

## Description

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

## Details

### GProxyResolver

    typedef struct _GProxyResolver GProxyResolver;

A helper class to enumerate proxies base on URI.

Since 2.26

### struct GProxyResolverInterface

    struct GProxyResolverInterface {
      GTypeInterface g_iface;

      /* Virtual Table */
      gboolean (* is_supported)  (GProxyResolver       *resolver);

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

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

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

### 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. [transfer none]

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`. [allow-none]
`error` : | return location for a GError, or `NULL`
Returns : | A NULL-terminated array of proxy URIs. Must be freed with `g_strfreev()`. [transfer full][array zero-terminated=1]

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`. [allow-none]
`callback` : | callback to call after resolution completes. [scope async]
`user_data` : | data for `callback`. [closure]

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()`. [transfer full][array zero-terminated=1]

Since 2.26