src/third_party/libjingle/source/talk/base/network.cc

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