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