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 #ifndef NET_PROXY_PROXY_SERVICE_H_ 6 #define NET_PROXY_PROXY_SERVICE_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/gtest_prod_util.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/synchronization/waitable_event.h" 15 #include "base/threading/non_thread_safe.h" 16 #include "net/base/completion_callback.h" 17 #include "net/base/load_states.h" 18 #include "net/base/net_export.h" 19 #include "net/base/net_log.h" 20 #include "net/base/network_change_notifier.h" 21 #include "net/proxy/proxy_config_service.h" 22 #include "net/proxy/proxy_info.h" 23 #include "net/proxy/proxy_server.h" 24 25 class GURL; 26 27 namespace base { 28 class SingleThreadTaskRunner; 29 class TimeDelta; 30 } // namespace base 31 32 namespace net { 33 34 class DhcpProxyScriptFetcher; 35 class HostResolver; 36 class NetworkDelegate; 37 class ProxyResolver; 38 class ProxyResolverScriptData; 39 class ProxyScriptDecider; 40 class ProxyScriptFetcher; 41 42 // This class can be used to resolve the proxy server to use when loading a 43 // HTTP(S) URL. It uses the given ProxyResolver to handle the actual proxy 44 // resolution. See ProxyResolverV8 for example. 45 class NET_EXPORT ProxyService : public NetworkChangeNotifier::IPAddressObserver, 46 public NetworkChangeNotifier::DNSObserver, 47 public ProxyConfigService::Observer, 48 NON_EXPORTED_BASE(public base::NonThreadSafe) { 49 public: 50 static const size_t kDefaultNumPacThreads = 4; 51 52 // This interface defines the set of policies for when to poll the PAC 53 // script for changes. 54 // 55 // The polling policy decides what the next poll delay should be in 56 // milliseconds. It also decides how to wait for this delay -- either 57 // by starting a timer to do the poll at exactly |next_delay_ms| 58 // (MODE_USE_TIMER) or by waiting for the first network request issued after 59 // |next_delay_ms| (MODE_START_AFTER_ACTIVITY). 60 // 61 // The timer method is more precise and guarantees that polling happens when 62 // it was requested. However it has the disadvantage of causing spurious CPU 63 // and network activity. It is a reasonable choice to use for short poll 64 // intervals which only happen a couple times. 65 // 66 // However for repeated timers this will prevent the browser from going 67 // idle. MODE_START_AFTER_ACTIVITY solves this problem by only polling in 68 // direct response to network activity. The drawback to 69 // MODE_START_AFTER_ACTIVITY is since the poll is initiated only after the 70 // request is received, the first couple requests initiated after a long 71 // period of inactivity will likely see a stale version of the PAC script 72 // until the background polling gets a chance to update things. 73 class NET_EXPORT_PRIVATE PacPollPolicy { 74 public: 75 enum Mode { 76 MODE_USE_TIMER, 77 MODE_START_AFTER_ACTIVITY, 78 }; 79 80 virtual ~PacPollPolicy() {} 81 82 // Decides the next poll delay. |current_delay| is the delay used 83 // by the preceding poll, or a negative TimeDelta value if determining 84 // the delay for the initial poll. |initial_error| is the network error 85 // code that the last PAC fetch (or WPAD initialization) failed with, 86 // or OK if it completed successfully. Implementations must set 87 // |next_delay| to a non-negative value. 88 virtual Mode GetNextDelay(int initial_error, 89 base::TimeDelta current_delay, 90 base::TimeDelta* next_delay) const = 0; 91 }; 92 93 // The instance takes ownership of |config_service| and |resolver|. 94 // |net_log| is a possibly NULL destination to send log events to. It must 95 // remain alive for the lifetime of this ProxyService. 96 ProxyService(ProxyConfigService* config_service, 97 ProxyResolver* resolver, 98 NetLog* net_log); 99 100 virtual ~ProxyService(); 101 102 // Used internally to handle PAC queries. 103 // TODO(eroman): consider naming this simply "Request". 104 class PacRequest; 105 106 // Returns ERR_IO_PENDING if the proxy information could not be provided 107 // synchronously, to indicate that the result will be available when the 108 // callback is run. The callback is run on the thread that calls 109 // ResolveProxy. 110 // 111 // The caller is responsible for ensuring that |results| and |callback| 112 // remain valid until the callback is run or until |pac_request| is cancelled 113 // via CancelPacRequest. |pac_request| is only valid while the completion 114 // callback is still pending. NULL can be passed for |pac_request| if 115 // the caller will not need to cancel the request. 116 // 117 // We use the three possible proxy access types in the following order, 118 // doing fallback if one doesn't work. See "pac_script_decider.h" 119 // for the specifics. 120 // 1. WPAD auto-detection 121 // 2. PAC URL 122 // 3. named proxy 123 // 124 // Profiling information for the request is saved to |net_log| if non-NULL. 125 int ResolveProxy(const GURL& url, 126 int load_flags, 127 ProxyInfo* results, 128 const net::CompletionCallback& callback, 129 PacRequest** pac_request, 130 NetworkDelegate* network_delegate, 131 const BoundNetLog& net_log); 132 133 // This method is called after a failure to connect or resolve a host name. 134 // It gives the proxy service an opportunity to reconsider the proxy to use. 135 // The |results| parameter contains the results returned by an earlier call 136 // to ResolveProxy. The |net_error| parameter contains the network error 137 // code associated with the failure. See "net/base/net_error_list.h" for a 138 // list of possible values. The semantics of this call are otherwise 139 // similar to ResolveProxy. 140 // 141 // NULL can be passed for |pac_request| if the caller will not need to 142 // cancel the request. 143 // 144 // Returns ERR_FAILED if there is not another proxy config to try. 145 // 146 // Profiling information for the request is saved to |net_log| if non-NULL. 147 int ReconsiderProxyAfterError(const GURL& url, 148 int load_flags, 149 int net_error, 150 ProxyInfo* results, 151 const CompletionCallback& callback, 152 PacRequest** pac_request, 153 NetworkDelegate* network_delegate, 154 const BoundNetLog& net_log); 155 156 // Explicitly trigger proxy fallback for the given |results| by updating our 157 // list of bad proxies to include the first entry of |results|, and, 158 // optionally, another bad proxy. Will retry after |retry_delay| if positive, 159 // and will use the default proxy retry duration otherwise. Proxies marked as 160 // bad will not be retried until |retry_delay| has passed. Returns true if 161 // there will be at least one proxy remaining in the list after fallback and 162 // false otherwise. This method should be used to add proxies to the bad 163 // proxy list only for reasons other than a network error. If a proxy needs 164 // to be added to the bad proxy list because a network error was encountered 165 // when trying to connect to it, use |ReconsiderProxyAfterError|. 166 bool MarkProxiesAsBadUntil(const ProxyInfo& results, 167 base::TimeDelta retry_delay, 168 const ProxyServer& another_bad_proxy, 169 const BoundNetLog& net_log); 170 171 // Called to report that the last proxy connection succeeded. If |proxy_info| 172 // has a non empty proxy_retry_info map, the proxies that have been tried (and 173 // failed) for this request will be marked as bad. |network_delegate| will 174 // be notified of any proxy fallbacks. 175 void ReportSuccess(const ProxyInfo& proxy_info, 176 NetworkDelegate* network_delegate); 177 178 // Call this method with a non-null |pac_request| to cancel the PAC request. 179 void CancelPacRequest(PacRequest* pac_request); 180 181 // Returns the LoadState for this |pac_request| which must be non-NULL. 182 LoadState GetLoadState(const PacRequest* pac_request) const; 183 184 // Sets the ProxyScriptFetcher and DhcpProxyScriptFetcher dependencies. This 185 // is needed if the ProxyResolver is of type ProxyResolverWithoutFetch. 186 // ProxyService takes ownership of both objects. 187 void SetProxyScriptFetchers( 188 ProxyScriptFetcher* proxy_script_fetcher, 189 DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher); 190 ProxyScriptFetcher* GetProxyScriptFetcher() const; 191 192 // Tells this ProxyService to start using a new ProxyConfigService to 193 // retrieve its ProxyConfig from. The new ProxyConfigService will immediately 194 // be queried for new config info which will be used for all subsequent 195 // ResolveProxy calls. ProxyService takes ownership of 196 // |new_proxy_config_service|. 197 void ResetConfigService(ProxyConfigService* new_proxy_config_service); 198 199 // Returns the last configuration fetched from ProxyConfigService. 200 const ProxyConfig& fetched_config() { 201 return fetched_config_; 202 } 203 204 // Returns the current configuration being used by ProxyConfigService. 205 const ProxyConfig& config() { 206 return config_; 207 } 208 209 // Returns the map of proxies which have been marked as "bad". 210 const ProxyRetryInfoMap& proxy_retry_info() const { 211 return proxy_retry_info_; 212 } 213 214 // Clears the list of bad proxy servers that has been cached. 215 void ClearBadProxiesCache() { 216 proxy_retry_info_.clear(); 217 } 218 219 // Forces refetching the proxy configuration, and applying it. 220 // This re-does everything from fetching the system configuration, 221 // to downloading and testing the PAC files. 222 void ForceReloadProxyConfig(); 223 224 // Same as CreateProxyServiceUsingV8ProxyResolver, except it uses system 225 // libraries for evaluating the PAC script if available, otherwise skips 226 // proxy autoconfig. 227 static ProxyService* CreateUsingSystemProxyResolver( 228 ProxyConfigService* proxy_config_service, 229 size_t num_pac_threads, 230 NetLog* net_log); 231 232 // Creates a ProxyService without support for proxy autoconfig. 233 static ProxyService* CreateWithoutProxyResolver( 234 ProxyConfigService* proxy_config_service, 235 NetLog* net_log); 236 237 // Convenience methods that creates a proxy service using the 238 // specified fixed settings. 239 static ProxyService* CreateFixed(const ProxyConfig& pc); 240 static ProxyService* CreateFixed(const std::string& proxy); 241 242 // Creates a proxy service that uses a DIRECT connection for all requests. 243 static ProxyService* CreateDirect(); 244 // |net_log|'s lifetime must exceed ProxyService. 245 static ProxyService* CreateDirectWithNetLog(NetLog* net_log); 246 247 // This method is used by tests to create a ProxyService that returns a 248 // hardcoded proxy fallback list (|pac_string|) for every URL. 249 // 250 // |pac_string| is a list of proxy servers, in the format that a PAC script 251 // would return it. For example, "PROXY foobar:99; SOCKS fml:2; DIRECT" 252 static ProxyService* CreateFixedFromPacResult(const std::string& pac_string); 253 254 // Creates a config service appropriate for this platform that fetches the 255 // system proxy settings. 256 static ProxyConfigService* CreateSystemProxyConfigService( 257 const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner, 258 const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner); 259 260 // This method should only be used by unit tests. 261 void set_stall_proxy_auto_config_delay(base::TimeDelta delay) { 262 stall_proxy_auto_config_delay_ = delay; 263 } 264 265 // This method should only be used by unit tests. Returns the previously 266 // active policy. 267 static const PacPollPolicy* set_pac_script_poll_policy( 268 const PacPollPolicy* policy); 269 270 // This method should only be used by unit tests. Creates an instance 271 // of the default internal PacPollPolicy used by ProxyService. 272 static scoped_ptr<PacPollPolicy> CreateDefaultPacPollPolicy(); 273 274 void set_quick_check_enabled(bool value) { 275 quick_check_enabled_ = value; 276 } 277 278 bool quick_check_enabled() const { return quick_check_enabled_; } 279 280 private: 281 FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest, UpdateConfigAfterFailedAutodetect); 282 FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest, UpdateConfigFromPACToDirect); 283 friend class PacRequest; 284 class InitProxyResolver; 285 class ProxyScriptDeciderPoller; 286 287 // TODO(eroman): change this to a std::set. Note that this requires updating 288 // some tests in proxy_service_unittest.cc such as: 289 // ProxyServiceTest.InitialPACScriptDownload 290 // which expects requests to finish in the order they were added. 291 typedef std::vector<scoped_refptr<PacRequest> > PendingRequests; 292 293 enum State { 294 STATE_NONE, 295 STATE_WAITING_FOR_PROXY_CONFIG, 296 STATE_WAITING_FOR_INIT_PROXY_RESOLVER, 297 STATE_READY, 298 }; 299 300 // Resets all the variables associated with the current proxy configuration, 301 // and rewinds the current state to |STATE_NONE|. Returns the previous value 302 // of |current_state_|. If |reset_fetched_config| is true then 303 // |fetched_config_| will also be reset, otherwise it will be left as-is. 304 // Resetting it means that we will have to re-fetch the configuration from 305 // the ProxyConfigService later. 306 State ResetProxyConfig(bool reset_fetched_config); 307 308 // Retrieves the current proxy configuration from the ProxyConfigService, and 309 // starts initializing for it. 310 void ApplyProxyConfigIfAvailable(); 311 312 // Callback for when the proxy resolver has been initialized with a 313 // PAC script. 314 void OnInitProxyResolverComplete(int result); 315 316 // Returns ERR_IO_PENDING if the request cannot be completed synchronously. 317 // Otherwise it fills |result| with the proxy information for |url|. 318 // Completing synchronously means we don't need to query ProxyResolver. 319 int TryToCompleteSynchronously(const GURL& url, 320 int load_flags, 321 NetworkDelegate* network_delegate, 322 ProxyInfo* result); 323 324 // Cancels all of the requests sent to the ProxyResolver. These will be 325 // restarted when calling SetReady(). 326 void SuspendAllPendingRequests(); 327 328 // Advances the current state to |STATE_READY|, and resumes any pending 329 // requests which had been stalled waiting for initialization to complete. 330 void SetReady(); 331 332 // Returns true if |pending_requests_| contains |req|. 333 bool ContainsPendingRequest(PacRequest* req); 334 335 // Removes |req| from the list of pending requests. 336 void RemovePendingRequest(PacRequest* req); 337 338 // Called when proxy resolution has completed (either synchronously or 339 // asynchronously). Handles logging the result, and cleaning out 340 // bad entries from the results list. 341 int DidFinishResolvingProxy(const GURL& url, 342 int load_flags, 343 NetworkDelegate* network_delegate, 344 ProxyInfo* result, 345 int result_code, 346 const BoundNetLog& net_log); 347 348 // Start initialization using |fetched_config_|. 349 void InitializeUsingLastFetchedConfig(); 350 351 // Start the initialization skipping past the "decision" phase. 352 void InitializeUsingDecidedConfig( 353 int decider_result, 354 ProxyResolverScriptData* script_data, 355 const ProxyConfig& effective_config); 356 357 // NetworkChangeNotifier::IPAddressObserver 358 // When this is called, we re-fetch PAC scripts and re-run WPAD. 359 virtual void OnIPAddressChanged() OVERRIDE; 360 361 // NetworkChangeNotifier::DNSObserver 362 // We respond as above. 363 virtual void OnDNSChanged() OVERRIDE; 364 365 // ProxyConfigService::Observer 366 virtual void OnProxyConfigChanged( 367 const ProxyConfig& config, 368 ProxyConfigService::ConfigAvailability availability) OVERRIDE; 369 370 scoped_ptr<ProxyConfigService> config_service_; 371 scoped_ptr<ProxyResolver> resolver_; 372 373 // We store the proxy configuration that was last fetched from the 374 // ProxyConfigService, as well as the resulting "effective" configuration. 375 // The effective configuration is what we condense the original fetched 376 // settings to after testing the various automatic settings (auto-detect 377 // and custom PAC url). 378 ProxyConfig fetched_config_; 379 ProxyConfig config_; 380 381 // Increasing ID to give to the next ProxyConfig that we set. 382 int next_config_id_; 383 384 // The time when the proxy configuration was last read from the system. 385 base::TimeTicks config_last_update_time_; 386 387 // Map of the known bad proxies and the information about the retry time. 388 ProxyRetryInfoMap proxy_retry_info_; 389 390 // Set of pending/inprogress requests. 391 PendingRequests pending_requests_; 392 393 // The fetcher to use when downloading PAC scripts for the ProxyResolver. 394 // This dependency can be NULL if our ProxyResolver has no need for 395 // external PAC script fetching. 396 scoped_ptr<ProxyScriptFetcher> proxy_script_fetcher_; 397 398 // The fetcher to use when attempting to download the most appropriate PAC 399 // script configured in DHCP, if any. Can be NULL if the ProxyResolver has 400 // no need for DHCP PAC script fetching. 401 scoped_ptr<DhcpProxyScriptFetcher> dhcp_proxy_script_fetcher_; 402 403 // Helper to download the PAC script (wpad + custom) and apply fallback rules. 404 // 405 // Note that the declaration is important here: |proxy_script_fetcher_| and 406 // |proxy_resolver_| must outlive |init_proxy_resolver_|. 407 scoped_ptr<InitProxyResolver> init_proxy_resolver_; 408 409 // Helper to poll the PAC script for changes. 410 scoped_ptr<ProxyScriptDeciderPoller> script_poller_; 411 412 State current_state_; 413 414 // Either OK or an ERR_* value indicating that a permanent error (e.g. 415 // failed to fetch the PAC script) prevents proxy resolution. 416 int permanent_error_; 417 418 // This is the log where any events generated by |init_proxy_resolver_| are 419 // sent to. 420 NetLog* net_log_; 421 422 // The earliest time at which we should run any proxy auto-config. (Used to 423 // stall re-configuration following an IP address change). 424 base::TimeTicks stall_proxy_autoconfig_until_; 425 426 // The amount of time to stall requests following IP address changes. 427 base::TimeDelta stall_proxy_auto_config_delay_; 428 429 // Whether child ProxyScriptDeciders should use QuickCheck 430 bool quick_check_enabled_; 431 432 DISALLOW_COPY_AND_ASSIGN(ProxyService); 433 }; 434 435 } // namespace net 436 437 #endif // NET_PROXY_PROXY_SERVICE_H_ 438