From 4b2f07958137e82acdc6648d342fa5e182973268 Mon Sep 17 00:00:00 2001 From: Francisco Paisana Date: Thu, 2 Sep 2021 11:57:09 +0200 Subject: [PATCH] gtpu: renamed lcid to eps_bearer_id as parte of the refactor of gtpu to use eps_bearer_ids --- lib/include/srsran/common/common_lte.h | 7 +- srsenb/hdr/stack/upper/gtpu.h | 51 +++++----- srsenb/src/stack/upper/gtpu.cc | 123 +++++++++++++------------ srsenb/test/upper/gtpu_test.cc | 16 ++-- 4 files changed, 104 insertions(+), 93 deletions(-) diff --git a/lib/include/srsran/common/common_lte.h b/lib/include/srsran/common/common_lte.h index 0152a692b..5b1ee9cfa 100644 --- a/lib/include/srsran/common/common_lte.h +++ b/lib/include/srsran/common/common_lte.h @@ -49,9 +49,10 @@ inline bool is_lte_cell_nof_prb(uint32_t nof_prb) enum class lte_srb { srb0, srb1, srb2, count }; const uint32_t MAX_LTE_SRB_ID = 2; enum class lte_drb { drb1 = 1, drb2, drb3, drb4, drb5, drb6, drb7, drb8, drb9, drb10, drb11, invalid }; -const uint32_t MAX_LTE_DRB_ID = 11; -const uint32_t MAX_LTE_LCID = 10; // logicalChannelIdentity 3..10 in TS 36.331 v15.3 -const uint32_t INVALID_LCID = 99; // random invalid LCID +const uint32_t MAX_LTE_DRB_ID = 11; +const uint32_t MAX_LTE_LCID = 10; // logicalChannelIdentity 3..10 in TS 36.331 v15.3 +const uint32_t INVALID_LCID = 99; // random invalid LCID +const uint32_t INVALID_EPS_BEARER_ID = 99; // random invalid eps bearer id constexpr bool is_lte_rb(uint32_t lcid) { diff --git a/srsenb/hdr/stack/upper/gtpu.h b/srsenb/hdr/stack/upper/gtpu.h index 976a865b2..eff0e747d 100644 --- a/srsenb/hdr/stack/upper/gtpu.h +++ b/srsenb/hdr/stack/upper/gtpu.h @@ -53,11 +53,11 @@ public: enum class tunnel_state { pdcp_active, buffering, forward_to, forwarded_from, inactive }; struct tunnel { - uint16_t rnti = SRSRAN_INVALID_RNTI; - uint32_t lcid = srsran::INVALID_LCID; - uint32_t teid_in = 0; - uint32_t teid_out = 0; - uint32_t spgw_addr = 0; + uint16_t rnti = SRSRAN_INVALID_RNTI; + uint32_t eps_bearer_id = srsran::INVALID_EPS_BEARER_ID; + uint32_t teid_in = 0; + uint32_t teid_out = 0; + uint32_t spgw_addr = 0; tunnel_state state = tunnel_state::pdcp_active; srsran::unique_timer rx_timer; @@ -76,27 +76,30 @@ public: } }; - struct lcid_tunnel { - uint32_t lcid; + struct bearer_teid_pair { + uint32_t eps_bearer_id; uint32_t teid; - bool operator<(const lcid_tunnel& other) const + bool operator<(const bearer_teid_pair& other) const { - return lcid < other.lcid or (lcid == other.lcid and teid < other.teid); + return eps_bearer_id < other.eps_bearer_id or (eps_bearer_id == other.eps_bearer_id and teid < other.teid); + } + bool operator==(const bearer_teid_pair& other) const + { + return eps_bearer_id == other.eps_bearer_id and teid == other.teid; } - bool operator==(const lcid_tunnel& other) const { return lcid == other.lcid and teid == other.teid; } }; - using ue_lcid_tunnel_list = srsran::bounded_vector; + using ue_bearer_tunnel_list = srsran::bounded_vector; explicit gtpu_tunnel_manager(srsran::task_sched_handle task_sched_, srslog::basic_logger& logger); void init(const gtpu_args_t& gtpu_args, pdcp_interface_gtpu* pdcp_); - bool has_teid(uint32_t teid) const { return tunnels.contains(teid); } - const tunnel* find_tunnel(uint32_t teid); - ue_lcid_tunnel_list* find_rnti_tunnels(uint16_t rnti); - srsran::span find_rnti_lcid_tunnels(uint16_t rnti, uint32_t lcid); + bool has_teid(uint32_t teid) const { return tunnels.contains(teid); } + const tunnel* find_tunnel(uint32_t teid); + ue_bearer_tunnel_list* find_rnti_tunnels(uint16_t rnti); + srsran::span find_rnti_bearer_tunnels(uint16_t rnti, uint32_t eps_bearer_id); - const tunnel* add_tunnel(uint16_t rnti, uint32_t lcid, uint32_t teidout, uint32_t spgw_addr); + const tunnel* add_tunnel(uint16_t rnti, uint32_t eps_bearer_id, uint32_t teidout, uint32_t spgw_addr); bool update_rnti(uint16_t old_rnti, uint16_t new_rnti); void activate_tunnel(uint32_t teid); @@ -119,8 +122,8 @@ private: pdcp_interface_gtpu* pdcp = nullptr; srslog::basic_logger& logger; - rnti_map_t ue_teidin_db; - tunnel_list_t tunnels; + rnti_map_t ue_teidin_db; + tunnel_list_t tunnels; }; using gtpu_tunnel_state = gtpu_tunnel_manager::tunnel_state; @@ -139,17 +142,17 @@ public: // gtpu_interface_rrc srsran::expected add_bearer(uint16_t rnti, - uint32_t lcid, + uint32_t eps_bearer_id, uint32_t addr, uint32_t teid_out, const bearer_props* props = nullptr) override; void set_tunnel_status(uint32_t teidin, bool dl_active) override; - void rem_bearer(uint16_t rnti, uint32_t lcid) override; + void rem_bearer(uint16_t rnti, uint32_t eps_bearer_id) override; void mod_bearer_rnti(uint16_t old_rnti, uint16_t new_rnti) override; void rem_user(uint16_t rnti) override; // gtpu_interface_pdcp - void write_pdu(uint16_t rnti, uint32_t lcid, srsran::unique_byte_buffer_t pdu) override; + void write_pdu(uint16_t rnti, uint32_t eps_bearer_id, srsran::unique_byte_buffer_t pdu) override; // stack interface void handle_gtpu_s1u_rx_packet(srsran::unique_byte_buffer_t pdu, const sockaddr_in& addr); @@ -190,9 +193,9 @@ private: std::string m1u_multiaddr; std::string m1u_if_addr; - bool initiated = false; - int m1u_sd = -1; - int lcid_counter = 0; + bool initiated = false; + int m1u_sd = -1; + int bearer_counter = 0; }; m1u_handler m1u; diff --git a/srsenb/src/stack/upper/gtpu.cc b/srsenb/src/stack/upper/gtpu.cc index c6a20dc41..8d8e946a5 100644 --- a/srsenb/src/stack/upper/gtpu.cc +++ b/srsenb/src/stack/upper/gtpu.cc @@ -48,7 +48,7 @@ const gtpu_tunnel_manager::tunnel* gtpu_tunnel_manager::find_tunnel(uint32_t tei return it != tunnels.end() ? &it->second : nullptr; } -gtpu_tunnel_manager::ue_lcid_tunnel_list* gtpu_tunnel_manager::find_rnti_tunnels(uint16_t rnti) +gtpu_tunnel_manager::ue_bearer_tunnel_list* gtpu_tunnel_manager::find_rnti_tunnels(uint16_t rnti) { if (not ue_teidin_db.contains(rnti)) { return nullptr; @@ -56,26 +56,28 @@ gtpu_tunnel_manager::ue_lcid_tunnel_list* gtpu_tunnel_manager::find_rnti_tunnels return &ue_teidin_db[rnti]; } -srsran::span gtpu_tunnel_manager::find_rnti_lcid_tunnels(uint16_t rnti, uint32_t lcid) +srsran::span +gtpu_tunnel_manager::find_rnti_bearer_tunnels(uint16_t rnti, uint32_t eps_bearer_id) { - if (not is_lte_rb(lcid)) { - logger.warning("Searching for bearer with invalid lcid=%d", lcid); + if (not is_lte_rb(eps_bearer_id)) { + logger.warning("Searching for bearer with invalid eps-BearerID=%d", eps_bearer_id); return {}; } auto* ue_ptr = find_rnti_tunnels(rnti); if (ue_ptr == nullptr) { return {}; } - auto lcid_it_begin = std::lower_bound(ue_ptr->begin(), ue_ptr->end(), lcid_tunnel{lcid, 0}); - auto lcid_it_end = std::lower_bound(ue_ptr->begin(), ue_ptr->end(), lcid_tunnel{lcid + 1, 0}); + auto bearer_it_begin = std::lower_bound(ue_ptr->begin(), ue_ptr->end(), bearer_teid_pair{eps_bearer_id, 0}); + auto bearer_it_end = std::lower_bound(ue_ptr->begin(), ue_ptr->end(), bearer_teid_pair{eps_bearer_id + 1, 0}); - return srsran::span(&(*lcid_it_begin), &(*lcid_it_end)); + return srsran::span(&(*bearer_it_begin), &(*bearer_it_end)); } -const gtpu_tunnel* gtpu_tunnel_manager::add_tunnel(uint16_t rnti, uint32_t lcid, uint32_t teidout, uint32_t spgw_addr) +const gtpu_tunnel* +gtpu_tunnel_manager::add_tunnel(uint16_t rnti, uint32_t eps_bearer_id, uint32_t teidout, uint32_t spgw_addr) { - if (not is_lte_rb(lcid)) { - logger.warning("Adding TEID with invalid lcid=%d", lcid); + if (not is_lte_rb(eps_bearer_id)) { + logger.warning("Adding TEID with invalid eps-BearerID=%d", eps_bearer_id); return nullptr; } auto ret_pair = tunnels.insert(tunnel()); @@ -83,15 +85,15 @@ const gtpu_tunnel* gtpu_tunnel_manager::add_tunnel(uint16_t rnti, uint32_t lcid, logger.warning("Unable to create new GTPU TEID In"); return nullptr; } - tunnel* tun = &tunnels[ret_pair.value()]; - tun->teid_in = ret_pair.value(); - tun->rnti = rnti; - tun->lcid = lcid; - tun->teid_out = teidout; - tun->spgw_addr = spgw_addr; + tunnel* tun = &tunnels[ret_pair.value()]; + tun->teid_in = ret_pair.value(); + tun->rnti = rnti; + tun->eps_bearer_id = eps_bearer_id; + tun->teid_out = teidout; + tun->spgw_addr = spgw_addr; if (not ue_teidin_db.contains(rnti)) { - auto ret = ue_teidin_db.insert(rnti, ue_lcid_tunnel_list()); + auto ret = ue_teidin_db.insert(rnti, ue_bearer_tunnel_list()); if (ret.is_error()) { logger.error("Failed to allocate rnti=0x%x", rnti); return nullptr; @@ -104,16 +106,16 @@ const gtpu_tunnel* gtpu_tunnel_manager::add_tunnel(uint16_t rnti, uint32_t lcid, tunnels.erase(tun->teid_in); return nullptr; } - ue_tunnels.push_back(lcid_tunnel{lcid, tun->teid_in}); + ue_tunnels.push_back(bearer_teid_pair{eps_bearer_id, tun->teid_in}); std::sort(ue_tunnels.begin(), ue_tunnels.end()); fmt::memory_buffer str_buffer; srsran::gtpu_ntoa(str_buffer, htonl(spgw_addr)); - logger.info("New tunnel created - " TEID_IN_FMT ", " TEID_OUT_FMT ", rnti=0x%x, lcid=%d, remote addr=%s", + logger.info("New tunnel created - " TEID_IN_FMT ", " TEID_OUT_FMT ", rnti=0x%x, eps-BearerID=%d, remote addr=%s", tun->teid_in, teidout, rnti, - lcid, + eps_bearer_id, srsran::to_c_str(str_buffer)); return tun; @@ -129,22 +131,22 @@ bool gtpu_tunnel_manager::update_rnti(uint16_t old_rnti, uint16_t new_rnti) logger.info("Modifying bearer rnti. Old rnti: 0x%x, new rnti: 0x%x", old_rnti, new_rnti); // create new RNTI and update TEIDs of old rnti to reflect new rnti - if (not ue_teidin_db.insert(new_rnti, ue_lcid_tunnel_list())) { + if (not ue_teidin_db.insert(new_rnti, ue_bearer_tunnel_list())) { logger.error("Failure to create new rnti=0x%x", new_rnti); return false; } std::swap(ue_teidin_db[new_rnti], *old_rnti_ptr); - ue_lcid_tunnel_list& new_rnti_obj = ue_teidin_db[new_rnti]; + ue_bearer_tunnel_list& new_rnti_obj = ue_teidin_db[new_rnti]; srsran::bounded_vector to_remove; - for (lcid_tunnel& bearer : new_rnti_obj) { + for (bearer_teid_pair& bearer : new_rnti_obj) { tunnels[bearer.teid].rnti = new_rnti; // Remove forwarding path if (tunnels[bearer.teid].state == tunnel_state::forward_to) { tunnels[bearer.teid].state = tunnel_state::pdcp_active; tunnels[bearer.teid].fwd_tunnel = nullptr; - logger.info("Taking down forwarding tunnel for rnti=0x%x, lcid=%d. New default " TEID_IN_FMT, + logger.info("Taking down forwarding tunnel for rnti=0x%x, eps-BearerID=%d. New default " TEID_IN_FMT, new_rnti, - bearer.lcid, + bearer.eps_bearer_id, bearer.teid); } else if (tunnels[bearer.teid].state == tunnel_state::forwarded_from) { to_remove.push_back(bearer.teid); @@ -169,12 +171,13 @@ bool gtpu_tunnel_manager::remove_tunnel(uint32_t teidin) deactivate_tunnel(teidin); // erase keeping the relative order - auto& ue = ue_teidin_db[tun.rnti]; - auto lcid_it = std::lower_bound(ue.begin(), ue.end(), lcid_tunnel{tun.lcid, tun.teid_in}); - srsran_assert(lcid_it->teid == tun.teid_in and lcid_it->lcid == tun.lcid, "TEID in undefined state"); - ue.erase(lcid_it); + auto& ue = ue_teidin_db[tun.rnti]; + auto bearer_it = std::lower_bound(ue.begin(), ue.end(), bearer_teid_pair{tun.eps_bearer_id, tun.teid_in}); + srsran_assert(bearer_it->teid == tun.teid_in and bearer_it->eps_bearer_id == tun.eps_bearer_id, + "TEID in undefined state"); + ue.erase(bearer_it); - logger.info("Removed rnti=0x%x,lcid=%d tunnel with " TEID_IN_FMT, tun.rnti, tun.lcid, teidin); + logger.info("Removed rnti=0x%x,eps-BearerID=%d tunnel with " TEID_IN_FMT, tun.rnti, tun.eps_bearer_id, teidin); tunnels.erase(teidin); return true; } @@ -216,7 +219,8 @@ void gtpu_tunnel_manager::activate_tunnel(uint32_t teid) for (auto& sdu_pair : *tun.buffer) { uint32_t pdcp_sn = sdu_pair.first; - pdcp->write_sdu(tun.rnti, tun.lcid, std::move(sdu_pair.second), pdcp_sn == undefined_pdcp_sn ? -1 : pdcp_sn); + pdcp->write_sdu( + tun.rnti, tun.eps_bearer_id, std::move(sdu_pair.second), pdcp_sn == undefined_pdcp_sn ? -1 : pdcp_sn); } tun.buffer.reset(); tun.state = tunnel_state::pdcp_active; @@ -240,9 +244,9 @@ void gtpu_tunnel_manager::deactivate_tunnel(uint32_t teid) if (tun.state == tunnel_state::forwarded_from) { // Deactivate respective MME->SeNB forwarding tunnel - for (auto lcid_tun : find_rnti_lcid_tunnels(tun.rnti, tun.lcid)) { - if (lcid_tun.teid != tun.teid_in) { - const gtpu_tunnel_manager::tunnel* mmeenb_tun = find_tunnel(lcid_tun.teid); + for (auto bearer_tun : find_rnti_bearer_tunnels(tun.rnti, tun.eps_bearer_id)) { + if (bearer_tun.teid != tun.teid_in) { + const gtpu_tunnel_manager::tunnel* mmeenb_tun = find_tunnel(bearer_tun.teid); if (mmeenb_tun->state == gtpu_tunnel_manager::tunnel_state::forward_to and mmeenb_tun->fwd_tunnel == &tun) { deactivate_tunnel(mmeenb_tun->teid_in); } @@ -334,8 +338,10 @@ void gtpu_tunnel_manager::setup_forwarding(uint32_t rx_teid, uint32_t tx_teid) fmt::format_to(addrbuf, ":0x{:x} > ", rx_tun.teid_out); srsran::gtpu_ntoa(addrbuf, htonl(tx_tun.spgw_addr)); fmt::format_to(addrbuf, ":0x{:x}", tx_tun.teid_out); - logger.info( - "Created forwarding tunnel for rnti=0x%x, lcid=%d, %s", rx_tun.rnti, rx_tun.lcid, srsran::to_c_str(addrbuf)); + logger.info("Created forwarding tunnel for rnti=0x%x, eps-BearerID=%d, %s", + rx_tun.rnti, + rx_tun.eps_bearer_id, + srsran::to_c_str(addrbuf)); } /******************** @@ -423,11 +429,11 @@ void gtpu::stop() } // gtpu_interface_pdcp -void gtpu::write_pdu(uint16_t rnti, uint32_t lcid, srsran::unique_byte_buffer_t pdu) +void gtpu::write_pdu(uint16_t rnti, uint32_t eps_bearer_id, srsran::unique_byte_buffer_t pdu) { - srsran::span teids = tunnels.find_rnti_lcid_tunnels(rnti, lcid); + srsran::span teids = tunnels.find_rnti_bearer_tunnels(rnti, eps_bearer_id); if (teids.empty()) { - logger.warning("The rnti=0x%x,lcid=%d does not have any pdcp_active tunnel", rnti, lcid); + logger.warning("The rnti=0x%x,eps-BearerID=%d does not have any pdcp_active tunnel", rnti, eps_bearer_id); return; } const gtpu_tunnel& tx_tun = *tunnels.find_tunnel(teids[0].teid); @@ -475,10 +481,10 @@ void gtpu::send_pdu_to_tunnel(const gtpu_tunnel& tx_tun, srsran::unique_byte_buf } srsran::expected -gtpu::add_bearer(uint16_t rnti, uint32_t lcid, uint32_t addr, uint32_t teid_out, const bearer_props* props) +gtpu::add_bearer(uint16_t rnti, uint32_t eps_bearer_id, uint32_t addr, uint32_t teid_out, const bearer_props* props) { // Allocate a TEID for the incoming tunnel - const gtpu_tunnel* new_tun = tunnels.add_tunnel(rnti, lcid, teid_out, addr); + const gtpu_tunnel* new_tun = tunnels.add_tunnel(rnti, eps_bearer_id, teid_out, addr); if (new_tun == nullptr) { return default_error_t(); } @@ -519,17 +525,18 @@ void gtpu::set_tunnel_status(uint32_t teidin, bool dl_active) } } -void gtpu::rem_bearer(uint16_t rnti, uint32_t lcid) +void gtpu::rem_bearer(uint16_t rnti, uint32_t eps_bearer_id) { - srsran::span lcid_tuns = tunnels.find_rnti_lcid_tunnels(rnti, lcid); - if (lcid_tuns.empty()) { - logger.info("Removing bearer rnti=0x%x,lcid=%d without any active tunnels", rnti, lcid); + srsran::span bearer_tuns = + tunnels.find_rnti_bearer_tunnels(rnti, eps_bearer_id); + if (bearer_tuns.empty()) { + logger.info("Removing bearer rnti=0x%x,eps-BearerID=%d without any active tunnels", rnti, eps_bearer_id); return; } do { - rem_tunnel(lcid_tuns.front().teid); - lcid_tuns = tunnels.find_rnti_lcid_tunnels(rnti, lcid); - } while (not lcid_tuns.empty()); + rem_tunnel(bearer_tuns.front().teid); + bearer_tuns = tunnels.find_rnti_bearer_tunnels(rnti, eps_bearer_id); + } while (not bearer_tuns.empty()); } void gtpu::mod_bearer_rnti(uint16_t old_rnti, uint16_t new_rnti) @@ -558,7 +565,7 @@ void gtpu::rem_tunnel(uint32_t teidin) void gtpu::rem_user(uint16_t rnti) { - const gtpu_tunnel_manager::ue_lcid_tunnel_list* tun_lst = tunnels.find_rnti_tunnels(rnti); + const gtpu_tunnel_manager::ue_bearer_tunnel_list* tun_lst = tunnels.find_rnti_tunnels(rnti); if (tun_lst == nullptr) { logger.info("Removing user - rnti=0x%x not found.", rnti); return; @@ -650,8 +657,8 @@ void gtpu::handle_msg_data_pdu(const gtpu_header_t& header, pdcp_sn = (header.ext_buffer[1] << 8U) + header.ext_buffer[2]; } - uint16_t rnti = rx_tunnel.rnti; - uint16_t lcid = rx_tunnel.lcid; + uint16_t rnti = rx_tunnel.rnti; + uint16_t eps_bearer_id = rx_tunnel.eps_bearer_id; log_message(rx_tunnel, true, srsran::make_span(pdu)); @@ -668,7 +675,7 @@ void gtpu::handle_msg_data_pdu(const gtpu_header_t& header, break; } case gtpu_tunnel_manager::tunnel_state::pdcp_active: { - pdcp->write_sdu(rnti, lcid, std::move(pdu), pdcp_sn == undefined_pdcp_sn ? -1 : (int)pdcp_sn); + pdcp->write_sdu(rnti, eps_bearer_id, std::move(pdu), pdcp_sn == undefined_pdcp_sn ? -1 : (int)pdcp_sn); break; } case gtpu_tunnel_manager::tunnel_state::forwarded_from: @@ -696,7 +703,7 @@ int gtpu::create_dl_fwd_tunnel(uint32_t rx_teid_in, uint32_t tx_teid_in) tunnels.setup_forwarding(rx_teid_in, tx_teid_in); // Get all buffered PDCP PDUs, and forward them through tx tunnel - std::map pdus = pdcp->get_buffered_pdus(rx_tun->rnti, rx_tun->lcid); + std::map pdus = pdcp->get_buffered_pdus(rx_tun->rnti, rx_tun->eps_bearer_id); for (auto& pdu_pair : pdus) { uint32_t pdcp_sn = pdu_pair.first; log_message(*tx_tun, false, srsran::make_span(pdu_pair.second), pdcp_sn); @@ -861,11 +868,11 @@ void gtpu::log_message(const gtpu_tunnel& tun, bool is_rx, srsran::span fmt::format_to(strbuf2, "> {}:0x{:0x}, ", srsran::to_c_str(addrbuf), tun.teid_in); } fmt::format_to(strbuf, - "{} S1-U SDU, {}rnti=0x{:0x}, lcid={}, n_bytes={}, IPv{}", + "{} S1-U SDU, {}rnti=0x{:0x}, eps-BearerID={}, n_bytes={}, IPv{}", dir, fmt::to_string(strbuf2), tun.rnti, - tun.lcid, + tun.eps_bearer_id, pdu.size(), (int)ip_pkt->version); if (ip_pkt->version == 4) { @@ -927,8 +934,8 @@ bool gtpu::m1u_handler::init(std::string m1u_multiaddr_, std::string m1u_if_addr } logger.info("M1-U initialized"); - initiated = true; - lcid_counter = 1; + initiated = true; + bearer_counter = 1; // Assign a handler to rx M1U packets auto rx_callback = [this](srsran::unique_byte_buffer_t pdu, const sockaddr_in& from) { @@ -946,7 +953,7 @@ void gtpu::m1u_handler::handle_rx_packet(srsran::unique_byte_buffer_t pdu, const gtpu_header_t header; gtpu_read_header(pdu.get(), &header, logger); - pdcp->write_sdu(SRSRAN_MRNTI, lcid_counter, std::move(pdu)); + pdcp->write_sdu(SRSRAN_MRNTI, bearer_counter, std::move(pdu)); } } // namespace srsenb diff --git a/srsenb/test/upper/gtpu_test.cc b/srsenb/test/upper/gtpu_test.cc index b6b1d6fba..6d37df47f 100644 --- a/srsenb/test/upper/gtpu_test.cc +++ b/srsenb/test/upper/gtpu_test.cc @@ -161,7 +161,7 @@ void test_gtpu_tunnel_manager() gtpu_tunnel_manager tunnels(&task_sched, srslog::fetch_basic_logger("GTPU")); tunnels.init(gtpu_args, nullptr); TESTASSERT(tunnels.find_tunnel(0) == nullptr); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x46, drb1_lcid).empty()); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x46, drb1_lcid).empty()); TESTASSERT(tunnels.find_rnti_tunnels(0x46) == nullptr); // Creation of tunnels for different users and lcids @@ -174,19 +174,19 @@ void test_gtpu_tunnel_manager() tun2 = tunnels.add_tunnel(0x47, drb1_lcid + 1, 7, sgw_addr); TESTASSERT(tun2 != nullptr); TESTASSERT(tunnels.find_tunnel(tun2->teid_in) == tun2); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x46, drb1_lcid).size() == 1); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x47, drb1_lcid).size() == 1); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x47, drb1_lcid + 1).size() == 1); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x46, drb1_lcid).size() == 1); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x47, drb1_lcid).size() == 1); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x47, drb1_lcid + 1).size() == 1); // TEST: Creation/Removal of indirect tunnel const gtpu_tunnel* fwd_tun = tunnels.add_tunnel(0x46, drb1_lcid, 8, sgw_addr); TESTASSERT(fwd_tun != nullptr); TESTASSERT(tunnels.find_tunnel(fwd_tun->teid_in) == fwd_tun); tunnels.setup_forwarding(tun->teid_in, fwd_tun->teid_in); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x46, drb1_lcid).size() == 2); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x46, drb1_lcid).size() == 2); // Removing a tunnel also clears any associated forwarding tunnel TESTASSERT(tunnels.remove_tunnel(tun->teid_in)); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x46, drb1_lcid).empty()); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x46, drb1_lcid).empty()); // TEST: Prioritization of one TEID over another const gtpu_tunnel* before_tun = tunnels.add_tunnel(0x46, drb1_lcid, 7, sgw_addr); @@ -200,9 +200,9 @@ void test_gtpu_tunnel_manager() tunnels.handle_rx_pdcp_sdu(before_tun->teid_in); } // Removing active TEID, will automatically switch TEID paths - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x46, drb1_lcid).size() == 2); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x46, drb1_lcid).size() == 2); tunnels.remove_tunnel(before_tun->teid_in); - TESTASSERT(tunnels.find_rnti_lcid_tunnels(0x46, drb1_lcid).size() == 1); + TESTASSERT(tunnels.find_rnti_bearer_tunnels(0x46, drb1_lcid).size() == 1); TESTASSERT(after_tun->state == gtpu_tunnel_manager::tunnel_state::pdcp_active); }