- fix crash when add multiple cubes to one interfaces

- add a CLI to check the cubes attaches to a interface

Signed-off-by: Jianwen Pi<jianwpi@gmail.com>

Author: goldenrye

src/polycubed/src/extiface.cpp

@@ -32,7 +32,7 @@ const std::string PARAMETER_MAC = "MAC";
 const std::string PARAMETER_IP = "IP";
 const std::string PARAMETER_PEER = "PEER";
 
-std::set<std::string> ExtIface::used_ifaces;
+std::map<std::string, ExtIface*> ExtIface::used_ifaces;
 
 ExtIface::ExtIface(const std::string &iface)
     : PeerIface(iface_mutex_),
@@ -43,7 +43,7 @@ ExtIface::ExtIface(const std::string &iface)
     throw std::runtime_error("Iface already in use");
   }
 
-  used_ifaces.insert(iface);
+  used_ifaces.insert({iface, this});
 
   // Save the ifindex
   ifindex_iface = if_nametoindex(iface.c_str());
@@ -60,6 +60,14 @@ ExtIface::~ExtIface() {
   used_ifaces.erase(iface_);
 }
 
+ExtIface* ExtIface::get_extiface(const std::string &iface_name) {
+  if (used_ifaces.count(iface_name) == 0) {
+      return NULL;
+  }
+
+  return used_ifaces[iface_name];
+}
+
 uint16_t ExtIface::get_index() const {
   return index_;
 }
@@ -243,12 +251,6 @@ void ExtIface::update_indexes() {
   }
 }
 
-// in external ifaces the cubes must be allocated in the inverse order.
-// first is the one that hits ingress traffic.
-int ExtIface::calculate_cube_index(int index) {
-  return 0 - index;
-}
-
 bool ExtIface::is_used() const {
   std::lock_guard<std::mutex> guard(iface_mutex_);
   return cubes_.size() > 0 || peer_ != nullptr;

src/polycubed/src/extiface.h

@@ -41,6 +41,13 @@ class ExtIface : public PeerIface {
   ExtIface(const ExtIface &) = delete;
   ExtIface &operator=(const ExtIface &) = delete;
 
+  /* return ExtIface pointer given interface name
+   * or return null if
+   * - either the interface name doesn't exist
+   * - or no extiface created for the interface name
+   */
+  static ExtIface* get_extiface(const std::string &iface_name);
+
   uint16_t get_index() const override;
   uint16_t get_port_id() const override;
   void set_peer_iface(PeerIface *peer) override;
@@ -71,7 +78,7 @@ class ExtIface : public PeerIface {
 
   std::mutex event_mutex;
 
-  static std::set<std::string> used_ifaces;
+  static std::map<std::string, ExtIface*> used_ifaces;
   int load_ingress();
   int load_egress();
   int load_tx();
@@ -82,7 +89,6 @@ class ExtIface : public PeerIface {
   virtual bpf_prog_type get_program_type() const = 0;
 
   void update_indexes() override;
-  int calculate_cube_index(int index) override;
 
   ebpf::BPF ingress_program_;
   ebpf::BPF egress_program_;

src/polycubed/src/polycubed_core.cpp

@@ -208,6 +208,16 @@ std::string PolycubedCore::topology() {
   return j.dump(4);
 }
 
+std::string PolycubedCore::get_if_topology(const std::string &if_name) {
+   json j = {{"name", if_name}};
+
+   auto extIface = polycube::polycubed::ExtIface::get_extiface(if_name);
+   if (extIface != NULL) {
+       j["cubes"] = extIface->get_cubes_names();
+   }
+   return j.dump(4);
+}
+
 std::string get_port_peer(const std::string &port) {
   std::smatch match;
   std::regex rule("(\\S+):(\\S+)");

src/polycubed/src/polycubed_core.h

@@ -64,6 +64,7 @@ class PolycubedCore {
   std::string get_netdevs();
 
   std::string topology();
+  std::string get_if_topology(const std::string &if_name);
 
   void connect(const std::string &peer1, const std::string &peer2);
   void disconnect(const std::string &peer1, const std::string &peer2);

src/polycubed/src/rest_server.cpp

@@ -271,6 +271,8 @@ void RestServer::setup_routes() {
   // topology
   router_->get(base + std::string("/topology"),
                bind(&RestServer::topology, this));
+  router_->get(base + std::string("/topology/:ifname"),
+               bind(&RestServer::get_if_topology, this));
 
   router_->options(base + std::string("/topology"),
                    bind(&RestServer::topology_help, this));
@@ -830,6 +832,19 @@ void RestServer::topology(const Pistache::Rest::Request &request,
   }
 }
 
+void RestServer::get_if_topology(const Pistache::Rest::Request &request,
+                                Pistache::Http::ResponseWriter response) {
+  logRequest(request);
+  try {
+      auto ifname = request.param(":ifname").as<std::string>();
+      std::string retJsonStr = core.get_if_topology(ifname);
+      response.send(Pistache::Http::Code::Ok, retJsonStr);
+  } catch (const std::runtime_error &e) {
+      logger->error("{0}", e.what());
+      response.send(Pistache::Http::Code::Bad_Request, e.what());
+  }
+}
+
 void RestServer::topology_help(const Pistache::Rest::Request &request,
                                Pistache::Http::ResponseWriter response) {
   json j = json::object();

src/polycubed/src/rest_server.h

@@ -122,6 +122,8 @@ class RestServer {
               Pistache::Http::ResponseWriter response);
   void topology(const Pistache::Rest::Request &request,
                 Pistache::Http::ResponseWriter response);
+  void get_if_topology(const Pistache::Rest::Request &request,
+                Pistache::Http::ResponseWriter response);
   void topology_help(const Pistache::Rest::Request &request,
                      Pistache::Http::ResponseWriter response);