REMOVE COMMENTS cout and unaccessary logs

add: test, framed routing module, framed routing config setup routing
uplink
refactor: oai_upf cmake-file

src/upf_app/framed_routing/FramedRouting.cpp

@@ -6,6 +6,9 @@
 #include <utility>
 #include <sstream>
 #include <iostream>
+#include <upf_config.hpp>
+
+extern oai::config::upf_config upf_cfg;
 
 namespace fr {
 
@@ -13,40 +16,68 @@ FramedRouting::FramedRouting(std::shared_ptr<LocalRouting> localRouting)
     : localRouting(std::move(localRouting)) {}
 
 void FramedRouting::addFramedRoute(
-    const uint32_t ue_ip, const pfcp::framed_route_s& framed_route_s,
-    uint32_t gatewayIP) {
+    const uint32_t ue_ip, const pfcp::framed_route_s& framed_route_s) {
   std::stringstream ss(framed_route_s.framed_route);
-  const char delimiter = ' ';
   std::string ipsubnetmask;
-  while (std::getline(ss, ipsubnetmask, delimiter)) {
+  while (std::getline(ss, ipsubnetmask, this->pdi_fr_delimeter)) {
     std::pair<uint32_t, uint32_t> ipCidr = this->extractIPCidr(ipsubnetmask);
     auto key                             = createFramedRoutingKey(ipCidr);
-    auto routing_info = createLocalRoutingInformation(ipCidr, gatewayIP);
+    auto routing_info = createLocalRoutingInformation(ipCidr);
+    auto snat_info    = createLocalSnatInformation(ipCidr);
+    std::cout << "retrieve dest ip subnet: " << ipCidr.second << std::endl;
+    std::cout << "retrieve network ip: " << key.networkAdress << std::endl;
     this->KeyToIp.insert({key, ue_ip});
-    localRouting->addRoute(routing_info);
+    localRouting->add_route(routing_info);
+    localRouting->add_source_snat(snat_info);
   }
 }
 
-uint32_t FramedRouting::retrieveFramedUEIp(
-    const uint32_t destination_ip) const {
+uint32_t FramedRouting::retrieveUEIp(const uint32_t destination_ip) const {
+  std::cout << "retrieve dest ip " << destination_ip << std::endl;
   for (uint32_t i = 32; i > 0; --i) {
     FramedRoutingKey framedRoutingKey =
         createFramedRoutingKey({destination_ip, i});
+    std::cout << "retrieve dest ip subnet: " << i << std::endl;
+    std::cout << "retrieve network ip: " << framedRoutingKey.networkAdress
+              << std::endl;
+
     auto ip = this->KeyToIp.find(framedRoutingKey);
+
     if (ip != KeyToIp.end()) {
+      std::cout << "find at: " << i << std::endl;
       return ip->second;
     };
   };
   return 0;
 };
 
-void FramedRouting::removeEntry(uint32_t ue_ip) {
+uint32_t FramedRouting::retrieveUEIp(
+    const pfcp::framed_route_s& framed_route_s) const {
+  std::cout << framed_route_s.framed_route << std::endl;
+
+  std::stringstream ss(framed_route_s.framed_route);
+  std::string ipsubnetmask;
+  Logger::pfcp_switch().info(
+      "Retrieving Frame string: " + framed_route_s.framed_route);
+  while (std::getline(ss, ipsubnetmask, this->pdi_fr_delimeter)) {
+    Logger::pfcp_switch().info("Retrieving Frame string: " + ipsubnetmask);
+    std::pair<uint32_t, uint32_t> ipCidr = this->extractIPCidr(ipsubnetmask);
+    FramedRoutingKey framedRoutingKey =
+        createFramedRoutingKey({ipCidr.first, ipCidr.second});
+    auto ip = this->KeyToIp.find(framedRoutingKey);
+    if (ip != KeyToIp.end()) {
+      return ip->second;
+    }
+  }
+  return 0;
+};
+void FramedRouting::remove_entry(uint32_t ue_ip) {
   for (uint32_t i = 32; i > 0; --i) {
     FramedRoutingKey framedRoutingKey = createFramedRoutingKey({ue_ip, i});
     auto ip                           = this->KeyToIp.find(framedRoutingKey);
     if (ip != KeyToIp.end()) {
       this->KeyToIp.erase(ip);
-      this->localRouting->deleteRoute(ip->second);
+      this->localRouting->delete_route(ip->second);
     };
   };
 }
@@ -106,20 +137,33 @@ FramedRoutingKey FramedRouting::createFramedRoutingKey(
   return FramedRoutingKey{networkAdress, subnet_adress};
 }
 
+// todo(phine.tech) replace with better method in local routing.
 RoutingInformation FramedRouting::createLocalRoutingInformation(
-    const std::pair<uint32_t, uint32_t> ipCidr,
-    const uint32_t gateway_ip) const {
+    const std::pair<uint32_t, uint32_t>& ipCidr) const {
   struct in_addr addr;
   addr.s_addr             = htonl(ipCidr.first);
   std::string destination = inet_ntoa(addr);
   uint32_t netmask        = ipCidr.second;
   std::string device      = "tun0";
   // todo (phine.tech) use correct DNN
-  struct in_addr address4_gw  = {};
-  address4_gw.s_addr          = gateway_ip;
+  struct in_addr address4_gw = {};
+  address4_gw.s_addr         = upf_cfg.pdns[0].network_ipv4.s_addr + be32toh(1);
   std::string gateway_address = inet_ntoa(address4_gw);
 
   return fr::RoutingInformation{destination, netmask, device, gateway_address};
 }
 
+// todo(phine.tech) replace with better method in local routing.
+SourceNatInformation FramedRouting::createLocalSnatInformation(
+    const std::pair<uint32_t, uint32_t>& ipCidr) const {
+  struct in_addr addr;
+  addr.s_addr              = htonl(ipCidr.first);
+  std::string destination  = inet_ntoa(addr);
+  uint32_t netmask         = ipCidr.second;
+  std::string device       = upf_cfg.n6.if_name;
+  std::string snat_address = oai::utils::conv::toString(upf_cfg.n6.addr4);
+
+  return SourceNatInformation{destination, netmask, device, snat_address};
+}
+
 }  // namespace fr
\ No newline at end of file

src/upf_app/framed_routing/FramedRouting.hpp

@@ -22,15 +22,18 @@ namespace fr {
         virtual ~FramedRouting() = default;
 
         [[nodiscard]] uint32_t
-        retrieveFramedUEIp(const uint32_t destination_ip) const;
+        retrieveUEIp(const uint32_t destination_ip) const;
 
-        void addFramedRoute(uint32_t ue_ip, const pfcp::framed_route_s &framed_route_s,uint32_t gatewayIP);
+        [[nodiscard]] uint32_t retrieveUEIp(const pfcp::framed_route_s &framed_route_s) const;
 
-        void removeEntry(uint32_t ue_ip);
+        void addFramedRoute(uint32_t ue_ip, const pfcp::framed_route_s &framed_route_s);
+
+        void remove_entry(uint32_t ue_ip);
 
         // todo(kw) create a facade for fr options.
 
     private:
+        const char pdi_fr_delimeter = ' ';
 
         // todo(kw) discuss size or use constant
         std::shared_ptr<LocalRouting> localRouting;
@@ -43,7 +46,13 @@ namespace fr {
         [[nodiscard]] std::pair<uint32_t, uint32_t> extractIPCidr(const std::string &fr_subnet) const;
 
         [[nodiscard]] FramedRoutingKey createFramedRoutingKey(std::pair<uint32_t, uint32_t> ipCidr) const;
-        [[nodiscard]] RoutingInformation createLocalRoutingInformation(std::pair<uint32_t, uint32_t> ipCidr, uint32_t gateway_ip) const;
+
+        [[nodiscard]] RoutingInformation
+        createLocalRoutingInformation(const std::pair<uint32_t, uint32_t> &ipCidr) const;
+
+        [[nodiscard]]   SourceNatInformation
+        createLocalSnatInformation(const std::pair<uint32_t, uint32_t> &ipCidr) const;
+
     };
 
 

src/upf_app/framed_routing/LocalRouting.cpp

@@ -10,40 +10,62 @@
 
 namespace fr {
 
-void LocalRouting::addRoute(const RoutingInformation& routing_information) {
-    auto original_cerr_streambuf = std::cerr.rdbuf(nullptr );
-  auto cmd = fmt::format(
+void LocalRouting::add_route(const RoutingInformation& routing_information) {
+  auto original_cerr_streambuf = std::cerr.rdbuf(nullptr);
+  auto cmd                     = fmt::format(
       "ip route add {}/{} via {} dev tun0", routing_information.destination,
       routing_information.netmask, routing_information.gateway_address);
   auto rc = system((const char*) cmd.c_str());
-    if (rc == 0) {
-        Logger::pfcp_switch().info(
-                "Route created");
-      this->routeInfoToRtEntry.insert({routing_information.destination,routing_information});
+  if (rc == 0) {
+    Logger::pfcp_switch().info("Route created");
+    this->routeInfoToRtEntry.insert(
+        {routing_information.destination, routing_information});
+  } else {
+    Logger::pfcp_switch().warn("Route information not correct or does exists!");
   }
-    Logger::pfcp_switch().warn(
-            "Route information not correct or does not exists!");
 }
 
-void LocalRouting::deleteRoute(const uint32_t& network_address) {
+void LocalRouting::delete_route(const uint32_t& network_address) {
   // todo(phine.tech) create function remove dublicated_code
-    auto original_cerr_streambuf = std::cerr.rdbuf(nullptr );
-    struct in_addr addr;
-  addr.s_addr                = htonl(network_address);
-  std::string destination    = inet_ntoa(addr);
-  auto routing_info_iterator = this->routeInfoToRtEntry.find(destination);
+  auto original_cerr_streambuf = std::cerr.rdbuf(nullptr);
+  std::string destination      = convert_s_addr_to_string(network_address);
+  auto routing_info_iterator   = this->routeInfoToRtEntry.find(destination);
   if (routing_info_iterator != routeInfoToRtEntry.end()) {
     const auto routing_information = routing_info_iterator->second;
     auto cmd                       = fmt::format(
         "ip route del {}/{} via {} dev tun0", routing_information.destination,
         routing_information.netmask, routing_information.gateway_address);
-    auto rc = system((const char*) cmd.c_str() );
+    const auto rc = system((const char*) cmd.c_str());
     if (rc == 0) {
-        Logger::pfcp_switch().info(
-                "Route deleted");
-    }
+      Logger::pfcp_switch().info("Route deleted");
+    } else {
       Logger::pfcp_switch().warn(
-              "Route information not correct or does not exists!");
+          "Route information not correct or does not exists!");
+    }
   }
 };
+
+void LocalRouting::add_source_snat(
+    const SourceNatInformation& source_nat_information) {
+  const std::string cmd = fmt::format(
+      "iptables -t nat -A POSTROUTING -s {}/{} -o {} -j SNAT --to "
+      "{}",
+      source_nat_information.destination, source_nat_information.netmask,
+      source_nat_information.device, source_nat_information.snat_address);
+  const auto rc = system((const char*) cmd.c_str());
+  if (rc == 0) {
+    Logger::pfcp_switch().info("Source NAT added");
+  } else {
+    Logger::pfcp_switch().warn("Source NAT not correct or does exists!");
+  }
+}
+
+void LocalRouting::delete_ssnat(const uint32_t& network_address) {}
+
+std::string LocalRouting::convert_s_addr_to_string(
+    const uint32_t& network_address) {
+  struct in_addr addr;
+  addr.s_addr = htonl(network_address);
+  return inet_ntoa(addr);
+}
 }  // namespace fr
\ No newline at end of file

src/upf_app/framed_routing/LocalRouting.hpp

@@ -11,25 +11,35 @@
 namespace fr {
     struct RoutingInformation {
         std::string destination;
-        uint32_t netmask;
+        uint32_t netmask =0;
         std::string device;
         std::string gateway_address;
     };
+
+    struct SourceNatInformation {
+        std::string destination;
+        uint32_t netmask =0;
+        std::string device;
+        std::string snat_address;
+    };
 //todo (kw) rename class
     class LocalRouting {
     public:
-        virtual void addRoute(const RoutingInformation &routing_information);
+        virtual void add_route(const RoutingInformation &routing_information);
 
-        virtual void deleteRoute(const uint32_t & network_address);
+        virtual void delete_route(const uint32_t & network_address);
 
-    private:
+        virtual void add_source_snat(const SourceNatInformation &source_nat_information);
 
-        std::unordered_map<std::string, RoutingInformation> routeInfoToRtEntry{};
 
+        // todo(phine.tech) implement delete if needed
+        virtual void delete_ssnat(const uint32_t & network_address);
 
-       short getInterfaceIndex(const std::string& interfaceName);
+    private:
 
+        std::unordered_map<std::string, RoutingInformation> routeInfoToRtEntry{};
 
+        std::string convert_s_addr_to_string(const uint32_t &network_address);
     };
 
 } // fr

src/upf_app/simpleswitch/pfcp_pdr.cpp

@@ -32,7 +32,6 @@
 using namespace pfcp;
 using namespace oai::upf::app;
 
-
 extern upf_n4* upf_n4_inst;
 extern oai::config::upf_config upf_cfg;
 //------------------------------------------------------------------------------
@@ -66,8 +65,8 @@ bool pfcp_pdr::look_up_pack_in_access(
       if (!pdi.second.ue_ip_address.second.v4) {
         return false;
       }
-      if (!upf_cfg.enable_fr&&pdi.second.ue_ip_address.second.ipv4_address.s_addr != iph->saddr) {
-              return false;
+      if (pdi.second.ue_ip_address.second.ipv4_address.s_addr != iph->saddr) {
+        return false;
       }
     }
     // SDF filter
@@ -103,7 +102,8 @@ bool pfcp_pdr::look_up_pack_in_core(
       return false;
     }
 
-    if (!upf_cfg.enable_fr&& pdi.second.ue_ip_address.second.ipv4_address.s_addr != iph->daddr) {
+    if (!upf_cfg.enable_fr &&
+        pdi.second.ue_ip_address.second.ipv4_address.s_addr != iph->daddr) {
       // Logger::pfcp_switch().info( "look_up_pack_in_core failed PDR id %4x,
       // cause PDR ue_ip_address %8X do not match IP dest %8X of packet ",
       //    pdr_id.rule_id, pdi.second.ue_ip_address.second.ipv4_address.s_addr,

src/upf_app/simpleswitch/pfcp_switch.cpp

@@ -333,17 +333,15 @@ void pfcp_switch::setup_pdn_interfaces() {
             oai::utils::conv::toString(it.network_ipv4),
             static_cast<uint32_t>(it.prefix_ipv4), "tun0",
             oai::utils::conv::toString(address4_gw)};
-        local_routing->addRoute(routing_info);
+        local_routing->add_route(routing_info);
       }
 
       if (upf_cfg.enable_snat) {
-        cmd = fmt::format(
-            "iptables -t nat -A POSTROUTING -s {}/{} -o {} -j SNAT --to "
-            "{}",
-            oai::utils::conv::toString(it.network_ipv4).c_str(), it.prefix_ipv4,
-            upf_cfg.n6.if_name.c_str(),
-            oai::utils::conv::toString(upf_cfg.n6.addr4).c_str());
-        rc = system((const char*) cmd.c_str());
+        auto snat_info = fr::SourceNatInformation{
+            oai::utils::conv::toString(it.network_ipv4),
+            static_cast<uint32_t>(it.prefix_ipv4), upf_cfg.n6.if_name,
+            oai::utils::conv::toString(upf_cfg.n6.addr4)};
+        local_routing->add_source_snat(snat_info);
       }
     }
     if (it.prefix_ipv6) {
@@ -631,9 +629,11 @@ void pfcp_switch::add_pfcp_dl_pdr_by_ue_ip(
         entry(ue_ip, pdrs);
     ue_ipv4_hbo2pfcp_pdr.insert(entry);
     if (upf_cfg.enable_fr) {
-      fr->addFramedRoute(
-          ue_ip, pdr->pdi.second.framed_route.second,
-          upf_cfg.pdns[0].network_ipv4.s_addr + be32toh(1));
+      Logger::pfcp_switch().info("fr_ue_ip %4x ", ue_ip);
+      Logger::pfcp_switch().info(
+          "framed routing ip: " +
+          pdr->pdi.second.framed_route.second.framed_route);
+      fr->addFramedRoute(ue_ip, pdr->pdi.second.framed_route.second);
     }
     // Logger::pfcp_switch().info( "add_pfcp_dl_pdr_by_ue_ip UE IP %8x", ue_ip);
   } else {
@@ -656,7 +656,8 @@ void pfcp_switch::add_pfcp_dl_pdr_by_ue_ip(
 void pfcp_switch::remove_pfcp_dl_pdrs_by_ue_ip(const uint32_t ue_ip) {
   ue_ipv4_hbo2pfcp_pdr.erase(ue_ip);
   if (upf_cfg.enable_fr) {
-    this->fr->removeEntry(ue_ip);
+    std::cout << "remove fr entry" << std::endl;
+    this->fr->remove_entry(ue_ip);
   }
 }
 
@@ -1140,17 +1141,43 @@ void pfcp_switch::handle_pfcp_session_deletion_request(
 void pfcp_switch::pfcp_session_look_up_pack_in_access(
     struct iphdr* const iph, const std::size_t num_bytes,
     const endpoint& r_endpoint, const uint32_t tunnel_id) {
+  bool isInAccess = false;
   if (!upf_cfg.nsf.bypass_ul_pfcp_rules) {
     std::shared_ptr<std::vector<std::shared_ptr<pfcp::pfcp_pdr>>> pdrs = {};
     if (get_pfcp_ul_pdrs_by_up_teid(tunnel_id, pdrs)) {
       bool nocp = false;
       bool buff = false;
-      for (std::vector<std::shared_ptr<pfcp::pfcp_pdr>>::iterator it_pdr =
-               pdrs->begin();
-           it_pdr < pdrs->end(); ++it_pdr) {
-        if ((*it_pdr)->look_up_pack_in_access(
-                iph, num_bytes, r_endpoint, tunnel_id) ||
-            (upf_cfg.enable_fr && fr->retrieveFramedUEIp(iph->saddr) > 0)) {
+      for (auto it_pdr = pdrs->begin(); it_pdr < pdrs->end(); ++it_pdr) {
+        // todo (kw) framed route ip
+        isInAccess = (*it_pdr)->look_up_pack_in_access(
+            iph, num_bytes, r_endpoint, tunnel_id);
+        if (upf_cfg.enable_fr) {
+          std::cout
+              << it_pdr->get()->pdi.second.framed_route.second.framed_route
+              << std::endl;
+
+          const auto fr_ue_ip = fr->retrieveUEIp(be32toh(iph->saddr));
+          Logger::pfcp_switch().info(
+              "iph->saddr %d ",
+              it_pdr->get()->pdi.second.framed_route.second.framed_route);
+          Logger::pfcp_switch().info("iph->daddr %4x ", iph->daddr);
+          Logger::pfcp_switch().info("iph->saddr %4x ", iph->saddr);
+          Logger::pfcp_switch().info("fr_ue_ip %4x ", fr_ue_ip);
+          Logger::pfcp_switch().info(
+              "ipv4_address.s_addr: %4x ",
+              it_pdr->get()
+                  ->pdi.second.ue_ip_address.second.ipv4_address.s_addr);
+          isInAccess =
+              fr_ue_ip ==
+              it_pdr->get()
+                  ->pdi.second.ue_ip_address.second.ipv4_address.s_addr;
+        }
+        if (isInAccess) {
+          Logger::pfcp_switch().info(
+              "PDR/PDI IP is %4x ",
+              it_pdr->get()
+                  ->pdi.second.ue_ip_address.second.ipv4_address.s_addr);
+          Logger::pfcp_switch().info("Upstream IP is %4x ", iph->saddr);
           std::shared_ptr<pfcp::pfcp_session> ssession = {};
           uint64_t lseid                               = 0;
           if ((*it_pdr)->get(lseid)) {
@@ -1218,11 +1245,9 @@ void pfcp_switch::pfcp_session_look_up_pack_in_core(
     bool is_pdr_ue_ip = get_pfcp_dl_pdrs_by_ue_ip(ue_ip, pdrs);
     Logger::pfcp_switch().info("Is PDR", is_pdr_ue_ip);
     if (!is_pdr_ue_ip && upf_cfg.enable_fr) {
-      uint32_t fr_ip = fr->retrieveFramedUEIp(ue_ip);
-      Logger::pfcp_switch().info("Fr IP", fr_ip);
-      Logger::pfcp_switch().info("UE", ue_ip);
-      ue_ip        = fr_ip != 0 ? fr_ip : ue_ip;
-      is_pdr_ue_ip = get_pfcp_dl_pdrs_by_ue_ip(ue_ip, pdrs);
+      uint32_t fr_ip = fr->retrieveUEIp(ue_ip);
+      ue_ip          = fr_ip != 0 ? fr_ip : ue_ip;
+      is_pdr_ue_ip   = get_pfcp_dl_pdrs_by_ue_ip(ue_ip, pdrs);
     }
     if (is_pdr_ue_ip) {
       bool nocp = false;

src/upf_app/tests/CMakeLists.txt

@@ -33,9 +33,8 @@ add_executable(
         framed_routing/FramedRoutingTest.cpp
         framed_routing/mocks/LocalRoutingMock.h
 )
-
-add_dependencies(UPFTest upf)
-        target_link_libraries(UPFTest PUBLIC FRAMED_ROUTING SIMPLE_SWITCH GTest::gtest_main GTest::gmock_main fmt)
+set_property(TARGET upf PROPERTY ${CMAKE_CURRENT_BINARY_DIR}../upf)
+        target_link_libraries(UPFTest PUBLIC  GTest::gtest_main GTest::gmock_main fmt)
         include(GoogleTest)
         gtest_discover_tests(UPFTest)
 

src/upf_app/tests/framed_routing/FramedRoutingTest.cpp

+#include <upf_config.hpp>
 #include "FramedRoutingTest.h"
+extern oai::config::upf_config upf_cfg;
 
 namespace fr {
 TEST_F(FramedRoutingTest, CreateFramedRoute) {
@@ -8,47 +10,46 @@ TEST_F(FramedRoutingTest, CreateFramedRoute) {
 }
 
 TEST_F(FramedRoutingTest, AddRoutes) {
-  const uint32_t gatewayip = 0x01010102;
-  auto framed_route        = pfcp::framed_route_s{
-      "192.168.2.0/24 192.168.1.0/24 12.1.1.0/25 192.168.1.0/25 130.0.0.5 192.168.128.0"};
+  auto framed_route = pfcp::framed_route_s{
+      "192.168.2.0/24 192.168.1.0/24 12.1.1.0/25 192.168.1.0/25 130.0.0.5 "
+      "192.168.128.0"};
 
-
-  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route, gatewayip);
+  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route);
 
   EXPECT_NO_FATAL_FAILURE();
 }
 
 TEST_F(FramedRoutingTest, AddRoutesEmptyIP) {
   auto framed_route = pfcp::framed_route_s{""};
-  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route, 0);
+  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route);
   EXPECT_NO_FATAL_FAILURE();
 }
 
 TEST_F(FramedRoutingTest, AddRoutesDuplicates) {
   auto framed_route = pfcp::framed_route_s{"192.168.2.10/24 192.168.2.10/24"};
-  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route, 0);
+  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route);
   EXPECT_NO_FATAL_FAILURE();
 }
 
 TEST_F(FramedRoutingTest, retrieveSubnetNotExisting) {
-  const auto dest_ip = FramedRoutingTest::fr->retrieveFramedUEIp(ue_ip_one);
+  const auto dest_ip = FramedRoutingTest::fr->retrieveUEIp(ue_ip_one);
   EXPECT_EQ(dest_ip, 0);
 }
 
 TEST_F(FramedRoutingTest, retrieveSubnetIP) {
   auto framed_route = pfcp::framed_route_s{"192.168.2.0/25"};
-  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route, 0);
+  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route);
 
   uint32_t lookup_ip = 0xc0a8027a;  // 192.168.2.122
-  const auto dest_ip = FramedRoutingTest::fr->retrieveFramedUEIp(lookup_ip);
+  const auto dest_ip = FramedRoutingTest::fr->retrieveUEIp(lookup_ip);
 
   EXPECT_EQ(dest_ip, ue_ip_one);
 }
 TEST_F(FramedRoutingTest, retrieveSubnetIPWrongSubnet) {
   auto framed_route = pfcp::framed_route_s{"192.168.2.10/25"};
-  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route, 0);
+  FramedRoutingTest::fr->addFramedRoute(ue_ip_one, framed_route);
   uint32_t lookup_ip = 0xc0a80280;
-  const auto dest_ip = FramedRoutingTest::fr->retrieveFramedUEIp(lookup_ip);
+  const auto dest_ip = FramedRoutingTest::fr->retrieveUEIp(lookup_ip);
   EXPECT_EQ(dest_ip, 0);
 }
 }  // namespace fr
\ No newline at end of file

src/upf_app/tests/framed_routing/LocalRoutingTest.cpp

@@ -6,16 +6,17 @@
 #include "LocalRoutingTest.h"
 
 namespace fr {
-    TEST_F(LocalRoutingTest, AddAndDeleteRoutes) {
-        const auto localRouting = std::make_shared<LocalRouting>();
-        // 0xC0A80232= 192.168.2.50
-        const std::string destination_adress = "192.168.128.0";
-        const int network_mask = 24;
-        const std::string device = "tun0";
-        const std::string gateway = "12.1.1.1";
-        RoutingInformation routingInformation = {destination_adress, network_mask, device, gateway};
-       localRouting->addRoute(routingInformation);
-        localRouting->deleteRoute(0xC0A88000);
-        ASSERT_NO_FATAL_FAILURE();
-    }
-}
+TEST_F(LocalRoutingTest, AddAndDeleteRoutes) {
+  const auto localRouting = std::make_shared<LocalRouting>();
+  // 0xC0A80232= 192.168.2.50
+  const std::string destination_adress  = "192.168.128.0";
+  const int network_mask                = 24;
+  const std::string device              = "tun0";
+  const std::string gateway             = "12.1.1.1";
+  RoutingInformation routingInformation = {
+      destination_adress, network_mask, device, gateway};
+  localRouting->add_route(routingInformation);
+  localRouting->delete_route(0xC0A88000);
+  ASSERT_NO_FATAL_FAILURE();
+}
\ No newline at end of file
+}  // namespace fr
\ No newline at end of file

src/upf_app/tests/framed_routing/mocks/LocalRoutingMock.h

@@ -9,7 +9,7 @@
 namespace fr {
     class MockLocalRouting : public LocalRouting {
     public:
-        MOCK_METHOD(bool, addRoute,(const RoutingInformation & routing_information),(override));
-        MOCK_METHOD(bool, deleteRoute,(const uint32_t & network_address),(override));
+        MOCK_METHOD(void, add_route,(const RoutingInformation & routing_information),(override));
+        MOCK_METHOD(void, delete_route,(const uint32_t & network_address),(override));
     };
 }