Home | History | Annotate | Download | only in chromeos 
      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          base::Value::CreateIntegerValue(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 ListValue* list_value = static_cast<const ListValue*>(in_value);
    272       for (size_t x = 0; x < list_value->GetSize(); x++) {
    273         std::string val;
    274         if (list_value->GetString(x, &val))
    275           bypass_rules.AddRuleFromString(val);
    276       }
    277       config.SetBypassRules(bypass_rules);
    278     }
    279   } else {
    280     LOG(WARNING) << "Unknown proxy settings path " << path;
    281     return;
    282   }
    283 
    284   config_service->SetProxyConfig(config);
    285 }
    286 
    287 bool GetProxyPrefValue(const UIProxyConfigService& config_service,
    288                        const std::string& path,
    289                        base::Value** out_value) {
    290   std::string controlled_by;
    291   base::Value* data = NULL;
    292   UIProxyConfig config;
    293   config_service.GetProxyConfig(&config);
    294 
    295   if (path == kProxyPacUrl) {
    296     // Only show pacurl for pac-script mode.
    297     if (config.mode == UIProxyConfig::MODE_PAC_SCRIPT &&
    298         config.automatic_proxy.pac_url.is_valid()) {
    299       data = new base::StringValue(config.automatic_proxy.pac_url.spec());
    300     }
    301   } else if (path == kProxySingleHttp) {
    302     data = CreateServerHostValue(config.single_proxy);
    303   } else if (path == kProxySingleHttpPort) {
    304     data = CreateServerPortValue(config.single_proxy);
    305   } else if (path == kProxyHttpUrl) {
    306     data = CreateServerHostValue(config.http_proxy);
    307   } else if (path == kProxyHttpsUrl) {
    308     data = CreateServerHostValue(config.https_proxy);
    309   } else if (path == kProxyType) {
    310     if (config.mode == UIProxyConfig::MODE_AUTO_DETECT ||
    311         config.mode == UIProxyConfig::MODE_PAC_SCRIPT) {
    312       data = base::Value::CreateIntegerValue(3);
    313     } else if (config.mode == UIProxyConfig::MODE_SINGLE_PROXY ||
    314                config.mode == UIProxyConfig::MODE_PROXY_PER_SCHEME) {
    315       data = base::Value::CreateIntegerValue(2);
    316     } else {
    317       data = base::Value::CreateIntegerValue(1);
    318     }
    319     switch (config.state) {
    320       case ProxyPrefs::CONFIG_POLICY:
    321         controlled_by = "policy";
    322         break;
    323       case ProxyPrefs::CONFIG_EXTENSION:
    324         controlled_by = "extension";
    325         break;
    326       case ProxyPrefs::CONFIG_OTHER_PRECEDE:
    327         controlled_by = "other";
    328         break;
    329       default:
    330         if (!config.user_modifiable)
    331           controlled_by = "shared";
    332         break;
    333     }
    334   } else if (path == kProxySingle) {
    335     data = base::Value::CreateBooleanValue(
    336         config.mode == UIProxyConfig::MODE_SINGLE_PROXY);
    337   } else if (path == kProxyUsePacUrl) {
    338     data = base::Value::CreateBooleanValue(
    339         config.mode == UIProxyConfig::MODE_PAC_SCRIPT);
    340   } else if (path == kProxyFtpUrl) {
    341     data = CreateServerHostValue(config.ftp_proxy);
    342   } else if (path == kProxySocks) {
    343     data = CreateServerHostValue(config.socks_proxy);
    344   } else if (path == kProxyHttpPort) {
    345     data = CreateServerPortValue(config.http_proxy);
    346   } else if (path == kProxyHttpsPort) {
    347     data = CreateServerPortValue(config.https_proxy);
    348   } else if (path == kProxyFtpPort) {
    349     data = CreateServerPortValue(config.ftp_proxy);
    350   } else if (path == kProxySocksPort) {
    351     data = CreateServerPortValue(config.socks_proxy);
    352   } else if (path == kProxyIgnoreList) {
    353     ListValue* list =  new ListValue();
    354     net::ProxyBypassRules::RuleList bypass_rules = config.bypass_rules.rules();
    355     for (size_t x = 0; x < bypass_rules.size(); x++)
    356       list->Append(new base::StringValue(bypass_rules[x]->ToString()));
    357     data = list;
    358   } else {
    359     *out_value = NULL;
    360     return false;
    361   }
    362 
    363   // Decorate pref value as CoreOptionsHandler::CreateValueForPref() does.
    364   DictionaryValue* dict = new DictionaryValue;
    365   if (!data)
    366     data = new base::StringValue("");
    367   dict->Set("value", data);
    368   if (path == kProxyType) {
    369     if (!controlled_by.empty())
    370       dict->SetString("controlledBy", controlled_by);
    371     dict->SetBoolean("disabled", !config.user_modifiable);
    372   } else {
    373     dict->SetBoolean("disabled", false);
    374   }
    375   *out_value = dict;
    376   return true;
    377 }
    378 
    379 }  // namespace proxy_cros_settings_parser
    380 
    381 }  // namespace chromeos
    382