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
57namespace rtc {
58namespace {
59
60const uint32 kUpdateNetworksMessage = 1;
61const uint32 kSignalNetworksMessage = 2;
62
63// Fetch list of networks every two seconds.
64const int kNetworksUpdateIntervalMs = 2000;
65
66const int kHighestNetworkPreference = 127;
67
68typedef struct {
69  Network* net;
70  std::vector<InterfaceAddress> ips;
71} AddressList;
72
73bool 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
82bool 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
106std::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
126std::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
133NetworkManager::NetworkManager() {
134}
135
136NetworkManager::~NetworkManager() {
137}
138
139NetworkManagerBase::NetworkManagerBase() : ipv6_enabled_(true) {
140}
141
142NetworkManagerBase::~NetworkManagerBase() {
143  for (NetworkMap::iterator i = networks_map_.begin();
144       i != networks_map_.end(); ++i) {
145    delete i->second;
146  }
147}
148
149void NetworkManagerBase::GetNetworks(NetworkList* result) const {
150  *result = networks_;
151}
152
153void 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
245BasicNetworkManager::BasicNetworkManager()
246    : thread_(NULL), sent_first_update_(false), start_count_(0),
247      ignore_non_default_routes_(false) {
248}
249
250BasicNetworkManager::~BasicNetworkManager() {
251}
252
253#if defined(__native_client__)
254
255bool 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)
263void 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
328bool 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
345unsigned 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
386bool 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)
483bool 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
509bool 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
545void 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
559void 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
571void 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
586void 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
607void 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
626Network::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
634Network::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.
644bool 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.
666IPAddress 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
703std::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