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_announced_offline_(IsOffline()) { 61 memset(&addr_overlapped_, 0, sizeof addr_overlapped_); 62 addr_overlapped_.hEvent = WSACreateEvent(); 63 dns_config_service_thread_->StartWithOptions( 64 base::Thread::Options(base::MessageLoop::TYPE_IO, 0)); 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::GetCurrentConnectionType() const { 139 140 // TODO(eroman): We could cache this value, and only re-calculate it on 141 // network changes. For now we recompute it each time asked, 142 // since it is relatively fast (sub 1ms) and not called often. 143 144 EnsureWinsockInit(); 145 146 // The following code was adapted from: 147 // http://src.chromium.org/viewvc/chrome/trunk/src/chrome/common/net/notifier/base/win/async_network_alive_win32.cc?view=markup&pathrev=47343 148 // The main difference is we only call WSALookupServiceNext once, whereas 149 // the earlier code would traverse the entire list and pass LUP_FLUSHPREVIOUS 150 // to skip past the large results. 151 152 HANDLE ws_handle; 153 WSAQUERYSET query_set = {0}; 154 query_set.dwSize = sizeof(WSAQUERYSET); 155 query_set.dwNameSpace = NS_NLA; 156 // Initiate a client query to iterate through the 157 // currently connected networks. 158 if (0 != WSALookupServiceBegin(&query_set, LUP_RETURN_ALL, 159 &ws_handle)) { 160 LOG(ERROR) << "WSALookupServiceBegin failed with: " << WSAGetLastError(); 161 return NetworkChangeNotifier::CONNECTION_UNKNOWN; 162 } 163 164 bool found_connection = false; 165 166 // Retrieve the first available network. In this function, we only 167 // need to know whether or not there is network connection. 168 // Allocate 256 bytes for name, it should be enough for most cases. 169 // If the name is longer, it is OK as we will check the code returned and 170 // set correct network status. 171 char result_buffer[sizeof(WSAQUERYSET) + 256] = {0}; 172 DWORD length = sizeof(result_buffer); 173 reinterpret_cast<WSAQUERYSET*>(&result_buffer[0])->dwSize = 174 sizeof(WSAQUERYSET); 175 int result = WSALookupServiceNext( 176 ws_handle, 177 LUP_RETURN_NAME, 178 &length, 179 reinterpret_cast<WSAQUERYSET*>(&result_buffer[0])); 180 181 if (result == 0) { 182 // Found a connection! 183 found_connection = true; 184 } else { 185 DCHECK_EQ(SOCKET_ERROR, result); 186 result = WSAGetLastError(); 187 188 // Error code WSAEFAULT means there is a network connection but the 189 // result_buffer size is too small to contain the results. The 190 // variable "length" returned from WSALookupServiceNext is the minimum 191 // number of bytes required. We do not need to retrieve detail info, 192 // it is enough knowing there was a connection. 193 if (result == WSAEFAULT) { 194 found_connection = true; 195 } else if (result == WSA_E_NO_MORE || result == WSAENOMORE) { 196 // There was nothing to iterate over! 197 } else { 198 LOG(WARNING) << "WSALookupServiceNext() failed with:" << result; 199 } 200 } 201 202 result = WSALookupServiceEnd(ws_handle); 203 LOG_IF(ERROR, result != 0) 204 << "WSALookupServiceEnd() failed with: " << result; 205 206 // TODO(droger): Return something more detailed than CONNECTION_UNKNOWN. 207 return found_connection ? NetworkChangeNotifier::CONNECTION_UNKNOWN : 208 NetworkChangeNotifier::CONNECTION_NONE; 209 } 210 211 void NetworkChangeNotifierWin::OnObjectSignaled(HANDLE object) { 212 DCHECK(CalledOnValidThread()); 213 DCHECK(is_watching_); 214 is_watching_ = false; 215 216 // Start watching for the next address change. 217 WatchForAddressChange(); 218 219 NotifyObservers(); 220 } 221 222 void NetworkChangeNotifierWin::NotifyObservers() { 223 DCHECK(CalledOnValidThread()); 224 NotifyObserversOfIPAddressChange(); 225 226 // Calling GetConnectionType() at this very moment is likely to give 227 // the wrong result, so we delay that until a little bit later. 228 // 229 // The one second delay chosen here was determined experimentally 230 // by adamk on Windows 7. 231 // If after one second we determine we are still offline, we will 232 // delay again. 233 offline_polls_ = 0; 234 timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this, 235 &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange); 236 } 237 238 void NetworkChangeNotifierWin::WatchForAddressChange() { 239 DCHECK(CalledOnValidThread()); 240 DCHECK(!is_watching_); 241 242 // NotifyAddrChange occasionally fails with ERROR_OPEN_FAILED for unknown 243 // reasons. More rarely, it's also been observed failing with 244 // ERROR_NO_SYSTEM_RESOURCES. When either of these happens, we retry later. 245 if (!WatchForAddressChangeInternal()) { 246 ++sequential_failures_; 247 248 // TODO(mmenke): If the UMA histograms indicate that this fixes 249 // http://crbug.com/69198, remove this histogram and consider reducing the 250 // retry interval. 251 if (sequential_failures_ == 2000) { 252 UMA_HISTOGRAM_COUNTS_10000("Net.NotifyAddrChangeFailures", 253 sequential_failures_); 254 } 255 256 base::MessageLoop::current()->PostDelayedTask( 257 FROM_HERE, 258 base::Bind(&NetworkChangeNotifierWin::WatchForAddressChange, 259 weak_factory_.GetWeakPtr()), 260 base::TimeDelta::FromMilliseconds( 261 kWatchForAddressChangeRetryIntervalMs)); 262 return; 263 } 264 265 // Treat the transition from NotifyAddrChange failing to succeeding as a 266 // network change event, since network changes were not being observed in 267 // that interval. 268 if (sequential_failures_ > 0) 269 NotifyObservers(); 270 271 if (sequential_failures_ < 2000) { 272 UMA_HISTOGRAM_COUNTS_10000("Net.NotifyAddrChangeFailures", 273 sequential_failures_); 274 } 275 276 is_watching_ = true; 277 sequential_failures_ = 0; 278 } 279 280 bool NetworkChangeNotifierWin::WatchForAddressChangeInternal() { 281 DCHECK(CalledOnValidThread()); 282 HANDLE handle = NULL; 283 DWORD ret = NotifyAddrChange(&handle, &addr_overlapped_); 284 if (ret != ERROR_IO_PENDING) 285 return false; 286 287 addr_watcher_.StartWatching(addr_overlapped_.hEvent, this); 288 return true; 289 } 290 291 void NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange() { 292 bool current_offline = IsOffline(); 293 offline_polls_++; 294 // If we continue to appear offline, delay sending out the notification in 295 // case we appear to go online within 20 seconds. UMA histogram data shows 296 // we may not detect the transition to online state after 1 second but within 297 // 20 seconds we generally do. 298 if (last_announced_offline_ && current_offline && offline_polls_ <= 20) { 299 timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(1), this, 300 &NetworkChangeNotifierWin::NotifyParentOfConnectionTypeChange); 301 return; 302 } 303 if (last_announced_offline_) 304 UMA_HISTOGRAM_CUSTOM_COUNTS("NCN.OfflinePolls", offline_polls_, 1, 50, 50); 305 last_announced_offline_ = current_offline; 306 307 NotifyObserversOfConnectionTypeChange(); 308 } 309 310 } // namespace net 311