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.
5 #ifndef NET_PROXY_PROXY_SERVICE_H_
6 #define NET_PROXY_PROXY_SERVICE_H_
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"
28 class SingleThreadTaskRunner;
34 class DhcpProxyScriptFetcher;
36 class NetworkDelegate;
38 class ProxyResolverScriptData;
39 class ProxyScriptDecider;
40 class ProxyScriptFetcher;
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) {
50 static const size_t kDefaultNumPacThreads = 4;
52 // This interface defines the set of policies for when to poll the PAC
53 // script for changes.
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).
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.
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 {
77 MODE_START_AFTER_ACTIVITY,
80 virtual ~PacPollPolicy() {}
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;
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,
100 virtual ~ProxyService();
102 // Used internally to handle PAC queries.
103 // TODO(eroman): consider naming this simply "Request".
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
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.
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
124 // Profiling information for the request is saved to |net_log| if non-NULL.
125 int ResolveProxy(const GURL& url,
128 const net::CompletionCallback& callback,
129 PacRequest** pac_request,
130 NetworkDelegate* network_delegate,
131 const BoundNetLog& net_log);
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.
141 // NULL can be passed for |pac_request| if the caller will not need to
142 // cancel the request.
144 // Returns ERR_FAILED if there is not another proxy config to try.
146 // Profiling information for the request is saved to |net_log| if non-NULL.
147 int ReconsiderProxyAfterError(const GURL& url,
151 const CompletionCallback& callback,
152 PacRequest** pac_request,
153 NetworkDelegate* network_delegate,
154 const BoundNetLog& net_log);
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);
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);
178 // Call this method with a non-null |pac_request| to cancel the PAC request.
179 void CancelPacRequest(PacRequest* pac_request);
181 // Returns the LoadState for this |pac_request| which must be non-NULL.
182 LoadState GetLoadState(const PacRequest* pac_request) const;
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;
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);
199 // Returns the last configuration fetched from ProxyConfigService.
200 const ProxyConfig& fetched_config() {
201 return fetched_config_;
204 // Returns the current configuration being used by ProxyConfigService.
205 const ProxyConfig& config() {
209 // Returns the map of proxies which have been marked as "bad".
210 const ProxyRetryInfoMap& proxy_retry_info() const {
211 return proxy_retry_info_;
214 // Clears the list of bad proxy servers that has been cached.
215 void ClearBadProxiesCache() {
216 proxy_retry_info_.clear();
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();
224 // Same as CreateProxyServiceUsingV8ProxyResolver, except it uses system
225 // libraries for evaluating the PAC script if available, otherwise skips
227 static ProxyService* CreateUsingSystemProxyResolver(
228 ProxyConfigService* proxy_config_service,
229 size_t num_pac_threads,
232 // Creates a ProxyService without support for proxy autoconfig.
233 static ProxyService* CreateWithoutProxyResolver(
234 ProxyConfigService* proxy_config_service,
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);
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);
247 // This method is used by tests to create a ProxyService that returns a
248 // hardcoded proxy fallback list (|pac_string|) for every URL.
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);
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);
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;
265 // This method should only be used by unit tests. Returns the previously
267 static const PacPollPolicy* set_pac_script_poll_policy(
268 const PacPollPolicy* policy);
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();
274 void set_quick_check_enabled(bool value) {
275 quick_check_enabled_ = value;
278 bool quick_check_enabled() const { return quick_check_enabled_; }
281 FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest, UpdateConfigAfterFailedAutodetect);
282 FRIEND_TEST_ALL_PREFIXES(ProxyServiceTest, UpdateConfigFromPACToDirect);
283 friend class PacRequest;
284 class InitProxyResolver;
285 class ProxyScriptDeciderPoller;
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;
295 STATE_WAITING_FOR_PROXY_CONFIG,
296 STATE_WAITING_FOR_INIT_PROXY_RESOLVER,
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);
308 // Retrieves the current proxy configuration from the ProxyConfigService, and
309 // starts initializing for it.
310 void ApplyProxyConfigIfAvailable();
312 // Callback for when the proxy resolver has been initialized with a
314 void OnInitProxyResolverComplete(int result);
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,
321 NetworkDelegate* network_delegate,
324 // Cancels all of the requests sent to the ProxyResolver. These will be
325 // restarted when calling SetReady().
326 void SuspendAllPendingRequests();
328 // Advances the current state to |STATE_READY|, and resumes any pending
329 // requests which had been stalled waiting for initialization to complete.
332 // Returns true if |pending_requests_| contains |req|.
333 bool ContainsPendingRequest(PacRequest* req);
335 // Removes |req| from the list of pending requests.
336 void RemovePendingRequest(PacRequest* req);
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,
343 NetworkDelegate* network_delegate,
346 const BoundNetLog& net_log);
348 // Start initialization using |fetched_config_|.
349 void InitializeUsingLastFetchedConfig();
351 // Start the initialization skipping past the "decision" phase.
352 void InitializeUsingDecidedConfig(
354 ProxyResolverScriptData* script_data,
355 const ProxyConfig& effective_config);
357 // NetworkChangeNotifier::IPAddressObserver
358 // When this is called, we re-fetch PAC scripts and re-run WPAD.
359 virtual void OnIPAddressChanged() OVERRIDE;
361 // NetworkChangeNotifier::DNSObserver
362 // We respond as above.
363 virtual void OnDNSChanged() OVERRIDE;
365 // ProxyConfigService::Observer
366 virtual void OnProxyConfigChanged(
367 const ProxyConfig& config,
368 ProxyConfigService::ConfigAvailability availability) OVERRIDE;
370 scoped_ptr<ProxyConfigService> config_service_;
371 scoped_ptr<ProxyResolver> resolver_;
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_;
381 // Increasing ID to give to the next ProxyConfig that we set.
384 // The time when the proxy configuration was last read from the system.
385 base::TimeTicks config_last_update_time_;
387 // Map of the known bad proxies and the information about the retry time.
388 ProxyRetryInfoMap proxy_retry_info_;
390 // Set of pending/inprogress requests.
391 PendingRequests pending_requests_;
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_;
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_;
403 // Helper to download the PAC script (wpad + custom) and apply fallback rules.
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_;
409 // Helper to poll the PAC script for changes.
410 scoped_ptr<ProxyScriptDeciderPoller> script_poller_;
412 State current_state_;
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_;
418 // This is the log where any events generated by |init_proxy_resolver_| are
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_;
426 // The amount of time to stall requests following IP address changes.
427 base::TimeDelta stall_proxy_auto_config_delay_;
429 // Whether child ProxyScriptDeciders should use QuickCheck
430 bool quick_check_enabled_;
432 DISALLOW_COPY_AND_ASSIGN(ProxyService);
437 #endif // NET_PROXY_PROXY_SERVICE_H_