5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- Upgrade the gtpu class in lib dir to srslog.

Browse Source 
- Propagate old log elimination through all the dependencies of gtpu.
master
faluco 4 years ago committed by faluco
parent 62fcf04083
commit 6359a2d948
13 changed files with 54 additions and 65 deletions
Show Stats Download Patch File Download Diff File

16
lib/include/srslte/upper/gtpu.h
Unescape Escape View File

@ -70,35 +70,35 @@ struct gtpu_header_t {
std::vector<uint8_t> ext_buffer;
};
bool gtpu_read_header(srslte::byte_buffer_t* pdu, gtpu_header_t* header, srslte::log_ref gtpu_log);
bool gtpu_write_header(gtpu_header_t* header, srslte::byte_buffer_t* pdu, srslte::log_ref gtpu_log);
bool gtpu_read_header(srslte::byte_buffer_t* pdu, gtpu_header_t* header, srslog::basic_logger& logger);
bool gtpu_write_header(gtpu_header_t* header, srslte::byte_buffer_t* pdu, srslog::basic_logger& logger);
std::string gtpu_ntoa(uint32_t addr);
inline bool gtpu_supported_flags_check(gtpu_header_t* header, srslte::log_ref gtpu_log)
inline bool gtpu_supported_flags_check(gtpu_header_t* header, srslog::basic_logger& logger)
{
// flags
if ((header->flags & GTPU_FLAGS_VERSION_MASK) != GTPU_FLAGS_VERSION_V1) {
gtpu_log->error("gtpu_header - Unhandled GTP-U Version. Flags: 0x%x\n", header->flags);
logger.error("gtpu_header - Unhandled GTP-U Version. Flags: 0x%x", header->flags);
return false;
}
if (!(header->flags & GTPU_FLAGS_GTP_PROTOCOL)) {
gtpu_log->error("gtpu_header - Unhandled Protocol Type. Flags: 0x%x\n\n", header->flags);
logger.error("gtpu_header - Unhandled Protocol Type. Flags: 0x%x", header->flags);
return false;
}
if (header->flags & GTPU_FLAGS_PACKET_NUM) {
gtpu_log->error("gtpu_header - Unhandled Packet Number. Flags: 0x%x\n\n", header->flags);
logger.error("gtpu_header - Unhandled Packet Number. Flags: 0x%x", header->flags);
return false;
}
return true;
}
inline bool gtpu_supported_msg_type_check(gtpu_header_t* header, srslte::log_ref gtpu_log)
inline bool gtpu_supported_msg_type_check(gtpu_header_t* header, srslog::basic_logger& logger)
{
// msg_tpye
if (header->message_type != GTPU_MSG_DATA_PDU && header->message_type != GTPU_MSG_ECHO_REQUEST &&
header->message_type != GTPU_MSG_ECHO_RESPONSE && header->message_type != GTPU_MSG_ERROR_INDICATION &&
header->message_type != GTPU_MSG_END_MARKER) {
gtpu_log->error("gtpu_header - Unhandled message type: 0x%x\n", header->message_type);
logger.error("gtpu_header - Unhandled message type: 0x%x", header->message_type);
return false;
}
return true;

33
lib/src/upper/gtpu.cc
Unescape Escape View File

@ -23,24 +23,24 @@ const static size_t HEADER_PDCP_PDU_NUMBER_SIZE = 4;
* Header pack/unpack helper functions
* Ref: 3GPP TS 29.281 v10.1.0 Section 5
***************************************************************************/
bool gtpu_write_header(gtpu_header_t* header, srslte::byte_buffer_t* pdu, srslte::log_ref gtpu_log)
bool gtpu_write_header(gtpu_header_t* header, srslte::byte_buffer_t* pdu, srslog::basic_logger& logger)
{
// flags
if (!gtpu_supported_flags_check(header, gtpu_log)) {
gtpu_log->error("gtpu_write_header - Unhandled GTP-U Flags. Flags: 0x%x\n", header->flags);
if (!gtpu_supported_flags_check(header, logger)) {
logger.error("gtpu_write_header - Unhandled GTP-U Flags. Flags: 0x%x", header->flags);
return false;
}
// msg type
if (!gtpu_supported_msg_type_check(header, gtpu_log)) {
gtpu_log->error("gtpu_write_header - Unhandled GTP-U Message Type. Message Type: 0x%x\n", header->message_type);
if (!gtpu_supported_msg_type_check(header, logger)) {
logger.error("gtpu_write_header - Unhandled GTP-U Message Type. Message Type: 0x%x", header->message_type);
return false;
}
// If E, S or PN are set, the header is longer
if (header->flags & (GTPU_FLAGS_EXTENDED_HDR | GTPU_FLAGS_SEQUENCE | GTPU_FLAGS_PACKET_NUM)) {
if (pdu->get_headroom() < GTPU_EXTENDED_HEADER_LEN) {
gtpu_log->error("gtpu_write_header - No room in PDU for header\n");
logger.error("gtpu_write_header - No room in PDU for header");
return false;
}
pdu->msg -= GTPU_EXTENDED_HEADER_LEN;
@ -51,7 +51,7 @@ bool gtpu_write_header(gtpu_header_t* header, srslte::byte_buffer_t* pdu, srslte
}
} else {
if (pdu->get_headroom() < GTPU_BASE_HEADER_LEN) {
gtpu_log->error("gtpu_write_header - No room in PDU for header\n");
logger.error("gtpu_write_header - No room in PDU for header");
return false;
}
pdu->msg -= GTPU_BASE_HEADER_LEN;
@ -101,7 +101,10 @@ bool gtpu_write_header(gtpu_header_t* header, srslte::byte_buffer_t* pdu, srslte
return true;
}
bool gtpu_read_ext_header(srslte::byte_buffer_t* pdu, uint8_t** ptr, gtpu_header_t* header, srslte::log_ref gtpu_log)
bool gtpu_read_ext_header(srslte::byte_buffer_t* pdu,
uint8_t** ptr,
gtpu_header_t* header,
srslog::basic_logger& logger)
{
if ((header->flags & GTPU_FLAGS_EXTENDED_HDR) == 0 or header->next_ext_hdr_type == 0) {
return true;
@ -116,13 +119,13 @@ bool gtpu_read_ext_header(srslte::byte_buffer_t* pdu, uint8_t** ptr, gtpu_header
(*ptr)++;
}
} else {
gtpu_log->error("gtpu_read_header - Unhandled GTP-U Extension Header Type: 0x%x\n", header->next_ext_hdr_type);
logger.error("gtpu_read_header - Unhandled GTP-U Extension Header Type: 0x%x", header->next_ext_hdr_type);
return false;
}
return true;
}
bool gtpu_read_header(srslte::byte_buffer_t* pdu, gtpu_header_t* header, srslte::log_ref gtpu_log)
bool gtpu_read_header(srslte::byte_buffer_t* pdu, gtpu_header_t* header, srslog::basic_logger& logger)
{
uint8_t* ptr = pdu->msg;
@ -136,14 +139,14 @@ bool gtpu_read_header(srslte::byte_buffer_t* pdu, gtpu_header_t* header, srslte:
ptr += 4;
// flags
if (!gtpu_supported_flags_check(header, gtpu_log)) {
gtpu_log->error("gtpu_read_header - Unhandled GTP-U Flags. Flags: 0x%x\n", header->flags);
if (!gtpu_supported_flags_check(header, logger)) {
logger.error("gtpu_read_header - Unhandled GTP-U Flags. Flags: 0x%x", header->flags);
return false;
}
// message_type
if (!gtpu_supported_msg_type_check(header, gtpu_log)) {
gtpu_log->error("gtpu_read_header - Unhandled GTP-U Message Type. Flags: 0x%x\n", header->message_type);
if (!gtpu_supported_msg_type_check(header, logger)) {
logger.error("gtpu_read_header - Unhandled GTP-U Message Type. Flags: 0x%x", header->message_type);
return false;
}
@ -161,7 +164,7 @@ bool gtpu_read_header(srslte::byte_buffer_t* pdu, gtpu_header_t* header, srslte:
header->next_ext_hdr_type = *ptr;
ptr++;
if (not gtpu_read_ext_header(pdu, &ptr, header, gtpu_log)) {
if (not gtpu_read_ext_header(pdu, &ptr, header, logger)) {
return false;
}
} else {

2
srsenb/hdr/stack/upper/gtpu.h
Unescape Escape View File

@ -69,7 +69,6 @@ private:
std::string gtp_bind_addr;
std::string mme_addr;
srsenb::pdcp_interface_gtpu* pdcp = nullptr;
srslte::log_ref gtpu_log;
srslog::basic_logger& logger;
// Class to create
@ -88,7 +87,6 @@ private:
private:
gtpu* parent = nullptr;
pdcp_interface_gtpu* pdcp = nullptr;
srslte::log_ref gtpu_log;
srslog::basic_logger& logger;
std::string m1u_multiaddr;
std::string m1u_if_addr;

21
srsenb/src/stack/upper/gtpu.cc
Unescape Escape View File

@ -21,7 +21,7 @@
using namespace srslte;
namespace srsenb {
gtpu::gtpu(srslog::basic_logger& logger) : m1u(this), gtpu_log("GTPU"), logger(logger) {}
gtpu::gtpu(srslog::basic_logger& logger) : m1u(this), logger(logger) {}
int gtpu::init(std::string gtp_bind_addr_,
std::string mme_addr_,
@ -128,7 +128,7 @@ void gtpu::send_pdu_to_tunnel(tunnel& tx_tun, srslte::unique_byte_buffer_t pdu,
servaddr.sin_addr.s_addr = htonl(tx_tun.spgw_addr);
servaddr.sin_port = htons(GTPU_PORT);
if (!gtpu_write_header(&header, pdu.get(), gtpu_log)) {
if (!gtpu_write_header(&header, pdu.get(), logger)) {
logger.error("Error writing GTP-U Header. Flags 0x%x, Message Type 0x%x", header.flags, header.message_type);
return;
}
@ -225,12 +225,12 @@ void gtpu::mod_bearer_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);
if (ue_teidin_db.count(new_rnti) != 0) {
gtpu_log->error("New rnti already exists, aborting.\n");
logger.error("New rnti already exists, aborting.");
return;
}
auto old_it = ue_teidin_db.find(old_rnti);
if (old_it == ue_teidin_db.end()) {
gtpu_log->error("Old rnti does not exist, aborting.\n");
logger.error("Old rnti does not exist, aborting.");
return;
}
@ -285,7 +285,7 @@ void gtpu::handle_gtpu_s1u_rx_packet(srslte::unique_byte_buffer_t pdu, const soc
pdu->set_timestamp();
gtpu_header_t header;
if (not gtpu_read_header(pdu.get(), &header, gtpu_log)) {
if (not gtpu_read_header(pdu.get(), &header, logger)) {
return;
}
@ -416,7 +416,7 @@ void gtpu::error_indication(in_addr_t addr, in_port_t port, uint32_t err_teid)
header.n_pdu = 0;
header.next_ext_hdr_type = 0;
gtpu_write_header(&header, pdu.get(), gtpu_log);
gtpu_write_header(&header, pdu.get(), logger);
struct sockaddr_in servaddr;
servaddr.sin_family = AF_INET;
@ -446,7 +446,7 @@ void gtpu::echo_response(in_addr_t addr, in_port_t port, uint16_t seq)
header.n_pdu = 0;
header.next_ext_hdr_type = 0;
gtpu_write_header(&header, pdu.get(), gtpu_log);
gtpu_write_header(&header, pdu.get(), logger);
struct sockaddr_in servaddr;
servaddr.sin_family = AF_INET;
@ -473,7 +473,7 @@ void gtpu::end_marker(uint32_t teidin)
header.teid = tunnel.teid_out;
header.length = 0;
gtpu_write_header(&header, pdu.get(), gtpu_log);
gtpu_write_header(&header, pdu.get(), logger);
struct sockaddr_in servaddr = {};
servaddr.sin_family = AF_INET;
@ -502,7 +502,7 @@ srslte::span<uint32_t> gtpu::get_lcid_teids(uint16_t rnti, uint32_t lcid)
auto ue_it = ue_teidin_db.find(rnti);
if (ue_it == ue_teidin_db.end() or lcid < SRSENB_N_SRB or lcid >= SRSENB_N_RADIO_BEARERS or
ue_it->second[lcid].empty()) {
logger.error("Could not find bearer rnti=0x%x, lcid=%d\n", rnti, lcid);
logger.error("Could not find bearer rnti=0x%x, lcid=%d", rnti, lcid);
return {};
}
return ue_it->second[lcid];
@ -572,7 +572,6 @@ bool gtpu::m1u_handler::init(std::string m1u_multiaddr_, std::string m1u_if_addr
m1u_multiaddr = std::move(m1u_multiaddr_);
m1u_if_addr = std::move(m1u_if_addr_);
pdcp = parent->pdcp;
gtpu_log = parent->gtpu_log;
// Set up sink socket
struct sockaddr_in bindaddr = {};
@ -616,7 +615,7 @@ void gtpu::m1u_handler::handle_rx_packet(srslte::unique_byte_buffer_t pdu, const
logger.debug("Received %d bytes from M1-U interface", pdu->N_bytes);
gtpu_header_t header;
gtpu_read_header(pdu.get(), &header, gtpu_log);
gtpu_read_header(pdu.get(), &header, logger);
pdcp->write_sdu(SRSLTE_MRNTI, lcid_counter, std::move(pdu));
}

13
srsenb/test/upper/gtpu_test.cc
Unescape Escape View File

@ -98,7 +98,7 @@ srslte::unique_byte_buffer_t encode_gtpu_packet(srslte::span<uint8_t> data,
header.length = pdu->N_bytes;
header.teid = teid;
gtpu_write_header(&header, pdu.get(), srslte::log_ref("GTPU"));
gtpu_write_header(&header, pdu.get(), srslog::fetch_basic_logger("GTPU"));
return pdu;
}
@ -113,7 +113,7 @@ srslte::unique_byte_buffer_t encode_end_marker(uint32_t teid)
header.length = 0;
header.teid = teid;
gtpu_write_header(&header, pdu.get(), srslte::log_ref("GTPU"));
gtpu_write_header(&header, pdu.get(), srslog::fetch_basic_logger("GTPU"));
return pdu;
}
@ -247,17 +247,16 @@ int test_gtpu_direct_tunneling()
int main()
{
// Setup logging.
srslog::sink& log_sink = srslog::fetch_stdout_sink();
srslog::log_channel* chan = srslog::create_log_channel("gtpu_test", log_sink);
srslte::srslog_wrapper log_wrapper(*chan);
auto& logger = srslog::fetch_basic_logger("GTPU", false);
logger.set_level(srslog::basic_levels::debug);
logger.set_hex_dump_max_size(-1);
// Start the log backend.
srslog::init();
srslte::logmap::set_default_log_level(srslte::LOG_LEVEL_DEBUG);
srslte::logmap::set_default_hex_limit(100000);
TESTASSERT(srsenb::test_gtpu_direct_tunneling() == SRSLTE_SUCCESS);
srslog::flush();
srslte::console("Success");
}

3
srsepc/hdr/mbms-gw/mbms-gw.h
Unescape Escape View File

@ -55,7 +55,7 @@ class mbms_gw : public srslte::thread
public:
static mbms_gw* get_instance(void);
static void cleanup(void);
int init(mbms_gw_args_t* args, srslte::log_ref mbms_gw_log);
int init(mbms_gw_args_t* args);
void stop();
void run_thread();
@ -72,7 +72,6 @@ private:
/* Members */
bool m_running;
srslte::log_ref m_mbms_gw_log;
srslog::basic_logger& m_logger = srslog::fetch_basic_logger("MBMS");
bool m_sgi_mb_up;

4
srsepc/hdr/spgw/gtpu.h
Unescape Escape View File

@ -29,7 +29,7 @@ class spgw::gtpu : public gtpu_interface_gtpc
public:
gtpu();
virtual ~gtpu();
int init(spgw_args_t* args, spgw* spgw, gtpc_interface_gtpu* gtpc, srslte::log_ref gtpu_log);
int init(spgw_args_t* args, spgw* spgw, gtpc_interface_gtpu* gtpc);
void stop();
int init_sgi(spgw_args_t* args);
@ -65,8 +65,6 @@ public:
// for downlink notifications.
srslog::basic_logger& m_logger = srslog::fetch_basic_logger("GTPU");
//:TODO: remove this once srslte common code loggers have been upgraded.
srslte::log_ref m_gtpu_log;
};
inline int spgw::gtpu::get_sgi()

2
srsepc/hdr/spgw/spgw.h
Unescape Escape View File

@ -61,7 +61,7 @@ class spgw : public srslte::thread
public:
static spgw* get_instance(void);
static void cleanup(void);
int init(spgw_args_t* args, srslte::log_ref gtpu_log, const std::map<std::string, uint64_t>& ip_to_imsi);
int init(spgw_args_t* args, const std::map<std::string, uint64_t>& ip_to_imsi);
void stop();
void run_thread();

2
srsepc/src/main.cc
Unescape Escape View File

@ -472,7 +472,7 @@ int main(int argc, char* argv[])
}
spgw* spgw = spgw::get_instance();
if (spgw->init(&args.spgw_args, gtpu_log, hss->get_ip_to_imsi())) {
if (spgw->init(&args.spgw_args, hss->get_ip_to_imsi())) {
cout << "Error initializing SP-GW" << endl;
exit(1);
}

3
srsepc/src/mbms-gw/main.cc
Unescape Escape View File

@ -67,7 +67,6 @@ string config_file;
void parse_args(all_args_t* args, int argc, char* argv[])
{
string mbms_gw_name;
string mbms_gw_sgi_mb_if_name;
string mbms_gw_sgi_mb_if_addr;
@ -216,7 +215,7 @@ int main(int argc, char* argv[])
mbms_gw_logger.set_hex_dump_max_size(args.log_args.mbms_gw_hex_limit);
mbms_gw* mbms_gw = mbms_gw::get_instance();
if (mbms_gw->init(&args.mbms_gw_args, mbms_gw_log)) {
if (mbms_gw->init(&args.mbms_gw_args)) {
cout << "Error initializing MBMS-GW" << endl;
exit(1);
}

7
srsepc/src/mbms-gw/mbms-gw.cc
Unescape Escape View File

@ -60,13 +60,10 @@ void mbms_gw::cleanup(void)
pthread_mutex_unlock(&mbms_gw_instance_mutex);
}
int mbms_gw::init(mbms_gw_args_t* args, srslte::log_ref mbms_gw_log)
int mbms_gw::init(mbms_gw_args_t* args)
{
int err;
// Init log
m_mbms_gw_log = mbms_gw_log;
err = init_sgi_mb_if(args);
if (err != SRSLTE_SUCCESS) {
srslte::console("Error initializing SGi-MB.\n");
@ -275,7 +272,7 @@ void mbms_gw::handle_sgi_md_pdu(srslte::byte_buffer_t* msg)
}
// Write GTP-U header into packet
if (!srslte::gtpu_write_header(&header, msg, m_mbms_gw_log)) {
if (!srslte::gtpu_write_header(&header, msg, m_logger)) {
srslte::console("Error writing GTP-U header on PDU\n");
}

9
srsepc/src/spgw/gtpu.cc
Unescape Escape View File

@ -43,13 +43,10 @@ spgw::gtpu::~gtpu()
return;
}
int spgw::gtpu::init(spgw_args_t* args, spgw* spgw, gtpc_interface_gtpu* gtpc, srslte::log_ref gtpu_log)
int spgw::gtpu::init(spgw_args_t* args, spgw* spgw, gtpc_interface_gtpu* gtpc)
{
int err;
// Init log
m_gtpu_log = gtpu_log;
// Store interfaces
m_spgw = spgw;
m_gtpc = gtpc;
@ -243,7 +240,7 @@ void spgw::gtpu::handle_sgi_pdu(srslte::unique_byte_buffer_t msg)
void spgw::gtpu::handle_s1u_pdu(srslte::byte_buffer_t* msg)
{
srslte::gtpu_header_t header;
srslte::gtpu_read_header(msg, &header, m_gtpu_log);
srslte::gtpu_read_header(msg, &header, m_logger);
m_logger.debug("Received PDU from S1-U. Bytes=%d", msg->N_bytes);
m_logger.debug("TEID 0x%x. Bytes=%d", header.teid, msg->N_bytes);
@ -276,7 +273,7 @@ void spgw::gtpu::send_s1u_pdu(srslte::gtp_fteid_t enb_fteid, srslte::byte_buffer
// Write header into packet
int n;
if (!srslte::gtpu_write_header(&header, msg, m_gtpu_log)) {
if (!srslte::gtpu_write_header(&header, msg, m_logger)) {
m_logger.error("Error writing GTP-U header on PDU");
goto out;
}

4
srsepc/src/spgw/spgw.cc
Unescape Escape View File

@ -56,12 +56,12 @@ void spgw::cleanup()
pthread_mutex_unlock(&spgw_instance_mutex);
}
int spgw::init(spgw_args_t* args, srslte::log_ref gtpu_log, const std::map<std::string, uint64_t>& ip_to_imsi)
int spgw::init(spgw_args_t* args, const std::map<std::string, uint64_t>& ip_to_imsi)
{
int err;
// Init GTP-U
if (m_gtpu->init(args, this, m_gtpc, gtpu_log) != SRSLTE_SUCCESS) {
if (m_gtpu->init(args, this, m_gtpc) != SRSLTE_SUCCESS) {
srslte::console("Could not initialize the SPGW's GTP-U.\n");
return SRSLTE_ERROR_CANT_START;
}

Write Preview
Loading…
Cancel
Save