blob: 9351b873f104b173724f53328f96dbbe5af5e7fa [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
2 * libjingle
3 * Copyright 2004--2005, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#ifdef HAVE_CONFIG_H
29#include "config.h"
30#endif
31
32#include "talk/base/network.h"
33
34#ifdef POSIX
35#include <sys/socket.h>
36#include <sys/utsname.h>
37#include <sys/ioctl.h>
38#include <net/if.h>
39#include <unistd.h>
40#include <errno.h>
41#ifdef ANDROID
42#include "talk/base/ifaddrs-android.h"
43#else
44#include <ifaddrs.h>
45#endif
46#endif // POSIX
47
48#ifdef WIN32
49#include "talk/base/win32.h"
50#include <Iphlpapi.h>
51#endif
52
53#include <algorithm>
54#include <cstdio>
55
56#include "talk/base/host.h"
57#include "talk/base/logging.h"
58#include "talk/base/scoped_ptr.h"
59#include "talk/base/socket.h" // includes something that makes windows happy
60#include "talk/base/stream.h"
61#include "talk/base/stringencode.h"
62#include "talk/base/thread.h"
63
64namespace talk_base {
65namespace {
66
67const uint32 kUpdateNetworksMessage = 1;
68const uint32 kSignalNetworksMessage = 2;
69
70// Fetch list of networks every two seconds.
71const int kNetworksUpdateIntervalMs = 2000;
72
73
74// Makes a string key for this network. Used in the network manager's maps.
75// Network objects are keyed on interface name, network prefix and the
76// length of that prefix.
77std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
78 int prefix_length) {
79 std::ostringstream ost;
80 ost << name << "%" << prefix.ToString() << "/" << prefix_length;
81 return ost.str();
82}
83
84bool CompareNetworks(const Network* a, const Network* b) {
85 if (a->prefix_length() == b->prefix_length()) {
86 if (a->name() == b->name()) {
87 return a->prefix() < b->prefix();
88 }
89 }
90 return a->name() < b->name();
91}
92
93
94} // namespace
95
96NetworkManager::NetworkManager() {
97}
98
99NetworkManager::~NetworkManager() {
100}
101
102NetworkManagerBase::NetworkManagerBase() : ipv6_enabled_(true) {
103}
104
105NetworkManagerBase::~NetworkManagerBase() {
106 for (NetworkMap::iterator i = networks_map_.begin();
107 i != networks_map_.end(); ++i) {
108 delete i->second;
109 }
110}
111
112void NetworkManagerBase::GetNetworks(NetworkList* result) const {
113 *result = networks_;
114}
115
116void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks,
117 bool* changed) {
118 // Sort the list so that we can detect when it changes.
119 typedef std::pair<Network*, std::vector<IPAddress> > address_list;
120 std::map<std::string, address_list> address_map;
121 NetworkList list(new_networks);
122 NetworkList merged_list;
123 std::sort(list.begin(), list.end(), CompareNetworks);
124
125 *changed = false;
126
127 if (networks_.size() != list.size())
128 *changed = true;
129
130 // First, build a set of network-keys to the ipaddresses.
131 for (uint32 i = 0; i < list.size(); ++i) {
132 bool might_add_to_merged_list = false;
133 std::string key = MakeNetworkKey(list[i]->name(),
134 list[i]->prefix(),
135 list[i]->prefix_length());
136 if (address_map.find(key) == address_map.end()) {
137 address_map[key] = address_list(list[i], std::vector<IPAddress>());
138 might_add_to_merged_list = true;
139 }
140 const std::vector<IPAddress>& addresses = list[i]->GetIPs();
141 address_list& current_list = address_map[key];
142 for (std::vector<IPAddress>::const_iterator it = addresses.begin();
143 it != addresses.end();
144 ++it) {
145 current_list.second.push_back(*it);
146 }
147 if (!might_add_to_merged_list) {
148 delete list[i];
149 }
150 }
151
152 // Next, look for existing network objects to re-use.
153 for (std::map<std::string, address_list >::iterator it = address_map.begin();
154 it != address_map.end();
155 ++it) {
156 const std::string& key = it->first;
157 Network* net = it->second.first;
158 NetworkMap::iterator existing = networks_map_.find(key);
159 if (existing == networks_map_.end()) {
160 // This network is new. Place it in the network map.
161 merged_list.push_back(net);
162 networks_map_[key] = net;
163 *changed = true;
164 } else {
165 // This network exists in the map already. Reset its IP addresses.
166 *changed = existing->second->SetIPs(it->second.second, *changed);
167 merged_list.push_back(existing->second);
168 if (existing->second != net) {
169 delete net;
170 }
171 }
172 }
173 networks_ = merged_list;
174}
175
176BasicNetworkManager::BasicNetworkManager()
177 : thread_(NULL),
178 start_count_(0) {
179}
180
181BasicNetworkManager::~BasicNetworkManager() {
182}
183
184#if defined(POSIX)
185void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
186 bool include_ignored,
187 NetworkList* networks) const {
188 NetworkMap current_networks;
189 for (struct ifaddrs* cursor = interfaces;
190 cursor != NULL; cursor = cursor->ifa_next) {
191 IPAddress prefix;
192 IPAddress mask;
193 IPAddress ip;
194 int scope_id = 0;
195
196 // Some interfaces may not have address assigned.
197 if (!cursor->ifa_addr || !cursor->ifa_netmask)
198 continue;
199
200 switch (cursor->ifa_addr->sa_family) {
201 case AF_INET: {
202 ip = IPAddress(
203 reinterpret_cast<sockaddr_in*>(cursor->ifa_addr)->sin_addr);
204 mask = IPAddress(
205 reinterpret_cast<sockaddr_in*>(cursor->ifa_netmask)->sin_addr);
206 break;
207 }
208 case AF_INET6: {
209 if (ipv6_enabled()) {
210 ip = IPAddress(
211 reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_addr);
212 mask = IPAddress(
213 reinterpret_cast<sockaddr_in6*>(cursor->ifa_netmask)->sin6_addr);
214 scope_id =
215 reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
216 break;
217 } else {
218 continue;
219 }
220 }
221 default: {
222 continue;
223 }
224 }
225 int prefix_length = CountIPMaskBits(mask);
226 prefix = TruncateIP(ip, prefix_length);
227 std::string key = MakeNetworkKey(std::string(cursor->ifa_name),
228 prefix, prefix_length);
229 NetworkMap::iterator existing_network = current_networks.find(key);
230 if (existing_network == current_networks.end()) {
231 scoped_ptr<Network> network(new Network(cursor->ifa_name,
232 cursor->ifa_name,
233 prefix,
234 prefix_length));
235 network->set_scope_id(scope_id);
236 network->AddIP(ip);
237 bool ignored = ((cursor->ifa_flags & IFF_LOOPBACK) ||
238 IsIgnoredNetwork(*network));
239 network->set_ignored(ignored);
240 if (include_ignored || !network->ignored()) {
241 networks->push_back(network.release());
242 }
243 } else {
244 (*existing_network).second->AddIP(ip);
245 }
246 }
247}
248
249bool BasicNetworkManager::CreateNetworks(bool include_ignored,
250 NetworkList* networks) const {
251 struct ifaddrs* interfaces;
252 int error = getifaddrs(&interfaces);
253 if (error != 0) {
254 LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error;
255 return false;
256 }
257
258 ConvertIfAddrs(interfaces, include_ignored, networks);
259
260 freeifaddrs(interfaces);
261 return true;
262}
263
264#elif defined(WIN32)
265
266unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
267 const IPAddress& ip, IPAddress* prefix) {
268 IPAddress current_prefix;
269 IPAddress best_prefix;
270 unsigned int best_length = 0;
271 while (prefixlist) {
272 // Look for the longest matching prefix in the prefixlist.
273 if (prefixlist->Address.lpSockaddr == NULL ||
274 prefixlist->Address.lpSockaddr->sa_family != ip.family()) {
275 prefixlist = prefixlist->Next;
276 continue;
277 }
278 switch (prefixlist->Address.lpSockaddr->sa_family) {
279 case AF_INET: {
280 sockaddr_in* v4_addr =
281 reinterpret_cast<sockaddr_in*>(prefixlist->Address.lpSockaddr);
282 current_prefix = IPAddress(v4_addr->sin_addr);
283 break;
284 }
285 case AF_INET6: {
286 sockaddr_in6* v6_addr =
287 reinterpret_cast<sockaddr_in6*>(prefixlist->Address.lpSockaddr);
288 current_prefix = IPAddress(v6_addr->sin6_addr);
289 break;
290 }
291 default: {
292 prefixlist = prefixlist->Next;
293 continue;
294 }
295 }
296 if (TruncateIP(ip, prefixlist->PrefixLength) == current_prefix &&
297 prefixlist->PrefixLength > best_length) {
298 best_prefix = current_prefix;
299 best_length = prefixlist->PrefixLength;
300 }
301 prefixlist = prefixlist->Next;
302 }
303 *prefix = best_prefix;
304 return best_length;
305}
306
307bool BasicNetworkManager::CreateNetworks(bool include_ignored,
308 NetworkList* networks) const {
309 NetworkMap current_networks;
310 // MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses.
311 size_t buffer_size = 16384;
312 scoped_array<char> adapter_info(new char[buffer_size]);
313 PIP_ADAPTER_ADDRESSES adapter_addrs =
314 reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
315 int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST |
316 GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_INCLUDE_PREFIX);
317 int ret = 0;
318 do {
319 adapter_info.reset(new char[buffer_size]);
320 adapter_addrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
321 ret = GetAdaptersAddresses(AF_UNSPEC, adapter_flags,
322 0, adapter_addrs,
323 reinterpret_cast<PULONG>(&buffer_size));
324 } while (ret == ERROR_BUFFER_OVERFLOW);
325 if (ret != ERROR_SUCCESS) {
326 return false;
327 }
328 int count = 0;
329 while (adapter_addrs) {
330 if (adapter_addrs->OperStatus == IfOperStatusUp) {
331 PIP_ADAPTER_UNICAST_ADDRESS address = adapter_addrs->FirstUnicastAddress;
332 PIP_ADAPTER_PREFIX prefixlist = adapter_addrs->FirstPrefix;
333 std::string name;
334 std::string description;
335#ifdef _DEBUG
336 name = ToUtf8(adapter_addrs->FriendlyName,
337 wcslen(adapter_addrs->FriendlyName));
338#endif
339 description = ToUtf8(adapter_addrs->Description,
340 wcslen(adapter_addrs->Description));
341 for (; address; address = address->Next) {
342#ifndef _DEBUG
343 name = talk_base::ToString(count);
344#endif
345
346 IPAddress ip;
347 int scope_id = 0;
348 scoped_ptr<Network> network;
349 switch (address->Address.lpSockaddr->sa_family) {
350 case AF_INET: {
351 sockaddr_in* v4_addr =
352 reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
353 ip = IPAddress(v4_addr->sin_addr);
354 break;
355 }
356 case AF_INET6: {
357 if (ipv6_enabled()) {
358 sockaddr_in6* v6_addr =
359 reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);
360 scope_id = v6_addr->sin6_scope_id;
361 ip = IPAddress(v6_addr->sin6_addr);
362 break;
363 } else {
364 continue;
365 }
366 }
367 default: {
368 continue;
369 }
370 }
371 IPAddress prefix;
372 int prefix_length = GetPrefix(prefixlist, ip, &prefix);
373 std::string key = MakeNetworkKey(name, prefix, prefix_length);
374 NetworkMap::iterator existing_network = current_networks.find(key);
375 if (existing_network == current_networks.end()) {
376 scoped_ptr<Network> network(new Network(name,
377 description,
378 prefix,
379 prefix_length));
380 network->set_scope_id(scope_id);
381 network->AddIP(ip);
382 bool ignore = ((adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) ||
383 IsIgnoredNetwork(*network));
384 network->set_ignored(ignore);
385 if (include_ignored || !network->ignored()) {
386 networks->push_back(network.release());
387 }
388 } else {
389 (*existing_network).second->AddIP(ip);
390 }
391 }
392 // Count is per-adapter - all 'Networks' created from the same
393 // adapter need to have the same name.
394 ++count;
395 }
396 adapter_addrs = adapter_addrs->Next;
397 }
398 return true;
399}
400#endif // WIN32
401
402bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) {
403#ifdef POSIX
404 // Ignore local networks (lo, lo0, etc)
405 // Also filter out VMware interfaces, typically named vmnet1 and vmnet8
406 if (strncmp(network.name().c_str(), "vmnet", 5) == 0 ||
407 strncmp(network.name().c_str(), "vnic", 4) == 0) {
408 return true;
409 }
410#elif defined(WIN32)
411 // Ignore any HOST side vmware adapters with a description like:
412 // VMware Virtual Ethernet Adapter for VMnet1
413 // but don't ignore any GUEST side adapters with a description like:
414 // VMware Accelerated AMD PCNet Adapter #2
415 if (strstr(network.description().c_str(), "VMnet") != NULL) {
416 return true;
417 }
418#endif
419
420 // Ignore any networks with a 0.x.y.z IP
421 if (network.prefix().family() == AF_INET) {
422 return (network.prefix().v4AddressAsHostOrderInteger() < 0x01000000);
423 }
424 return false;
425}
426
427void BasicNetworkManager::StartUpdating() {
428 thread_ = Thread::Current();
429 if (start_count_) {
430 // If network interfaces are already discovered and signal is sent,
431 // we should trigger network signal immediately for the new clients
432 // to start allocating ports.
433 if (sent_first_update_)
434 thread_->Post(this, kSignalNetworksMessage);
435 } else {
436 thread_->Post(this, kUpdateNetworksMessage);
437 }
438 ++start_count_;
439}
440
441void BasicNetworkManager::StopUpdating() {
442 ASSERT(Thread::Current() == thread_);
443 if (!start_count_)
444 return;
445
446 --start_count_;
447 if (!start_count_) {
448 thread_->Clear(this);
449 sent_first_update_ = false;
450 }
451}
452
453void BasicNetworkManager::OnMessage(Message* msg) {
454 switch (msg->message_id) {
455 case kUpdateNetworksMessage: {
456 DoUpdateNetworks();
457 break;
458 }
459 case kSignalNetworksMessage: {
460 SignalNetworksChanged();
461 break;
462 }
463 default:
464 ASSERT(false);
465 }
466}
467
468void BasicNetworkManager::DoUpdateNetworks() {
469 if (!start_count_)
470 return;
471
472 ASSERT(Thread::Current() == thread_);
473
474 NetworkList list;
475 if (!CreateNetworks(false, &list)) {
476 SignalError();
477 } else {
478 bool changed;
479 MergeNetworkList(list, &changed);
480 if (changed || !sent_first_update_) {
481 SignalNetworksChanged();
482 sent_first_update_ = true;
483 }
484 }
485
486 thread_->PostDelayed(kNetworksUpdateIntervalMs, this, kUpdateNetworksMessage);
487}
488
489void BasicNetworkManager::DumpNetworks(bool include_ignored) {
490 NetworkList list;
491 CreateNetworks(include_ignored, &list);
492 LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:";
493 for (size_t i = 0; i < list.size(); ++i) {
494 const Network* network = list[i];
495 if (!network->ignored() || include_ignored) {
496 LOG(LS_INFO) << network->ToString() << ": "
497 << network->description()
498 << ((network->ignored()) ? ", Ignored" : "");
499 }
500 }
henrike@webrtc.org723d6832013-07-12 16:04:50 +0000501 // Release the network list created previously.
502 // Do this in a seperated for loop for better readability.
503 for (size_t i = 0; i < list.size(); ++i) {
504 delete list[i];
505 }
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000506}
507
508Network::Network(const std::string& name, const std::string& desc,
509 const IPAddress& prefix, int prefix_length)
510 : name_(name), description_(desc), prefix_(prefix),
511 prefix_length_(prefix_length), scope_id_(0), ignored_(false),
512 uniform_numerator_(0), uniform_denominator_(0), exponential_numerator_(0),
513 exponential_denominator_(0) {
514}
515
516std::string Network::ToString() const {
517 std::stringstream ss;
518 // Print out the first space-terminated token of the network desc, plus
519 // the IP address.
520 ss << "Net[" << description_.substr(0, description_.find(' '))
521 << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_ << "]";
522 return ss.str();
523}
524
525// Sets the addresses of this network. Returns true if the address set changed.
526// Change detection is short circuited if the changed argument is true.
527bool Network::SetIPs(const std::vector<IPAddress>& ips, bool changed) {
528 changed = changed || ips.size() != ips_.size();
529 // Detect changes with a nested loop; n-squared but we expect on the order
530 // of 2-3 addresses per network.
531 for (std::vector<IPAddress>::const_iterator it = ips.begin();
532 !changed && it != ips.end();
533 ++it) {
534 bool found = false;
535 for (std::vector<IPAddress>::iterator inner_it = ips_.begin();
536 !found && inner_it != ips_.end();
537 ++inner_it) {
538 if (*it == *inner_it) {
539 found = true;
540 }
541 }
542 changed = !found;
543 }
544 ips_ = ips;
545 return changed;
546}
547} // namespace talk_base