Google Git
Sign in
android / platform / external / chromium_org / 862bd7759b5ede90f02436dab473f47a24ab7e9b / . / net / proxy / proxy_config_service_linux.cc
blob: 158fd5c1ff72d405eacec058b746d97065f7317b [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/proxy/proxy_config_service_linux.h"
// glib >=2.40 deprecate g_settings_list_schemas in favor of
// g_settings_schema_source_list_schemas. This function is not available on
// earlier versions that we still need to support (specifically, 2.32), so
// disable the warning.
// TODO(mgiuca): Remove this suppression when we drop support for Ubuntu 13.10
// (saucy) and earlier. Update the code to use
// g_settings_schema_source_list_schemas instead.
#define GLIB_DISABLE_DEPRECATION_WARNINGS
#include <errno.h>
#include <fcntl.h>
#if defined(USE_GCONF)
#include <gconf/gconf-client.h>
#endif // defined(USE_GCONF)
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/inotify.h>
#include <unistd.h>
#include <map>
#include "base/bind.h"
#include "base/compiler_specific.h"
#include "base/debug/leak_annotations.h"
#include "base/environment.h"
#include "base/file_util.h"
#include "base/files/file_path.h"
#include "base/files/scoped_file.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
#include "base/nix/xdg_util.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_tokenizer.h"
#include "base/strings/string_util.h"
#include "base/threading/thread_restrictions.h"
#include "base/timer/timer.h"
#include "net/base/net_errors.h"
#include "net/http/http_util.h"
#include "net/proxy/proxy_config.h"
#include "net/proxy/proxy_server.h"
#include "url/url_canon.h"
#if defined(USE_GIO)
#include "library_loaders/libgio.h"
#endif // defined(USE_GIO)
namespace net {
namespace {
// Given a proxy hostname from a setting, returns that hostname with
// an appropriate proxy server scheme prefix.
// scheme indicates the desired proxy scheme: usually http, with
// socks 4 or 5 as special cases.
// TODO(arindam): Remove URI string manipulation by using MapUrlSchemeToProxy.
std::string FixupProxyHostScheme(ProxyServer::Scheme scheme,
std::string host) {
if (scheme == ProxyServer::SCHEME_SOCKS5 &&
StartsWithASCII(host, "socks4://", false)) {
// We default to socks 5, but if the user specifically set it to
// socks4://, then use that.
scheme = ProxyServer::SCHEME_SOCKS4;
}
// Strip the scheme if any.
std::string::size_type colon = host.find("://");
if (colon != std::string::npos)
host = host.substr(colon + 3);
// If a username and perhaps password are specified, give a warning.
std::string::size_type at_sign = host.find("@");
// Should this be supported?
if (at_sign != std::string::npos) {
// ProxyConfig does not support authentication parameters, but Chrome
// will prompt for the password later. Disregard the
// authentication parameters and continue with this hostname.
LOG(WARNING) << "Proxy authentication parameters ignored, see bug 16709";
host = host.substr(at_sign + 1);
}
// If this is a socks proxy, prepend a scheme so as to tell
// ProxyServer. This also allows ProxyServer to choose the right
// default port.
if (scheme == ProxyServer::SCHEME_SOCKS4)
host = "socks4://" + host;
else if (scheme == ProxyServer::SCHEME_SOCKS5)
host = "socks5://" + host;
// If there is a trailing slash, remove it so |host| will parse correctly
// even if it includes a port number (since the slash is not numeric).
if (host.length() && host[host.length() - 1] == '/')
host.resize(host.length() - 1);
return host;
}
} // namespace
ProxyConfigServiceLinux::Delegate::~Delegate() {
}
bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVarForScheme(
const char* variable, ProxyServer::Scheme scheme,
ProxyServer* result_server) {
std::string env_value;
if (env_var_getter_->GetVar(variable, &env_value)) {
if (!env_value.empty()) {
env_value = FixupProxyHostScheme(scheme, env_value);
ProxyServer proxy_server =
ProxyServer::FromURI(env_value, ProxyServer::SCHEME_HTTP);
if (proxy_server.is_valid() && !proxy_server.is_direct()) {
*result_server = proxy_server;
return true;
} else {
LOG(ERROR) << "Failed to parse environment variable " << variable;
}
}
}
return false;
}
bool ProxyConfigServiceLinux::Delegate::GetProxyFromEnvVar(
const char* variable, ProxyServer* result_server) {
return GetProxyFromEnvVarForScheme(variable, ProxyServer::SCHEME_HTTP,
result_server);
}
bool ProxyConfigServiceLinux::Delegate::GetConfigFromEnv(ProxyConfig* config) {
// Check for automatic configuration first, in
// "auto_proxy". Possibly only the "environment_proxy" firefox
// extension has ever used this, but it still sounds like a good
// idea.
std::string auto_proxy;
if (env_var_getter_->GetVar("auto_proxy", &auto_proxy)) {
if (auto_proxy.empty()) {
// Defined and empty => autodetect
config->set_auto_detect(true);
} else {
// specified autoconfig URL
config->set_pac_url(GURL(auto_proxy));
}
return true;
}
// "all_proxy" is a shortcut to avoid defining {http,https,ftp}_proxy.
ProxyServer proxy_server;
if (GetProxyFromEnvVar("all_proxy", &proxy_server)) {
config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_server);
} else {
bool have_http = GetProxyFromEnvVar("http_proxy", &proxy_server);
if (have_http)
config->proxy_rules().proxies_for_http.SetSingleProxyServer(proxy_server);
// It would be tempting to let http_proxy apply for all protocols
// if https_proxy and ftp_proxy are not defined. Googling turns up
// several documents that mention only http_proxy. But then the
// user really might not want to proxy https. And it doesn't seem
// like other apps do this. So we will refrain.
bool have_https = GetProxyFromEnvVar("https_proxy", &proxy_server);
if (have_https)
config->proxy_rules().proxies_for_https.
SetSingleProxyServer(proxy_server);
bool have_ftp = GetProxyFromEnvVar("ftp_proxy", &proxy_server);
if (have_ftp)
config->proxy_rules().proxies_for_ftp.SetSingleProxyServer(proxy_server);
if (have_http || have_https || have_ftp) {
// mustn't change type unless some rules are actually set.
config->proxy_rules().type =
ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME;
}
}
if (config->proxy_rules().empty()) {
// If the above were not defined, try for socks.
// For environment variables, we default to version 5, per the gnome
// documentation: http://library.gnome.org/devel/gnet/stable/gnet-socks.html
ProxyServer::Scheme scheme = ProxyServer::SCHEME_SOCKS5;
std::string env_version;
if (env_var_getter_->GetVar("SOCKS_VERSION", &env_version)
&& env_version == "4")
scheme = ProxyServer::SCHEME_SOCKS4;
if (GetProxyFromEnvVarForScheme("SOCKS_SERVER", scheme, &proxy_server)) {
config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_server);
}
}
// Look for the proxy bypass list.
std::string no_proxy;
env_var_getter_->GetVar("no_proxy", &no_proxy);
if (config->proxy_rules().empty()) {
// Having only "no_proxy" set, presumably to "*", makes it
// explicit that env vars do specify a configuration: having no
// rules specified only means the user explicitly asks for direct
// connections.
return !no_proxy.empty();
}
// Note that this uses "suffix" matching. So a bypass of "google.com"
// is understood to mean a bypass of "*google.com".
config->proxy_rules().bypass_rules.ParseFromStringUsingSuffixMatching(
no_proxy);
return true;
}
namespace {
const int kDebounceTimeoutMilliseconds = 250;
#if defined(USE_GCONF)
// This setting getter uses gconf, as used in GNOME 2 and some GNOME 3 desktops.
class SettingGetterImplGConf : public ProxyConfigServiceLinux::SettingGetter {
public:
SettingGetterImplGConf()
: client_(NULL), system_proxy_id_(0), system_http_proxy_id_(0),
notify_delegate_(NULL) {
}
virtual ~SettingGetterImplGConf() {
// client_ should have been released before now, from
// Delegate::OnDestroy(), while running on the UI thread. However
// on exiting the process, it may happen that Delegate::OnDestroy()
// task is left pending on the glib loop after the loop was quit,
// and pending tasks may then be deleted without being run.
if (client_) {
// gconf client was not cleaned up.
if (task_runner_->BelongsToCurrentThread()) {
// We are on the UI thread so we can clean it safely. This is
// the case at least for ui_tests running under Valgrind in
// bug 16076.
VLOG(1) << "~SettingGetterImplGConf: releasing gconf client";
ShutDown();
} else {
// This is very bad! We are deleting the setting getter but we're not on
// the UI thread. This is not supposed to happen: the setting getter is
// owned by the proxy config service's delegate, which is supposed to be
// destroyed on the UI thread only. We will get change notifications to
// a deleted object if we continue here, so fail now.
LOG(FATAL) << "~SettingGetterImplGConf: deleting on wrong thread!";
}
}
DCHECK(!client_);
}
virtual bool Init(base::SingleThreadTaskRunner* glib_thread_task_runner,
base::MessageLoopForIO* file_loop) OVERRIDE {
DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
DCHECK(!client_);
DCHECK(!task_runner_.get());
task_runner_ = glib_thread_task_runner;
client_ = gconf_client_get_default();
if (!client_) {
// It's not clear whether/when this can return NULL.
LOG(ERROR) << "Unable to create a gconf client";
task_runner_ = NULL;
return false;
}
GError* error = NULL;
bool added_system_proxy = false;
// We need to add the directories for which we'll be asking
// for notifications, and we might as well ask to preload them.
// These need to be removed again in ShutDown(); we are careful
// here to only leave client_ non-NULL if both have been added.
gconf_client_add_dir(client_, "/system/proxy",
GCONF_CLIENT_PRELOAD_ONELEVEL, &error);
if (error == NULL) {
added_system_proxy = true;
gconf_client_add_dir(client_, "/system/http_proxy",
GCONF_CLIENT_PRELOAD_ONELEVEL, &error);
}
if (error != NULL) {
LOG(ERROR) << "Error requesting gconf directory: " << error->message;
g_error_free(error);
if (added_system_proxy)
gconf_client_remove_dir(client_, "/system/proxy", NULL);
g_object_unref(client_);
client_ = NULL;
task_runner_ = NULL;
return false;
}
return true;
}
virtual void ShutDown() OVERRIDE {
if (client_) {
DCHECK(task_runner_->BelongsToCurrentThread());
// We must explicitly disable gconf notifications here, because the gconf
// client will be shared between all setting getters, and they do not all
// have the same lifetimes. (For instance, incognito sessions get their
// own, which is destroyed when the session ends.)
gconf_client_notify_remove(client_, system_http_proxy_id_);
gconf_client_notify_remove(client_, system_proxy_id_);
gconf_client_remove_dir(client_, "/system/http_proxy", NULL);
gconf_client_remove_dir(client_, "/system/proxy", NULL);
g_object_unref(client_);
client_ = NULL;
task_runner_ = NULL;
}
}
virtual bool SetUpNotifications(
ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
DCHECK(client_);
DCHECK(task_runner_->BelongsToCurrentThread());
GError* error = NULL;
notify_delegate_ = delegate;
// We have to keep track of the IDs returned by gconf_client_notify_add() so
// that we can remove them in ShutDown(). (Otherwise, notifications will be
// delivered to this object after it is deleted, which is bad, m'kay?)
system_proxy_id_ = gconf_client_notify_add(
client_, "/system/proxy",
OnGConfChangeNotification, this,
NULL, &error);
if (error == NULL) {
system_http_proxy_id_ = gconf_client_notify_add(
client_, "/system/http_proxy",
OnGConfChangeNotification, this,
NULL, &error);
}
if (error != NULL) {
LOG(ERROR) << "Error requesting gconf notifications: " << error->message;
g_error_free(error);
ShutDown();
return false;
}
// Simulate a change to avoid possibly losing updates before this point.
OnChangeNotification();
return true;
}
virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
return task_runner_.get();
}
virtual ProxyConfigSource GetConfigSource() OVERRIDE {
return PROXY_CONFIG_SOURCE_GCONF;
}
virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
switch (key) {
case PROXY_MODE:
return GetStringByPath("/system/proxy/mode", result);
case PROXY_AUTOCONF_URL:
return GetStringByPath("/system/proxy/autoconfig_url", result);
case PROXY_HTTP_HOST:
return GetStringByPath("/system/http_proxy/host", result);
case PROXY_HTTPS_HOST:
return GetStringByPath("/system/proxy/secure_host", result);
case PROXY_FTP_HOST:
return GetStringByPath("/system/proxy/ftp_host", result);
case PROXY_SOCKS_HOST:
return GetStringByPath("/system/proxy/socks_host", result);
}
return false; // Placate compiler.
}
virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
switch (key) {
case PROXY_USE_HTTP_PROXY:
return GetBoolByPath("/system/http_proxy/use_http_proxy", result);
case PROXY_USE_SAME_PROXY:
return GetBoolByPath("/system/http_proxy/use_same_proxy", result);
case PROXY_USE_AUTHENTICATION:
return GetBoolByPath("/system/http_proxy/use_authentication", result);
}
return false; // Placate compiler.
}
virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
switch (key) {
case PROXY_HTTP_PORT:
return GetIntByPath("/system/http_proxy/port", result);
case PROXY_HTTPS_PORT:
return GetIntByPath("/system/proxy/secure_port", result);
case PROXY_FTP_PORT:
return GetIntByPath("/system/proxy/ftp_port", result);
case PROXY_SOCKS_PORT:
return GetIntByPath("/system/proxy/socks_port", result);
}
return false; // Placate compiler.
}
virtual bool GetStringList(StringListSetting key,
std::vector<std::string>* result) OVERRIDE {
switch (key) {
case PROXY_IGNORE_HOSTS:
return GetStringListByPath("/system/http_proxy/ignore_hosts", result);
}
return false; // Placate compiler.
}
virtual bool BypassListIsReversed() OVERRIDE {
// This is a KDE-specific setting.
return false;
}
virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
return false;
}
private:
bool GetStringByPath(const char* key, std::string* result) {
DCHECK(client_);
DCHECK(task_runner_->BelongsToCurrentThread());
GError* error = NULL;
gchar* value = gconf_client_get_string(client_, key, &error);
if (HandleGError(error, key))
return false;
if (!value)
return false;
*result = value;
g_free(value);
return true;
}
bool GetBoolByPath(const char* key, bool* result) {
DCHECK(client_);
DCHECK(task_runner_->BelongsToCurrentThread());
GError* error = NULL;
// We want to distinguish unset values from values defaulting to
// false. For that we need to use the type-generic
// gconf_client_get() rather than gconf_client_get_bool().
GConfValue* gconf_value = gconf_client_get(client_, key, &error);
if (HandleGError(error, key))
return false;
if (!gconf_value) {
// Unset.
return false;
}
if (gconf_value->type != GCONF_VALUE_BOOL) {
gconf_value_free(gconf_value);
return false;
}
gboolean bool_value = gconf_value_get_bool(gconf_value);
*result = static_cast<bool>(bool_value);
gconf_value_free(gconf_value);
return true;
}
bool GetIntByPath(const char* key, int* result) {
DCHECK(client_);
DCHECK(task_runner_->BelongsToCurrentThread());
GError* error = NULL;
int value = gconf_client_get_int(client_, key, &error);
if (HandleGError(error, key))
return false;
// We don't bother to distinguish an unset value because callers
// don't care. 0 is returned if unset.
*result = value;
return true;
}
bool GetStringListByPath(const char* key, std::vector<std::string>* result) {
DCHECK(client_);
DCHECK(task_runner_->BelongsToCurrentThread());
GError* error = NULL;
GSList* list = gconf_client_get_list(client_, key,
GCONF_VALUE_STRING, &error);
if (HandleGError(error, key))
return false;
if (!list)
return false;
for (GSList *it = list; it; it = it->next) {
result->push_back(static_cast<char*>(it->data));
g_free(it->data);
}
g_slist_free(list);
return true;
}
// Logs and frees a glib error. Returns false if there was no error
// (error is NULL).
bool HandleGError(GError* error, const char* key) {
if (error != NULL) {
LOG(ERROR) << "Error getting gconf value for " << key
<< ": " << error->message;
g_error_free(error);
return true;
}
return false;
}
// This is the callback from the debounce timer.
void OnDebouncedNotification() {
DCHECK(task_runner_->BelongsToCurrentThread());
CHECK(notify_delegate_);
// Forward to a method on the proxy config service delegate object.
notify_delegate_->OnCheckProxyConfigSettings();
}
void OnChangeNotification() {
// We don't use Reset() because the timer may not yet be running.
// (In that case Stop() is a no-op.)
debounce_timer_.Stop();
debounce_timer_.Start(FROM_HERE,
base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
this, &SettingGetterImplGConf::OnDebouncedNotification);
}
// gconf notification callback, dispatched on the default glib main loop.
static void OnGConfChangeNotification(GConfClient* client, guint cnxn_id,
GConfEntry* entry, gpointer user_data) {
VLOG(1) << "gconf change notification for key "
<< gconf_entry_get_key(entry);
// We don't track which key has changed, just that something did change.
SettingGetterImplGConf* setting_getter =
reinterpret_cast<SettingGetterImplGConf*>(user_data);
setting_getter->OnChangeNotification();
}
GConfClient* client_;
// These ids are the values returned from gconf_client_notify_add(), which we
// will need in order to later call gconf_client_notify_remove().
guint system_proxy_id_;
guint system_http_proxy_id_;
ProxyConfigServiceLinux::Delegate* notify_delegate_;
base::OneShotTimer<SettingGetterImplGConf> debounce_timer_;
// Task runner for the thread that we make gconf calls on. It should
// be the UI thread and all our methods should be called on this
// thread. Only for assertions.
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGConf);
};
#endif // defined(USE_GCONF)
#if defined(USE_GIO)
const char kProxyGConfSchema[] = "org.gnome.system.proxy";
// This setting getter uses gsettings, as used in most GNOME 3 desktops.
class SettingGetterImplGSettings
: public ProxyConfigServiceLinux::SettingGetter {
public:
SettingGetterImplGSettings() :
client_(NULL),
http_client_(NULL),
https_client_(NULL),
ftp_client_(NULL),
socks_client_(NULL),
notify_delegate_(NULL) {
}
virtual ~SettingGetterImplGSettings() {
// client_ should have been released before now, from
// Delegate::OnDestroy(), while running on the UI thread. However
// on exiting the process, it may happen that
// Delegate::OnDestroy() task is left pending on the glib loop
// after the loop was quit, and pending tasks may then be deleted
// without being run.
if (client_) {
// gconf client was not cleaned up.
if (task_runner_->BelongsToCurrentThread()) {
// We are on the UI thread so we can clean it safely. This is
// the case at least for ui_tests running under Valgrind in
// bug 16076.
VLOG(1) << "~SettingGetterImplGSettings: releasing gsettings client";
ShutDown();
} else {
LOG(WARNING) << "~SettingGetterImplGSettings: leaking gsettings client";
client_ = NULL;
}
}
DCHECK(!client_);
}
bool SchemaExists(const char* schema_name) {
const gchar* const* schemas = libgio_loader_.g_settings_list_schemas();
while (*schemas) {
if (strcmp(schema_name, static_cast<const char*>(*schemas)) == 0)
return true;
schemas++;
}
return false;
}
// LoadAndCheckVersion() must be called *before* Init()!
bool LoadAndCheckVersion(base::Environment* env);
virtual bool Init(base::SingleThreadTaskRunner* glib_thread_task_runner,
base::MessageLoopForIO* file_loop) OVERRIDE {
DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
DCHECK(!client_);
DCHECK(!task_runner_.get());
if (!SchemaExists(kProxyGConfSchema) ||
!(client_ = libgio_loader_.g_settings_new(kProxyGConfSchema))) {
// It's not clear whether/when this can return NULL.
LOG(ERROR) << "Unable to create a gsettings client";
return false;
}
task_runner_ = glib_thread_task_runner;
// We assume these all work if the above call worked.
http_client_ = libgio_loader_.g_settings_get_child(client_, "http");
https_client_ = libgio_loader_.g_settings_get_child(client_, "https");
ftp_client_ = libgio_loader_.g_settings_get_child(client_, "ftp");
socks_client_ = libgio_loader_.g_settings_get_child(client_, "socks");
DCHECK(http_client_ && https_client_ && ftp_client_ && socks_client_);
return true;
}
virtual void ShutDown() OVERRIDE {
if (client_) {
DCHECK(task_runner_->BelongsToCurrentThread());
// This also disables gsettings notifications.
g_object_unref(socks_client_);
g_object_unref(ftp_client_);
g_object_unref(https_client_);
g_object_unref(http_client_);
g_object_unref(client_);
// We only need to null client_ because it's the only one that we check.
client_ = NULL;
task_runner_ = NULL;
}
}
virtual bool SetUpNotifications(
ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
DCHECK(client_);
DCHECK(task_runner_->BelongsToCurrentThread());
notify_delegate_ = delegate;
// We could watch for the change-event signal instead of changed, but
// since we have to watch more than one object, we'd still have to
// debounce change notifications. This is conceptually simpler.
g_signal_connect(G_OBJECT(client_), "changed",
G_CALLBACK(OnGSettingsChangeNotification), this);
g_signal_connect(G_OBJECT(http_client_), "changed",
G_CALLBACK(OnGSettingsChangeNotification), this);
g_signal_connect(G_OBJECT(https_client_), "changed",
G_CALLBACK(OnGSettingsChangeNotification), this);
g_signal_connect(G_OBJECT(ftp_client_), "changed",
G_CALLBACK(OnGSettingsChangeNotification), this);
g_signal_connect(G_OBJECT(socks_client_), "changed",
G_CALLBACK(OnGSettingsChangeNotification), this);
// Simulate a change to avoid possibly losing updates before this point.
OnChangeNotification();
return true;
}
virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
return task_runner_.get();
}
virtual ProxyConfigSource GetConfigSource() OVERRIDE {
return PROXY_CONFIG_SOURCE_GSETTINGS;
}
virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
DCHECK(client_);
switch (key) {
case PROXY_MODE:
return GetStringByPath(client_, "mode", result);
case PROXY_AUTOCONF_URL:
return GetStringByPath(client_, "autoconfig-url", result);
case PROXY_HTTP_HOST:
return GetStringByPath(http_client_, "host", result);
case PROXY_HTTPS_HOST:
return GetStringByPath(https_client_, "host", result);
case PROXY_FTP_HOST:
return GetStringByPath(ftp_client_, "host", result);
case PROXY_SOCKS_HOST:
return GetStringByPath(socks_client_, "host", result);
}
return false; // Placate compiler.
}
virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
DCHECK(client_);
switch (key) {
case PROXY_USE_HTTP_PROXY:
// Although there is an "enabled" boolean in http_client_, it is not set
// to true by the proxy config utility. We ignore it and return false.
return false;
case PROXY_USE_SAME_PROXY:
// Similarly, although there is a "use-same-proxy" boolean in client_,
// it is never set to false by the proxy config utility. We ignore it.
return false;
case PROXY_USE_AUTHENTICATION:
// There is also no way to set this in the proxy config utility, but it
// doesn't hurt us to get the actual setting (unlike the two above).
return GetBoolByPath(http_client_, "use-authentication", result);
}
return false; // Placate compiler.
}
virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
DCHECK(client_);
switch (key) {
case PROXY_HTTP_PORT:
return GetIntByPath(http_client_, "port", result);
case PROXY_HTTPS_PORT:
return GetIntByPath(https_client_, "port", result);
case PROXY_FTP_PORT:
return GetIntByPath(ftp_client_, "port", result);
case PROXY_SOCKS_PORT:
return GetIntByPath(socks_client_, "port", result);
}
return false; // Placate compiler.
}
virtual bool GetStringList(StringListSetting key,
std::vector<std::string>* result) OVERRIDE {
DCHECK(client_);
switch (key) {
case PROXY_IGNORE_HOSTS:
return GetStringListByPath(client_, "ignore-hosts", result);
}
return false; // Placate compiler.
}
virtual bool BypassListIsReversed() OVERRIDE {
// This is a KDE-specific setting.
return false;
}
virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
return false;
}
private:
bool GetStringByPath(GSettings* client, const char* key,
std::string* result) {
DCHECK(task_runner_->BelongsToCurrentThread());
gchar* value = libgio_loader_.g_settings_get_string(client, key);
if (!value)
return false;
*result = value;
g_free(value);
return true;
}
bool GetBoolByPath(GSettings* client, const char* key, bool* result) {
DCHECK(task_runner_->BelongsToCurrentThread());
*result = static_cast<bool>(
libgio_loader_.g_settings_get_boolean(client, key));
return true;
}
bool GetIntByPath(GSettings* client, const char* key, int* result) {
DCHECK(task_runner_->BelongsToCurrentThread());
*result = libgio_loader_.g_settings_get_int(client, key);
return true;
}
bool GetStringListByPath(GSettings* client, const char* key,
std::vector<std::string>* result) {
DCHECK(task_runner_->BelongsToCurrentThread());
gchar** list = libgio_loader_.g_settings_get_strv(client, key);
if (!list)
return false;
for (size_t i = 0; list[i]; ++i) {
result->push_back(static_cast<char*>(list[i]));
g_free(list[i]);
}
g_free(list);
return true;
}
// This is the callback from the debounce timer.
void OnDebouncedNotification() {
DCHECK(task_runner_->BelongsToCurrentThread());
CHECK(notify_delegate_);
// Forward to a method on the proxy config service delegate object.
notify_delegate_->OnCheckProxyConfigSettings();
}
void OnChangeNotification() {
// We don't use Reset() because the timer may not yet be running.
// (In that case Stop() is a no-op.)
debounce_timer_.Stop();
debounce_timer_.Start(FROM_HERE,
base::TimeDelta::FromMilliseconds(kDebounceTimeoutMilliseconds),
this, &SettingGetterImplGSettings::OnDebouncedNotification);
}
// gsettings notification callback, dispatched on the default glib main loop.
static void OnGSettingsChangeNotification(GSettings* client, gchar* key,
gpointer user_data) {
VLOG(1) << "gsettings change notification for key " << key;
// We don't track which key has changed, just that something did change.
SettingGetterImplGSettings* setting_getter =
reinterpret_cast<SettingGetterImplGSettings*>(user_data);
setting_getter->OnChangeNotification();
}
GSettings* client_;
GSettings* http_client_;
GSettings* https_client_;
GSettings* ftp_client_;
GSettings* socks_client_;
ProxyConfigServiceLinux::Delegate* notify_delegate_;
base::OneShotTimer<SettingGetterImplGSettings> debounce_timer_;
// Task runner for the thread that we make gsettings calls on. It should
// be the UI thread and all our methods should be called on this
// thread. Only for assertions.
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
LibGioLoader libgio_loader_;
DISALLOW_COPY_AND_ASSIGN(SettingGetterImplGSettings);
};
bool SettingGetterImplGSettings::LoadAndCheckVersion(
base::Environment* env) {
// LoadAndCheckVersion() must be called *before* Init()!
DCHECK(!client_);
// The APIs to query gsettings were introduced after the minimum glib
// version we target, so we can't link directly against them. We load them
// dynamically at runtime, and if they don't exist, return false here. (We
// support linking directly via gyp flags though.) Additionally, even when
// they are present, we do two additional checks to make sure we should use
// them and not gconf. First, we attempt to load the schema for proxy
// settings. Second, we check for the program that was used in older
// versions of GNOME to configure proxy settings, and return false if it
// exists. Some distributions (e.g. Ubuntu 11.04) have the API and schema
// but don't use gsettings for proxy settings, but they do have the old
// binary, so we detect these systems that way.
{
// TODO(phajdan.jr): Redesign the code to load library on different thread.
base::ThreadRestrictions::ScopedAllowIO allow_io;
// Try also without .0 at the end; on some systems this may be required.
if (!libgio_loader_.Load("libgio-2.0.so.0") &&
!libgio_loader_.Load("libgio-2.0.so")) {
VLOG(1) << "Cannot load gio library. Will fall back to gconf.";
return false;
}
}
GSettings* client = NULL;
if (SchemaExists(kProxyGConfSchema)) {
ANNOTATE_SCOPED_MEMORY_LEAK; // http://crbug.com/380782
client = libgio_loader_.g_settings_new(kProxyGConfSchema);
}
if (!client) {
VLOG(1) << "Cannot create gsettings client. Will fall back to gconf.";
return false;
}
g_object_unref(client);
std::string path;
if (!env->GetVar("PATH", &path)) {
LOG(ERROR) << "No $PATH variable. Assuming no gnome-network-properties.";
} else {
// Yes, we're on the UI thread. Yes, we're accessing the file system.
// Sadly, we don't have much choice. We need the proxy settings and we
// need them now, and to figure out where to get them, we have to check
// for this binary. See http://crbug.com/69057 for additional details.
base::ThreadRestrictions::ScopedAllowIO allow_io;
std::vector<std::string> paths;
Tokenize(path, ":", &paths);
for (size_t i = 0; i < paths.size(); ++i) {
base::FilePath file(paths[i]);
if (base::PathExists(file.Append("gnome-network-properties"))) {
VLOG(1) << "Found gnome-network-properties. Will fall back to gconf.";
return false;
}
}
}
VLOG(1) << "All gsettings tests OK. Will get proxy config from gsettings.";
return true;
}
#endif // defined(USE_GIO)
// This is the KDE version that reads kioslaverc and simulates gconf.
// Doing this allows the main Delegate code, as well as the unit tests
// for it, to stay the same - and the settings map fairly well besides.
class SettingGetterImplKDE : public ProxyConfigServiceLinux::SettingGetter,
public base::MessagePumpLibevent::Watcher {
public:
explicit SettingGetterImplKDE(base::Environment* env_var_getter)
: inotify_fd_(-1), notify_delegate_(NULL), indirect_manual_(false),
auto_no_pac_(false), reversed_bypass_list_(false),
env_var_getter_(env_var_getter), file_loop_(NULL) {
// This has to be called on the UI thread (http://crbug.com/69057).
base::ThreadRestrictions::ScopedAllowIO allow_io;
// Derive the location of the kde config dir from the environment.
std::string home;
if (env_var_getter->GetVar("KDEHOME", &home) && !home.empty()) {
// $KDEHOME is set. Use it unconditionally.
kde_config_dir_ = KDEHomeToConfigPath(base::FilePath(home));
} else {
// $KDEHOME is unset. Try to figure out what to use. This seems to be
// the common case on most distributions.
if (!env_var_getter->GetVar(base::env_vars::kHome, &home))
// User has no $HOME? Give up. Later we'll report the failure.
return;
if (base::nix::GetDesktopEnvironment(env_var_getter) ==
base::nix::DESKTOP_ENVIRONMENT_KDE3) {
// KDE3 always uses .kde for its configuration.
base::FilePath kde_path = base::FilePath(home).Append(".kde");
kde_config_dir_ = KDEHomeToConfigPath(kde_path);
} else {
// Some distributions patch KDE4 to use .kde4 instead of .kde, so that
// both can be installed side-by-side. Sadly they don't all do this, and
// they don't always do this: some distributions have started switching
// back as well. So if there is a .kde4 directory, check the timestamps
// of the config directories within and use the newest one.
// Note that we should currently be running in the UI thread, because in
// the gconf version, that is the only thread that can access the proxy
// settings (a gconf restriction). As noted below, the initial read of
// the proxy settings will be done in this thread anyway, so we check
// for .kde4 here in this thread as well.
base::FilePath kde3_path = base::FilePath(home).Append(".kde");
base::FilePath kde3_config = KDEHomeToConfigPath(kde3_path);
base::FilePath kde4_path = base::FilePath(home).Append(".kde4");
base::FilePath kde4_config = KDEHomeToConfigPath(kde4_path);
bool use_kde4 = false;
if (base::DirectoryExists(kde4_path)) {
base::File::Info kde3_info;
base::File::Info kde4_info;
if (base::GetFileInfo(kde4_config, &kde4_info)) {
if (base::GetFileInfo(kde3_config, &kde3_info)) {
use_kde4 = kde4_info.last_modified >= kde3_info.last_modified;
} else {
use_kde4 = true;
}
}
}
if (use_kde4) {
kde_config_dir_ = KDEHomeToConfigPath(kde4_path);
} else {
kde_config_dir_ = KDEHomeToConfigPath(kde3_path);
}
}
}
}
virtual ~SettingGetterImplKDE() {
// inotify_fd_ should have been closed before now, from
// Delegate::OnDestroy(), while running on the file thread. However
// on exiting the process, it may happen that Delegate::OnDestroy()
// task is left pending on the file loop after the loop was quit,
// and pending tasks may then be deleted without being run.
// Here in the KDE version, we can safely close the file descriptor
// anyway. (Not that it really matters; the process is exiting.)
if (inotify_fd_ >= 0)
ShutDown();
DCHECK(inotify_fd_ < 0);
}
virtual bool Init(base::SingleThreadTaskRunner* glib_thread_task_runner,
base::MessageLoopForIO* file_loop) OVERRIDE {
// This has to be called on the UI thread (http://crbug.com/69057).
base::ThreadRestrictions::ScopedAllowIO allow_io;
DCHECK(inotify_fd_ < 0);
inotify_fd_ = inotify_init();
if (inotify_fd_ < 0) {
PLOG(ERROR) << "inotify_init failed";
return false;
}
int flags = fcntl(inotify_fd_, F_GETFL);
if (fcntl(inotify_fd_, F_SETFL, flags | O_NONBLOCK) < 0) {
PLOG(ERROR) << "fcntl failed";
close(inotify_fd_);
inotify_fd_ = -1;
return false;
}
file_loop_ = file_loop;
// The initial read is done on the current thread, not |file_loop_|,
// since we will need to have it for SetUpAndFetchInitialConfig().
UpdateCachedSettings();
return true;
}
virtual void ShutDown() OVERRIDE {
if (inotify_fd_ >= 0) {
ResetCachedSettings();
inotify_watcher_.StopWatchingFileDescriptor();
close(inotify_fd_);
inotify_fd_ = -1;
}
}
virtual bool SetUpNotifications(
ProxyConfigServiceLinux::Delegate* delegate) OVERRIDE {
DCHECK(inotify_fd_ >= 0);
DCHECK(base::MessageLoop::current() == file_loop_);
// We can't just watch the kioslaverc file directly, since KDE will write
// a new copy of it and then rename it whenever settings are changed and
// inotify watches inodes (so we'll be watching the old deleted file after
// the first change, and it will never change again). So, we watch the
// directory instead. We then act only on changes to the kioslaverc entry.
if (inotify_add_watch(inotify_fd_, kde_config_dir_.value().c_str(),
IN_MODIFY | IN_MOVED_TO) < 0)
return false;
notify_delegate_ = delegate;
if (!file_loop_->WatchFileDescriptor(inotify_fd_,
true,
base::MessageLoopForIO::WATCH_READ,
&inotify_watcher_,
this))
return false;
// Simulate a change to avoid possibly losing updates before this point.
OnChangeNotification();
return true;
}
virtual base::SingleThreadTaskRunner* GetNotificationTaskRunner() OVERRIDE {
return file_loop_ ? file_loop_->message_loop_proxy().get() : NULL;
}
// Implement base::MessagePumpLibevent::Watcher.
virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE {
DCHECK_EQ(fd, inotify_fd_);
DCHECK(base::MessageLoop::current() == file_loop_);
OnChangeNotification();
}
virtual void OnFileCanWriteWithoutBlocking(int fd) OVERRIDE {
NOTREACHED();
}
virtual ProxyConfigSource GetConfigSource() OVERRIDE {
return PROXY_CONFIG_SOURCE_KDE;
}
virtual bool GetString(StringSetting key, std::string* result) OVERRIDE {
string_map_type::iterator it = string_table_.find(key);
if (it == string_table_.end())
return false;
*result = it->second;
return true;
}
virtual bool GetBool(BoolSetting key, bool* result) OVERRIDE {
// We don't ever have any booleans.
return false;
}
virtual bool GetInt(IntSetting key, int* result) OVERRIDE {
// We don't ever have any integers. (See AddProxy() below about ports.)
return false;
}
virtual bool GetStringList(StringListSetting key,
std::vector<std::string>* result) OVERRIDE {
strings_map_type::iterator it = strings_table_.find(key);
if (it == strings_table_.end())
return false;
*result = it->second;
return true;
}
virtual bool BypassListIsReversed() OVERRIDE {
return reversed_bypass_list_;
}
virtual bool MatchHostsUsingSuffixMatching() OVERRIDE {
return true;
}
private:
void ResetCachedSettings() {
string_table_.clear();
strings_table_.clear();
indirect_manual_ = false;
auto_no_pac_ = false;
reversed_bypass_list_ = false;
}
base::FilePath KDEHomeToConfigPath(const base::FilePath& kde_home) {
return kde_home.Append("share").Append("config");
}
void AddProxy(StringSetting host_key, const std::string& value) {
if (value.empty() || value.substr(0, 3) == "//:")
// No proxy.
return;
size_t space = value.find(' ');
if (space != std::string::npos) {
// Newer versions of KDE use a space rather than a colon to separate the
// port number from the hostname. If we find this, we need to convert it.
std::string fixed = value;
fixed[space] = ':';
string_table_[host_key] = fixed;
} else {
// We don't need to parse the port number out; GetProxyFromSettings()
// would only append it right back again. So we just leave the port
// number right in the host string.
string_table_[host_key] = value;
}
}
void AddHostList(StringListSetting key, const std::string& value) {
std::vector<std::string> tokens;
base::StringTokenizer tk(value, ", ");
while (tk.GetNext()) {
std::string token = tk.token();
if (!token.empty())
tokens.push_back(token);
}
strings_table_[key] = tokens;
}
void AddKDESetting(const std::string& key, const std::string& value) {
if (key == "ProxyType") {
const char* mode = "none";
indirect_manual_ = false;
auto_no_pac_ = false;
int int_value;
base::StringToInt(value, &int_value);
switch (int_value) {
case 0: // No proxy, or maybe kioslaverc syntax error.
break;
case 1: // Manual configuration.
mode = "manual";
break;
case 2: // PAC URL.
mode = "auto";
break;
case 3: // WPAD.
mode = "auto";
auto_no_pac_ = true;
break;
case 4: // Indirect manual via environment variables.
mode = "manual";
indirect_manual_ = true;
break;
}
string_table_[PROXY_MODE] = mode;
} else if (key == "Proxy Config Script") {
string_table_[PROXY_AUTOCONF_URL] = value;
} else if (key == "httpProxy") {
AddProxy(PROXY_HTTP_HOST, value);
} else if (key == "httpsProxy") {
AddProxy(PROXY_HTTPS_HOST, value);
} else if (key == "ftpProxy") {
AddProxy(PROXY_FTP_HOST, value);
} else if (key == "socksProxy") {
// Older versions of KDE configure SOCKS in a weird way involving
// LD_PRELOAD and a library that intercepts network calls to SOCKSify
// them. We don't support it. KDE 4.8 added a proper SOCKS setting.
AddProxy(PROXY_SOCKS_HOST, value);
} else if (key == "ReversedException") {
// We count "true" or any nonzero number as true, otherwise false.
// Note that if the value is not actually numeric StringToInt()
// will return 0, which we count as false.
int int_value;
base::StringToInt(value, &int_value);
reversed_bypass_list_ = (value == "true" || int_value);
} else if (key == "NoProxyFor") {
AddHostList(PROXY_IGNORE_HOSTS, value);
} else if (key == "AuthMode") {
// Check for authentication, just so we can warn.
int mode;
base::StringToInt(value, &mode);
if (mode) {
// ProxyConfig does not support authentication parameters, but
// Chrome will prompt for the password later. So we ignore this.
LOG(WARNING) <<
"Proxy authentication parameters ignored, see bug 16709";
}
}
}
void ResolveIndirect(StringSetting key) {
string_map_type::iterator it = string_table_.find(key);
if (it != string_table_.end()) {
std::string value;
if (env_var_getter_->GetVar(it->second.c_str(), &value))
it->second = value;
else
string_table_.erase(it);
}
}
void ResolveIndirectList(StringListSetting key) {
strings_map_type::iterator it = strings_table_.find(key);
if (it != strings_table_.end()) {
std::string value;
if (!it->second.empty() &&
env_var_getter_->GetVar(it->second[0].c_str(), &value))
AddHostList(key, value);
else
strings_table_.erase(it);
}
}
// The settings in kioslaverc could occur in any order, but some affect
// others. Rather than read the whole file in and then query them in an
// order that allows us to handle that, we read the settings in whatever
// order they occur and do any necessary tweaking after we finish.
void ResolveModeEffects() {
if (indirect_manual_) {
ResolveIndirect(PROXY_HTTP_HOST);
ResolveIndirect(PROXY_HTTPS_HOST);
ResolveIndirect(PROXY_FTP_HOST);
ResolveIndirectList(PROXY_IGNORE_HOSTS);
}
if (auto_no_pac_) {
// Remove the PAC URL; we're not supposed to use it.
string_table_.erase(PROXY_AUTOCONF_URL);
}
}
// Reads kioslaverc one line at a time and calls AddKDESetting() to add
// each relevant name-value pair to the appropriate value table.
void UpdateCachedSettings() {
base::FilePath kioslaverc = kde_config_dir_.Append("kioslaverc");
base::ScopedFILE input(base::OpenFile(kioslaverc, "r"));
if (!input.get())
return;
ResetCachedSettings();
bool in_proxy_settings = false;
bool line_too_long = false;
char line[BUFFER_SIZE];
// fgets() will return NULL on EOF or error.
while (fgets(line, sizeof(line), input.get())) {
// fgets() guarantees the line will be properly terminated.
size_t length = strlen(line);
if (!length)
continue;
// This should be true even with CRLF endings.
if (line[length - 1] != '\n') {
line_too_long = true;
continue;
}
if (line_too_long) {
// The previous line had no line ending, but this done does. This is
// the end of the line that was too long, so warn here and skip it.
LOG(WARNING) << "skipped very long line in " << kioslaverc.value();
line_too_long = false;
continue;
}
// Remove the LF at the end, and the CR if there is one.
line[--length] = '\0';
if (length && line[length - 1] == '\r')
line[--length] = '\0';
// Now parse the line.
if (line[0] == '[') {
// Switching sections. All we care about is whether this is
// the (a?) proxy settings section, for both KDE3 and KDE4.
in_proxy_settings = !strncmp(line, "[Proxy Settings]", 16);
} else if (in_proxy_settings) {
// A regular line, in the (a?) proxy settings section.
char* split = strchr(line, '=');
// Skip this line if it does not contain an = sign.
if (!split)
continue;
// Split the line on the = and advance |split|.
*(split++) = 0;
std::string key = line;
std::string value = split;
base::TrimWhitespaceASCII(key, base::TRIM_ALL, &key);
base::TrimWhitespaceASCII(value, base::TRIM_ALL, &value);
// Skip this line if the key name is empty.
if (key.empty())
continue;
// Is the value name localized?
if (key[key.length() - 1] == ']') {
// Find the matching bracket.
length = key.rfind('[');
// Skip this line if the localization indicator is malformed.
if (length == std::string::npos)
continue;
// Trim the localization indicator off.
key.resize(length);
// Remove any resulting trailing whitespace.
base::TrimWhitespaceASCII(key, base::TRIM_TRAILING, &key);
// Skip this line if the key name is now empty.
if (key.empty())
continue;
}
// Now fill in the tables.
AddKDESetting(key, value);
}
}
if (ferror(input.get()))
LOG(ERROR) << "error reading " << kioslaverc.value();
ResolveModeEffects();
}
// This is the callback from the debounce timer.
void OnDebouncedNotification() {
DCHECK(base::MessageLoop::current() == file_loop_);
VLOG(1) << "inotify change notification for kioslaverc";
UpdateCachedSettings();
CHECK(notify_delegate_);
// Forward to a method on the proxy config service delegate object.
notify_delegate_->OnCheckProxyConfigSettings();
}
// Called by OnFileCanReadWithoutBlocking() on the file thread. Reads
// from the inotify file descriptor and starts up a debounce timer if
// an event for kioslaverc is seen.
void OnChangeNotification() {
DCHECK_GE(inotify_fd_, 0);
DCHECK(base::MessageLoop::current() == file_loop_);
char event_buf[(sizeof(inotify_event) + NAME_MAX + 1) * 4];
bool kioslaverc_touched = false;
ssize_t r;
while ((r = read(inotify_fd_, event_buf, sizeof(event_buf))) > 0) {
// inotify returns variable-length structures, which is why we have
// this strange-looking loop instead of iterating through an array.
char* event_ptr = event_buf;
while (event_ptr < event_buf + r) {
inotify_event* event = reinterpret_cast<inotify_event*>(event_ptr);
// The kernel always feeds us whole events.
CHECK_LE(event_ptr + sizeof(inotify_event), event_buf + r);
CHECK_LE(event->name + event->len, event_buf + r);
if (!strcmp(event->name, "kioslaverc"))
kioslaverc_touched = true;
// Advance the pointer just past the end of the filename.
event_ptr = event->name + event->len;
}
// We keep reading even if |kioslaverc_touched| is true to drain the
// inotify event queue.
}
if (!r)
// Instead of returning -1 and setting errno to EINVAL if there is not
// enough buffer space, older kernels (< 2.6.21) return 0. Simulate the
// new behavior (EINVAL) so we can reuse the code below.
errno = EINVAL;
if (errno != EAGAIN) {
PLOG(WARNING) << "error reading inotify file descriptor";
if (errno == EINVAL) {
// Our buffer is not large enough to read the next event. This should
// not happen (because its size is calculated to always be sufficiently
// large), but if it does we'd warn continuously since |inotify_fd_|
// would be forever ready to read. Close it and stop watching instead.
LOG(ERROR) << "inotify failure; no longer watching kioslaverc!";
inotify_watcher_.StopWatchingFileDescriptor();
close(inotify_fd_);
inotify_fd_ = -1;
}
}
if (kioslaverc_touched) {
// We don't use Reset() because the timer may not yet be running.
// (In that case Stop() is a no-op.)
debounce_timer_.Stop();
debounce_timer_.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
kDebounceTimeoutMilliseconds), this,
&SettingGetterImplKDE::OnDebouncedNotification);
}
}
typedef std::map<StringSetting, std::string> string_map_type;
typedef std::map<StringListSetting,
std::vector<std::string> > strings_map_type;
int inotify_fd_;
base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
ProxyConfigServiceLinux::Delegate* notify_delegate_;
base::OneShotTimer<SettingGetterImplKDE> debounce_timer_;
base::FilePath kde_config_dir_;
bool indirect_manual_;
bool auto_no_pac_;
bool reversed_bypass_list_;
// We don't own |env_var_getter_|. It's safe to hold a pointer to it, since
// both it and us are owned by ProxyConfigServiceLinux::Delegate, and have the
// same lifetime.
base::Environment* env_var_getter_;
// We cache these settings whenever we re-read the kioslaverc file.
string_map_type string_table_;
strings_map_type strings_table_;
// Message loop of the file thread, for reading kioslaverc. If NULL,
// just read it directly (for testing). We also handle inotify events
// on this thread.
base::MessageLoopForIO* file_loop_;
DISALLOW_COPY_AND_ASSIGN(SettingGetterImplKDE);
};
} // namespace
bool ProxyConfigServiceLinux::Delegate::GetProxyFromSettings(
SettingGetter::StringSetting host_key,
ProxyServer* result_server) {
std::string host;
if (!setting_getter_->GetString(host_key, &host) || host.empty()) {
// Unset or empty.
return false;
}
// Check for an optional port.
int port = 0;
SettingGetter::IntSetting port_key =
SettingGetter::HostSettingToPortSetting(host_key);
setting_getter_->GetInt(port_key, &port);
if (port != 0) {
// If a port is set and non-zero:
host += ":" + base::IntToString(port);
}
// gconf settings do not appear to distinguish between SOCKS version. We
// default to version 5. For more information on this policy decision, see:
// http://code.google.com/p/chromium/issues/detail?id=55912#c2
ProxyServer::Scheme scheme = (host_key == SettingGetter::PROXY_SOCKS_HOST) ?
ProxyServer::SCHEME_SOCKS5 : ProxyServer::SCHEME_HTTP;
host = FixupProxyHostScheme(scheme, host);
ProxyServer proxy_server = ProxyServer::FromURI(host,
ProxyServer::SCHEME_HTTP);
if (proxy_server.is_valid()) {
*result_server = proxy_server;
return true;
}
return false;
}
bool ProxyConfigServiceLinux::Delegate::GetConfigFromSettings(
ProxyConfig* config) {
std::string mode;
if (!setting_getter_->GetString(SettingGetter::PROXY_MODE, &mode)) {
// We expect this to always be set, so if we don't see it then we
// probably have a gconf/gsettings problem, and so we don't have a valid
// proxy config.
return false;
}
if (mode == "none") {
// Specifically specifies no proxy.
return true;
}
if (mode == "auto") {
// Automatic proxy config.
std::string pac_url_str;
if (setting_getter_->GetString(SettingGetter::PROXY_AUTOCONF_URL,
&pac_url_str)) {
if (!pac_url_str.empty()) {
// If the PAC URL is actually a file path, then put file:// in front.
if (pac_url_str[0] == '/')
pac_url_str = "file://" + pac_url_str;
GURL pac_url(pac_url_str);
if (!pac_url.is_valid())
return false;
config->set_pac_url(pac_url);
return true;
}
}
config->set_auto_detect(true);
return true;
}
if (mode != "manual") {
// Mode is unrecognized.
return false;
}
bool use_http_proxy;
if (setting_getter_->GetBool(SettingGetter::PROXY_USE_HTTP_PROXY,
&use_http_proxy)
&& !use_http_proxy) {
// Another master switch for some reason. If set to false, then no
// proxy. But we don't panic if the key doesn't exist.
return true;
}
bool same_proxy = false;
// Indicates to use the http proxy for all protocols. This one may
// not exist (presumably on older versions); we assume false in that
// case.
setting_getter_->GetBool(SettingGetter::PROXY_USE_SAME_PROXY,
&same_proxy);
ProxyServer proxy_for_http;
ProxyServer proxy_for_https;
ProxyServer proxy_for_ftp;
ProxyServer socks_proxy; // (socks)
// This counts how many of the above ProxyServers were defined and valid.
size_t num_proxies_specified = 0;
// Extract the per-scheme proxies. If we failed to parse it, or no proxy was
// specified for the scheme, then the resulting ProxyServer will be invalid.
if (GetProxyFromSettings(SettingGetter::PROXY_HTTP_HOST, &proxy_for_http))
num_proxies_specified++;
if (GetProxyFromSettings(SettingGetter::PROXY_HTTPS_HOST, &proxy_for_https))
num_proxies_specified++;
if (GetProxyFromSettings(SettingGetter::PROXY_FTP_HOST, &proxy_for_ftp))
num_proxies_specified++;
if (GetProxyFromSettings(SettingGetter::PROXY_SOCKS_HOST, &socks_proxy))
num_proxies_specified++;
if (same_proxy) {
if (proxy_for_http.is_valid()) {
// Use the http proxy for all schemes.
config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
config->proxy_rules().single_proxies.SetSingleProxyServer(proxy_for_http);
}
} else if (num_proxies_specified > 0) {
if (socks_proxy.is_valid() && num_proxies_specified == 1) {
// If the only proxy specified was for SOCKS, use it for all schemes.
config->proxy_rules().type = ProxyConfig::ProxyRules::TYPE_SINGLE_PROXY;
config->proxy_rules().single_proxies.SetSingleProxyServer(socks_proxy);
} else {
// Otherwise use the indicated proxies per-scheme.
config->proxy_rules().type =
ProxyConfig::ProxyRules::TYPE_PROXY_PER_SCHEME;
config->proxy_rules().proxies_for_http.
SetSingleProxyServer(proxy_for_http);
config->proxy_rules().proxies_for_https.
SetSingleProxyServer(proxy_for_https);
config->proxy_rules().proxies_for_ftp.SetSingleProxyServer(proxy_for_ftp);
config->proxy_rules().fallback_proxies.SetSingleProxyServer(socks_proxy);
}
}
if (config->proxy_rules().empty()) {
// Manual mode but we couldn't parse any rules.
return false;
}
// Check for authentication, just so we can warn.
bool use_auth = false;
setting_getter_->GetBool(SettingGetter::PROXY_USE_AUTHENTICATION,
&use_auth);
if (use_auth) {
// ProxyConfig does not support authentication parameters, but
// Chrome will prompt for the password later. So we ignore
// /system/http_proxy/*auth* settings.
LOG(WARNING) << "Proxy authentication parameters ignored, see bug 16709";
}
// Now the bypass list.
std::vector<std::string> ignore_hosts_list;
config->proxy_rules().bypass_rules.Clear();
if (setting_getter_->GetStringList(SettingGetter::PROXY_IGNORE_HOSTS,
&ignore_hosts_list)) {
std::vector<std::string>::const_iterator it(ignore_hosts_list.begin());
for (; it != ignore_hosts_list.end(); ++it) {
if (setting_getter_->MatchHostsUsingSuffixMatching()) {
config->proxy_rules().bypass_rules.
AddRuleFromStringUsingSuffixMatching(*it);
} else {
config->proxy_rules().bypass_rules.AddRuleFromString(*it);
}
}
}
// Note that there are no settings with semantics corresponding to
// bypass of local names in GNOME. In KDE, "<local>" is supported
// as a hostname rule.
// KDE allows one to reverse the bypass rules.
config->proxy_rules().reverse_bypass =
setting_getter_->BypassListIsReversed();
return true;
}
ProxyConfigServiceLinux::Delegate::Delegate(base::Environment* env_var_getter)
: env_var_getter_(env_var_getter) {
// Figure out which SettingGetterImpl to use, if any.
switch (base::nix::GetDesktopEnvironment(env_var_getter)) {
case base::nix::DESKTOP_ENVIRONMENT_GNOME:
case base::nix::DESKTOP_ENVIRONMENT_UNITY:
#if defined(USE_GIO)
{
scoped_ptr<SettingGetterImplGSettings> gs_getter(
new SettingGetterImplGSettings());
// We have to load symbols and check the GNOME version in use to decide
// if we should use the gsettings getter. See LoadAndCheckVersion().
if (gs_getter->LoadAndCheckVersion(env_var_getter))
setting_getter_.reset(gs_getter.release());
}
#endif
#if defined(USE_GCONF)
// Fall back on gconf if gsettings is unavailable or incorrect.
if (!setting_getter_.get())
setting_getter_.reset(new SettingGetterImplGConf());
#endif
break;
case base::nix::DESKTOP_ENVIRONMENT_KDE3:
case base::nix::DESKTOP_ENVIRONMENT_KDE4:
setting_getter_.reset(new SettingGetterImplKDE(env_var_getter));
break;
case base::nix::DESKTOP_ENVIRONMENT_XFCE:
case base::nix::DESKTOP_ENVIRONMENT_OTHER:
break;
}
}
ProxyConfigServiceLinux::Delegate::Delegate(
base::Environment* env_var_getter, SettingGetter* setting_getter)
: env_var_getter_(env_var_getter), setting_getter_(setting_getter) {
}
void ProxyConfigServiceLinux::Delegate::SetUpAndFetchInitialConfig(
base::SingleThreadTaskRunner* glib_thread_task_runner,
base::SingleThreadTaskRunner* io_thread_task_runner,
base::MessageLoopForIO* file_loop) {
// We should be running on the default glib main loop thread right
// now. gconf can only be accessed from this thread.
DCHECK(glib_thread_task_runner->BelongsToCurrentThread());
glib_thread_task_runner_ = glib_thread_task_runner;
io_thread_task_runner_ = io_thread_task_runner;
// If we are passed a NULL |io_thread_task_runner| or |file_loop|,
// then we don't set up proxy setting change notifications. This
// should not be the usual case but is intended to simplify test
// setups.
if (!io_thread_task_runner_.get() || !file_loop)
VLOG(1) << "Monitoring of proxy setting changes is disabled";
// Fetch and cache the current proxy config. The config is left in
// cached_config_, where GetLatestProxyConfig() running on the IO thread
// will expect to find it. This is safe to do because we return
// before this ProxyConfigServiceLinux is passed on to
// the ProxyService.
// Note: It would be nice to prioritize environment variables
// and only fall back to gconf if env vars were unset. But
// gnome-terminal "helpfully" sets http_proxy and no_proxy, and it
// does so even if the proxy mode is set to auto, which would
// mislead us.
bool got_config = false;
if (setting_getter_.get() &&
setting_getter_->Init(glib_thread_task_runner, file_loop) &&
GetConfigFromSettings(&cached_config_)) {
cached_config_.set_id(1); // Mark it as valid.
cached_config_.set_source(setting_getter_->GetConfigSource());
VLOG(1) << "Obtained proxy settings from "
<< ProxyConfigSourceToString(cached_config_.source());
// If gconf proxy mode is "none", meaning direct, then we take
// that to be a valid config and will not check environment
// variables. The alternative would have been to look for a proxy
// whereever we can find one.
got_config = true;
// Keep a copy of the config for use from this thread for
// comparison with updated settings when we get notifications.
reference_config_ = cached_config_;
reference_config_.set_id(1); // Mark it as valid.
// We only set up notifications if we have IO and file loops available.
// We do this after getting the initial configuration so that we don't have
// to worry about cancelling it if the initial fetch above fails. Note that
// setting up notifications has the side effect of simulating a change, so
// that we won't lose any updates that may have happened after the initial
// fetch and before setting up notifications. We'll detect the common case
// of no changes in OnCheckProxyConfigSettings() (or sooner) and ignore it.
if (io_thread_task_runner && file_loop) {
scoped_refptr<base::SingleThreadTaskRunner> required_loop =
setting_getter_->GetNotificationTaskRunner();
if (!required_loop.get() || required_loop->BelongsToCurrentThread()) {
// In this case we are already on an acceptable thread.
SetUpNotifications();
} else {
// Post a task to set up notifications. We don't wait for success.
required_loop->PostTask(FROM_HERE, base::Bind(
&ProxyConfigServiceLinux::Delegate::SetUpNotifications, this));
}
}
}
if (!got_config) {
// We fall back on environment variables.
//
// Consulting environment variables doesn't need to be done from the
// default glib main loop, but it's a tiny enough amount of work.
if (GetConfigFromEnv(&cached_config_)) {
cached_config_.set_source(PROXY_CONFIG_SOURCE_ENV);
cached_config_.set_id(1); // Mark it as valid.
VLOG(1) << "Obtained proxy settings from environment variables";
}
}
}
// Depending on the SettingGetter in use, this method will be called
// on either the UI thread (GConf) or the file thread (KDE).
void ProxyConfigServiceLinux::Delegate::SetUpNotifications() {
scoped_refptr<base::SingleThreadTaskRunner> required_loop =
setting_getter_->GetNotificationTaskRunner();
DCHECK(!required_loop.get() || required_loop->BelongsToCurrentThread());
if (!setting_getter_->SetUpNotifications(this))
LOG(ERROR) << "Unable to set up proxy configuration change notifications";
}
void ProxyConfigServiceLinux::Delegate::AddObserver(Observer* observer) {
observers_.AddObserver(observer);
}
void ProxyConfigServiceLinux::Delegate::RemoveObserver(Observer* observer) {
observers_.RemoveObserver(observer);
}
ProxyConfigService::ConfigAvailability
ProxyConfigServiceLinux::Delegate::GetLatestProxyConfig(
ProxyConfig* config) {
// This is called from the IO thread.
DCHECK(!io_thread_task_runner_.get() ||
io_thread_task_runner_->BelongsToCurrentThread());
// Simply return the last proxy configuration that glib_default_loop
// notified us of.
if (cached_config_.is_valid()) {
*config = cached_config_;
} else {
*config = ProxyConfig::CreateDirect();
config->set_source(PROXY_CONFIG_SOURCE_SYSTEM_FAILED);
}
// We return CONFIG_VALID to indicate that *config was filled in. It is always
// going to be available since we initialized eagerly on the UI thread.
// TODO(eroman): do lazy initialization instead, so we no longer need
// to construct ProxyConfigServiceLinux on the UI thread.
// In which case, we may return false here.
return CONFIG_VALID;
}
// Depending on the SettingGetter in use, this method will be called
// on either the UI thread (GConf) or the file thread (KDE).
void ProxyConfigServiceLinux::Delegate::OnCheckProxyConfigSettings() {
scoped_refptr<base::SingleThreadTaskRunner> required_loop =
setting_getter_->GetNotificationTaskRunner();
DCHECK(!required_loop.get() || required_loop->BelongsToCurrentThread());
ProxyConfig new_config;
bool valid = GetConfigFromSettings(&new_config);
if (valid)
new_config.set_id(1); // mark it as valid
// See if it is different from what we had before.
if (new_config.is_valid() != reference_config_.is_valid() ||
!new_config.Equals(reference_config_)) {
// Post a task to the IO thread with the new configuration, so it can
// update |cached_config_|.
io_thread_task_runner_->PostTask(FROM_HERE, base::Bind(
&ProxyConfigServiceLinux::Delegate::SetNewProxyConfig,
this, new_config));
// Update the thread-private copy in |reference_config_| as well.
reference_config_ = new_config;
} else {
VLOG(1) << "Detected no-op change to proxy settings. Doing nothing.";
}
}
void ProxyConfigServiceLinux::Delegate::SetNewProxyConfig(
const ProxyConfig& new_config) {
DCHECK(io_thread_task_runner_->BelongsToCurrentThread());
VLOG(1) << "Proxy configuration changed";
cached_config_ = new_config;
FOR_EACH_OBSERVER(
Observer, observers_,
OnProxyConfigChanged(new_config, ProxyConfigService::CONFIG_VALID));
}
void ProxyConfigServiceLinux::Delegate::PostDestroyTask() {
if (!setting_getter_.get())
return;
scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
setting_getter_->GetNotificationTaskRunner();
if (!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread()) {
// Already on the right thread, call directly.
// This is the case for the unittests.
OnDestroy();
} else {
// Post to shutdown thread. Note that on browser shutdown, we may quit
// this MessageLoop and exit the program before ever running this.
shutdown_loop->PostTask(FROM_HERE, base::Bind(
&ProxyConfigServiceLinux::Delegate::OnDestroy, this));
}
}
void ProxyConfigServiceLinux::Delegate::OnDestroy() {
scoped_refptr<base::SingleThreadTaskRunner> shutdown_loop =
setting_getter_->GetNotificationTaskRunner();
DCHECK(!shutdown_loop.get() || shutdown_loop->BelongsToCurrentThread());
setting_getter_->ShutDown();
}
ProxyConfigServiceLinux::ProxyConfigServiceLinux()
: delegate_(new Delegate(base::Environment::Create())) {
}
ProxyConfigServiceLinux::~ProxyConfigServiceLinux() {
delegate_->PostDestroyTask();
}
ProxyConfigServiceLinux::ProxyConfigServiceLinux(
base::Environment* env_var_getter)
: delegate_(new Delegate(env_var_getter)) {
}
ProxyConfigServiceLinux::ProxyConfigServiceLinux(
base::Environment* env_var_getter, SettingGetter* setting_getter)
: delegate_(new Delegate(env_var_getter, setting_getter)) {
}
void ProxyConfigServiceLinux::AddObserver(Observer* observer) {
delegate_->AddObserver(observer);
}
void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
delegate_->RemoveObserver(observer);
}
ProxyConfigService::ConfigAvailability
ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
return delegate_->GetLatestProxyConfig(config);
}
} // namespace net