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.

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


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