Home | History | Annotate | Download | only in proxy 
      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 "net/proxy/proxy_config.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/strings/string_util.h"
      9 #include "base/strings/string_tokenizer.h"
     10 #include "base/values.h"
     11 #include "net/proxy/proxy_info.h"
     12 
     13 namespace net {
     14 
     15 namespace {
     16 
     17 // If |proxies| is non-empty, sets it in |dict| under the key |name|.
     18 void AddProxyListToValue(const char* name,
     19                          const ProxyList& proxies,
     20                          base::DictionaryValue* dict) {
     21   if (!proxies.IsEmpty())
     22     dict->Set(name, proxies.ToValue());
     23 }
     24 
     25 // Split the |uri_list| on commas and add each entry to |proxy_list| in turn.
     26 void AddProxyURIListToProxyList(std::string uri_list,
     27                                 ProxyList* proxy_list,
     28                                 ProxyServer::Scheme default_scheme) {
     29   base::StringTokenizer proxy_uri_list(uri_list, ",");
     30   while (proxy_uri_list.GetNext()) {
     31     proxy_list->AddProxyServer(
     32         ProxyServer::FromURI(proxy_uri_list.token(), default_scheme));
     33   }
     34 }
     35 
     36 }  // namespace
     37 
     38 ProxyConfig::ProxyRules::ProxyRules()
     39     : reverse_bypass(false),
     40       type(TYPE_NO_RULES) {
     41 }
     42 
     43 ProxyConfig::ProxyRules::~ProxyRules() {
     44 }
     45 
     46 void ProxyConfig::ProxyRules::Apply(const GURL& url, ProxyInfo* result) const {
     47   if (empty()) {
     48     result->UseDirect();
     49     return;
     50   }
     51 
     52   bool bypass_proxy = bypass_rules.Matches(url);
     53   if (reverse_bypass)
     54     bypass_proxy = !bypass_proxy;
     55   if (bypass_proxy) {
     56     result->UseDirectWithBypassedProxy();
     57     return;
     58   }
     59 
     60   switch (type) {
     61     case ProxyRules::TYPE_SINGLE_PROXY: {
     62       result->UseProxyList(single_proxies);
     63       return;
     64     }
     65     case ProxyRules::TYPE_PROXY_PER_SCHEME: {
     66       const ProxyList* entry = MapUrlSchemeToProxyList(url.scheme());
     67       if (entry) {
     68         result->UseProxyList(*entry);
     69       } else {
     70         // We failed to find a matching proxy server for the current URL
     71         // scheme. Default to direct.
     72         result->UseDirect();
     73       }
     74       return;
     75     }
     76     default: {
     77       result->UseDirect();
     78       NOTREACHED();
     79       return;
     80     }
     81   }
     82 }
     83 
     84 void ProxyConfig::ProxyRules::ParseFromString(const std::string& proxy_rules) {
     85   // Reset.
     86   type = TYPE_NO_RULES;
     87   single_proxies = ProxyList();
     88   proxies_for_http = ProxyList();
     89   proxies_for_https = ProxyList();
     90   proxies_for_ftp = ProxyList();
     91   fallback_proxies = ProxyList();
     92 
     93   base::StringTokenizer proxy_server_list(proxy_rules, ";");
     94   while (proxy_server_list.GetNext()) {
     95     base::StringTokenizer proxy_server_for_scheme(
     96         proxy_server_list.token_begin(), proxy_server_list.token_end(), "=");
     97 
     98     while (proxy_server_for_scheme.GetNext()) {
     99       std::string url_scheme = proxy_server_for_scheme.token();
    100 
    101       // If we fail to get the proxy server here, it means that
    102       // this is a regular proxy server configuration, i.e. proxies
    103       // are not configured per protocol.
    104       if (!proxy_server_for_scheme.GetNext()) {
    105         if (type == TYPE_PROXY_PER_SCHEME)
    106           continue;  // Unexpected.
    107         AddProxyURIListToProxyList(url_scheme,
    108                                    &single_proxies,
    109                                    ProxyServer::SCHEME_HTTP);
    110         type = TYPE_SINGLE_PROXY;
    111         return;
    112       }
    113 
    114       // Trim whitespace off the url scheme.
    115       base::TrimWhitespaceASCII(url_scheme, base::TRIM_ALL, &url_scheme);
    116 
    117       // Add it to the per-scheme mappings (if supported scheme).
    118       type = TYPE_PROXY_PER_SCHEME;
    119       ProxyList* entry = MapUrlSchemeToProxyListNoFallback(url_scheme);
    120       ProxyServer::Scheme default_scheme = ProxyServer::SCHEME_HTTP;
    121 
    122       // socks=XXX is inconsistent with the other formats, since "socks"
    123       // is not a URL scheme. Rather this means "for everything else, send
    124       // it to the SOCKS proxy server XXX".
    125       if (url_scheme == "socks") {
    126         DCHECK(!entry);
    127         entry = &fallback_proxies;
    128         // Note that here 'socks' is understood to be SOCKS4, even though
    129         // 'socks' maps to SOCKS5 in ProxyServer::GetSchemeFromURIInternal.
    130         default_scheme = ProxyServer::SCHEME_SOCKS4;
    131       }
    132 
    133       if (entry) {
    134         AddProxyURIListToProxyList(proxy_server_for_scheme.token(),
    135                                    entry,
    136                                    default_scheme);
    137       }
    138     }
    139   }
    140 }
    141 
    142 const ProxyList* ProxyConfig::ProxyRules::MapUrlSchemeToProxyList(
    143     const std::string& url_scheme) const {
    144   const ProxyList* proxy_server_list = const_cast<ProxyRules*>(this)->
    145       MapUrlSchemeToProxyListNoFallback(url_scheme);
    146   if (proxy_server_list && !proxy_server_list->IsEmpty())
    147     return proxy_server_list;
    148   if (url_scheme == "ws" || url_scheme == "wss")
    149     return GetProxyListForWebSocketScheme();
    150   if (!fallback_proxies.IsEmpty())
    151     return &fallback_proxies;
    152   return NULL;  // No mapping for this scheme. Use direct.
    153 }
    154 
    155 bool ProxyConfig::ProxyRules::Equals(const ProxyRules& other) const {
    156   return type == other.type &&
    157          single_proxies.Equals(other.single_proxies) &&
    158          proxies_for_http.Equals(other.proxies_for_http) &&
    159          proxies_for_https.Equals(other.proxies_for_https) &&
    160          proxies_for_ftp.Equals(other.proxies_for_ftp) &&
    161          fallback_proxies.Equals(other.fallback_proxies) &&
    162          bypass_rules.Equals(other.bypass_rules) &&
    163          reverse_bypass == other.reverse_bypass;
    164 }
    165 
    166 ProxyList* ProxyConfig::ProxyRules::MapUrlSchemeToProxyListNoFallback(
    167     const std::string& scheme) {
    168   DCHECK_EQ(TYPE_PROXY_PER_SCHEME, type);
    169   if (scheme == "http")
    170     return &proxies_for_http;
    171   if (scheme == "https")
    172     return &proxies_for_https;
    173   if (scheme == "ftp")
    174     return &proxies_for_ftp;
    175   return NULL;  // No mapping for this scheme.
    176 }
    177 
    178 const ProxyList* ProxyConfig::ProxyRules::GetProxyListForWebSocketScheme()
    179     const {
    180   if (!fallback_proxies.IsEmpty())
    181     return &fallback_proxies;
    182   if (!proxies_for_https.IsEmpty())
    183     return &proxies_for_https;
    184   if (!proxies_for_http.IsEmpty())
    185     return &proxies_for_http;
    186   return NULL;
    187 }
    188 
    189 ProxyConfig::ProxyConfig()
    190     : auto_detect_(false), pac_mandatory_(false),
    191       source_(PROXY_CONFIG_SOURCE_UNKNOWN), id_(kInvalidConfigID)  {
    192 }
    193 
    194 ProxyConfig::ProxyConfig(const ProxyConfig& config)
    195     : auto_detect_(config.auto_detect_),
    196       pac_url_(config.pac_url_),
    197       pac_mandatory_(config.pac_mandatory_),
    198       proxy_rules_(config.proxy_rules_),
    199       source_(config.source_),
    200       id_(config.id_) {
    201 }
    202 
    203 ProxyConfig::~ProxyConfig() {
    204 }
    205 
    206 ProxyConfig& ProxyConfig::operator=(const ProxyConfig& config) {
    207   auto_detect_ = config.auto_detect_;
    208   pac_url_ = config.pac_url_;
    209   pac_mandatory_ = config.pac_mandatory_;
    210   proxy_rules_ = config.proxy_rules_;
    211   source_ = config.source_;
    212   id_ = config.id_;
    213   return *this;
    214 }
    215 
    216 bool ProxyConfig::Equals(const ProxyConfig& other) const {
    217   // The two configs can have different IDs and sources.  We are just interested
    218   // in if they have the same settings.
    219   return auto_detect_ == other.auto_detect_ &&
    220          pac_url_ == other.pac_url_ &&
    221          pac_mandatory_ == other.pac_mandatory_ &&
    222          proxy_rules_.Equals(other.proxy_rules());
    223 }
    224 
    225 bool ProxyConfig::HasAutomaticSettings() const {
    226   return auto_detect_ || has_pac_url();
    227 }
    228 
    229 void ProxyConfig::ClearAutomaticSettings() {
    230   auto_detect_ = false;
    231   pac_url_ = GURL();
    232 }
    233 
    234 base::DictionaryValue* ProxyConfig::ToValue() const {
    235   base::DictionaryValue* dict = new base::DictionaryValue();
    236 
    237   // Output the automatic settings.
    238   if (auto_detect_)
    239     dict->SetBoolean("auto_detect", auto_detect_);
    240   if (has_pac_url()) {
    241     dict->SetString("pac_url", pac_url_.possibly_invalid_spec());
    242     if (pac_mandatory_)
    243       dict->SetBoolean("pac_mandatory", pac_mandatory_);
    244   }
    245 
    246   // Output the manual settings.
    247   if (proxy_rules_.type != ProxyRules::TYPE_NO_RULES) {
    248     switch (proxy_rules_.type) {
    249       case ProxyRules::TYPE_SINGLE_PROXY:
    250         AddProxyListToValue("single_proxy",
    251                             proxy_rules_.single_proxies, dict);
    252         break;
    253       case ProxyRules::TYPE_PROXY_PER_SCHEME: {
    254         base::DictionaryValue* dict2 = new base::DictionaryValue();
    255         AddProxyListToValue("http", proxy_rules_.proxies_for_http, dict2);
    256         AddProxyListToValue("https", proxy_rules_.proxies_for_https, dict2);
    257         AddProxyListToValue("ftp", proxy_rules_.proxies_for_ftp, dict2);
    258         AddProxyListToValue("fallback", proxy_rules_.fallback_proxies, dict2);
    259         dict->Set("proxy_per_scheme", dict2);
    260         break;
    261       }
    262       default:
    263         NOTREACHED();
    264     }
    265 
    266     // Output the bypass rules.
    267     const ProxyBypassRules& bypass = proxy_rules_.bypass_rules;
    268     if (!bypass.rules().empty()) {
    269       if (proxy_rules_.reverse_bypass)
    270         dict->SetBoolean("reverse_bypass", true);
    271 
    272       base::ListValue* list = new base::ListValue();
    273 
    274       for (ProxyBypassRules::RuleList::const_iterator it =
    275               bypass.rules().begin();
    276            it != bypass.rules().end(); ++it) {
    277         list->Append(new base::StringValue((*it)->ToString()));
    278       }
    279 
    280       dict->Set("bypass_list", list);
    281     }
    282   }
    283 
    284   // Output the source.
    285   dict->SetString("source", ProxyConfigSourceToString(source_));
    286 
    287   return dict;
    288 }
    289 
    290 }  // namespace net
    291