// 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. #ifndef NET_PROXY_PROXY_CONFIG_H_ #define NET_PROXY_PROXY_CONFIG_H_ #include <string> #include "net/base/net_export.h" #include "net/proxy/proxy_bypass_rules.h" #include "net/proxy/proxy_config_source.h" #include "net/proxy/proxy_list.h" #include "net/proxy/proxy_server.h" #include "url/gurl.h" namespace base { class Value; } namespace net { class ProxyInfo; // ProxyConfig describes a user's proxy settings. // // There are two categories of proxy settings: // (1) Automatic (indicates the methods to obtain a PAC script) // (2) Manual (simple set of proxy servers per scheme, and bypass patterns) // // When both automatic and manual settings are specified, the Automatic ones // take precedence over the manual ones. // // For more details see: // http://www.chromium.org/developers/design-documents/proxy-settings-fallback class NET_EXPORT ProxyConfig { public: // ProxyRules describes the "manual" proxy settings. // TODO(eroman): Turn this into a class. // TODO(marq): Update the enum names; "TYPE_SINGLE_PROXY" really means // the same set of proxies are used for all requests. struct NET_EXPORT ProxyRules { enum Type { TYPE_NO_RULES, TYPE_SINGLE_PROXY, TYPE_PROXY_PER_SCHEME, }; // Note that the default of TYPE_NO_RULES results in direct connections // being made when using this ProxyConfig. ProxyRules(); ~ProxyRules(); bool empty() const { return type == TYPE_NO_RULES; } // Sets |result| with the proxies to use for |url| based on the current // rules. void Apply(const GURL& url, ProxyInfo* result) const; // Parses the rules from a string, indicating which proxies to use. // // proxy-uri = [<proxy-scheme>"://"]<proxy-host>[":"<proxy-port>] // // proxy-uri-list = <proxy-uri>[","<proxy-uri-list>] // // url-scheme = "http" | "https" | "ftp" | "socks" // // scheme-proxies = [<url-scheme>"="]<proxy-uri-list> // // proxy-rules = scheme-proxies[";"<scheme-proxies>] // // Thus, the proxy-rules string should be a semicolon-separated list of // ordered proxies that apply to a particular URL scheme. Unless specified, // the proxy scheme for proxy-uris is assumed to be http. // // Some special cases: // * If the scheme is omitted from the first proxy list, that list applies // to all URL schemes and subsequent lists are ignored. // * If a scheme is omitted from any proxy list after a list where a scheme // has been provided, the list without a scheme is ignored. // * If the url-scheme is set to 'socks', that sets a fallback list that // to all otherwise unspecified url-schemes, however the default proxy- // scheme for proxy urls in the 'socks' list is understood to be // socks4:// if unspecified. // // For example: // "http=foopy:80;ftp=foopy2" -- use HTTP proxy "foopy:80" for http:// // URLs, and HTTP proxy "foopy2:80" for // ftp:// URLs. // "foopy:80" -- use HTTP proxy "foopy:80" for all URLs. // "foopy:80,bar,direct://" -- use HTTP proxy "foopy:80" for all URLs, // failing over to "bar" if "foopy:80" is // unavailable, and after that using no // proxy. // "socks4://foopy" -- use SOCKS v4 proxy "foopy:1080" for all // URLs. // "http=foop,socks5://bar.com -- use HTTP proxy "foopy" for http URLs, // and fail over to the SOCKS5 proxy // "bar.com" if "foop" is unavailable. // "http=foopy,direct:// -- use HTTP proxy "foopy" for http URLs, // and use no proxy if "foopy" is // unavailable. // "http=foopy;socks=foopy2 -- use HTTP proxy "foopy" for http URLs, // and use socks4://foopy2 for all other // URLs. void ParseFromString(const std::string& proxy_rules); // Returns one of {&proxies_for_http, &proxies_for_https, &proxies_for_ftp, // &fallback_proxies}, or NULL if there is no proxy to use. // Should only call this if the type is TYPE_PROXY_PER_SCHEME. const ProxyList* MapUrlSchemeToProxyList( const std::string& url_scheme) const; // Returns true if |*this| describes the same configuration as |other|. bool Equals(const ProxyRules& other) const; // Exceptions for when not to use a proxy. ProxyBypassRules bypass_rules; // Reverse the meaning of |bypass_rules|. bool reverse_bypass; Type type; // Set if |type| is TYPE_SINGLE_PROXY. ProxyList single_proxies; // Set if |type| is TYPE_PROXY_PER_SCHEME. ProxyList proxies_for_http; ProxyList proxies_for_https; ProxyList proxies_for_ftp; // Used when a fallback has been defined and the url to be proxied doesn't // match any of the standard schemes. ProxyList fallback_proxies; private: // Returns one of {&proxies_for_http, &proxies_for_https, &proxies_for_ftp} // or NULL if it is a scheme that we don't have a mapping // for. Should only call this if the type is TYPE_PROXY_PER_SCHEME. ProxyList* MapUrlSchemeToProxyListNoFallback(const std::string& scheme); }; typedef int ID; // Indicates an invalid proxy config. static const ID kInvalidConfigID = 0; ProxyConfig(); ProxyConfig(const ProxyConfig& config); ~ProxyConfig(); ProxyConfig& operator=(const ProxyConfig& config); // Used to numerically identify this configuration. ID id() const { return id_; } void set_id(ID id) { id_ = id; } bool is_valid() const { return id_ != kInvalidConfigID; } // Returns true if the given config is equivalent to this config. The // comparison ignores differences in |id()| and |source()|. bool Equals(const ProxyConfig& other) const; // Returns true if this config contains any "automatic" settings. See the // class description for what that means. bool HasAutomaticSettings() const; void ClearAutomaticSettings(); // Creates a Value dump of this configuration. The caller is responsible for // deleting the returned value. base::DictionaryValue* ToValue() const; ProxyRules& proxy_rules() { return proxy_rules_; } const ProxyRules& proxy_rules() const { return proxy_rules_; } void set_pac_url(const GURL& url) { pac_url_ = url; } const GURL& pac_url() const { return pac_url_; } void set_pac_mandatory(bool enable_pac_mandatory) { pac_mandatory_ = enable_pac_mandatory; } bool pac_mandatory() const { return pac_mandatory_; } bool has_pac_url() const { return pac_url_.is_valid(); } void set_auto_detect(bool enable_auto_detect) { auto_detect_ = enable_auto_detect; } bool auto_detect() const { return auto_detect_; } void set_source(ProxyConfigSource source) { source_ = source; } ProxyConfigSource source() const { return source_; } // Helpers to construct some common proxy configurations. static ProxyConfig CreateDirect() { return ProxyConfig(); } static ProxyConfig CreateAutoDetect() { ProxyConfig config; config.set_auto_detect(true); return config; } static ProxyConfig CreateFromCustomPacURL(const GURL& pac_url) { ProxyConfig config; config.set_pac_url(pac_url); // By default fall back to direct connection in case PAC script fails. config.set_pac_mandatory(false); return config; } private: // True if the proxy configuration should be auto-detected. bool auto_detect_; // If non-empty, indicates the URL of the proxy auto-config file to use. GURL pac_url_; // If true, blocks all traffic in case fetching the pac script from |pac_url_| // fails. Only valid if |pac_url_| is non-empty. bool pac_mandatory_; // Manual proxy settings. ProxyRules proxy_rules_; // Source of proxy settings. ProxyConfigSource source_; ID id_; }; } // namespace net #endif // NET_PROXY_PROXY_CONFIG_H_