Debian Codegraph @

proxy/gnome/gproxyresolvergnome.c

raw
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /*
3 * GIO - GLib Input, Output and Streaming Library
4 *
5 * Copyright 2010 Red Hat, Inc.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, see
19 * <http://www.gnu.org/licenses/>.
20 */
21
22 #include "config.h"
23
24 #include <stdlib.h>
25
26 #include "gproxyresolvergnome.h"
27
28 #include <glib/gi18n-lib.h>
29 #include <gdesktop-enums.h>
30
31 #define GNOME_PROXY_SETTINGS_SCHEMA "org.gnome.system.proxy"
32 #define GNOME_PROXY_MODE_KEY "mode"
33 #define GNOME_PROXY_AUTOCONFIG_URL_KEY "autoconfig-url"
34 #define GNOME_PROXY_IGNORE_HOSTS_KEY "ignore-hosts"
35 #define GNOME_PROXY_USE_SAME_PROXY_KEY "use-same-proxy"
36
37 #define GNOME_PROXY_HTTP_CHILD_SCHEMA "http"
38 #define GNOME_PROXY_HTTP_HOST_KEY "host"
39 #define GNOME_PROXY_HTTP_PORT_KEY "port"
40 #define GNOME_PROXY_HTTP_USE_AUTH_KEY "use-authentication"
41 #define GNOME_PROXY_HTTP_USER_KEY "authentication-user"
42 #define GNOME_PROXY_HTTP_PASSWORD_KEY "authentication-password"
43
44 #define GNOME_PROXY_HTTPS_CHILD_SCHEMA "https"
45 #define GNOME_PROXY_HTTPS_HOST_KEY "host"
46 #define GNOME_PROXY_HTTPS_PORT_KEY "port"
47
48 #define GNOME_PROXY_FTP_CHILD_SCHEMA "ftp"
49 #define GNOME_PROXY_FTP_HOST_KEY "host"
50 #define GNOME_PROXY_FTP_PORT_KEY "port"
51
52 #define GNOME_PROXY_SOCKS_CHILD_SCHEMA "socks"
53 #define GNOME_PROXY_SOCKS_HOST_KEY "host"
54 #define GNOME_PROXY_SOCKS_PORT_KEY "port"
55
56 /* We have to has-a GSimpleProxyResolver rather than is-a one,
57 * because a dynamic type cannot reimplement an interface that
58 * its parent also implements... for some reason.
59 */
60
61 struct _GProxyResolverGnome {
62 GObject parent_instance;
63
64 GProxyResolver *base_resolver;
65
66 GSettings *proxy_settings;
67 GSettings *http_settings;
68 GSettings *https_settings;
69 GSettings *ftp_settings;
70 GSettings *socks_settings;
71 gboolean need_update;
72
73 GDesktopProxyMode mode;
74 gchar *autoconfig_url;
75 gboolean use_same_proxy;
76
77 GDBusProxy *pacrunner;
78
79 GMutex lock;
80 };
81
82 static GProxyResolverInterface *g_proxy_resolver_gnome_parent_iface;
83
84 static void g_proxy_resolver_gnome_iface_init (GProxyResolverInterface *iface);
85
86 G_DEFINE_DYNAMIC_TYPE_EXTENDED (GProxyResolverGnome,
87 g_proxy_resolver_gnome,
88 G_TYPE_OBJECT, G_TYPE_FLAG_FINAL,
89 G_IMPLEMENT_INTERFACE_DYNAMIC (G_TYPE_PROXY_RESOLVER,
90 g_proxy_resolver_gnome_iface_init))
91
92 static void
93 g_proxy_resolver_gnome_class_finalize (GProxyResolverGnomeClass *klass)
94 {
95 }
96
97 static void
98 gsettings_changed (GSettings *settings,
99 const gchar *key,
100 gpointer user_data)
101 {
102 GProxyResolverGnome *resolver = user_data;
103
104 g_mutex_lock (&resolver->lock);
105 resolver->need_update = TRUE;
106 g_mutex_unlock (&resolver->lock);
107 }
108
109 static void
110 g_proxy_resolver_gnome_finalize (GObject *object)
111 {
112 GProxyResolverGnome *resolver = G_PROXY_RESOLVER_GNOME (object);
113
114 if (resolver->proxy_settings)
115 {
116 g_signal_handlers_disconnect_by_func (resolver->proxy_settings,
117 (gpointer)gsettings_changed,
118 resolver);
119 g_object_unref (resolver->proxy_settings);
120
121 g_signal_handlers_disconnect_by_func (resolver->http_settings,
122 (gpointer)gsettings_changed,
123 resolver);
124 g_object_unref (resolver->http_settings);
125
126 g_signal_handlers_disconnect_by_func (resolver->https_settings,
127 (gpointer)gsettings_changed,
128 resolver);
129 g_object_unref (resolver->https_settings);
130
131 g_signal_handlers_disconnect_by_func (resolver->ftp_settings,
132 (gpointer)gsettings_changed,
133 resolver);
134 g_object_unref (resolver->ftp_settings);
135
136 g_signal_handlers_disconnect_by_func (resolver->socks_settings,
137 (gpointer)gsettings_changed,
138 resolver);
139 g_object_unref (resolver->socks_settings);
140 }
141
142 g_clear_object (&resolver->base_resolver);
143 g_clear_object (&resolver->pacrunner);
144
145 g_free (resolver->autoconfig_url);
146
147 g_mutex_clear (&resolver->lock);
148
149 G_OBJECT_CLASS (g_proxy_resolver_gnome_parent_class)->finalize (object);
150 }
151
152 static void
153 g_proxy_resolver_gnome_init (GProxyResolverGnome *resolver)
154 {
155 g_mutex_init (&resolver->lock);
156
157 resolver->base_resolver = g_simple_proxy_resolver_new (NULL, NULL);
158
159 resolver->proxy_settings = g_settings_new (GNOME_PROXY_SETTINGS_SCHEMA);
160 g_signal_connect (resolver->proxy_settings, "changed",
161 G_CALLBACK (gsettings_changed), resolver);
162 resolver->http_settings = g_settings_get_child (resolver->proxy_settings,
163 GNOME_PROXY_HTTP_CHILD_SCHEMA);
164 g_signal_connect (resolver->http_settings, "changed",
165 G_CALLBACK (gsettings_changed), resolver);
166 resolver->https_settings = g_settings_get_child (resolver->proxy_settings,
167 GNOME_PROXY_HTTPS_CHILD_SCHEMA);
168 g_signal_connect (resolver->https_settings, "changed",
169 G_CALLBACK (gsettings_changed), resolver);
170 resolver->ftp_settings = g_settings_get_child (resolver->proxy_settings,
171 GNOME_PROXY_FTP_CHILD_SCHEMA);
172 g_signal_connect (resolver->ftp_settings, "changed",
173 G_CALLBACK (gsettings_changed), resolver);
174 resolver->socks_settings = g_settings_get_child (resolver->proxy_settings,
175 GNOME_PROXY_SOCKS_CHILD_SCHEMA);
176 g_signal_connect (resolver->socks_settings, "changed",
177 G_CALLBACK (gsettings_changed), resolver);
178
179 resolver->need_update = TRUE;
180 }
181
182 /* called with lock held */
183 static void
184 update_settings (GProxyResolverGnome *resolver)
185 {
186 GSimpleProxyResolver *simple = G_SIMPLE_PROXY_RESOLVER (resolver->base_resolver);
187 gchar **ignore_hosts;
188 gchar *host, *http_proxy, *proxy;
189 guint port;
190 GError *error = NULL;
191
192 resolver->need_update = FALSE;
193
194 g_free (resolver->autoconfig_url);
195 g_simple_proxy_resolver_set_default_proxy (simple, NULL);
196 g_simple_proxy_resolver_set_ignore_hosts (simple, NULL);
197 g_simple_proxy_resolver_set_uri_proxy (simple, "http", NULL);
198 g_simple_proxy_resolver_set_uri_proxy (simple, "https", NULL);
199 g_simple_proxy_resolver_set_uri_proxy (simple, "ftp", NULL);
200
201 resolver->mode =
202 g_settings_get_enum (resolver->proxy_settings, GNOME_PROXY_MODE_KEY);
203 resolver->autoconfig_url =
204 g_settings_get_string (resolver->proxy_settings, GNOME_PROXY_AUTOCONFIG_URL_KEY);
205
206 if (resolver->mode == G_DESKTOP_PROXY_MODE_AUTO && !resolver->pacrunner)
207 {
208 resolver->pacrunner =
209 g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
210 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
211 G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
212 NULL,
213 "org.gtk.GLib.PACRunner",
214 "/org/gtk/GLib/PACRunner",
215 "org.gtk.GLib.PACRunner",
216 NULL, &error);
217 if (error)
218 {
219 g_warning ("Could not start proxy autoconfiguration helper:"
220 "\n %s\nProxy autoconfiguration will not work",
221 error->message);
222 }
223 g_clear_error (&error);
224 }
225 else if (resolver->mode != G_DESKTOP_PROXY_MODE_AUTO && resolver->pacrunner)
226 {
227 g_object_unref (resolver->pacrunner);
228 resolver->pacrunner = NULL;
229 }
230
231 ignore_hosts =
232 g_settings_get_strv (resolver->proxy_settings, GNOME_PROXY_IGNORE_HOSTS_KEY);
233 g_simple_proxy_resolver_set_ignore_hosts (simple, ignore_hosts);
234 g_strfreev (ignore_hosts);
235
236 if (resolver->mode == G_DESKTOP_PROXY_MODE_AUTO)
237 {
238 /* We use the base_resolver to handle ignore_hosts in the AUTO case,
239 * so we have to set a non-"direct://" default proxy so we can distinguish
240 * the two cases.
241 */
242 g_simple_proxy_resolver_set_default_proxy (simple, "use-proxy:");
243 }
244
245 if (resolver->mode != G_DESKTOP_PROXY_MODE_MANUAL)
246 return;
247
248 host = g_settings_get_string (resolver->http_settings, GNOME_PROXY_HTTP_HOST_KEY);
249 port = g_settings_get_int (resolver->http_settings, GNOME_PROXY_HTTP_PORT_KEY);
250 if (host && *host)
251 {
252 if (g_settings_get_boolean (resolver->http_settings, GNOME_PROXY_HTTP_USE_AUTH_KEY))
253 {
254 gchar *user, *password;
255 gchar *enc_user, *enc_password;
256
257 user = g_settings_get_string (resolver->http_settings, GNOME_PROXY_HTTP_USER_KEY);
258 enc_user = g_uri_escape_string (user, NULL, TRUE);
259 g_free (user);
260 password = g_settings_get_string (resolver->http_settings, GNOME_PROXY_HTTP_PASSWORD_KEY);
261 enc_password = g_uri_escape_string (password, NULL, TRUE);
262 g_free (password);
263
264 http_proxy = g_strdup_printf ("http://%s:%s@%s:%u",
265 enc_user, enc_password,
266 host, port);
267 g_free (enc_user);
268 g_free (enc_password);
269 }
270 else
271 http_proxy = g_strdup_printf ("http://%s:%u", host, port);
272
273 if (g_uri_is_valid (http_proxy, G_URI_FLAGS_NONE, &error))
274 {
275 g_simple_proxy_resolver_set_uri_proxy (simple, "http", http_proxy);
276 if (g_settings_get_boolean (resolver->proxy_settings, GNOME_PROXY_USE_SAME_PROXY_KEY))
277 g_simple_proxy_resolver_set_default_proxy (simple, http_proxy);
278 }
279 else
280 {
281 g_warning ("Invalid HTTP proxy URI %s from GNOME settings: %s", http_proxy, error->message);
282 g_clear_pointer (&http_proxy, g_free);
283 g_clear_error (&error);
284 }
285 }
286 else
287 http_proxy = NULL;
288 g_free (host);
289
290 host = g_settings_get_string (resolver->https_settings, GNOME_PROXY_HTTPS_HOST_KEY);
291 port = g_settings_get_int (resolver->https_settings, GNOME_PROXY_HTTPS_PORT_KEY);
292 if (host && *host)
293 {
294 proxy = g_strdup_printf ("http://%s:%u", host, port);
295 if (g_uri_is_valid (proxy, G_URI_FLAGS_NONE, &error))
296 {
297 g_simple_proxy_resolver_set_uri_proxy (simple, "https", proxy);
298 }
299 else
300 {
301 g_warning ("Invalid HTTPS proxy URI %s from GNOME settings: %s", proxy, error->message);
302 g_clear_error (&error);
303 }
304 g_free (proxy);
305 }
306 else if (http_proxy)
307 g_simple_proxy_resolver_set_uri_proxy (simple, "https", http_proxy);
308 g_free (host);
309
310 host = g_settings_get_string (resolver->socks_settings, GNOME_PROXY_SOCKS_HOST_KEY);
311 port = g_settings_get_int (resolver->socks_settings, GNOME_PROXY_SOCKS_PORT_KEY);
312 if (host && *host)
313 {
314 proxy = g_strdup_printf ("socks://%s:%u", host, port);
315 if (g_uri_is_valid (proxy, G_URI_FLAGS_NONE, &error))
316 {
317 g_simple_proxy_resolver_set_default_proxy (simple, proxy);
318 }
319 else
320 {
321 g_warning ("Invalid SOCKS proxy URI %s from GNOME settings: %s", proxy, error->message);
322 g_clear_error (&error);
323 }
324 g_free (proxy);
325 }
326 g_free (host);
327
328 g_free (http_proxy);
329
330 host = g_settings_get_string (resolver->ftp_settings, GNOME_PROXY_FTP_HOST_KEY);
331 port = g_settings_get_int (resolver->ftp_settings, GNOME_PROXY_FTP_PORT_KEY);
332 if (host && *host)
333 {
334 proxy = g_strdup_printf ("ftp://%s:%u", host, port);
335 if (g_uri_is_valid (proxy, G_URI_FLAGS_NONE, &error))
336 {
337 g_simple_proxy_resolver_set_uri_proxy (simple, "ftp", proxy);
338 }
339 else
340 {
341 g_warning ("Invalid FTP proxy URI %s from GNOME settings: %s", proxy, error->message);
342 g_clear_error (&error);
343 }
344 g_free (proxy);
345 }
346 g_free (host);
347 }
348
349 static gboolean
350 g_proxy_resolver_gnome_is_supported (GProxyResolver *object)
351 {
352 const char *desktops;
353
354 desktops = g_getenv ("XDG_CURRENT_DESKTOP");
355 if (!desktops)
356 return FALSE;
357
358 /* Remember that XDG_CURRENT_DESKTOP is a list of strings. Desktops that
359 * pretend to be GNOME and want to use our proxy settings will list
360 * themselves alongside GNOME. That's fine; they'll get our proxy settings.
361 */
362 return strstr (desktops, "GNOME") != NULL;
363 }
364
365 /* Threadsafely determines what to do with @uri; returns %FALSE if an
366 * error occurs, %TRUE and an array of proxies if the mode is NONE or
367 * MANUAL, or if @uri is covered by ignore-hosts, or %TRUE and a
368 * (transfer-full) pacrunner and autoconfig url if the mode is AUTOMATIC.
369 */
370 static gboolean
371 g_proxy_resolver_gnome_lookup_internal (GProxyResolverGnome *resolver,
372 const gchar *uri,
373 gchar ***out_proxies,
374 GDBusProxy **out_pacrunner,
375 gchar **out_autoconfig_url,
376 GCancellable *cancellable,
377 GError **error)
378 {
379 gchar **proxies = NULL;
380
381 *out_proxies = NULL;
382 *out_pacrunner = NULL;
383 *out_autoconfig_url = NULL;
384
385 g_mutex_lock (&resolver->lock);
386 if (resolver->need_update)
387 update_settings (resolver);
388
389 proxies = g_proxy_resolver_lookup (resolver->base_resolver,
390 uri, cancellable, error);
391 if (!proxies)
392 goto done;
393
394 /* Parent class does ignore-host handling */
395 if (!strcmp (proxies[0], "direct://") && !proxies[1])
396 goto done;
397
398 if (resolver->pacrunner)
399 {
400 g_clear_pointer (&proxies, g_strfreev);
401 *out_pacrunner = g_object_ref (resolver->pacrunner);
402 *out_autoconfig_url = g_strdup (resolver->autoconfig_url);
403 goto done;
404 }
405
406 done:
407 g_mutex_unlock (&resolver->lock);
408
409 if (proxies)
410 {
411 *out_proxies = proxies;
412 return TRUE;
413 }
414 else if (*out_pacrunner)
415 return TRUE;
416 else
417 return FALSE;
418 }
419
420 static gchar **
421 g_proxy_resolver_gnome_lookup (GProxyResolver *proxy_resolver,
422 const gchar *uri,
423 GCancellable *cancellable,
424 GError **error)
425 {
426 GProxyResolverGnome *resolver = G_PROXY_RESOLVER_GNOME (proxy_resolver);
427 GDBusProxy *pacrunner;
428 gchar **proxies, *autoconfig_url;
429
430 if (!g_proxy_resolver_gnome_lookup_internal (resolver, uri,
431 &proxies, &pacrunner, &autoconfig_url,
432 cancellable, error))
433 return NULL;
434
435 if (pacrunner)
436 {
437 GVariant *vproxies;
438
439 vproxies = g_dbus_proxy_call_sync (pacrunner,
440 "Lookup",
441 g_variant_new ("(ss)",
442 autoconfig_url,
443 uri),
444 G_DBUS_CALL_FLAGS_NONE,
445 -1,
446 cancellable, error);
447 if (vproxies)
448 {
449 g_variant_get (vproxies, "(^as)", &proxies);
450 g_variant_unref (vproxies);
451 }
452 else
453 proxies = NULL;
454
455 g_object_unref (pacrunner);
456 g_free (autoconfig_url);
457 }
458
459 return proxies;
460 }
461
462 static void
463 got_autoconfig_proxies (GObject *source,
464 GAsyncResult *result,
465 gpointer user_data)
466 {
467 GTask *task = user_data;
468 GVariant *vproxies;
469 char **proxies;
470 GError *error = NULL;
471
472 vproxies = g_dbus_proxy_call_finish (G_DBUS_PROXY (source),
473 result, &error);
474 if (vproxies)
475 {
476 g_variant_get (vproxies, "(^as)", &proxies);
477 g_task_return_pointer (task, proxies, (GDestroyNotify)g_strfreev);
478 g_variant_unref (vproxies);
479 }
480 else
481 g_task_return_error (task, error);
482 g_object_unref (task);
483 }
484
485 static void
486 g_proxy_resolver_gnome_lookup_async (GProxyResolver *proxy_resolver,
487 const gchar *uri,
488 GCancellable *cancellable,
489 GAsyncReadyCallback callback,
490 gpointer user_data)
491 {
492 GProxyResolverGnome *resolver = G_PROXY_RESOLVER_GNOME (proxy_resolver);
493 GTask *task;
494 char **proxies, *autoconfig_url;
495 GDBusProxy *pacrunner;
496 GError *error = NULL;
497
498 task = g_task_new (resolver, cancellable, callback, user_data);
499 g_task_set_source_tag (task, g_proxy_resolver_gnome_lookup_async);
500 g_task_set_name (task, "[glib-networking] g_proxy_resolver_gnome_lookup_async");
501
502 if (!g_proxy_resolver_gnome_lookup_internal (resolver, uri,
503 &proxies, &pacrunner, &autoconfig_url,
504 cancellable, &error))
505 {
506 g_task_return_error (task, error);
507 g_object_unref (task);
508 return;
509 }
510 else if (proxies)
511 {
512 g_task_return_pointer (task, proxies, (GDestroyNotify)g_strfreev);
513 g_object_unref (task);
514 return;
515 }
516
517 g_dbus_proxy_call (pacrunner,
518 "Lookup",
519 g_variant_new ("(ss)",
520 autoconfig_url,
521 uri),
522 G_DBUS_CALL_FLAGS_NONE,
523 -1,
524 cancellable,
525 got_autoconfig_proxies,
526 task);
527 g_object_unref (pacrunner);
528 g_free (autoconfig_url);
529 }
530
531 static gchar **
532 g_proxy_resolver_gnome_lookup_finish (GProxyResolver *resolver,
533 GAsyncResult *result,
534 GError **error)
535 {
536 g_return_val_if_fail (g_task_is_valid (result, resolver), NULL);
537 g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == g_proxy_resolver_gnome_lookup_async, NULL);
538
539 return g_task_propagate_pointer (G_TASK (result), error);
540 }
541
542 static void
543 g_proxy_resolver_gnome_class_init (GProxyResolverGnomeClass *resolver_class)
544 {
545 GObjectClass *object_class;
546
547 object_class = G_OBJECT_CLASS (resolver_class);
548 object_class->finalize = g_proxy_resolver_gnome_finalize;
549 }
550
551 static void
552 g_proxy_resolver_gnome_iface_init (GProxyResolverInterface *iface)
553 {
554 g_proxy_resolver_gnome_parent_iface = g_type_interface_peek_parent (iface);
555
556 iface->is_supported = g_proxy_resolver_gnome_is_supported;
557 iface->lookup = g_proxy_resolver_gnome_lookup;
558 iface->lookup_async = g_proxy_resolver_gnome_lookup_async;
559 iface->lookup_finish = g_proxy_resolver_gnome_lookup_finish;
560 }
561
562 void
563 g_proxy_resolver_gnome_register (GIOModule *module)
564 {
565 g_proxy_resolver_gnome_register_type (G_TYPE_MODULE (module));
566 if (!module)
567 g_io_extension_point_register (G_PROXY_RESOLVER_EXTENSION_POINT_NAME);
568 g_io_extension_point_implement (G_PROXY_RESOLVER_EXTENSION_POINT_NAME,
569 g_proxy_resolver_gnome_get_type(),
570 "gnome",
571 80);
572 }