• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #ifdef HAVE_CONFIG_H
12 #include "config.h"
13 #endif
14 
15 #include "webrtc/base/network.h"
16 
17 #if defined(WEBRTC_POSIX)
18 // linux/if.h can't be included at the same time as the posix sys/if.h, and
19 // it's transitively required by linux/route.h, so include that version on
20 // linux instead of the standard posix one.
21 #if defined(WEBRTC_LINUX)
22 #include <linux/if.h>
23 #include <linux/route.h>
24 #elif !defined(__native_client__)
25 #include <net/if.h>
26 #endif
27 #include <sys/socket.h>
28 #include <sys/utsname.h>
29 #include <sys/ioctl.h>
30 #include <unistd.h>
31 #include <errno.h>
32 
33 #if defined(WEBRTC_ANDROID)
34 #include "webrtc/base/ifaddrs-android.h"
35 #elif !defined(__native_client__)
36 #include <ifaddrs.h>
37 #endif
38 
39 #endif  // WEBRTC_POSIX
40 
41 #if defined(WEBRTC_WIN)
42 #include "webrtc/base/win32.h"
43 #include <Iphlpapi.h>
44 #endif
45 
46 #include <stdio.h>
47 
48 #include <algorithm>
49 
50 #include "webrtc/base/logging.h"
51 #include "webrtc/base/scoped_ptr.h"
52 #include "webrtc/base/socket.h"  // includes something that makes windows happy
53 #include "webrtc/base/stream.h"
54 #include "webrtc/base/stringencode.h"
55 #include "webrtc/base/thread.h"
56 
57 namespace rtc {
58 namespace {
59 
60 const uint32 kUpdateNetworksMessage = 1;
61 const uint32 kSignalNetworksMessage = 2;
62 
63 // Fetch list of networks every two seconds.
64 const int kNetworksUpdateIntervalMs = 2000;
65 
66 const int kHighestNetworkPreference = 127;
67 
68 typedef struct {
69   Network* net;
70   std::vector<InterfaceAddress> ips;
71 } AddressList;
72 
CompareNetworks(const Network * a,const Network * b)73 bool CompareNetworks(const Network* a, const Network* b) {
74   if (a->prefix_length() == b->prefix_length()) {
75     if (a->name() == b->name()) {
76       return a->prefix() < b->prefix();
77     }
78   }
79   return a->name() < b->name();
80 }
81 
SortNetworks(const Network * a,const Network * b)82 bool SortNetworks(const Network* a, const Network* b) {
83   // Network types will be preferred above everything else while sorting
84   // Networks.
85 
86   // Networks are sorted first by type.
87   if (a->type() != b->type()) {
88     return a->type() < b->type();
89   }
90 
91   IPAddress ip_a = a->GetBestIP();
92   IPAddress ip_b = b->GetBestIP();
93 
94   // After type, networks are sorted by IP address precedence values
95   // from RFC 3484-bis
96   if (IPAddressPrecedence(ip_a) != IPAddressPrecedence(ip_b)) {
97     return IPAddressPrecedence(ip_a) > IPAddressPrecedence(ip_b);
98   }
99 
100   // TODO(mallinath) - Add VPN and Link speed conditions while sorting.
101 
102   // Networks are sorted last by key.
103   return a->key() > b->key();
104 }
105 
AdapterTypeToString(AdapterType type)106 std::string AdapterTypeToString(AdapterType type) {
107   switch (type) {
108     case ADAPTER_TYPE_UNKNOWN:
109       return "Unknown";
110     case ADAPTER_TYPE_ETHERNET:
111       return "Ethernet";
112     case ADAPTER_TYPE_WIFI:
113       return "Wifi";
114     case ADAPTER_TYPE_CELLULAR:
115       return "Cellular";
116     case ADAPTER_TYPE_VPN:
117       return "VPN";
118     default:
119       ASSERT(false);
120       return std::string();
121   }
122 }
123 
124 }  // namespace
125 
MakeNetworkKey(const std::string & name,const IPAddress & prefix,int prefix_length)126 std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
127                            int prefix_length) {
128   std::ostringstream ost;
129   ost << name << "%" << prefix.ToString() << "/" << prefix_length;
130   return ost.str();
131 }
132 
NetworkManager()133 NetworkManager::NetworkManager() {
134 }
135 
~NetworkManager()136 NetworkManager::~NetworkManager() {
137 }
138 
NetworkManagerBase()139 NetworkManagerBase::NetworkManagerBase() : ipv6_enabled_(true) {
140 }
141 
~NetworkManagerBase()142 NetworkManagerBase::~NetworkManagerBase() {
143   for (NetworkMap::iterator i = networks_map_.begin();
144        i != networks_map_.end(); ++i) {
145     delete i->second;
146   }
147 }
148 
GetNetworks(NetworkList * result) const149 void NetworkManagerBase::GetNetworks(NetworkList* result) const {
150   *result = networks_;
151 }
152 
MergeNetworkList(const NetworkList & new_networks,bool * changed)153 void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks,
154                                           bool* changed) {
155   // AddressList in this map will track IP addresses for all Networks
156   // with the same key.
157   std::map<std::string, AddressList> consolidated_address_list;
158   NetworkList list(new_networks);
159 
160   // Result of Network merge. Element in this list should have unique key.
161   NetworkList merged_list;
162   std::sort(list.begin(), list.end(), CompareNetworks);
163 
164   *changed = false;
165 
166   if (networks_.size() != list.size())
167     *changed = true;
168 
169   // First, build a set of network-keys to the ipaddresses.
170   for (uint32 i = 0; i < list.size(); ++i) {
171     bool might_add_to_merged_list = false;
172     std::string key = MakeNetworkKey(list[i]->name(),
173                                      list[i]->prefix(),
174                                      list[i]->prefix_length());
175     if (consolidated_address_list.find(key) ==
176         consolidated_address_list.end()) {
177       AddressList addrlist;
178       addrlist.net = list[i];
179       consolidated_address_list[key] = addrlist;
180       might_add_to_merged_list = true;
181     }
182     const std::vector<InterfaceAddress>& addresses = list[i]->GetIPs();
183     AddressList& current_list = consolidated_address_list[key];
184     for (std::vector<InterfaceAddress>::const_iterator it = addresses.begin();
185          it != addresses.end();
186          ++it) {
187       current_list.ips.push_back(*it);
188     }
189     if (!might_add_to_merged_list) {
190       delete list[i];
191     }
192   }
193 
194   // Next, look for existing network objects to re-use.
195   for (std::map<std::string, AddressList>::iterator it =
196          consolidated_address_list.begin();
197        it != consolidated_address_list.end();
198        ++it) {
199     const std::string& key = it->first;
200     Network* net = it->second.net;
201     NetworkMap::iterator existing = networks_map_.find(key);
202     if (existing == networks_map_.end()) {
203       // This network is new. Place it in the network map.
204       merged_list.push_back(net);
205       networks_map_[key] = net;
206       // Also, we might have accumulated IPAddresses from the first
207       // step, set it here.
208       net->SetIPs(it->second.ips, true);
209       *changed = true;
210     } else {
211       // This network exists in the map already. Reset its IP addresses.
212       *changed = existing->second->SetIPs(it->second.ips, *changed);
213       merged_list.push_back(existing->second);
214       if (existing->second != net) {
215         delete net;
216       }
217     }
218   }
219   networks_ = merged_list;
220 
221   // If the network lists changes, we resort it.
222   if (changed) {
223     std::sort(networks_.begin(), networks_.end(), SortNetworks);
224     // Now network interfaces are sorted, we should set the preference value
225     // for each of the interfaces we are planning to use.
226     // Preference order of network interfaces might have changed from previous
227     // sorting due to addition of higher preference network interface.
228     // Since we have already sorted the network interfaces based on our
229     // requirements, we will just assign a preference value starting with 127,
230     // in decreasing order.
231     int pref = kHighestNetworkPreference;
232     for (NetworkList::const_iterator iter = networks_.begin();
233          iter != networks_.end(); ++iter) {
234       (*iter)->set_preference(pref);
235       if (pref > 0) {
236         --pref;
237       } else {
238         LOG(LS_ERROR) << "Too many network interfaces to handle!";
239         break;
240       }
241     }
242   }
243 }
244 
BasicNetworkManager()245 BasicNetworkManager::BasicNetworkManager()
246     : thread_(NULL), sent_first_update_(false), start_count_(0),
247       ignore_non_default_routes_(false) {
248 }
249 
~BasicNetworkManager()250 BasicNetworkManager::~BasicNetworkManager() {
251 }
252 
253 #if defined(__native_client__)
254 
CreateNetworks(bool include_ignored,NetworkList * networks) const255 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
256                                          NetworkList* networks) const {
257   ASSERT(false);
258   LOG(LS_WARNING) << "BasicNetworkManager doesn't work on NaCl yet";
259   return false;
260 }
261 
262 #elif defined(WEBRTC_POSIX)
ConvertIfAddrs(struct ifaddrs * interfaces,bool include_ignored,NetworkList * networks) const263 void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
264                                          bool include_ignored,
265                                          NetworkList* networks) const {
266   NetworkMap current_networks;
267   for (struct ifaddrs* cursor = interfaces;
268        cursor != NULL; cursor = cursor->ifa_next) {
269     IPAddress prefix;
270     IPAddress mask;
271     IPAddress ip;
272     int scope_id = 0;
273 
274     // Some interfaces may not have address assigned.
275     if (!cursor->ifa_addr || !cursor->ifa_netmask)
276       continue;
277 
278     switch (cursor->ifa_addr->sa_family) {
279       case AF_INET: {
280         ip = IPAddress(
281             reinterpret_cast<sockaddr_in*>(cursor->ifa_addr)->sin_addr);
282         mask = IPAddress(
283             reinterpret_cast<sockaddr_in*>(cursor->ifa_netmask)->sin_addr);
284         break;
285       }
286       case AF_INET6: {
287         if (ipv6_enabled()) {
288           ip = IPAddress(
289               reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_addr);
290           mask = IPAddress(
291               reinterpret_cast<sockaddr_in6*>(cursor->ifa_netmask)->sin6_addr);
292           scope_id =
293               reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
294           break;
295         } else {
296           continue;
297         }
298       }
299       default: {
300         continue;
301       }
302     }
303 
304     int prefix_length = CountIPMaskBits(mask);
305     prefix = TruncateIP(ip, prefix_length);
306     std::string key = MakeNetworkKey(std::string(cursor->ifa_name),
307                                      prefix, prefix_length);
308     NetworkMap::iterator existing_network = current_networks.find(key);
309     if (existing_network == current_networks.end()) {
310       scoped_ptr<Network> network(new Network(cursor->ifa_name,
311                                               cursor->ifa_name,
312                                               prefix,
313                                               prefix_length));
314       network->set_scope_id(scope_id);
315       network->AddIP(ip);
316       bool ignored = ((cursor->ifa_flags & IFF_LOOPBACK) ||
317                       IsIgnoredNetwork(*network));
318       network->set_ignored(ignored);
319       if (include_ignored || !network->ignored()) {
320         networks->push_back(network.release());
321       }
322     } else {
323       (*existing_network).second->AddIP(ip);
324     }
325   }
326 }
327 
CreateNetworks(bool include_ignored,NetworkList * networks) const328 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
329                                          NetworkList* networks) const {
330   struct ifaddrs* interfaces;
331   int error = getifaddrs(&interfaces);
332   if (error != 0) {
333     LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error;
334     return false;
335   }
336 
337   ConvertIfAddrs(interfaces, include_ignored, networks);
338 
339   freeifaddrs(interfaces);
340   return true;
341 }
342 
343 #elif defined(WEBRTC_WIN)
344 
GetPrefix(PIP_ADAPTER_PREFIX prefixlist,const IPAddress & ip,IPAddress * prefix)345 unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
346               const IPAddress& ip, IPAddress* prefix) {
347   IPAddress current_prefix;
348   IPAddress best_prefix;
349   unsigned int best_length = 0;
350   while (prefixlist) {
351     // Look for the longest matching prefix in the prefixlist.
352     if (prefixlist->Address.lpSockaddr == NULL ||
353         prefixlist->Address.lpSockaddr->sa_family != ip.family()) {
354       prefixlist = prefixlist->Next;
355       continue;
356     }
357     switch (prefixlist->Address.lpSockaddr->sa_family) {
358       case AF_INET: {
359         sockaddr_in* v4_addr =
360             reinterpret_cast<sockaddr_in*>(prefixlist->Address.lpSockaddr);
361         current_prefix = IPAddress(v4_addr->sin_addr);
362         break;
363       }
364       case AF_INET6: {
365           sockaddr_in6* v6_addr =
366               reinterpret_cast<sockaddr_in6*>(prefixlist->Address.lpSockaddr);
367           current_prefix = IPAddress(v6_addr->sin6_addr);
368           break;
369       }
370       default: {
371         prefixlist = prefixlist->Next;
372         continue;
373       }
374     }
375     if (TruncateIP(ip, prefixlist->PrefixLength) == current_prefix &&
376         prefixlist->PrefixLength > best_length) {
377       best_prefix = current_prefix;
378       best_length = prefixlist->PrefixLength;
379     }
380     prefixlist = prefixlist->Next;
381   }
382   *prefix = best_prefix;
383   return best_length;
384 }
385 
CreateNetworks(bool include_ignored,NetworkList * networks) const386 bool BasicNetworkManager::CreateNetworks(bool include_ignored,
387                                          NetworkList* networks) const {
388   NetworkMap current_networks;
389   // MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses.
390   size_t buffer_size = 16384;
391   scoped_ptr<char[]> adapter_info(new char[buffer_size]);
392   PIP_ADAPTER_ADDRESSES adapter_addrs =
393       reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
394   int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST |
395                        GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_INCLUDE_PREFIX);
396   int ret = 0;
397   do {
398     adapter_info.reset(new char[buffer_size]);
399     adapter_addrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
400     ret = GetAdaptersAddresses(AF_UNSPEC, adapter_flags,
401                                0, adapter_addrs,
402                                reinterpret_cast<PULONG>(&buffer_size));
403   } while (ret == ERROR_BUFFER_OVERFLOW);
404   if (ret != ERROR_SUCCESS) {
405     return false;
406   }
407   int count = 0;
408   while (adapter_addrs) {
409     if (adapter_addrs->OperStatus == IfOperStatusUp) {
410       PIP_ADAPTER_UNICAST_ADDRESS address = adapter_addrs->FirstUnicastAddress;
411       PIP_ADAPTER_PREFIX prefixlist = adapter_addrs->FirstPrefix;
412       std::string name;
413       std::string description;
414 #ifdef _DEBUG
415       name = ToUtf8(adapter_addrs->FriendlyName,
416                     wcslen(adapter_addrs->FriendlyName));
417 #endif
418       description = ToUtf8(adapter_addrs->Description,
419                            wcslen(adapter_addrs->Description));
420       for (; address; address = address->Next) {
421 #ifndef _DEBUG
422         name = rtc::ToString(count);
423 #endif
424 
425         IPAddress ip;
426         int scope_id = 0;
427         scoped_ptr<Network> network;
428         switch (address->Address.lpSockaddr->sa_family) {
429           case AF_INET: {
430             sockaddr_in* v4_addr =
431                 reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
432             ip = IPAddress(v4_addr->sin_addr);
433             break;
434           }
435           case AF_INET6: {
436             if (ipv6_enabled()) {
437               sockaddr_in6* v6_addr =
438                   reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);
439               scope_id = v6_addr->sin6_scope_id;
440               ip = IPAddress(v6_addr->sin6_addr);
441               break;
442             } else {
443               continue;
444             }
445           }
446           default: {
447             continue;
448           }
449         }
450 
451         IPAddress prefix;
452         int prefix_length = GetPrefix(prefixlist, ip, &prefix);
453         std::string key = MakeNetworkKey(name, prefix, prefix_length);
454         NetworkMap::iterator existing_network = current_networks.find(key);
455         if (existing_network == current_networks.end()) {
456           scoped_ptr<Network> network(new Network(name,
457                                                   description,
458                                                   prefix,
459                                                   prefix_length));
460           network->set_scope_id(scope_id);
461           network->AddIP(ip);
462           bool ignore = ((adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) ||
463                          IsIgnoredNetwork(*network));
464           network->set_ignored(ignore);
465           if (include_ignored || !network->ignored()) {
466             networks->push_back(network.release());
467           }
468         } else {
469           (*existing_network).second->AddIP(ip);
470         }
471       }
472       // Count is per-adapter - all 'Networks' created from the same
473       // adapter need to have the same name.
474       ++count;
475     }
476     adapter_addrs = adapter_addrs->Next;
477   }
478   return true;
479 }
480 #endif  // WEBRTC_WIN
481 
482 #if defined(WEBRTC_LINUX)
IsDefaultRoute(const std::string & network_name)483 bool IsDefaultRoute(const std::string& network_name) {
484   FileStream fs;
485   if (!fs.Open("/proc/net/route", "r", NULL)) {
486     LOG(LS_WARNING) << "Couldn't read /proc/net/route, skipping default "
487                     << "route check (assuming everything is a default route).";
488     return true;
489   } else {
490     std::string line;
491     while (fs.ReadLine(&line) == SR_SUCCESS) {
492       char iface_name[256];
493       unsigned int iface_ip, iface_gw, iface_mask, iface_flags;
494       if (sscanf(line.c_str(),
495                  "%255s %8X %8X %4X %*d %*u %*d %8X",
496                  iface_name, &iface_ip, &iface_gw,
497                  &iface_flags, &iface_mask) == 5 &&
498           network_name == iface_name &&
499           iface_mask == 0 &&
500           (iface_flags & (RTF_UP | RTF_HOST)) == RTF_UP) {
501         return true;
502       }
503     }
504   }
505   return false;
506 }
507 #endif
508 
IsIgnoredNetwork(const Network & network) const509 bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) const {
510   // Ignore networks on the explicit ignore list.
511   for (size_t i = 0; i < network_ignore_list_.size(); ++i) {
512     if (network.name() == network_ignore_list_[i]) {
513       return true;
514     }
515   }
516 #if defined(WEBRTC_POSIX)
517   // Filter out VMware interfaces, typically named vmnet1 and vmnet8
518   if (strncmp(network.name().c_str(), "vmnet", 5) == 0 ||
519       strncmp(network.name().c_str(), "vnic", 4) == 0) {
520     return true;
521   }
522 #if defined(WEBRTC_LINUX)
523   // Make sure this is a default route, if we're ignoring non-defaults.
524   if (ignore_non_default_routes_ && !IsDefaultRoute(network.name())) {
525     return true;
526   }
527 #endif
528 #elif defined(WEBRTC_WIN)
529   // Ignore any HOST side vmware adapters with a description like:
530   // VMware Virtual Ethernet Adapter for VMnet1
531   // but don't ignore any GUEST side adapters with a description like:
532   // VMware Accelerated AMD PCNet Adapter #2
533   if (strstr(network.description().c_str(), "VMnet") != NULL) {
534     return true;
535   }
536 #endif
537 
538   // Ignore any networks with a 0.x.y.z IP
539   if (network.prefix().family() == AF_INET) {
540     return (network.prefix().v4AddressAsHostOrderInteger() < 0x01000000);
541   }
542   return false;
543 }
544 
StartUpdating()545 void BasicNetworkManager::StartUpdating() {
546   thread_ = Thread::Current();
547   if (start_count_) {
548     // If network interfaces are already discovered and signal is sent,
549     // we should trigger network signal immediately for the new clients
550     // to start allocating ports.
551     if (sent_first_update_)
552       thread_->Post(this, kSignalNetworksMessage);
553   } else {
554     thread_->Post(this, kUpdateNetworksMessage);
555   }
556   ++start_count_;
557 }
558 
StopUpdating()559 void BasicNetworkManager::StopUpdating() {
560   ASSERT(Thread::Current() == thread_);
561   if (!start_count_)
562     return;
563 
564   --start_count_;
565   if (!start_count_) {
566     thread_->Clear(this);
567     sent_first_update_ = false;
568   }
569 }
570 
OnMessage(Message * msg)571 void BasicNetworkManager::OnMessage(Message* msg) {
572   switch (msg->message_id) {
573     case kUpdateNetworksMessage:  {
574       DoUpdateNetworks();
575       break;
576     }
577     case kSignalNetworksMessage:  {
578       SignalNetworksChanged();
579       break;
580     }
581     default:
582       ASSERT(false);
583   }
584 }
585 
DoUpdateNetworks()586 void BasicNetworkManager::DoUpdateNetworks() {
587   if (!start_count_)
588     return;
589 
590   ASSERT(Thread::Current() == thread_);
591 
592   NetworkList list;
593   if (!CreateNetworks(false, &list)) {
594     SignalError();
595   } else {
596     bool changed;
597     MergeNetworkList(list, &changed);
598     if (changed || !sent_first_update_) {
599       SignalNetworksChanged();
600       sent_first_update_ = true;
601     }
602   }
603 
604   thread_->PostDelayed(kNetworksUpdateIntervalMs, this, kUpdateNetworksMessage);
605 }
606 
DumpNetworks(bool include_ignored)607 void BasicNetworkManager::DumpNetworks(bool include_ignored) {
608   NetworkList list;
609   CreateNetworks(include_ignored, &list);
610   LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:";
611   for (size_t i = 0; i < list.size(); ++i) {
612     const Network* network = list[i];
613     if (!network->ignored() || include_ignored) {
614       LOG(LS_INFO) << network->ToString() << ": "
615                    << network->description()
616                    << ((network->ignored()) ? ", Ignored" : "");
617     }
618   }
619   // Release the network list created previously.
620   // Do this in a seperated for loop for better readability.
621   for (size_t i = 0; i < list.size(); ++i) {
622     delete list[i];
623   }
624 }
625 
Network(const std::string & name,const std::string & desc,const IPAddress & prefix,int prefix_length)626 Network::Network(const std::string& name, const std::string& desc,
627                  const IPAddress& prefix, int prefix_length)
628     : name_(name), description_(desc), prefix_(prefix),
629       prefix_length_(prefix_length),
630       key_(MakeNetworkKey(name, prefix, prefix_length)), scope_id_(0),
631       ignored_(false), type_(ADAPTER_TYPE_UNKNOWN), preference_(0) {
632 }
633 
Network(const std::string & name,const std::string & desc,const IPAddress & prefix,int prefix_length,AdapterType type)634 Network::Network(const std::string& name, const std::string& desc,
635                  const IPAddress& prefix, int prefix_length, AdapterType type)
636     : name_(name), description_(desc), prefix_(prefix),
637       prefix_length_(prefix_length),
638       key_(MakeNetworkKey(name, prefix, prefix_length)), scope_id_(0),
639       ignored_(false), type_(type), preference_(0) {
640 }
641 
642 // Sets the addresses of this network. Returns true if the address set changed.
643 // Change detection is short circuited if the changed argument is true.
SetIPs(const std::vector<InterfaceAddress> & ips,bool changed)644 bool Network::SetIPs(const std::vector<InterfaceAddress>& ips, bool changed) {
645   changed = changed || ips.size() != ips_.size();
646   // Detect changes with a nested loop; n-squared but we expect on the order
647   // of 2-3 addresses per network.
648   for (std::vector<InterfaceAddress>::const_iterator it = ips.begin();
649       !changed && it != ips.end();
650       ++it) {
651     bool found = false;
652     for (std::vector<InterfaceAddress>::iterator inner_it = ips_.begin();
653          !found && inner_it != ips_.end();
654          ++inner_it) {
655       if (*it == *inner_it) {
656         found = true;
657       }
658     }
659     changed = !found;
660   }
661   ips_ = ips;
662   return changed;
663 }
664 
665 // Select the best IP address to use from this Network.
GetBestIP() const666 IPAddress Network::GetBestIP() const {
667   if (ips_.size() == 0) {
668     return IPAddress();
669   }
670 
671   if (prefix_.family() == AF_INET) {
672     return static_cast<IPAddress>(ips_.at(0));
673   }
674 
675   InterfaceAddress selected_ip, ula_ip;
676 
677   for (size_t i = 0; i < ips_.size(); i++) {
678     // Ignore any address which has been deprecated already.
679     if (ips_[i].ipv6_flags() & IPV6_ADDRESS_FLAG_DEPRECATED)
680       continue;
681 
682     // ULA address should only be returned when we have no other
683     // global IP.
684     if (IPIsULA(static_cast<const IPAddress&>(ips_[i]))) {
685       ula_ip = ips_[i];
686       continue;
687     }
688     selected_ip = ips_[i];
689 
690     // Search could stop once a temporary non-deprecated one is found.
691     if (ips_[i].ipv6_flags() & IPV6_ADDRESS_FLAG_TEMPORARY)
692       break;
693   }
694 
695   // No proper global IPv6 address found, use ULA instead.
696   if (IPIsUnspec(selected_ip) && !IPIsUnspec(ula_ip)) {
697     selected_ip = ula_ip;
698   }
699 
700   return static_cast<IPAddress>(selected_ip);
701 }
702 
ToString() const703 std::string Network::ToString() const {
704   std::stringstream ss;
705   // Print out the first space-terminated token of the network desc, plus
706   // the IP address.
707   ss << "Net[" << description_.substr(0, description_.find(' '))
708      << ":" << prefix_.ToSensitiveString() << "/" << prefix_length_
709      << ":" << AdapterTypeToString(type_) << "]";
710   return ss.str();
711 }
712 
713 }  // namespace rtc
714