static void
use_resolver (gboolean synchronous)
{
GProxyResolver *resolver;
resolver = g_proxy_resolver_get_default ();
if (synchronous)
{
GError *error = NULL;
gchar **proxies;
proxies = g_proxy_resolver_lookup (resolver, info, cancellable, &error);
if (error)
print_and_free_error (error);
else
print_proxies (info, proxies);
g_strfreev (proxies);
}
else
{
GMainLoop *loop = g_main_loop_new (NULL, FALSE);
g_proxy_resolver_lookup_async (resolver,
info,
cancellable,
_proxy_lookup_cb,
loop);
g_main_loop_run (loop);
g_main_loop_unref (loop);
}
}
static void
soup_proxy_resolver_default_constructed (GObject *object)
{
SoupProxyResolverDefaultPrivate *priv = SOUP_PROXY_RESOLVER_DEFAULT_GET_PRIVATE (object);
if (!priv->gproxy_resolver) {
priv->gproxy_resolver = g_proxy_resolver_get_default ();
g_object_ref (priv->gproxy_resolver);
}
G_OBJECT_CLASS (soup_proxy_resolver_default_parent_class)->constructed (object);
}
static void
g_proxy_address_enumerator_next_async (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator);
GTask *task;
task = g_task_new (enumerator, cancellable, callback, user_data);
g_task_set_task_data (task, priv, NULL);
if (priv->proxies == NULL)
{
GProxyResolver *resolver = g_proxy_resolver_get_default ();
g_proxy_resolver_lookup_async (resolver,
priv->dest_uri,
cancellable,
proxy_lookup_cb,
task);
return;
}
if (priv->addr_enum)
{
if (priv->proxy_address)
{
return_result (task);
return;
}
else
{
g_socket_address_enumerator_next_async (priv->addr_enum,
cancellable,
address_enumerate_cb,
task);
return;
}
}
complete_async (task);
}
static void
network_set_soup_session_proxy (SoupSession *session, ProxyDetectMode mode, const gchar *host, guint port, const gchar *user, const gchar *password)
{
SoupURI *uri = NULL;
switch (mode) {
case PROXY_DETECT_MODE_AUTO:
/* Sets proxy-resolver to the default resolver, this unsets proxy-uri. */
g_object_set (G_OBJECT (session),
SOUP_SESSION_PROXY_RESOLVER, g_proxy_resolver_get_default (),
NULL);
break;
case PROXY_DETECT_MODE_NONE:
/* Sets proxy-resolver to NULL, this unsets proxy-uri. */
g_object_set (G_OBJECT (session),
SOUP_SESSION_PROXY_RESOLVER, NULL,
NULL);
break;
case PROXY_DETECT_MODE_MANUAL:
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (uri, host);
soup_uri_set_port (uri, port);
soup_uri_set_user (uri, user);
soup_uri_set_password (uri, password);
soup_uri_set_path (uri, "/");
if (SOUP_URI_IS_VALID (uri)) {
/* Sets proxy-uri, this unsets proxy-resolver. */
g_object_set (G_OBJECT (session),
SOUP_SESSION_PROXY_URI, uri,
NULL);
}
soup_uri_free (uri);
break;
}
}
static GSocketAddress *
g_proxy_address_enumerator_next (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GError **error)
{
GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator);
GSocketAddress *result = NULL;
GError *first_error = NULL;
if (priv->proxies == NULL)
{
GProxyResolver *resolver = g_proxy_resolver_get_default ();
priv->proxies = g_proxy_resolver_lookup (resolver,
priv->dest_uri,
cancellable,
error);
priv->next_proxy = priv->proxies;
if (priv->proxies == NULL)
return NULL;
}
while (result == NULL && (*priv->next_proxy || priv->addr_enum))
{
gchar *dest_hostname;
gchar *dest_protocol;
GInetSocketAddress *inetsaddr;
GInetAddress *inetaddr;
guint16 port;
next_enumerator (priv);
if (!priv->addr_enum)
continue;
if (priv->proxy_address == NULL)
{
priv->proxy_address = g_socket_address_enumerator_next (
priv->addr_enum,
cancellable,
first_error ? NULL : &first_error);
}
if (priv->proxy_address == NULL)
{
g_object_unref (priv->addr_enum);
priv->addr_enum = NULL;
if (priv->dest_ips)
{
g_resolver_free_addresses (priv->dest_ips);
priv->dest_ips = NULL;
}
continue;
}
if (strcmp ("direct", priv->proxy_type) == 0)
{
result = priv->proxy_address;
priv->proxy_address = NULL;
continue;
}
if (!priv->supports_hostname)
{
GInetAddress *dest_ip;
if (!priv->dest_ips)
{
GResolver *resolver;
resolver = g_resolver_get_default();
priv->dest_ips = g_resolver_lookup_by_name (resolver,
priv->dest_hostname,
cancellable,
first_error ? NULL : &first_error);
g_object_unref (resolver);
if (!priv->dest_ips)
{
g_object_unref (priv->proxy_address);
priv->proxy_address = NULL;
continue;
}
}
if (!priv->next_dest_ip)
priv->next_dest_ip = priv->dest_ips;
dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data);
dest_hostname = g_inet_address_to_string (dest_ip);
priv->next_dest_ip = g_list_next (priv->next_dest_ip);
}
else
{
dest_hostname = g_strdup (priv->dest_hostname);
}
dest_protocol = g_uri_parse_scheme (priv->dest_uri);
g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (priv->proxy_address),
NULL);
inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address);
inetaddr = g_inet_socket_address_get_address (inetsaddr);
port = g_inet_socket_address_get_port (inetsaddr);
result = g_object_new (G_TYPE_PROXY_ADDRESS,
"address", inetaddr,
"port", port,
"protocol", priv->proxy_type,
"destination-protocol", dest_protocol,
"destination-hostname", dest_hostname,
"destination-port", priv->dest_port,
"username", priv->proxy_username,
"password", priv->proxy_password,
"uri", priv->proxy_uri,
NULL);
g_free (dest_hostname);
g_free (dest_protocol);
if (priv->supports_hostname || priv->next_dest_ip == NULL)
{
g_object_unref (priv->proxy_address);
priv->proxy_address = NULL;
}
}
if (result == NULL && first_error)
g_propagate_error (error, first_error);
else if (first_error)
g_error_free (first_error);
return result;
}
static void
g_proxy_address_enumerator_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (object);
switch (property_id)
{
case PROP_URI:
{
const gchar *uri;
g_free (priv->dest_hostname);
priv->dest_hostname = NULL;
priv->dest_port = 0;
g_free (priv->dest_uri);
priv->dest_uri = NULL;
uri = g_value_get_string (value);
if (uri)
{
GSocketConnectable *conn;
conn = g_network_address_parse_uri (uri, 0, NULL);
if (conn)
{
guint port;
priv->dest_uri = g_strdup (uri);
g_object_get (conn,
"hostname", &priv->dest_hostname,
"port", &port,
NULL);
priv->dest_port = port;
g_object_unref (conn);
}
else
g_warning ("Invalid URI '%s'", uri);
}
break;
}
case PROP_CONNECTABLE:
priv->connectable = g_value_dup_object (value);
break;
case PROP_PROXY_RESOLVER:
if (priv->proxy_resolver)
g_object_unref (priv->proxy_resolver);
priv->proxy_resolver = g_value_get_object (value);
if (!priv->proxy_resolver)
priv->proxy_resolver = g_proxy_resolver_get_default ();
g_object_ref (priv->proxy_resolver);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
