net/base/network_change_notifier_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/base/network_change_notifier_win.h"
   6
   7 #include <iphlpapi.h>
   8 #include <winsock2.h>
   9
  10 #include "base/bind.h"
  11 #include "base/logging.h"
  12 #include "base/metrics/histogram.h"
  13 #include "base/threading/thread.h"
  14 #include "base/time/time.h"
  15 #include "net/base/winsock_init.h"
  16 #include "net/dns/dns_config_service.h"
  17
  18 #pragma comment(lib, "iphlpapi.lib")
  19
  20 namespace net {
  21
  22 namespace {
  23
  24 // Time between NotifyAddrChange retries, on failure.
  25 const int kWatchForAddressChangeRetryIntervalMs = 500;
  26
  27 }  // namespace
  28
  29 // Thread on which we can run DnsConfigService, which requires AssertIOAllowed
  30 // to open registry keys and to handle FilePathWatcher updates.
  31 class NetworkChangeNotifierWin::DnsConfigServiceThread : public base::Thread {
  32  public:
  33   DnsConfigServiceThread() : base::Thread("DnsConfigService") {}
  34
  35   virtual ~DnsConfigServiceThread() {
  36     Stop();
  37   }
  38
  39   virtual void Init() OVERRIDE {
  40     service_ = DnsConfigService::CreateSystemService();
  41     service_->WatchConfig(base::Bind(&NetworkChangeNotifier::SetDnsConfig));
  42   }
  43
  44   virtual void CleanUp() OVERRIDE {
  45     service_.reset();
  46   }
  47
  48  private:
  49   scoped_ptr<DnsConfigService> service_;
  50
  51   DISALLOW_COPY_AND_ASSIGN(DnsConfigServiceThread);
  52 };
  53
  54 NetworkChangeNotifierWin::NetworkChangeNotifierWin()
  55     : NetworkChangeNotifier(NetworkChangeCalculatorParamsWin()),
  56       is_watching_(false),
  57       sequential_failures_(0),
  58       weak_factory_(this),
  59       dns_config_service_thread_(new DnsConfigServiceThread()),
  60       last_computed_connection_type_(RecomputeCurrentConnectionType()),
  61       last_announced_offline_(
  62           last_computed_connection_type_ == CONNECTION_NONE) {
  63   memset(&addr_overlapped_, 0, sizeof addr_overlapped_);
  64   addr_overlapped_.hEvent = WSACreateEvent();
  65 }
  66
  67 NetworkChangeNotifierWin::~NetworkChangeNotifierWin() {
  68   if (is_watching_) {
  69     CancelIPChangeNotify(&addr_overlapped_);
  70     addr_watcher_.StopWatching();
  71   }
  72   WSACloseEvent(addr_overlapped_.hEvent);
  73 }
  74
  75 // static
  76 NetworkChangeNotifier::NetworkChangeCalculatorParams
  77 NetworkChangeNotifierWin::NetworkChangeCalculatorParamsWin() {
  78   NetworkChangeCalculatorParams params;
  79   // Delay values arrived at by simple experimentation and adjusted so as to
  80   // produce a single signal when switching between network connections.
  81   params.ip_address_offline_delay_ = base::TimeDelta::FromMilliseconds(1500);
  82   params.ip_address_online_delay_ = base::TimeDelta::FromMilliseconds(1500);
  83   params.connection_type_offline_delay_ =
  84       base::TimeDelta::FromMilliseconds(1500);
  85   params.connection_type_online_delay_ = base::TimeDelta::FromMilliseconds(500);
  86   return params;
  87 }
  88
  89 // This implementation does not return the actual connection type but merely
  90 // determines if the user is "online" (in which case it returns
  91 // CONNECTION_UNKNOWN) or "offline" (and then it returns CONNECTION_NONE).
  92 // This is challenging since the only thing we can test with certainty is
  93 // whether a *particular* host is reachable.
  94 //
  95 // While we can't conclusively determine when a user is "online", we can at
  96 // least reliably recognize some of the situtations when they are clearly
  97 // "offline". For example, if the user's laptop is not plugged into an ethernet
  98 // network and is not connected to any wireless networks, it must be offline.
  99 //
 100 // There are a number of different ways to implement this on Windows, each with
 101 // their pros and cons. Here is a comparison of various techniques considered:
 102 //
 103 // (1) Use InternetGetConnectedState (wininet.dll). This function is really easy
 104 // to use (literally a one-liner), and runs quickly. The drawback is it adds a
 105 // dependency on the wininet DLL.
 106 //
 107 // (2) Enumerate all of the network interfaces using GetAdaptersAddresses
 108 // (iphlpapi.dll), and assume we are "online" if there is at least one interface
 109 // that is connected, and that interface is not a loopback or tunnel.
 110 //
 111 // Safari on Windows has a fairly simple implementation that does this:
 112 // http://trac.webkit.org/browser/trunk/WebCore/platform/network/win/NetworkStateNotifierWin.cpp.
 113 //
 114 // Mozilla similarly uses this approach:
 115 // http://mxr.mozilla.org/mozilla1.9.2/source/netwerk/system/win32/nsNotifyAddrListener.cpp
 116 //
 117 // The biggest drawback to this approach is it is quite complicated.
 118 // WebKit's implementation for example doesn't seem to test for ICS gateways
 119 // (internet connection sharing), whereas Mozilla's implementation has extra
 120 // code to guess that.
 121 //
 122 // (3) The method used in this file comes from google talk, and is similar to
 123 // method (2). The main difference is it enumerates the winsock namespace
 124 // providers rather than the actual adapters.
 125 //
 126 // I ran some benchmarks comparing the performance of each on my Windows 7
 127 // workstation. Here is what I found:
 128 //   * Approach (1) was pretty much zero-cost after the initial call.
 129 //   * Approach (2) took an average of 3.25 milliseconds to enumerate the
 130 //     adapters.
 131 //   * Approach (3) took an average of 0.8 ms to enumerate the providers.
 132 //
 133 // In terms of correctness, all three approaches were comparable for the simple
 134 // experiments I ran... However none of them correctly returned "offline" when
 135 // executing 'ipconfig /release'.
 136 //
 137 NetworkChangeNotifier::ConnectionType
 138 NetworkChangeNotifierWin::RecomputeCurrentConnectionType() const {
 139   DCHECK(CalledOnValidThread());
 140
 141   EnsureWinsockInit();
 142
 143   // The following code was adapted from:
 144   // http://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/net/notifier/base/win/async_network_alive_win32.cc?view=markup&pathrev=47343
 145   // The main difference is we only call WSALookupServiceNext once, whereas
 146   // the earlier code would traverse the entire list and pass LUP_FLUSHPREVIOUS
 147   // to skip past the large results.
 148
 149   HANDLE ws_handle;
 150   WSAQUERYSET query_set = {0};
 151   query_set.dwSize = sizeof(WSAQUERYSET);
 152   query_set.dwNameSpace = NS_NLA;
 153   // Initiate a client query to iterate through the
 154   // currently connected networks.
 155   if (0 != WSALookupServiceBegin(&query_set, LUP_RETURN_ALL,
 156                                  &ws_handle)) {
 157     LOG(ERROR) << "WSALookupServiceBegin failed with: " << WSAGetLastError();
 158     return NetworkChangeNotifier::CONNECTION_UNKNOWN;
 159   }
 160
 161   bool found_connection = false;
 162
 163   // Retrieve the first available network. In this function, we only
 164   // need to know whether or not there is network connection.
 165   // Allocate 256 bytes for name, it should be enough for most cases.
 166   // If the name is longer, it is OK as we will check the code returned and
 167   // set correct network status.
 168   char result_buffer[sizeof(WSAQUERYSET) + 256] = {0};
 169   DWORD length = sizeof(result_buffer);
 170   reinterpret_cast<WSAQUERYSET*>(&result_buffer[0])->dwSize =
 171       sizeof(WSAQUERYSET);
 172   int result = WSALookupServiceNext(
 173       ws_handle,
 174       LUP_RETURN_NAME,
 175       &length,
 176       reinterpret_cast<WSAQUERYSET*>(&result_buffer[0]));
 177
 178   if (result == 0) {
 179     // Found a connection!
 180     found_connection = true;
 181   } else {
 182     DCHECK_EQ(SOCKET_ERROR, result);
 183     result = WSAGetLastError();
 184
 185     // Error code WSAEFAULT means there is a network connection but the
 186     // result_buffer size is too small to contain the results. The
 187     // variable "length" returned from WSALookupServiceNext is the minimum
 188     // number of bytes required. We do not need to retrieve detail info,
 189     // it is enough knowing there was a connection.
 190     if (result == WSAEFAULT) {
 191       found_connection = true;
 192     } else if (result == WSA_E_NO_MORE || result == WSAENOMORE) {
 193       // There was nothing to iterate over!
 194     } else {
 195       LOG(WARNING) << "WSALookupServiceNext() failed with:" << result;
 196     }
 197   }
 198
 199   result = WSALookupServiceEnd(ws_handle);
 200   LOG_IF(ERROR, result != 0)
 201       << "WSALookupServiceEnd() failed with: " << result;
 202
 203   // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN.
 204   return found_connection ? NetworkChangeNotifier::CONNECTION_UNKNOWN :
 205                             NetworkChangeNotifier::CONNECTION_NONE;
 206 }
 207
 208 NetworkChangeNotifier::ConnectionType
 209 NetworkChangeNotifierWin::GetCurrentConnectionType() const {
 210   base::AutoLock auto_lock(last_computed_connection_type_lock_);
 211   return last_computed_connection_type_;
 212 }
 213
 214 void NetworkChangeNotifierWin::SetCurrentConnectionType(
 215     ConnectionType connection_type) {
 216   base::AutoLock auto_lock(last_computed_connection_type_lock_);
 217   last_computed_connection_type_ = connection_type;
 218 }
 219
 220 void NetworkChangeNotifierWin::OnObjectSignaled(HANDLE object) {
 221   DCHECK(CalledOnValidThread());
 222   DCHECK(is_watching_);
 223   is_watching_ = false;
 224
 225   // Start watching for the next address change.
 226   WatchForAddressChange();
 227
 228   NotifyObservers();
 229 }
 230
 231 void NetworkChangeNotifierWin::NotifyObservers() {
 232   DCHECK(CalledOnValidThread());
 233   SetCurrentConnectionType(RecomputeCurrentConnectionType());
 234   NotifyObserversOfIPAddressChange();
 235
 236   // Calling GetConnectionType() at this very moment is likely to give
 237   // the wrong result, so we delay that until a little bit later.
 238   //
 239   // The one second delay chosen here was determined experimentally
 240   // by adamk on Windows 7.
 241   // If after one second we determine we are still offline, we will
 242   // delay again.
 243   offline_polls_ = 0;
 244   timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
 245                &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
 246 }
 247
 248 void NetworkChangeNotifierWin::WatchForAddressChange() {
 249   DCHECK(CalledOnValidThread());
 250   DCHECK(!is_watching_);
 251
 252   // NotifyAddrChange occasionally fails with ERROR_OPEN_FAILED for unknown
 253   // reasons.  More rarely, it's also been observed failing with
 254   // ERROR_NO_SYSTEM_RESOURCES.  When either of these happens, we retry later.
 255   if (!WatchForAddressChangeInternal()) {
 256     ++sequential_failures_;
 257
 258     // TODO(mmenke):  If the UMA histograms indicate that this fixes
 259     // http://crbug.com/69198, remove this histogram and consider reducing the
 260     // retry interval.
 261     if (sequential_failures_ == 2000) {
 262       UMA_HISTOGRAM_COUNTS_10000("Net.NotifyAddrChangeFailures",
 263                                  sequential_failures_);
 264     }
 265
 266     base::MessageLoop::current()->PostDelayedTask(
 267         FROM_HERE,
 268         base::Bind(&NetworkChangeNotifierWin::WatchForAddressChange,
 269                    weak_factory_.GetWeakPtr()),
 270         base::TimeDelta::FromMilliseconds(
 271             kWatchForAddressChangeRetryIntervalMs));
 272     return;
 273   }
 274
 275   // Treat the transition from NotifyAddrChange failing to succeeding as a
 276   // network change event, since network changes were not being observed in
 277   // that interval.
 278   if (sequential_failures_ > 0)
 279     NotifyObservers();
 280
 281   if (sequential_failures_ < 2000) {
 282     UMA_HISTOGRAM_COUNTS_10000("Net.NotifyAddrChangeFailures",
 283                                sequential_failures_);
 284   }
 285
 286   is_watching_ = true;
 287   sequential_failures_ = 0;
 288 }
 289
 290 bool NetworkChangeNotifierWin::WatchForAddressChangeInternal() {
 291   DCHECK(CalledOnValidThread());
 292
 293   if (!dns_config_service_thread_->IsRunning()) {
 294     dns_config_service_thread_->StartWithOptions(
 295       base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 296   }
 297
 298   HANDLE handle = NULL;
 299   DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_);
 300   if (ret != ERROR_IO_PENDING)
 301     return false;
 302
 303   addr_watcher_.StartWatching(addr_overlapped_.hEvent, this);
 304   return true;
 305 }
 306
 307 void NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange() {
 308   SetCurrentConnectionType(RecomputeCurrentConnectionType());
 309   bool current_offline = IsOffline();
 310   offline_polls_++;
 311   // If we continue to appear offline, delay sending out the notification in
 312   // case we appear to go online within 20 seconds.  UMA histogram data shows
 313   // we may not detect the transition to online state after 1 second but within
 314   // 20 seconds we generally do.
 315   if (last_announced_offline_ && current_offline && offline_polls_ <= 20) {
 316     timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this,
 317                  &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange);
 318     return;
 319   }
 320   if (last_announced_offline_)
 321     UMA_HISTOGRAM_CUSTOM_COUNTS("NCN.OfflinePolls", offline_polls_, 1, 50, 50);
 322   last_announced_offline_ = current_offline;
 323
 324   NotifyObserversOfConnectionTypeChange();
 325 }
 326
 327 }  // namespace net