gecko-dev/media/mtransport/nrinterfaceprioritizer.cpp

/* 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 + 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;
  }

  // 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 (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