1 /* GIO - GLib Input, Output and Streaming Library
3 * Copyright 2010, 2013 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see
17 * <http://www.gnu.org/licenses/>.
25 #include "gsimpleproxyresolver.h"
26 #include "ginetaddress.h"
27 #include "ginetaddressmask.h"
28 #include "gnetworkingprivate.h"
34 * SECTION:gsimpleproxyresolver
35 * @short_description: Simple proxy resolver implementation
37 * @see_also: g_socket_client_set_proxy_resolver()
39 * #GSimpleProxyResolver is a simple #GProxyResolver implementation
40 * that handles a single default proxy, multiple URI-scheme-specific
41 * proxies, and a list of hosts that proxies should not be used for.
43 * #GSimpleProxyResolver is never the default proxy resolver, but it
44 * can be used as the base class for another proxy resolver
45 * implementation, or it can be created and used manually, such as
46 * with g_socket_client_set_proxy_resolver().
55 } GSimpleProxyResolverDomain;
57 struct _GSimpleProxyResolverPrivate {
58 gchar *default_proxy, **ignore_hosts;
59 GHashTable *uri_proxies;
61 GPtrArray *ignore_ips;
62 GSimpleProxyResolverDomain *ignore_domains;
65 static void g_simple_proxy_resolver_iface_init (GProxyResolverInterface *iface);
67 G_DEFINE_TYPE_WITH_CODE (GSimpleProxyResolver, g_simple_proxy_resolver, G_TYPE_OBJECT,
68 G_ADD_PRIVATE (GSimpleProxyResolver)
69 G_IMPLEMENT_INTERFACE (G_TYPE_PROXY_RESOLVER,
70 g_simple_proxy_resolver_iface_init))
79 static void reparse_ignore_hosts (GSimpleProxyResolver *resolver);
82 g_simple_proxy_resolver_finalize (GObject *object)
84 GSimpleProxyResolver *resolver = G_SIMPLE_PROXY_RESOLVER (object);
85 GSimpleProxyResolverPrivate *priv = resolver->priv;
87 g_free (priv->default_proxy);
88 g_hash_table_destroy (priv->uri_proxies);
90 g_clear_pointer (&priv->ignore_hosts, g_strfreev);
91 /* This will free ignore_ips and ignore_domains */
92 reparse_ignore_hosts (resolver);
94 G_OBJECT_CLASS (g_simple_proxy_resolver_parent_class)->finalize (object);
98 g_simple_proxy_resolver_init (GSimpleProxyResolver *resolver)
100 resolver->priv = g_simple_proxy_resolver_get_instance_private (resolver);
101 resolver->priv->uri_proxies = g_hash_table_new_full (g_str_hash, g_str_equal,
106 g_simple_proxy_resolver_set_property (GObject *object,
111 GSimpleProxyResolver *resolver = G_SIMPLE_PROXY_RESOLVER (object);
115 case PROP_DEFAULT_PROXY:
116 g_simple_proxy_resolver_set_default_proxy (resolver, g_value_get_string (value));
119 case PROP_IGNORE_HOSTS:
120 g_simple_proxy_resolver_set_ignore_hosts (resolver, g_value_get_boxed (value));
124 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
129 g_simple_proxy_resolver_get_property (GObject *object,
134 GSimpleProxyResolver *resolver = G_SIMPLE_PROXY_RESOLVER (object);
138 case PROP_DEFAULT_PROXY:
139 g_value_set_string (value, resolver->priv->default_proxy);
142 case PROP_IGNORE_HOSTS:
143 g_value_set_boxed (value, resolver->priv->ignore_hosts);
147 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
152 reparse_ignore_hosts (GSimpleProxyResolver *resolver)
154 GSimpleProxyResolverPrivate *priv = resolver->priv;
155 GPtrArray *ignore_ips;
156 GArray *ignore_domains;
157 gchar *host, *tmp, *colon, *bracket;
159 GInetAddressMask *mask;
160 GSimpleProxyResolverDomain domain;
164 if (priv->ignore_ips)
165 g_ptr_array_free (priv->ignore_ips, TRUE);
166 if (priv->ignore_domains)
168 for (i = 0; priv->ignore_domains[i].name; i++)
169 g_free (priv->ignore_domains[i].name);
170 g_free (priv->ignore_domains);
172 priv->ignore_ips = NULL;
173 priv->ignore_domains = NULL;
175 if (!priv->ignore_hosts || !priv->ignore_hosts[0])
178 ignore_ips = g_ptr_array_new_with_free_func (g_object_unref);
179 ignore_domains = g_array_new (TRUE, FALSE, sizeof (GSimpleProxyResolverDomain));
181 for (i = 0; priv->ignore_hosts[i]; i++)
183 host = g_strchomp (priv->ignore_hosts[i]);
185 /* See if it's an IP address or IP/length mask */
186 mask = g_inet_address_mask_new_from_string (host, NULL);
189 g_ptr_array_add (ignore_ips, mask);
199 bracket = strchr (host, ']');
200 if (!bracket || !bracket[1] || bracket[1] != ':')
203 port = strtoul (bracket + 2, &tmp, 10);
211 colon = strchr (host, ':');
212 if (colon && !strchr (colon + 1, ':'))
214 /* hostname:port or IPv4:port */
215 port = strtoul (colon + 1, &tmp, 10);
222 iaddr = g_inet_address_new_from_string (host);
224 g_object_unref (iaddr);
227 if (g_str_has_prefix (host, "*."))
229 else if (*host == '.')
233 memset (&domain, 0, sizeof (domain));
234 domain.name = g_strdup (host);
235 domain.length = strlen (domain.name);
237 g_array_append_val (ignore_domains, domain);
241 g_warning ("Ignoring invalid ignore_hosts value '%s'", host);
245 priv->ignore_ips = ignore_ips;
247 g_ptr_array_free (ignore_ips, TRUE);
249 if (ignore_domains->len)
250 priv->ignore_domains = (GSimpleProxyResolverDomain *)ignore_domains->data;
251 g_array_free (ignore_domains, ignore_domains->len == 0);
255 ignore_host (GSimpleProxyResolver *resolver,
259 GSimpleProxyResolverPrivate *priv = resolver->priv;
260 gchar *ascii_host = NULL;
261 gboolean ignore = FALSE;
262 gint i, length, offset;
264 if (priv->ignore_ips)
268 iaddr = g_inet_address_new_from_string (host);
271 for (i = 0; i < priv->ignore_ips->len; i++)
273 GInetAddressMask *mask = priv->ignore_ips->pdata[i];
275 if (g_inet_address_mask_matches (mask, iaddr))
282 g_object_unref (iaddr);
288 if (priv->ignore_domains)
290 if (g_hostname_is_non_ascii (host))
291 host = ascii_host = g_hostname_to_ascii (host);
292 length = strlen (host);
294 for (i = 0; priv->ignore_domains[i].length; i++)
296 GSimpleProxyResolverDomain *domain = &priv->ignore_domains[i];
298 offset = length - domain->length;
299 if ((domain->port == 0 || domain->port == port) &&
300 (offset == 0 || (offset > 0 && host[offset - 1] == '.')) &&
301 (g_ascii_strcasecmp (domain->name, host + offset) == 0))
315 g_simple_proxy_resolver_lookup (GProxyResolver *proxy_resolver,
317 GCancellable *cancellable,
320 GSimpleProxyResolver *resolver = G_SIMPLE_PROXY_RESOLVER (proxy_resolver);
321 GSimpleProxyResolverPrivate *priv = resolver->priv;
322 const gchar *proxy = NULL;
325 if (priv->ignore_ips || priv->ignore_domains)
330 if (_g_uri_parse_authority (uri, &host, &port, NULL) &&
331 ignore_host (resolver, host, port))
337 if (!proxy && g_hash_table_size (priv->uri_proxies))
339 gchar *scheme = g_ascii_strdown (uri, strcspn (uri, ":"));
341 proxy = g_hash_table_lookup (priv->uri_proxies, scheme);
346 proxy = priv->default_proxy;
350 if (!strncmp (proxy, "socks://", 8))
352 proxies = g_new0 (gchar *, 4);
353 proxies[0] = g_strdup_printf ("socks5://%s", proxy + 8);
354 proxies[1] = g_strdup_printf ("socks4a://%s", proxy + 8);
355 proxies[2] = g_strdup_printf ("socks4://%s", proxy + 8);
360 proxies = g_new0 (gchar *, 2);
361 proxies[0] = g_strdup (proxy);
368 g_simple_proxy_resolver_lookup_async (GProxyResolver *proxy_resolver,
370 GCancellable *cancellable,
371 GAsyncReadyCallback callback,
374 GSimpleProxyResolver *resolver = G_SIMPLE_PROXY_RESOLVER (proxy_resolver);
376 GError *error = NULL;
379 task = g_task_new (resolver, cancellable, callback, user_data);
381 proxies = g_simple_proxy_resolver_lookup (proxy_resolver, uri,
382 cancellable, &error);
384 g_task_return_pointer (task, proxies, (GDestroyNotify)g_strfreev);
386 g_task_return_error (task, error);
387 g_object_unref (task);
391 g_simple_proxy_resolver_lookup_finish (GProxyResolver *resolver,
392 GAsyncResult *result,
395 g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
397 return g_task_propagate_pointer (G_TASK (result), error);
401 g_simple_proxy_resolver_class_init (GSimpleProxyResolverClass *resolver_class)
403 GObjectClass *object_class = G_OBJECT_CLASS (resolver_class);
405 object_class->get_property = g_simple_proxy_resolver_get_property;
406 object_class->set_property = g_simple_proxy_resolver_set_property;
407 object_class->finalize = g_simple_proxy_resolver_finalize;
410 * GSimpleProxyResolver:default-proxy:
412 * The default proxy URI that will be used for any URI that doesn't
413 * match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
414 * of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
416 * Note that as a special case, if this URI starts with
417 * "<literal>socks://</literal>", #GSimpleProxyResolver will treat
418 * it as referring to all three of the <literal>socks5</literal>,
419 * <literal>socks4a</literal>, and <literal>socks4</literal> proxy
422 g_object_class_install_property (object_class, PROP_DEFAULT_PROXY,
423 g_param_spec_string ("default-proxy",
425 P_("The default proxy URI"),
428 G_PARAM_STATIC_STRINGS));
431 * GSimpleProxyResolver:ignore-hosts:
433 * A list of hostnames and IP addresses that the resolver should
434 * allow direct connections to.
436 * Entries can be in one of 4 formats:
440 * A hostname, such as "<literal>example.com</literal>",
441 * "<literal>.example.com</literal>", or
442 * "<literal>*.example.com</literal>", any of which match
443 * "<literal>example.com</literal>" or any subdomain of it.
446 * An IPv4 or IPv6 address, such as
447 * "<literal>192.168.1.1</literal>", which matches only
451 * A hostname or IP address followed by a port, such as
452 * "<literal>example.com:80</literal>", which matches whatever
453 * the hostname or IP address would match, but only for URLs
454 * with the (explicitly) indicated port. In the case of an IPv6
455 * address, the address part must appear in brackets:
456 * "<literal>[::1]:443</literal>"
459 * An IP address range, given by a base address and prefix length,
460 * such as "<literal>fe80::/10</literal>", which matches any
461 * address in that range.
465 * Note that when dealing with Unicode hostnames, the matching is
466 * done against the ASCII form of the name.
468 * Also note that hostname exclusions apply only to connections made
469 * to hosts identified by name, and IP address exclusions apply only
470 * to connections made to hosts identified by address. That is, if
471 * <literal>example.com</literal> has an address of
472 * <literal>192.168.1.1</literal>, and the :ignore-hosts list
473 * contains only "<literal>192.168.1.1</literal>", then a connection
474 * to "<literal>example.com</literal>" (eg, via a #GNetworkAddress)
475 * will use the proxy, and a connection to
476 * "<literal>192.168.1.1</literal>" (eg, via a #GInetSocketAddress)
479 * These rules match the "ignore-hosts"/"noproxy" rules most
480 * commonly used by other applications.
482 g_object_class_install_property (object_class, PROP_IGNORE_HOSTS,
483 g_param_spec_boxed ("ignore-hosts",
485 P_("Hosts that will not use the proxy"),
488 G_PARAM_STATIC_STRINGS));
493 g_simple_proxy_resolver_iface_init (GProxyResolverInterface *iface)
495 iface->lookup = g_simple_proxy_resolver_lookup;
496 iface->lookup_async = g_simple_proxy_resolver_lookup_async;
497 iface->lookup_finish = g_simple_proxy_resolver_lookup_finish;
501 * g_simple_proxy_resolver_new:
502 * @default_proxy: (allow-none): the default proxy to use, eg
503 * "socks://192.168.1.1"
504 * @ignore_hosts: (allow-none): an optional list of hosts/IP addresses
505 * to not use a proxy for.
507 * Creates a new #GSimpleProxyResolver. See
508 * #GSimpleProxyResolver:default-proxy and
509 * #GSimpleProxyResolver:ignore-hosts for more details on how the
510 * arguments are interpreted.
512 * Returns: a new #GSimpleProxyResolver
517 g_simple_proxy_resolver_new (const gchar *default_proxy,
518 gchar **ignore_hosts)
520 return g_object_new (G_TYPE_SIMPLE_PROXY_RESOLVER,
521 "default-proxy", default_proxy,
522 "ignore-hosts", ignore_hosts,
527 * g_simple_proxy_resolver_set_default_proxy:
528 * @resolver: a #GSimpleProxyResolver
529 * @default_proxy: the default proxy to use
531 * Sets the default proxy on @resolver, to be used for any URIs that
532 * don't match #GSimpleProxyResolver:ignore-hosts or a proxy set
533 * via g_simple_proxy_resolver_set_uri_proxy().
535 * If @default_proxy starts with "<literal>socks://</literal>",
536 * #GSimpleProxyResolver will treat it as referring to all three of
537 * the <literal>socks5</literal>, <literal>socks4a</literal>, and
538 * <literal>socks4</literal> proxy types.
543 g_simple_proxy_resolver_set_default_proxy (GSimpleProxyResolver *resolver,
544 const gchar *default_proxy)
546 g_return_if_fail (G_IS_SIMPLE_PROXY_RESOLVER (resolver));
548 g_free (resolver->priv->default_proxy);
549 resolver->priv->default_proxy = g_strdup (default_proxy);
550 g_object_notify (G_OBJECT (resolver), "default-proxy");
554 * g_simple_proxy_resolver_set_ignore_hosts:
555 * @resolver: a #GSimpleProxyResolver
556 * @ignore_hosts: %NULL-terminated list of hosts/IP addresses
557 * to not use a proxy for
559 * Sets the list of ignored hosts.
561 * See #GSimpleProxyResolver:ignore-hosts for more details on how the
562 * @ignore_hosts argument is interpreted.
567 g_simple_proxy_resolver_set_ignore_hosts (GSimpleProxyResolver *resolver,
568 gchar **ignore_hosts)
570 g_return_if_fail (G_IS_SIMPLE_PROXY_RESOLVER (resolver));
572 g_strfreev (resolver->priv->ignore_hosts);
573 resolver->priv->ignore_hosts = g_strdupv (ignore_hosts);
574 reparse_ignore_hosts (resolver);
575 g_object_notify (G_OBJECT (resolver), "ignore-hosts");
579 * g_simple_proxy_resolver_set_uri_proxy:
580 * @resolver: a #GSimpleProxyResolver
581 * @uri_scheme: the URI scheme to add a proxy for
582 * @proxy: the proxy to use for @uri_scheme
584 * Adds a URI-scheme-specific proxy to @resolver; URIs whose scheme
585 * matches @uri_scheme (and which don't match
586 * #GSimpleProxyResolver:ignore-hosts) will be proxied via @proxy.
588 * As with #GSimpleProxyResolver:default-proxy, if @proxy starts with
589 * "<literal>socks://</literal>", #GSimpleProxyResolver will treat it
590 * as referring to all three of the <literal>socks5</literal>,
591 * <literal>socks4a</literal>, and <literal>socks4</literal> proxy
597 g_simple_proxy_resolver_set_uri_proxy (GSimpleProxyResolver *resolver,
598 const gchar *uri_scheme,
601 g_return_if_fail (G_IS_SIMPLE_PROXY_RESOLVER (resolver));
603 g_hash_table_replace (resolver->priv->uri_proxies,
604 g_ascii_strdown (uri_scheme, -1),