| OLD | NEW |
|---|
| (Empty) |
| 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/dhcp_proxy_script_fetcher_win.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/threading/sequenced_worker_pool.h" | |
| 10 #include "net/base/net_errors.h" | |
| 11 #include "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h" | |
| 12 | |
| 13 #include <winsock2.h> | |
| 14 #include <iphlpapi.h> | |
| 15 #pragma comment(lib, "iphlpapi.lib") | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 // How many threads to use at maximum to do DHCP lookups. This is | |
| 20 // chosen based on the following UMA data: | |
| 21 // - When OnWaitTimer fires, ~99.8% of users have 6 or fewer network | |
| 22 // adapters enabled for DHCP in total. | |
| 23 // - At the same measurement point, ~99.7% of users have 3 or fewer pending | |
| 24 // DHCP adapter lookups. | |
| 25 // - There is however a very long and thin tail of users who have | |
| 26 // systems reporting up to 100+ adapters (this must be some very weird | |
| 27 // OS bug (?), probably the cause of http://crbug.com/240034). | |
| 28 // | |
| 29 // The maximum number of threads is chosen such that even systems that | |
| 30 // report a huge number of network adapters should not run out of | |
| 31 // memory from this number of threads, while giving a good chance of | |
| 32 // getting back results for any responsive adapters. | |
| 33 // | |
| 34 // The ~99.8% of systems that have 6 or fewer network adapters will | |
| 35 // not grow the thread pool to its maximum size (rather, they will | |
| 36 // grow it to 6 or fewer threads) so setting the limit lower would not | |
| 37 // improve performance or memory usage on those systems. | |
| 38 const int kMaxDhcpLookupThreads = 12; | |
| 39 | |
| 40 // How long to wait at maximum after we get results (a PAC file or | |
| 41 // knowledge that no PAC file is configured) from whichever network | |
| 42 // adapter finishes first. | |
| 43 const int kMaxWaitAfterFirstResultMs = 400; | |
| 44 | |
| 45 const int kGetAdaptersAddressesErrors[] = { | |
| 46 ERROR_ADDRESS_NOT_ASSOCIATED, | |
| 47 ERROR_BUFFER_OVERFLOW, | |
| 48 ERROR_INVALID_PARAMETER, | |
| 49 ERROR_NOT_ENOUGH_MEMORY, | |
| 50 ERROR_NO_DATA, | |
| 51 }; | |
| 52 | |
| 53 } // namespace | |
| 54 | |
| 55 namespace net { | |
| 56 | |
| 57 DhcpProxyScriptFetcherWin::DhcpProxyScriptFetcherWin( | |
| 58 URLRequestContext* url_request_context) | |
| 59 : state_(STATE_START), | |
| 60 num_pending_fetchers_(0), | |
| 61 destination_string_(NULL), | |
| 62 url_request_context_(url_request_context) { | |
| 63 DCHECK(url_request_context_); | |
| 64 | |
| 65 worker_pool_ = new base::SequencedWorkerPool(kMaxDhcpLookupThreads, | |
| 66 "PacDhcpLookup"); | |
| 67 } | |
| 68 | |
| 69 DhcpProxyScriptFetcherWin::~DhcpProxyScriptFetcherWin() { | |
| 70 // Count as user-initiated if we are not yet in STATE_DONE. | |
| 71 Cancel(); | |
| 72 | |
| 73 worker_pool_->Shutdown(); | |
| 74 } | |
| 75 | |
| 76 int DhcpProxyScriptFetcherWin::Fetch(base::string16* utf16_text, | |
| 77 const CompletionCallback& callback) { | |
| 78 DCHECK(CalledOnValidThread()); | |
| 79 if (state_ != STATE_START && state_ != STATE_DONE) { | |
| 80 NOTREACHED(); | |
| 81 return ERR_UNEXPECTED; | |
| 82 } | |
| 83 | |
| 84 state_ = STATE_WAIT_ADAPTERS; | |
| 85 callback_ = callback; | |
| 86 destination_string_ = utf16_text; | |
| 87 | |
| 88 last_query_ = ImplCreateAdapterQuery(); | |
| 89 GetTaskRunner()->PostTaskAndReply( | |
| 90 FROM_HERE, | |
| 91 base::Bind( | |
| 92 &DhcpProxyScriptFetcherWin::AdapterQuery::GetCandidateAdapterNames, | |
| 93 last_query_.get()), | |
| 94 base::Bind( | |
| 95 &DhcpProxyScriptFetcherWin::OnGetCandidateAdapterNamesDone, | |
| 96 AsWeakPtr(), | |
| 97 last_query_)); | |
| 98 | |
| 99 return ERR_IO_PENDING; | |
| 100 } | |
| 101 | |
| 102 void DhcpProxyScriptFetcherWin::Cancel() { | |
| 103 DCHECK(CalledOnValidThread()); | |
| 104 | |
| 105 CancelImpl(); | |
| 106 } | |
| 107 | |
| 108 void DhcpProxyScriptFetcherWin::CancelImpl() { | |
| 109 DCHECK(CalledOnValidThread()); | |
| 110 | |
| 111 if (state_ != STATE_DONE) { | |
| 112 callback_.Reset(); | |
| 113 wait_timer_.Stop(); | |
| 114 state_ = STATE_DONE; | |
| 115 | |
| 116 for (FetcherVector::iterator it = fetchers_.begin(); | |
| 117 it != fetchers_.end(); | |
| 118 ++it) { | |
| 119 (*it)->Cancel(); | |
| 120 } | |
| 121 | |
| 122 fetchers_.clear(); | |
| 123 } | |
| 124 } | |
| 125 | |
| 126 void DhcpProxyScriptFetcherWin::OnGetCandidateAdapterNamesDone( | |
| 127 scoped_refptr<AdapterQuery> query) { | |
| 128 DCHECK(CalledOnValidThread()); | |
| 129 | |
| 130 // This can happen if this object is reused for multiple queries, | |
| 131 // and a previous query was cancelled before it completed. | |
| 132 if (query.get() != last_query_.get()) | |
| 133 return; | |
| 134 last_query_ = NULL; | |
| 135 | |
| 136 // Enable unit tests to wait for this to happen; in production this function | |
| 137 // call is a no-op. | |
| 138 ImplOnGetCandidateAdapterNamesDone(); | |
| 139 | |
| 140 // We may have been cancelled. | |
| 141 if (state_ != STATE_WAIT_ADAPTERS) | |
| 142 return; | |
| 143 | |
| 144 state_ = STATE_NO_RESULTS; | |
| 145 | |
| 146 const std::set<std::string>& adapter_names = query->adapter_names(); | |
| 147 | |
| 148 if (adapter_names.empty()) { | |
| 149 TransitionToDone(); | |
| 150 return; | |
| 151 } | |
| 152 | |
| 153 for (std::set<std::string>::const_iterator it = adapter_names.begin(); | |
| 154 it != adapter_names.end(); | |
| 155 ++it) { | |
| 156 DhcpProxyScriptAdapterFetcher* fetcher(ImplCreateAdapterFetcher()); | |
| 157 fetcher->Fetch( | |
| 158 *it, base::Bind(&DhcpProxyScriptFetcherWin::OnFetcherDone, | |
| 159 base::Unretained(this))); | |
| 160 fetchers_.push_back(fetcher); | |
| 161 } | |
| 162 num_pending_fetchers_ = fetchers_.size(); | |
| 163 } | |
| 164 | |
| 165 std::string DhcpProxyScriptFetcherWin::GetFetcherName() const { | |
| 166 DCHECK(CalledOnValidThread()); | |
| 167 return "win"; | |
| 168 } | |
| 169 | |
| 170 const GURL& DhcpProxyScriptFetcherWin::GetPacURL() const { | |
| 171 DCHECK(CalledOnValidThread()); | |
| 172 DCHECK_EQ(state_, STATE_DONE); | |
| 173 | |
| 174 return pac_url_; | |
| 175 } | |
| 176 | |
| 177 void DhcpProxyScriptFetcherWin::OnFetcherDone(int result) { | |
| 178 DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS); | |
| 179 | |
| 180 if (--num_pending_fetchers_ == 0) { | |
| 181 TransitionToDone(); | |
| 182 return; | |
| 183 } | |
| 184 | |
| 185 // If the only pending adapters are those less preferred than one | |
| 186 // with a valid PAC script, we do not need to wait any longer. | |
| 187 for (FetcherVector::iterator it = fetchers_.begin(); | |
| 188 it != fetchers_.end(); | |
| 189 ++it) { | |
| 190 bool did_finish = (*it)->DidFinish(); | |
| 191 int result = (*it)->GetResult(); | |
| 192 if (did_finish && result == OK) { | |
| 193 TransitionToDone(); | |
| 194 return; | |
| 195 } | |
| 196 if (!did_finish || result != ERR_PAC_NOT_IN_DHCP) { | |
| 197 break; | |
| 198 } | |
| 199 } | |
| 200 | |
| 201 // Once we have a single result, we set a maximum on how long to wait | |
| 202 // for the rest of the results. | |
| 203 if (state_ == STATE_NO_RESULTS) { | |
| 204 state_ = STATE_SOME_RESULTS; | |
| 205 wait_timer_.Start(FROM_HERE, | |
| 206 ImplGetMaxWait(), this, &DhcpProxyScriptFetcherWin::OnWaitTimer); | |
| 207 } | |
| 208 } | |
| 209 | |
| 210 void DhcpProxyScriptFetcherWin::OnWaitTimer() { | |
| 211 DCHECK_EQ(state_, STATE_SOME_RESULTS); | |
| 212 | |
| 213 TransitionToDone(); | |
| 214 } | |
| 215 | |
| 216 void DhcpProxyScriptFetcherWin::TransitionToDone() { | |
| 217 DCHECK(state_ == STATE_NO_RESULTS || state_ == STATE_SOME_RESULTS); | |
| 218 | |
| 219 int result = ERR_PAC_NOT_IN_DHCP; // Default if no fetchers. | |
| 220 if (!fetchers_.empty()) { | |
| 221 // Scan twice for the result; once through the whole list for success, | |
| 222 // then if no success, return result for most preferred network adapter, | |
| 223 // preferring "real" network errors to the ERR_PAC_NOT_IN_DHCP error. | |
| 224 // Default to ERR_ABORTED if no fetcher completed. | |
| 225 result = ERR_ABORTED; | |
| 226 for (FetcherVector::iterator it = fetchers_.begin(); | |
| 227 it != fetchers_.end(); | |
| 228 ++it) { | |
| 229 if ((*it)->DidFinish() && (*it)->GetResult() == OK) { | |
| 230 result = OK; | |
| 231 *destination_string_ = (*it)->GetPacScript(); | |
| 232 pac_url_ = (*it)->GetPacURL(); | |
| 233 break; | |
| 234 } | |
| 235 } | |
| 236 if (result != OK) { | |
| 237 destination_string_->clear(); | |
| 238 for (FetcherVector::iterator it = fetchers_.begin(); | |
| 239 it != fetchers_.end(); | |
| 240 ++it) { | |
| 241 if ((*it)->DidFinish()) { | |
| 242 result = (*it)->GetResult(); | |
| 243 if (result != ERR_PAC_NOT_IN_DHCP) { | |
| 244 break; | |
| 245 } | |
| 246 } | |
| 247 } | |
| 248 } | |
| 249 } | |
| 250 | |
| 251 CompletionCallback callback = callback_; | |
| 252 CancelImpl(); | |
| 253 DCHECK_EQ(state_, STATE_DONE); | |
| 254 DCHECK(fetchers_.empty()); | |
| 255 DCHECK(callback_.is_null()); // Invariant of data. | |
| 256 | |
| 257 // We may be deleted re-entrantly within this outcall. | |
| 258 callback.Run(result); | |
| 259 } | |
| 260 | |
| 261 int DhcpProxyScriptFetcherWin::num_pending_fetchers() const { | |
| 262 return num_pending_fetchers_; | |
| 263 } | |
| 264 | |
| 265 URLRequestContext* DhcpProxyScriptFetcherWin::url_request_context() const { | |
| 266 return url_request_context_; | |
| 267 } | |
| 268 | |
| 269 scoped_refptr<base::TaskRunner> DhcpProxyScriptFetcherWin::GetTaskRunner() { | |
| 270 return worker_pool_->GetTaskRunnerWithShutdownBehavior( | |
| 271 base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN); | |
| 272 } | |
| 273 | |
| 274 DhcpProxyScriptAdapterFetcher* | |
| 275 DhcpProxyScriptFetcherWin::ImplCreateAdapterFetcher() { | |
| 276 return new DhcpProxyScriptAdapterFetcher(url_request_context_, | |
| 277 GetTaskRunner()); | |
| 278 } | |
| 279 | |
| 280 DhcpProxyScriptFetcherWin::AdapterQuery* | |
| 281 DhcpProxyScriptFetcherWin::ImplCreateAdapterQuery() { | |
| 282 return new AdapterQuery(); | |
| 283 } | |
| 284 | |
| 285 base::TimeDelta DhcpProxyScriptFetcherWin::ImplGetMaxWait() { | |
| 286 return base::TimeDelta::FromMilliseconds(kMaxWaitAfterFirstResultMs); | |
| 287 } | |
| 288 | |
| 289 bool DhcpProxyScriptFetcherWin::GetCandidateAdapterNames( | |
| 290 std::set<std::string>* adapter_names) { | |
| 291 DCHECK(adapter_names); | |
| 292 adapter_names->clear(); | |
| 293 | |
| 294 // The GetAdaptersAddresses MSDN page recommends using a size of 15000 to | |
| 295 // avoid reallocation. | |
| 296 ULONG adapters_size = 15000; | |
| 297 scoped_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> adapters; | |
| 298 ULONG error = ERROR_SUCCESS; | |
| 299 int num_tries = 0; | |
| 300 | |
| 301 do { | |
| 302 adapters.reset(static_cast<IP_ADAPTER_ADDRESSES*>(malloc(adapters_size))); | |
| 303 // Return only unicast addresses, and skip information we do not need. | |
| 304 error = GetAdaptersAddresses(AF_UNSPEC, | |
| 305 GAA_FLAG_SKIP_ANYCAST | | |
| 306 GAA_FLAG_SKIP_MULTICAST | | |
| 307 GAA_FLAG_SKIP_DNS_SERVER | | |
| 308 GAA_FLAG_SKIP_FRIENDLY_NAME, | |
| 309 NULL, | |
| 310 adapters.get(), | |
| 311 &adapters_size); | |
| 312 ++num_tries; | |
| 313 } while (error == ERROR_BUFFER_OVERFLOW && num_tries <= 3); | |
| 314 | |
| 315 if (error == ERROR_NO_DATA) { | |
| 316 // There are no adapters that we care about. | |
| 317 return true; | |
| 318 } | |
| 319 | |
| 320 if (error != ERROR_SUCCESS) { | |
| 321 LOG(WARNING) << "Unexpected error retrieving WPAD configuration from DHCP."; | |
| 322 return false; | |
| 323 } | |
| 324 | |
| 325 IP_ADAPTER_ADDRESSES* adapter = NULL; | |
| 326 for (adapter = adapters.get(); adapter; adapter = adapter->Next) { | |
| 327 if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) | |
| 328 continue; | |
| 329 if ((adapter->Flags & IP_ADAPTER_DHCP_ENABLED) == 0) | |
| 330 continue; | |
| 331 | |
| 332 DCHECK(adapter->AdapterName); | |
| 333 adapter_names->insert(adapter->AdapterName); | |
| 334 } | |
| 335 | |
| 336 return true; | |
| 337 } | |
| 338 | |
| 339 DhcpProxyScriptFetcherWin::AdapterQuery::AdapterQuery() { | |
| 340 } | |
| 341 | |
| 342 DhcpProxyScriptFetcherWin::AdapterQuery::~AdapterQuery() { | |
| 343 } | |
| 344 | |
| 345 void DhcpProxyScriptFetcherWin::AdapterQuery::GetCandidateAdapterNames() { | |
| 346 ImplGetCandidateAdapterNames(&adapter_names_); | |
| 347 } | |
| 348 | |
| 349 const std::set<std::string>& | |
| 350 DhcpProxyScriptFetcherWin::AdapterQuery::adapter_names() const { | |
| 351 return adapter_names_; | |
| 352 } | |
| 353 | |
| 354 bool DhcpProxyScriptFetcherWin::AdapterQuery::ImplGetCandidateAdapterNames( | |
| 355 std::set<std::string>* adapter_names) { | |
| 356 return DhcpProxyScriptFetcherWin::GetCandidateAdapterNames(adapter_names); | |
| 357 } | |
| 358 | |
| 359 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master