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_list.h"
6
7#include "base/callback.h"
8#include "base/logging.h"
9#include "base/strings/string_tokenizer.h"
10#include "base/time/time.h"
11#include "base/values.h"
12#include "net/proxy/proxy_server.h"
13
14using base::TimeDelta;
15using base::TimeTicks;
16
17namespace net {
18
19ProxyList::ProxyList() {
20}
21
22ProxyList::~ProxyList() {
23}
24
25void ProxyList::Set(const std::string& proxy_uri_list) {
26  proxies_.clear();
27  base::StringTokenizer str_tok(proxy_uri_list, ";");
28  while (str_tok.GetNext()) {
29    ProxyServer uri = ProxyServer::FromURI(
30        str_tok.token_begin(), str_tok.token_end(), ProxyServer::SCHEME_HTTP);
31    // Silently discard malformed inputs.
32    if (uri.is_valid())
33      proxies_.push_back(uri);
34  }
35}
36
37void ProxyList::SetSingleProxyServer(const ProxyServer& proxy_server) {
38  proxies_.clear();
39  AddProxyServer(proxy_server);
40}
41
42void ProxyList::AddProxyServer(const ProxyServer& proxy_server) {
43  if (proxy_server.is_valid())
44    proxies_.push_back(proxy_server);
45}
46
47void ProxyList::DeprioritizeBadProxies(
48    const ProxyRetryInfoMap& proxy_retry_info) {
49  // Partition the proxy list in two:
50  //   (1) the known bad proxies
51  //   (2) everything else
52  std::vector<ProxyServer> good_proxies;
53  std::vector<ProxyServer> bad_proxies_to_try;
54
55  std::vector<ProxyServer>::const_iterator iter = proxies_.begin();
56  for (; iter != proxies_.end(); ++iter) {
57    ProxyRetryInfoMap::const_iterator bad_proxy =
58        proxy_retry_info.find(iter->ToURI());
59    if (bad_proxy != proxy_retry_info.end()) {
60      // This proxy is bad. Check if it's time to retry.
61      if (bad_proxy->second.bad_until >= TimeTicks::Now()) {
62        // still invalid.
63        if (bad_proxy->second.try_while_bad)
64          bad_proxies_to_try.push_back(*iter);
65        continue;
66      }
67    }
68    good_proxies.push_back(*iter);
69  }
70
71  // "proxies_ = good_proxies + bad_proxies"
72  proxies_.swap(good_proxies);
73  proxies_.insert(proxies_.end(), bad_proxies_to_try.begin(),
74                  bad_proxies_to_try.end());
75}
76
77void ProxyList::RemoveProxiesWithoutScheme(int scheme_bit_field) {
78  for (std::vector<ProxyServer>::iterator it = proxies_.begin();
79       it != proxies_.end(); ) {
80    if (!(scheme_bit_field & it->scheme())) {
81      it = proxies_.erase(it);
82      continue;
83    }
84    ++it;
85  }
86}
87
88void ProxyList::Clear() {
89  proxies_.clear();
90}
91
92bool ProxyList::IsEmpty() const {
93  return proxies_.empty();
94}
95
96size_t ProxyList::size() const {
97  return proxies_.size();
98}
99
100// Returns true if |*this| lists the same proxies as |other|.
101bool ProxyList::Equals(const ProxyList& other) const {
102  if (size() != other.size())
103    return false;
104  return proxies_ == other.proxies_;
105}
106
107const ProxyServer& ProxyList::Get() const {
108  DCHECK(!proxies_.empty());
109  return proxies_[0];
110}
111
112void ProxyList::SetFromPacString(const std::string& pac_string) {
113  base::StringTokenizer entry_tok(pac_string, ";");
114  proxies_.clear();
115  while (entry_tok.GetNext()) {
116    ProxyServer uri = ProxyServer::FromPacString(
117        entry_tok.token_begin(), entry_tok.token_end());
118    // Silently discard malformed inputs.
119    if (uri.is_valid())
120      proxies_.push_back(uri);
121  }
122
123  // If we failed to parse anything from the PAC results list, fallback to
124  // DIRECT (this basically means an error in the PAC script).
125  if (proxies_.empty()) {
126    proxies_.push_back(ProxyServer::Direct());
127  }
128}
129
130std::string ProxyList::ToPacString() const {
131  std::string proxy_list;
132  std::vector<ProxyServer>::const_iterator iter = proxies_.begin();
133  for (; iter != proxies_.end(); ++iter) {
134    if (!proxy_list.empty())
135      proxy_list += ";";
136    proxy_list += iter->ToPacString();
137  }
138  return proxy_list.empty() ? std::string() : proxy_list;
139}
140
141base::ListValue* ProxyList::ToValue() const {
142  base::ListValue* list = new base::ListValue();
143  for (size_t i = 0; i < proxies_.size(); ++i)
144    list->AppendString(proxies_[i].ToURI());
145  return list;
146}
147
148bool ProxyList::Fallback(ProxyRetryInfoMap* proxy_retry_info,
149                         int net_error,
150                         const BoundNetLog& net_log) {
151
152  // TODO(eroman): It would be good if instead of removing failed proxies
153  // from the list, we simply annotated them with the error code they failed
154  // with. Of course, ProxyService::ReconsiderProxyAfterError() would need to
155  // be given this information by the network transaction.
156  //
157  // The advantage of this approach is when the network transaction
158  // fails, we could output the full list of proxies that were attempted, and
159  // why each one of those failed (as opposed to just the last failure).
160  //
161  // And also, before failing the transaction wholesale, we could go back and
162  // retry the "bad proxies" which we never tried to begin with.
163  // (RemoveBadProxies would annotate them as 'expected bad' rather then delete
164  // them from the list, so we would know what they were).
165
166  if (proxies_.empty()) {
167    NOTREACHED();
168    return false;
169  }
170  // By default, proxies are not retried for 5 minutes.
171  UpdateRetryInfoOnFallback(proxy_retry_info,
172                            TimeDelta::FromMinutes(5),
173                            true,
174                            ProxyServer(),
175                            net_error,
176                            net_log);
177
178  // Remove this proxy from our list.
179  proxies_.erase(proxies_.begin());
180  return !proxies_.empty();
181}
182
183void ProxyList::AddProxyToRetryList(ProxyRetryInfoMap* proxy_retry_info,
184                                    base::TimeDelta retry_delay,
185                                    bool try_while_bad,
186                                    const ProxyServer& proxy_to_retry,
187                                    int net_error,
188                                    const BoundNetLog& net_log) const {
189  // Mark this proxy as bad.
190  std::string proxy_key = proxy_to_retry.ToURI();
191  ProxyRetryInfoMap::iterator iter = proxy_retry_info->find(proxy_key);
192  if (iter != proxy_retry_info->end()) {
193    // TODO(nsylvain): This is not the first time we get this. We should
194    // double the retry time. Bug 997660.
195    iter->second.bad_until = TimeTicks::Now() + iter->second.current_delay;
196  } else {
197    ProxyRetryInfo retry_info;
198    retry_info.current_delay = retry_delay;
199    retry_info.bad_until = TimeTicks().Now() + retry_info.current_delay;
200    retry_info.try_while_bad = try_while_bad;
201    retry_info.net_error = net_error;
202    (*proxy_retry_info)[proxy_key] = retry_info;
203  }
204  net_log.AddEvent(NetLog::TYPE_PROXY_LIST_FALLBACK,
205                   NetLog::StringCallback("bad_proxy", &proxy_key));
206}
207
208void ProxyList::UpdateRetryInfoOnFallback(
209    ProxyRetryInfoMap* proxy_retry_info,
210    base::TimeDelta retry_delay,
211    bool reconsider,
212    const ProxyServer& another_proxy_to_bypass,
213    int net_error,
214    const BoundNetLog& net_log) const {
215  DCHECK(retry_delay != base::TimeDelta());
216
217  if (proxies_.empty()) {
218    NOTREACHED();
219    return;
220  }
221
222  if (!proxies_[0].is_direct()) {
223    AddProxyToRetryList(proxy_retry_info,
224                        retry_delay,
225                        reconsider,
226                        proxies_[0],
227                        net_error,
228                        net_log);
229
230    // If an additional proxy to bypass is specified, add it to the retry map
231    // as well.
232    if (another_proxy_to_bypass.is_valid()) {
233      AddProxyToRetryList(proxy_retry_info,
234                          retry_delay,
235                          reconsider,
236                          another_proxy_to_bypass,
237                          net_error,
238                          net_log);
239    }
240  }
241}
242
243}  // namespace net
244