src/chrome/browser/chromeos/proxy_cros_settings_parser.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/proxy_cros_settings_parser.h"
   6
   7 #include "base/strings/string_util.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/chromeos/ui_proxy_config.h"
  10 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
  11
  12 namespace chromeos {
  13
  14 // Common prefix of all proxy prefs.
  15 const char kProxyPrefsPrefix[] = "cros.session.proxy";
  16
  17 // Names of proxy preferences.
  18 const char kProxyPacUrl[]         = "cros.session.proxy.pacurl";
  19 const char kProxySingleHttp[]     = "cros.session.proxy.singlehttp";
  20 const char kProxySingleHttpPort[] = "cros.session.proxy.singlehttpport";
  21 const char kProxyHttpUrl[]        = "cros.session.proxy.httpurl";
  22 const char kProxyHttpPort[]       = "cros.session.proxy.httpport";
  23 const char kProxyHttpsUrl[]       = "cros.session.proxy.httpsurl";
  24 const char kProxyHttpsPort[]      = "cros.session.proxy.httpsport";
  25 const char kProxyType[]           = "cros.session.proxy.type";
  26 const char kProxySingle[]         = "cros.session.proxy.single";
  27 const char kProxyFtpUrl[]         = "cros.session.proxy.ftpurl";
  28 const char kProxyFtpPort[]        = "cros.session.proxy.ftpport";
  29 const char kProxySocks[]          = "cros.session.proxy.socks";
  30 const char kProxySocksPort[]      = "cros.session.proxy.socksport";
  31 const char kProxyIgnoreList[]     = "cros.session.proxy.ignorelist";
  32 const char kProxyUsePacUrl[]      = "cros.session.proxy.usepacurl";
  33
  34 const char* const kProxySettings[] = {
  35   kProxyPacUrl,
  36   kProxySingleHttp,
  37   kProxySingleHttpPort,
  38   kProxyHttpUrl,
  39   kProxyHttpPort,
  40   kProxyHttpsUrl,
  41   kProxyHttpsPort,
  42   kProxyType,
  43   kProxySingle,
  44   kProxyFtpUrl,
  45   kProxyFtpPort,
  46   kProxySocks,
  47   kProxySocksPort,
  48   kProxyIgnoreList,
  49   kProxyUsePacUrl,
  50 };
  51
  52 // We have to explicitly export this because the arraysize macro doesn't like
  53 // extern arrays as their size is not known on compile time.
  54 const size_t kProxySettingsCount = arraysize(kProxySettings);
  55
  56 namespace {
  57
  58 base::Value* CreateServerHostValue(const UIProxyConfig::ManualProxy& proxy) {
  59   return proxy.server.is_valid() ?
  60          new base::StringValue(proxy.server.host_port_pair().host()) :
  61          NULL;
  62 }
  63
  64 base::Value* CreateServerPortValue(const UIProxyConfig::ManualProxy& proxy) {
  65   return proxy.server.is_valid()
  66              ? new base::FundamentalValue(proxy.server.host_port_pair().port())
  67              : NULL;
  68 }
  69
  70 net::ProxyServer CreateProxyServer(std::string host,
  71                                    uint16 port,
  72                                    net::ProxyServer::Scheme scheme) {
  73   if (host.empty() && port == 0)
  74     return net::ProxyServer();
  75   uint16 default_port = net::ProxyServer::GetDefaultPortForScheme(scheme);
  76   net::HostPortPair host_port_pair;
  77   // Check if host is a valid URL or a string of valid format <server>::<port>.
  78   GURL url(host);
  79   if (url.is_valid())  // See if host is URL.
  80     host_port_pair = net::HostPortPair::FromURL(url);
  81   if (host_port_pair.host().empty())  // See if host is <server>::<port>.
  82     host_port_pair = net::HostPortPair::FromString(host);
  83   if (host_port_pair.host().empty())  // Host is not URL or <server>::<port>.
  84     host_port_pair = net::HostPortPair(host, port);
  85   if (host_port_pair.port() == 0)  // No port in host, use default.
  86     host_port_pair.set_port(default_port);
  87   return net::ProxyServer(scheme, host_port_pair);
  88 }
  89
  90 net::ProxyServer CreateProxyServerFromHost(
  91     const std::string& host,
  92     const UIProxyConfig::ManualProxy& proxy,
  93     net::ProxyServer::Scheme scheme) {
  94   uint16 port = 0;
  95   if (proxy.server.is_valid())
  96     port = proxy.server.host_port_pair().port();
  97   return CreateProxyServer(host, port, scheme);
  98 }
  99
 100 net::ProxyServer CreateProxyServerFromPort(
 101     uint16 port,
 102     const UIProxyConfig::ManualProxy& proxy,
 103     net::ProxyServer::Scheme scheme) {
 104   std::string host;
 105   if (proxy.server.is_valid())
 106     host = proxy.server.host_port_pair().host();
 107   return CreateProxyServer(host, port, scheme);
 108 }
 109
 110 }  // namespace
 111
 112 namespace proxy_cros_settings_parser {
 113
 114 bool IsProxyPref(const std::string& path) {
 115   return StartsWithASCII(path, kProxyPrefsPrefix, true);
 116 }
 117
 118 void SetProxyPrefValue(const std::string& path,
 119                        const base::Value* in_value,
 120                        UIProxyConfigService* config_service) {
 121   if (!in_value) {
 122     NOTREACHED();
 123     return;
 124   }
 125
 126   // Retrieve proxy config.
 127   UIProxyConfig config;
 128   config_service->GetProxyConfig(&config);
 129
 130   if (path == kProxyPacUrl) {
 131     std::string val;
 132     if (in_value->GetAsString(&val)) {
 133       GURL url(val);
 134       if (url.is_valid())
 135         config.SetPacUrl(url);
 136       else
 137         config.mode = UIProxyConfig::MODE_AUTO_DETECT;
 138     }
 139   } else if (path == kProxySingleHttp) {
 140     std::string val;
 141     if (in_value->GetAsString(&val)) {
 142       config.SetSingleProxy(CreateProxyServerFromHost(
 143           val, config.single_proxy, net::ProxyServer::SCHEME_HTTP));
 144     }
 145   } else if (path == kProxySingleHttpPort) {
 146     int val;
 147     if (in_value->GetAsInteger(&val)) {
 148       config.SetSingleProxy(CreateProxyServerFromPort(
 149           val, config.single_proxy, net::ProxyServer::SCHEME_HTTP));
 150     }
 151   } else if (path == kProxyHttpUrl) {
 152     std::string val;
 153     if (in_value->GetAsString(&val)) {
 154       config.SetProxyForScheme(
 155           "http", CreateProxyServerFromHost(
 156               val, config.http_proxy, net::ProxyServer::SCHEME_HTTP));
 157     }
 158   } else if (path == kProxyHttpPort) {
 159     int val;
 160     if (in_value->GetAsInteger(&val)) {
 161       config.SetProxyForScheme(
 162           "http", CreateProxyServerFromPort(
 163               val, config.http_proxy, net::ProxyServer::SCHEME_HTTP));
 164     }
 165   } else if (path == kProxyHttpsUrl) {
 166     std::string val;
 167     if (in_value->GetAsString(&val)) {
 168       config.SetProxyForScheme(
 169           "https", CreateProxyServerFromHost(
 170               val, config.https_proxy, net::ProxyServer::SCHEME_HTTP));
 171     }
 172   } else if (path == kProxyHttpsPort) {
 173     int val;
 174     if (in_value->GetAsInteger(&val)) {
 175       config.SetProxyForScheme(
 176           "https", CreateProxyServerFromPort(
 177               val, config.https_proxy, net::ProxyServer::SCHEME_HTTP));
 178     }
 179   } else if (path == kProxyType) {
 180     int val;
 181     if (in_value->GetAsInteger(&val)) {
 182       if (val == 3) {
 183         if (config.automatic_proxy.pac_url.is_valid())
 184           config.SetPacUrl(config.automatic_proxy.pac_url);
 185         else
 186           config.mode = UIProxyConfig::MODE_AUTO_DETECT;
 187       } else if (val == 2) {
 188         if (config.single_proxy.server.is_valid()) {
 189           config.SetSingleProxy(config.single_proxy.server);
 190         } else {
 191           bool set_config = false;
 192           if (config.http_proxy.server.is_valid()) {
 193             config.SetProxyForScheme("http", config.http_proxy.server);
 194             set_config = true;
 195           }
 196           if (config.https_proxy.server.is_valid()) {
 197             config.SetProxyForScheme("https", config.https_proxy.server);
 198             set_config = true;
 199           }
 200           if (config.ftp_proxy.server.is_valid()) {
 201             config.SetProxyForScheme("ftp", config.ftp_proxy.server);
 202             set_config = true;
 203           }
 204           if (config.socks_proxy.server.is_valid()) {
 205             config.SetProxyForScheme("socks", config.socks_proxy.server);
 206             set_config = true;
 207           }
 208           if (!set_config)
 209             config.SetProxyForScheme("http", net::ProxyServer());
 210         }
 211       } else {
 212         config.mode = UIProxyConfig::MODE_DIRECT;
 213       }
 214     }
 215   } else if (path == kProxySingle) {
 216     bool val;
 217     if (in_value->GetAsBoolean(&val)) {
 218       if (val)
 219         config.SetSingleProxy(config.single_proxy.server);
 220       else
 221         config.SetProxyForScheme("http", config.http_proxy.server);
 222     }
 223   } else if (path == kProxyUsePacUrl) {
 224     bool use_pac_url;
 225     if (in_value->GetAsBoolean(&use_pac_url)) {
 226       if (use_pac_url && config.automatic_proxy.pac_url.is_valid())
 227         config.SetPacUrl(config.automatic_proxy.pac_url);
 228       else
 229         config.mode = UIProxyConfig::MODE_AUTO_DETECT;
 230     }
 231   } else if (path == kProxyFtpUrl) {
 232     std::string val;
 233     if (in_value->GetAsString(&val)) {
 234       config.SetProxyForScheme(
 235           "ftp", CreateProxyServerFromHost(
 236               val, config.ftp_proxy, net::ProxyServer::SCHEME_HTTP));
 237     }
 238   } else if (path == kProxyFtpPort) {
 239     int val;
 240     if (in_value->GetAsInteger(&val)) {
 241       config.SetProxyForScheme(
 242           "ftp", CreateProxyServerFromPort(
 243               val, config.ftp_proxy, net::ProxyServer::SCHEME_HTTP));
 244     }
 245   } else if (path == kProxySocks) {
 246     std::string val;
 247     if (in_value->GetAsString(&val)) {
 248       config.SetProxyForScheme(
 249           "socks", CreateProxyServerFromHost(
 250               val,
 251               config.socks_proxy,
 252               StartsWithASCII(val, "socks5://", false) ?
 253               net::ProxyServer::SCHEME_SOCKS5 :
 254               net::ProxyServer::SCHEME_SOCKS4));
 255     }
 256   } else if (path == kProxySocksPort) {
 257     int val;
 258     if (in_value->GetAsInteger(&val)) {
 259       std::string host = config.socks_proxy.server.host_port_pair().host();
 260       config.SetProxyForScheme(
 261           "socks", CreateProxyServerFromPort(
 262               val,
 263               config.socks_proxy,
 264               StartsWithASCII(host, "socks5://", false) ?
 265               net::ProxyServer::SCHEME_SOCKS5 :
 266               net::ProxyServer::SCHEME_SOCKS4));
 267     }
 268   } else if (path == kProxyIgnoreList) {
 269     net::ProxyBypassRules bypass_rules;
 270     if (in_value->GetType() == base::Value::TYPE_LIST) {
 271       const base::ListValue* list_value =
 272           static_cast<const base::ListValue*>(in_value);
 273       for (size_t x = 0; x < list_value->GetSize(); x++) {
 274         std::string val;
 275         if (list_value->GetString(x, &val))
 276           bypass_rules.AddRuleFromString(val);
 277       }
 278       config.SetBypassRules(bypass_rules);
 279     }
 280   } else {
 281     LOG(WARNING) << "Unknown proxy settings path " << path;
 282     return;
 283   }
 284
 285   config_service->SetProxyConfig(config);
 286 }
 287
 288 bool GetProxyPrefValue(const UIProxyConfigService& config_service,
 289                        const std::string& path,
 290                        base::Value** out_value) {
 291   std::string controlled_by;
 292   base::Value* data = NULL;
 293   UIProxyConfig config;
 294   config_service.GetProxyConfig(&config);
 295
 296   if (path == kProxyPacUrl) {
 297     // Only show pacurl for pac-script mode.
 298     if (config.mode == UIProxyConfig::MODE_PAC_SCRIPT &&
 299         config.automatic_proxy.pac_url.is_valid()) {
 300       data = new base::StringValue(config.automatic_proxy.pac_url.spec());
 301     }
 302   } else if (path == kProxySingleHttp) {
 303     data = CreateServerHostValue(config.single_proxy);
 304   } else if (path == kProxySingleHttpPort) {
 305     data = CreateServerPortValue(config.single_proxy);
 306   } else if (path == kProxyHttpUrl) {
 307     data = CreateServerHostValue(config.http_proxy);
 308   } else if (path == kProxyHttpsUrl) {
 309     data = CreateServerHostValue(config.https_proxy);
 310   } else if (path == kProxyType) {
 311     if (config.mode == UIProxyConfig::MODE_AUTO_DETECT ||
 312         config.mode == UIProxyConfig::MODE_PAC_SCRIPT) {
 313       data = new base::FundamentalValue(3);
 314     } else if (config.mode == UIProxyConfig::MODE_SINGLE_PROXY ||
 315                config.mode == UIProxyConfig::MODE_PROXY_PER_SCHEME) {
 316       data = new base::FundamentalValue(2);
 317     } else {
 318       data = new base::FundamentalValue(1);
 319     }
 320     switch (config.state) {
 321       case ProxyPrefs::CONFIG_POLICY:
 322         controlled_by = "policy";
 323         break;
 324       case ProxyPrefs::CONFIG_EXTENSION:
 325         controlled_by = "extension";
 326         break;
 327       case ProxyPrefs::CONFIG_OTHER_PRECEDE:
 328         controlled_by = "other";
 329         break;
 330       default:
 331         if (!config.user_modifiable)
 332           controlled_by = "shared";
 333         break;
 334     }
 335   } else if (path == kProxySingle) {
 336     data = new base::FundamentalValue(config.mode ==
 337                                       UIProxyConfig::MODE_SINGLE_PROXY);
 338   } else if (path == kProxyUsePacUrl) {
 339     data = new base::FundamentalValue(config.mode ==
 340                                       UIProxyConfig::MODE_PAC_SCRIPT);
 341   } else if (path == kProxyFtpUrl) {
 342     data = CreateServerHostValue(config.ftp_proxy);
 343   } else if (path == kProxySocks) {
 344     data = CreateServerHostValue(config.socks_proxy);
 345   } else if (path == kProxyHttpPort) {
 346     data = CreateServerPortValue(config.http_proxy);
 347   } else if (path == kProxyHttpsPort) {
 348     data = CreateServerPortValue(config.https_proxy);
 349   } else if (path == kProxyFtpPort) {
 350     data = CreateServerPortValue(config.ftp_proxy);
 351   } else if (path == kProxySocksPort) {
 352     data = CreateServerPortValue(config.socks_proxy);
 353   } else if (path == kProxyIgnoreList) {
 354     base::ListValue* list =  new base::ListValue();
 355     net::ProxyBypassRules::RuleList bypass_rules = config.bypass_rules.rules();
 356     for (size_t x = 0; x < bypass_rules.size(); x++)
 357       list->Append(new base::StringValue(bypass_rules[x]->ToString()));
 358     data = list;
 359   } else {
 360     *out_value = NULL;
 361     return false;
 362   }
 363
 364   // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
 365   base::DictionaryValue* dict = new base::DictionaryValue;
 366   if (!data)
 367     data = new base::StringValue("");
 368   dict->Set("value", data);
 369   if (path == kProxyType) {
 370     if (!controlled_by.empty())
 371       dict->SetString("controlledBy", controlled_by);
 372     dict->SetBoolean("disabled", !config.user_modifiable);
 373   } else {
 374     dict->SetBoolean("disabled", false);
 375   }
 376   *out_value = dict;
 377   return true;
 378 }
 379
 380 }  // namespace proxy_cros_settings_parser
 381
 382 }  // namespace chromeos