net/proxy/dhcp_proxy_script_fetcher_win.cc

   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