d64719d895
R=mallinath@webrtc.org Review URL: https://webrtc-codereview.appspot.com/1885005 git-svn-id: http://webrtc.googlecode.com/svn/trunk@4461 4adac7df-926f-26a2-2b94-8c16560cd09d
546 lines
18 KiB
C++
546 lines
18 KiB
C++
/*
|
|
* libjingle
|
|
* Copyright 2004--2005, Google Inc.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
|
|
* EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "talk/base/network.h"
|
|
|
|
#ifdef POSIX
|
|
#include <sys/socket.h>
|
|
#include <sys/utsname.h>
|
|
#include <sys/ioctl.h>
|
|
#include <net/if.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#ifdef ANDROID
|
|
#include "talk/base/ifaddrs-android.h"
|
|
#else
|
|
#include <ifaddrs.h>
|
|
#endif
|
|
#endif // POSIX
|
|
|
|
#ifdef WIN32
|
|
#include "talk/base/win32.h"
|
|
#include <Iphlpapi.h>
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
|
|
#include "talk/base/logging.h"
|
|
#include "talk/base/scoped_ptr.h"
|
|
#include "talk/base/socket.h" // includes something that makes windows happy
|
|
#include "talk/base/stream.h"
|
|
#include "talk/base/stringencode.h"
|
|
#include "talk/base/thread.h"
|
|
|
|
namespace talk_base {
|
|
namespace {
|
|
|
|
const uint32 kUpdateNetworksMessage = 1;
|
|
const uint32 kSignalNetworksMessage = 2;
|
|
|
|
// Fetch list of networks every two seconds.
|
|
const int kNetworksUpdateIntervalMs = 2000;
|
|
|
|
|
|
// Makes a string key for this network. Used in the network manager's maps.
|
|
// Network objects are keyed on interface name, network prefix and the
|
|
// length of that prefix.
|
|
std::string MakeNetworkKey(const std::string& name, const IPAddress& prefix,
|
|
int prefix_length) {
|
|
std::ostringstream ost;
|
|
ost << name << "%" << prefix.ToString() << "/" << prefix_length;
|
|
return ost.str();
|
|
}
|
|
|
|
bool CompareNetworks(const Network* a, const Network* b) {
|
|
if (a->prefix_length() == b->prefix_length()) {
|
|
if (a->name() == b->name()) {
|
|
return a->prefix() < b->prefix();
|
|
}
|
|
}
|
|
return a->name() < b->name();
|
|
}
|
|
|
|
|
|
} // namespace
|
|
|
|
NetworkManager::NetworkManager() {
|
|
}
|
|
|
|
NetworkManager::~NetworkManager() {
|
|
}
|
|
|
|
NetworkManagerBase::NetworkManagerBase() : ipv6_enabled_(true) {
|
|
}
|
|
|
|
NetworkManagerBase::~NetworkManagerBase() {
|
|
for (NetworkMap::iterator i = networks_map_.begin();
|
|
i != networks_map_.end(); ++i) {
|
|
delete i->second;
|
|
}
|
|
}
|
|
|
|
void NetworkManagerBase::GetNetworks(NetworkList* result) const {
|
|
*result = networks_;
|
|
}
|
|
|
|
void NetworkManagerBase::MergeNetworkList(const NetworkList& new_networks,
|
|
bool* changed) {
|
|
// Sort the list so that we can detect when it changes.
|
|
typedef std::pair<Network*, std::vector<IPAddress> > address_list;
|
|
std::map<std::string, address_list> address_map;
|
|
NetworkList list(new_networks);
|
|
NetworkList merged_list;
|
|
std::sort(list.begin(), list.end(), CompareNetworks);
|
|
|
|
*changed = false;
|
|
|
|
if (networks_.size() != list.size())
|
|
*changed = true;
|
|
|
|
// First, build a set of network-keys to the ipaddresses.
|
|
for (uint32 i = 0; i < list.size(); ++i) {
|
|
bool might_add_to_merged_list = false;
|
|
std::string key = MakeNetworkKey(list[i]->name(),
|
|
list[i]->prefix(),
|
|
list[i]->prefix_length());
|
|
if (address_map.find(key) == address_map.end()) {
|
|
address_map[key] = address_list(list[i], std::vector<IPAddress>());
|
|
might_add_to_merged_list = true;
|
|
}
|
|
const std::vector<IPAddress>& addresses = list[i]->GetIPs();
|
|
address_list& current_list = address_map[key];
|
|
for (std::vector<IPAddress>::const_iterator it = addresses.begin();
|
|
it != addresses.end();
|
|
++it) {
|
|
current_list.second.push_back(*it);
|
|
}
|
|
if (!might_add_to_merged_list) {
|
|
delete list[i];
|
|
}
|
|
}
|
|
|
|
// Next, look for existing network objects to re-use.
|
|
for (std::map<std::string, address_list >::iterator it = address_map.begin();
|
|
it != address_map.end();
|
|
++it) {
|
|
const std::string& key = it->first;
|
|
Network* net = it->second.first;
|
|
NetworkMap::iterator existing = networks_map_.find(key);
|
|
if (existing == networks_map_.end()) {
|
|
// This network is new. Place it in the network map.
|
|
merged_list.push_back(net);
|
|
networks_map_[key] = net;
|
|
*changed = true;
|
|
} else {
|
|
// This network exists in the map already. Reset its IP addresses.
|
|
*changed = existing->second->SetIPs(it->second.second, *changed);
|
|
merged_list.push_back(existing->second);
|
|
if (existing->second != net) {
|
|
delete net;
|
|
}
|
|
}
|
|
}
|
|
networks_ = merged_list;
|
|
}
|
|
|
|
BasicNetworkManager::BasicNetworkManager()
|
|
: thread_(NULL), sent_first_update_(false), start_count_(0) {
|
|
}
|
|
|
|
BasicNetworkManager::~BasicNetworkManager() {
|
|
}
|
|
|
|
#if defined(POSIX)
|
|
void BasicNetworkManager::ConvertIfAddrs(struct ifaddrs* interfaces,
|
|
bool include_ignored,
|
|
NetworkList* networks) const {
|
|
NetworkMap current_networks;
|
|
for (struct ifaddrs* cursor = interfaces;
|
|
cursor != NULL; cursor = cursor->ifa_next) {
|
|
IPAddress prefix;
|
|
IPAddress mask;
|
|
IPAddress ip;
|
|
int scope_id = 0;
|
|
|
|
// Some interfaces may not have address assigned.
|
|
if (!cursor->ifa_addr || !cursor->ifa_netmask)
|
|
continue;
|
|
|
|
switch (cursor->ifa_addr->sa_family) {
|
|
case AF_INET: {
|
|
ip = IPAddress(
|
|
reinterpret_cast<sockaddr_in*>(cursor->ifa_addr)->sin_addr);
|
|
mask = IPAddress(
|
|
reinterpret_cast<sockaddr_in*>(cursor->ifa_netmask)->sin_addr);
|
|
break;
|
|
}
|
|
case AF_INET6: {
|
|
if (ipv6_enabled()) {
|
|
ip = IPAddress(
|
|
reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_addr);
|
|
mask = IPAddress(
|
|
reinterpret_cast<sockaddr_in6*>(cursor->ifa_netmask)->sin6_addr);
|
|
scope_id =
|
|
reinterpret_cast<sockaddr_in6*>(cursor->ifa_addr)->sin6_scope_id;
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
default: {
|
|
continue;
|
|
}
|
|
}
|
|
int prefix_length = CountIPMaskBits(mask);
|
|
prefix = TruncateIP(ip, prefix_length);
|
|
std::string key = MakeNetworkKey(std::string(cursor->ifa_name),
|
|
prefix, prefix_length);
|
|
NetworkMap::iterator existing_network = current_networks.find(key);
|
|
if (existing_network == current_networks.end()) {
|
|
scoped_ptr<Network> network(new Network(cursor->ifa_name,
|
|
cursor->ifa_name,
|
|
prefix,
|
|
prefix_length));
|
|
network->set_scope_id(scope_id);
|
|
network->AddIP(ip);
|
|
bool ignored = ((cursor->ifa_flags & IFF_LOOPBACK) ||
|
|
IsIgnoredNetwork(*network));
|
|
network->set_ignored(ignored);
|
|
if (include_ignored || !network->ignored()) {
|
|
networks->push_back(network.release());
|
|
}
|
|
} else {
|
|
(*existing_network).second->AddIP(ip);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool BasicNetworkManager::CreateNetworks(bool include_ignored,
|
|
NetworkList* networks) const {
|
|
struct ifaddrs* interfaces;
|
|
int error = getifaddrs(&interfaces);
|
|
if (error != 0) {
|
|
LOG_ERR(LERROR) << "getifaddrs failed to gather interface data: " << error;
|
|
return false;
|
|
}
|
|
|
|
ConvertIfAddrs(interfaces, include_ignored, networks);
|
|
|
|
freeifaddrs(interfaces);
|
|
return true;
|
|
}
|
|
|
|
#elif defined(WIN32)
|
|
|
|
unsigned int GetPrefix(PIP_ADAPTER_PREFIX prefixlist,
|
|
const IPAddress& ip, IPAddress* prefix) {
|
|
IPAddress current_prefix;
|
|
IPAddress best_prefix;
|
|
unsigned int best_length = 0;
|
|
while (prefixlist) {
|
|
// Look for the longest matching prefix in the prefixlist.
|
|
if (prefixlist->Address.lpSockaddr == NULL ||
|
|
prefixlist->Address.lpSockaddr->sa_family != ip.family()) {
|
|
prefixlist = prefixlist->Next;
|
|
continue;
|
|
}
|
|
switch (prefixlist->Address.lpSockaddr->sa_family) {
|
|
case AF_INET: {
|
|
sockaddr_in* v4_addr =
|
|
reinterpret_cast<sockaddr_in*>(prefixlist->Address.lpSockaddr);
|
|
current_prefix = IPAddress(v4_addr->sin_addr);
|
|
break;
|
|
}
|
|
case AF_INET6: {
|
|
sockaddr_in6* v6_addr =
|
|
reinterpret_cast<sockaddr_in6*>(prefixlist->Address.lpSockaddr);
|
|
current_prefix = IPAddress(v6_addr->sin6_addr);
|
|
break;
|
|
}
|
|
default: {
|
|
prefixlist = prefixlist->Next;
|
|
continue;
|
|
}
|
|
}
|
|
if (TruncateIP(ip, prefixlist->PrefixLength) == current_prefix &&
|
|
prefixlist->PrefixLength > best_length) {
|
|
best_prefix = current_prefix;
|
|
best_length = prefixlist->PrefixLength;
|
|
}
|
|
prefixlist = prefixlist->Next;
|
|
}
|
|
*prefix = best_prefix;
|
|
return best_length;
|
|
}
|
|
|
|
bool BasicNetworkManager::CreateNetworks(bool include_ignored,
|
|
NetworkList* networks) const {
|
|
NetworkMap current_networks;
|
|
// MSDN recommends a 15KB buffer for the first try at GetAdaptersAddresses.
|
|
size_t buffer_size = 16384;
|
|
scoped_array<char> adapter_info(new char[buffer_size]);
|
|
PIP_ADAPTER_ADDRESSES adapter_addrs =
|
|
reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
|
|
int adapter_flags = (GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_ANYCAST |
|
|
GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_INCLUDE_PREFIX);
|
|
int ret = 0;
|
|
do {
|
|
adapter_info.reset(new char[buffer_size]);
|
|
adapter_addrs = reinterpret_cast<PIP_ADAPTER_ADDRESSES>(adapter_info.get());
|
|
ret = GetAdaptersAddresses(AF_UNSPEC, adapter_flags,
|
|
0, adapter_addrs,
|
|
reinterpret_cast<PULONG>(&buffer_size));
|
|
} while (ret == ERROR_BUFFER_OVERFLOW);
|
|
if (ret != ERROR_SUCCESS) {
|
|
return false;
|
|
}
|
|
int count = 0;
|
|
while (adapter_addrs) {
|
|
if (adapter_addrs->OperStatus == IfOperStatusUp) {
|
|
PIP_ADAPTER_UNICAST_ADDRESS address = adapter_addrs->FirstUnicastAddress;
|
|
PIP_ADAPTER_PREFIX prefixlist = adapter_addrs->FirstPrefix;
|
|
std::string name;
|
|
std::string description;
|
|
#ifdef _DEBUG
|
|
name = ToUtf8(adapter_addrs->FriendlyName,
|
|
wcslen(adapter_addrs->FriendlyName));
|
|
#endif
|
|
description = ToUtf8(adapter_addrs->Description,
|
|
wcslen(adapter_addrs->Description));
|
|
for (; address; address = address->Next) {
|
|
#ifndef _DEBUG
|
|
name = talk_base::ToString(count);
|
|
#endif
|
|
|
|
IPAddress ip;
|
|
int scope_id = 0;
|
|
scoped_ptr<Network> network;
|
|
switch (address->Address.lpSockaddr->sa_family) {
|
|
case AF_INET: {
|
|
sockaddr_in* v4_addr =
|
|
reinterpret_cast<sockaddr_in*>(address->Address.lpSockaddr);
|
|
ip = IPAddress(v4_addr->sin_addr);
|
|
break;
|
|
}
|
|
case AF_INET6: {
|
|
if (ipv6_enabled()) {
|
|
sockaddr_in6* v6_addr =
|
|
reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);
|
|
scope_id = v6_addr->sin6_scope_id;
|
|
ip = IPAddress(v6_addr->sin6_addr);
|
|
break;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
default: {
|
|
continue;
|
|
}
|
|
}
|
|
IPAddress prefix;
|
|
int prefix_length = GetPrefix(prefixlist, ip, &prefix);
|
|
std::string key = MakeNetworkKey(name, prefix, prefix_length);
|
|
NetworkMap::iterator existing_network = current_networks.find(key);
|
|
if (existing_network == current_networks.end()) {
|
|
scoped_ptr<Network> network(new Network(name,
|
|
description,
|
|
prefix,
|
|
prefix_length));
|
|
network->set_scope_id(scope_id);
|
|
network->AddIP(ip);
|
|
bool ignore = ((adapter_addrs->IfType == IF_TYPE_SOFTWARE_LOOPBACK) ||
|
|
IsIgnoredNetwork(*network));
|
|
network->set_ignored(ignore);
|
|
if (include_ignored || !network->ignored()) {
|
|
networks->push_back(network.release());
|
|
}
|
|
} else {
|
|
(*existing_network).second->AddIP(ip);
|
|
}
|
|
}
|
|
// Count is per-adapter - all 'Networks' created from the same
|
|
// adapter need to have the same name.
|
|
++count;
|
|
}
|
|
adapter_addrs = adapter_addrs->Next;
|
|
}
|
|
return true;
|
|
}
|
|
#endif // WIN32
|
|
|
|
bool BasicNetworkManager::IsIgnoredNetwork(const Network& network) {
|
|
#ifdef POSIX
|
|
// Ignore local networks (lo, lo0, etc)
|
|
// Also filter out VMware interfaces, typically named vmnet1 and vmnet8
|
|
if (strncmp(network.name().c_str(), "vmnet", 5) == 0 ||
|
|
strncmp(network.name().c_str(), "vnic", 4) == 0) {
|
|
return true;
|
|
}
|
|
#elif defined(WIN32)
|
|
// Ignore any HOST side vmware adapters with a description like:
|
|
// VMware Virtual Ethernet Adapter for VMnet1
|
|
// but don't ignore any GUEST side adapters with a description like:
|
|
// VMware Accelerated AMD PCNet Adapter #2
|
|
if (strstr(network.description().c_str(), "VMnet") != NULL) {
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
// Ignore any networks with a 0.x.y.z IP
|
|
if (network.prefix().family() == AF_INET) {
|
|
return (network.prefix().v4AddressAsHostOrderInteger() < 0x01000000);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void BasicNetworkManager::StartUpdating() {
|
|
thread_ = Thread::Current();
|
|
if (start_count_) {
|
|
// If network interfaces are already discovered and signal is sent,
|
|
// we should trigger network signal immediately for the new clients
|
|
// to start allocating ports.
|
|
if (sent_first_update_)
|
|
thread_->Post(this, kSignalNetworksMessage);
|
|
} else {
|
|
thread_->Post(this, kUpdateNetworksMessage);
|
|
}
|
|
++start_count_;
|
|
}
|
|
|
|
void BasicNetworkManager::StopUpdating() {
|
|
ASSERT(Thread::Current() == thread_);
|
|
if (!start_count_)
|
|
return;
|
|
|
|
--start_count_;
|
|
if (!start_count_) {
|
|
thread_->Clear(this);
|
|
sent_first_update_ = false;
|
|
}
|
|
}
|
|
|
|
void BasicNetworkManager::OnMessage(Message* msg) {
|
|
switch (msg->message_id) {
|
|
case kUpdateNetworksMessage: {
|
|
DoUpdateNetworks();
|
|
break;
|
|
}
|
|
case kSignalNetworksMessage: {
|
|
SignalNetworksChanged();
|
|
break;
|
|
}
|
|
default:
|
|
ASSERT(false);
|
|
}
|
|
}
|
|
|
|
void BasicNetworkManager::DoUpdateNetworks() {
|
|
if (!start_count_)
|
|
return;
|
|
|
|
ASSERT(Thread::Current() == thread_);
|
|
|
|
NetworkList list;
|
|
if (!CreateNetworks(false, &list)) {
|
|
SignalError();
|
|
} else {
|
|
bool changed;
|
|
MergeNetworkList(list, &changed);
|
|
if (changed || !sent_first_update_) {
|
|
SignalNetworksChanged();
|
|
sent_first_update_ = true;
|
|
}
|
|
}
|
|
|
|
thread_->PostDelayed(kNetworksUpdateIntervalMs, this, kUpdateNetworksMessage);
|
|
}
|
|
|
|
void BasicNetworkManager::DumpNetworks(bool include_ignored) {
|
|
NetworkList list;
|
|
CreateNetworks(include_ignored, &list);
|
|
LOG(LS_INFO) << "NetworkManager detected " << list.size() << " networks:";
|
|
for (size_t i = 0; i < list.size(); ++i) {
|
|
const Network* network = list[i];
|
|
if (!network->ignored() || include_ignored) {
|
|
LOG(LS_INFO) << network->ToString() << ": "
|
|
<< network->description()
|
|
<< ((network->ignored()) ? ", Ignored" : "");
|
|
}
|
|
}
|
|
// Release the network list created previously.
|
|
// Do this in a seperated for loop for better readability.
|
|
for (size_t i = 0; i < list.size(); ++i) {
|
|
delete list[i];
|
|
}
|
|
}
|
|
|
|
Network::Network(const std::string& name, const std::string& desc,
|
|
const IPAddress& prefix, int prefix_length)
|
|
: name_(name), description_(desc), prefix_(prefix),
|
|
prefix_length_(prefix_length), scope_id_(0), ignored_(false),
|
|
uniform_numerator_(0), uniform_denominator_(0), exponential_numerator_(0),
|
|
exponential_denominator_(0) {
|
|
}
|
|
|
|
std::string Network::ToString() const {
|
|
std::stringstream ss;
|
|
// Print out the first space-terminated token of the network desc, plus
|
|
// the IP address.
|
|
ss << "Net[" << description_.substr(0, description_.find(' '))
|
|
<< ":" << prefix_.ToSensitiveString() << "/" << prefix_length_ << "]";
|
|
return ss.str();
|
|
}
|
|
|
|
// Sets the addresses of this network. Returns true if the address set changed.
|
|
// Change detection is short circuited if the changed argument is true.
|
|
bool Network::SetIPs(const std::vector<IPAddress>& ips, bool changed) {
|
|
changed = changed || ips.size() != ips_.size();
|
|
// Detect changes with a nested loop; n-squared but we expect on the order
|
|
// of 2-3 addresses per network.
|
|
for (std::vector<IPAddress>::const_iterator it = ips.begin();
|
|
!changed && it != ips.end();
|
|
++it) {
|
|
bool found = false;
|
|
for (std::vector<IPAddress>::iterator inner_it = ips_.begin();
|
|
!found && inner_it != ips_.end();
|
|
++inner_it) {
|
|
if (*it == *inner_it) {
|
|
found = true;
|
|
}
|
|
}
|
|
changed = !found;
|
|
}
|
|
ips_ = ips;
|
|
return changed;
|
|
}
|
|
} // namespace talk_base
|