tor-browser

nrinterfaceprioritizer.cpp (7049B)

---

/* 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,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nrinterfaceprioritizer.h"

#include <algorithm>
#include <map>
#include <set>
#include <string>
#include <vector>

#include "logging.h"
#include "nr_api.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.iface.type & NR_INTERFACE_TYPE_VPN) != 0 ? 1 : 0;
   estimated_speed_ = local_addr.iface.estimated_speed;
   type_preference_ = GetNetworkTypePreference(local_addr.iface.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;
 }

 // TODO(bug 895790): Once we can get useful interface properties on Darwin,
 // 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