/* 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 <algorithm> #include <map> #include <set> #include <string> #include <vector> #include "logging.h" #include "nrinterfaceprioritizer.h" #include "nsCOMPtr.h" MOZ_MTLOG_MODULE("mtransport") namespace { class LocalAddress { public: LocalAddress() : ifname_(), addr_(), key_(), 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 + 41]; 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; } 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() : local_addrs_(), preference_map_(), 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 (std::set<LocalAddress>::iterator i = local_addrs_.begin(); i != local_addrs_.end(); ++i) { if (tmp_pref == 0) { return R_FAILED; } preference_map_.insert(make_pair(i->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 = 0; 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