Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
#include <algorithm>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "logging.h"
#include "nr_api.h"
#include "nrinterfaceprioritizer.h"
MOZ_MTLOG_MODULE("mtransport")
namespace {
class LocalAddress {
public:
LocalAddress()
: is_vpn_(-1),
estimated_speed_(-1),
type_preference_(-1),
ip_version_(-1) {}
bool Init(const nr_local_addr& local_addr) {
ifname_ = local_addr.addr.ifname;
char buf[MAXIFNAME + 47];
int r = nr_transport_addr_fmt_ifname_addr_string(&local_addr.addr, buf,
sizeof(buf));
if (r) {
MOZ_MTLOG(ML_ERROR, "Error formatting interface key.");
return false;
}
key_ = buf;
r = nr_transport_addr_get_addrstring(&local_addr.addr, buf, sizeof(buf));
if (r) {
MOZ_MTLOG(ML_ERROR, "Error formatting address string.");
return false;
}
addr_ = buf;
is_vpn_ = (local_addr.interface.type & NR_INTERFACE_TYPE_VPN) != 0 ? 1 : 0;
estimated_speed_ = local_addr.interface.estimated_speed;
type_preference_ = GetNetworkTypePreference(local_addr.interface.type);
ip_version_ = local_addr.addr.ip_version;
return true;
}
bool operator<(const LocalAddress& rhs) const {
// Interface that is "less" here is preferred.
// If type preferences are different, we should simply sort by
// |type_preference_|.
if (type_preference_ != rhs.type_preference_) {
return type_preference_ < rhs.type_preference_;
}
// If type preferences are the same, the next thing we use to sort is vpn.
// If two LocalAddress are different in |is_vpn_|, the LocalAddress that is
// not in vpn gets priority.
if (is_vpn_ != rhs.is_vpn_) {
return is_vpn_ < rhs.is_vpn_;
}
// Compare estimated speed.
if (estimated_speed_ != rhs.estimated_speed_) {
return estimated_speed_ > rhs.estimated_speed_;
}
// See if our hard-coded pref list helps us.
auto thisindex = std::find(interface_preference_list().begin(),
interface_preference_list().end(), ifname_);
auto rhsindex = std::find(interface_preference_list().begin(),
interface_preference_list().end(), rhs.ifname_);
if (thisindex != rhsindex) {
return thisindex < rhsindex;
}
// Prefer IPV6 over IPV4
if (ip_version_ != rhs.ip_version_) {
return ip_version_ > rhs.ip_version_;
}
// Now we start getting into arbitrary stuff
if (ifname_ != rhs.ifname_) {
return ifname_ < rhs.ifname_;
}
return addr_ < rhs.addr_;
}
const std::string& GetKey() const { return key_; }
private:
// Getting the preference corresponding to a type. Getting lower number here
// means the type of network is preferred.
static inline int GetNetworkTypePreference(int type) {
if (type & NR_INTERFACE_TYPE_WIRED) {
return 1;
}
if (type & NR_INTERFACE_TYPE_WIFI) {
return 2;
}
if (type & NR_INTERFACE_TYPE_MOBILE) {
return 3;
}
if (type & NR_INTERFACE_TYPE_TEREDO) {
// Teredo gets penalty because it's IP relayed
return 5;
}
return 4;
}
// we should remove this stuff.
static const std::vector<std::string>& interface_preference_list() {
static std::vector<std::string> list(build_interface_preference_list());
return list;
}
static std::vector<std::string> build_interface_preference_list() {
std::vector<std::string> result;
result.push_back("rl0");
result.push_back("wi0");
result.push_back("en0");
result.push_back("enp2s0");
result.push_back("enp3s0");
result.push_back("en1");
result.push_back("en2");
result.push_back("en3");
result.push_back("eth0");
result.push_back("eth1");
result.push_back("eth2");
result.push_back("em1");
result.push_back("em0");
result.push_back("ppp");
result.push_back("ppp0");
result.push_back("vmnet1");
result.push_back("vmnet0");
result.push_back("vmnet3");
result.push_back("vmnet4");
result.push_back("vmnet5");
result.push_back("vmnet6");
result.push_back("vmnet7");
result.push_back("vmnet8");
result.push_back("virbr0");
result.push_back("wlan0");
result.push_back("lo0");
return result;
}
std::string ifname_;
std::string addr_;
std::string key_;
int is_vpn_;
int estimated_speed_;
int type_preference_;
int ip_version_;
};
class InterfacePrioritizer {
public:
InterfacePrioritizer() : sorted_(false) {}
int add(const nr_local_addr* iface) {
LocalAddress addr;
if (!addr.Init(*iface)) {
return R_FAILED;
}
std::pair<std::set<LocalAddress>::iterator, bool> r =
local_addrs_.insert(addr);
if (!r.second) {
return R_ALREADY; // This address is already in the set.
}
sorted_ = false;
return 0;
}
int sort() {
UCHAR tmp_pref = 127;
preference_map_.clear();
for (const auto& local_addr : local_addrs_) {
if (tmp_pref == 0) {
return R_FAILED;
}
preference_map_.insert(make_pair(local_addr.GetKey(), tmp_pref--));
}
sorted_ = true;
return 0;
}
int getPreference(const char* key, UCHAR* pref) {
if (!sorted_) {
return R_FAILED;
}
std::map<std::string, UCHAR>::iterator i = preference_map_.find(key);
if (i == preference_map_.end()) {
return R_NOT_FOUND;
}
*pref = i->second;
return 0;
}
private:
std::set<LocalAddress> local_addrs_;
std::map<std::string, UCHAR> preference_map_;
bool sorted_;
};
} // anonymous namespace
static int add_interface(void* obj, nr_local_addr* iface) {
InterfacePrioritizer* ip = static_cast<InterfacePrioritizer*>(obj);
return ip->add(iface);
}
static int get_priority(void* obj, const char* key, UCHAR* pref) {
InterfacePrioritizer* ip = static_cast<InterfacePrioritizer*>(obj);
return ip->getPreference(key, pref);
}
static int sort_preference(void* obj) {
InterfacePrioritizer* ip = static_cast<InterfacePrioritizer*>(obj);
return ip->sort();
}
static int destroy(void** objp) {
if (!objp || !*objp) {
return 0;
}
InterfacePrioritizer* ip = static_cast<InterfacePrioritizer*>(*objp);
*objp = nullptr;
delete ip;
return 0;
}
static nr_interface_prioritizer_vtbl priorizer_vtbl = {
add_interface, get_priority, sort_preference, destroy};
namespace mozilla {
nr_interface_prioritizer* CreateInterfacePrioritizer() {
nr_interface_prioritizer* ip;
int r = nr_interface_prioritizer_create_int(new InterfacePrioritizer(),
&priorizer_vtbl, &ip);
if (r != 0) {
return nullptr;
}
return ip;
}
} // namespace mozilla