PentHertz
/
srsLTE
mirror of https://github.com/PentHertz/srsLTE.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

all: check return value of make_byte_buffer() and handle them safely

This commit is contained in:
Andre Puschmann 2021-03-22 17:24:52 +01:00
parent 46d46e70ff
commit 1a0891df51
33 changed files with 272 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/include/srsran/common/basic_pnf.h
View File

@ -363,6 +363,9 @@ private:
uint32_t len = sizeof(*msg) - sizeof(msg->pdus->data) + msg->pdus->length;
srsran::unique_byte_buffer_t tx = srsran::make_byte_buffer();
if (tx == nullptr) {
return -1;
}
memcpy(tx->msg, msg, len);
rf_out_queue->push(std::move(tx));
}

5
lib/src/common/basic_vnf.cc
View File

@ -183,14 +183,15 @@ int srsran_basic_vnf::handle_dl_ind(basic_vnf_api::dl_ind_msg_t* msg)
for (uint32_t i = 0; i < msg->nof_pdus; ++i) {
dl_grant.tb[i] = srsran::make_byte_buffer();
if (dl_grant.tb[i]->get_tailroom() >= msg->pdus[i].length) {
if (dl_grant.tb[i] && dl_grant.tb[i]->get_tailroom() >= msg->pdus[i].length) {
memcpy(dl_grant.tb[i]->msg, msg->pdus[i].data, msg->pdus[i].length);
dl_grant.tb[i]->N_bytes = msg->pdus[i].length;
if (msg->pdus[i].type == basic_vnf_api::PDSCH) {
m_ue_stack->tb_decoded(cc_idx, dl_grant);
}
} else {
logger.error("TB too big to fit into buffer (%d > %d)", msg->pdus[i].length, dl_grant.tb[i]->get_tailroom());
logger.error("TB too big to fit into buffer (%d)", msg->pdus[i].length);
return SRSRAN_ERROR;
}
}

8
lib/src/upper/pdcp_entity_lte.cc
View File

@ -958,8 +958,12 @@ std::map<uint32_t, srsran::unique_byte_buffer_t> undelivered_sdus_queue::get_buf
if (sdu.sdu != nullptr) {
// TODO: Find ways to avoid deep copy
srsran::unique_byte_buffer_t fwd_sdu = make_byte_buffer();
*fwd_sdu = *sdu.sdu;
fwd_sdus.emplace(sdu.sdu->md.pdcp_sn, std::move(fwd_sdu));
if (fwd_sdu != nullptr) {
*fwd_sdu = *sdu.sdu;
fwd_sdus.emplace(sdu.sdu->md.pdcp_sn, std::move(fwd_sdu));
} else {
srslog::fetch_basic_logger("PDCP").warning("Can't allocate buffer to forward buffered SDUs.");
}
}
}
return fwd_sdus;

2
lib/test/asn1/srsran_asn1_nas_test.cc
View File

@ -32,7 +32,9 @@ int nas_dedicated_eps_bearer_context_setup_request_test()
srsran::unique_byte_buffer_t tst_msg, out_msg;
tst_msg = srsran::make_byte_buffer();
TESTASSERT(tst_msg != nullptr);
out_msg = srsran::make_byte_buffer();
TESTASSERT(out_msg != nullptr);
LIBLTE_MME_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_REQUEST_MSG_STRUCT ded_bearer_req;

3
lib/test/common/byte_buffer_queue_test.cc
View File

@ -27,6 +27,9 @@ void* write_thread(void* a)
args_t* args = (args_t*)a;
for (uint32_t i = 0; i < NMSGS; i++) {
unique_byte_buffer_t b = srsran::make_byte_buffer();
if (b == nullptr) {
return nullptr;
}
memcpy(b->msg, &i, 4);
b->N_bytes = 4;
args->q->write(std::move(b));

2
lib/test/common/choice_type_test.cc
View File

@ -200,6 +200,7 @@ int test_visit()
// TEST: visitor hits type E and steals pdu
E e;
e.pdu = srsran::make_byte_buffer();
TESTASSERT(e.pdu != nullptr);
c = std::move(e);
TESTASSERT(c.is<E>() and srsran::get<E>(c).pdu != nullptr);
srsran::visit(v, c);
@ -209,6 +210,7 @@ int test_visit()
// TEST: visitor hits type E and steals pdu. Second type called there is no pdu to steal.
v.pdu = nullptr;
e.pdu = srsran::make_byte_buffer();
TESTASSERT(e.pdu != nullptr);
c = std::move(e);
srsran::visit(v, c);
TESTASSERT(v.pdu != nullptr);

4
lib/test/upper/pdcp_lte_test_discard_sdu.cc
View File

@ -37,10 +37,12 @@ int test_tx_sdu_notify(const srsran::pdcp_lte_state_t& init_state,
// Write test SDU
srsran::unique_byte_buffer_t sdu = srsran::make_byte_buffer();
TESTASSERT(sdu != nullptr);
sdu->append_bytes(sdu1, sizeof(sdu1));
pdcp->write_sdu(std::move(sdu));
srsran::unique_byte_buffer_t out_pdu = srsran::make_byte_buffer();
TESTASSERT(out_pdu != nullptr);
rlc->get_last_sdu(out_pdu);
TESTASSERT(out_pdu->N_bytes == 4);
@ -84,10 +86,12 @@ int test_tx_sdu_discard(const srsran::pdcp_lte_state_t& init_state,
// Write test SDU
srsran::unique_byte_buffer_t sdu = srsran::make_byte_buffer();
TESTASSERT(sdu != nullptr);
sdu->append_bytes(sdu1, sizeof(sdu1));
pdcp->write_sdu(std::move(sdu));
srsran::unique_byte_buffer_t out_pdu = srsran::make_byte_buffer();
TESTASSERT(out_pdu != nullptr);
rlc->get_last_sdu(out_pdu);
TESTASSERT(out_pdu->N_bytes == 4);

14
srsenb/hdr/stack/rrc/rrc.h
View File

@ -52,13 +52,13 @@ public:
explicit rrc(srsran::task_sched_handle task_sched_);
~rrc();
void init(const rrc_cfg_t& cfg_,
phy_interface_rrc_lte* phy,
mac_interface_rrc* mac,
rlc_interface_rrc* rlc,
pdcp_interface_rrc* pdcp,
s1ap_interface_rrc* s1ap,
gtpu_interface_rrc* gtpu);
int32_t init(const rrc_cfg_t& cfg_,
phy_interface_rrc_lte* phy,
mac_interface_rrc* mac,
rlc_interface_rrc* rlc,
pdcp_interface_rrc* pdcp,
s1ap_interface_rrc* s1ap,
gtpu_interface_rrc* gtpu);
void stop();
void get_metrics(rrc_metrics_t& m);

16
srsenb/hdr/stack/rrc/rrc_nr.h
View File

@ -63,13 +63,13 @@ class rrc_nr final : public rrc_interface_pdcp_nr,
public:
explicit rrc_nr(srsran::timer_handler* timers_);
void init(const rrc_nr_cfg_t& cfg,
phy_interface_stack_nr* phy,
mac_interface_rrc_nr* mac,
rlc_interface_rrc_nr* rlc,
pdcp_interface_rrc_nr* pdcp,
ngap_interface_rrc_nr* ngap_,
gtpu_interface_rrc_nr* gtpu);
int32_t init(const rrc_nr_cfg_t& cfg,
phy_interface_stack_nr* phy,
mac_interface_rrc_nr* mac,
rlc_interface_rrc_nr* rlc,
pdcp_interface_rrc_nr* pdcp,
ngap_interface_rrc_nr* ngap_,
gtpu_interface_rrc_nr* gtpu);
void stop();
@ -78,7 +78,7 @@ public:
rrc_nr_cfg_t update_default_cfg(const rrc_nr_cfg_t& rrc_cfg);
void add_user(uint16_t rnti);
void config_mac();
uint32_t generate_sibs();
int32_t generate_sibs();
int read_pdu_bcch_bch(const uint32_t tti, srsran::unique_byte_buffer_t& buffer) final;
int read_pdu_bcch_dlsch(uint32_t sib_index, srsran::unique_byte_buffer_t& buffer) final;

5
srsenb/src/stack/enb_stack_lte.cc
View File

@ -122,7 +122,10 @@ int enb_stack_lte::init(const stack_args_t& args_, const rrc_cfg_t& rrc_cfg_)
}
rlc.init(&pdcp, &rrc, &mac, task_sched.get_timer_handler());
pdcp.init(&rlc, &rrc, &gtpu);
rrc.init(rrc_cfg, phy, &mac, &rlc, &pdcp, &s1ap, &gtpu);
if (rrc.init(rrc_cfg, phy, &mac, &rlc, &pdcp, &s1ap, &gtpu) != SRSRAN_SUCCESS) {
stack_logger.error("Couldn't initialize RRC");
return SRSRAN_ERROR;
}
if (s1ap.init(args.s1ap, &rrc, this) != SRSRAN_SUCCESS) {
stack_logger.error("Couldn't initialize S1AP");
return SRSRAN_ERROR;

27
srsenb/src/stack/mac/mac_nr.cc
View File

@ -22,14 +22,6 @@ namespace srsenb {
mac_nr::mac_nr() : logger(srslog::fetch_basic_logger("MAC"))
{
bcch_bch_payload = srsran::make_byte_buffer();
// allocate 8 tx buffers for UE (TODO: as we don't handle softbuffers why do we need so many buffers)
for (int i = 0; i < SRSRAN_FDD_NOF_HARQ; i++) {
ue_tx_buffer.emplace_back(srsran::make_byte_buffer());
}
ue_rlc_buffer = srsran::make_byte_buffer();
}
mac_nr::~mac_nr()
@ -58,6 +50,25 @@ int mac_nr::init(const mac_nr_args_t& args_,
pcap->open(args.pcap.filename);
}
bcch_bch_payload = srsran::make_byte_buffer();
if (bcch_bch_payload == nullptr) {
return SRSRAN_ERROR;
}
// allocate 8 tx buffers for UE (TODO: as we don't handle softbuffers why do we need so many buffers)
for (int i = 0; i < SRSRAN_FDD_NOF_HARQ; i++) {
srsran::unique_byte_buffer_t buffer = srsran::make_byte_buffer();
if (buffer == nullptr) {
return SRSRAN_ERROR;
}
ue_tx_buffer.emplace_back(std::move(buffer));
}
ue_rlc_buffer = srsran::make_byte_buffer();
if (ue_rlc_buffer == nullptr) {
return SRSRAN_ERROR;
}
logger.info("Started");
started = true;

34
srsenb/src/stack/rrc/rrc.cc
View File

@ -40,13 +40,13 @@ rrc::rrc(srsran::task_sched_handle task_sched_) :
rrc::~rrc() {}
void rrc::init(const rrc_cfg_t& cfg_,
phy_interface_rrc_lte* phy_,
mac_interface_rrc* mac_,
rlc_interface_rrc* rlc_,
pdcp_interface_rrc* pdcp_,
s1ap_interface_rrc* s1ap_,
gtpu_interface_rrc* gtpu_)
int32_t rrc::init(const rrc_cfg_t& cfg_,
phy_interface_rrc_lte* phy_,
mac_interface_rrc* mac_,
rlc_interface_rrc* rlc_,
pdcp_interface_rrc* pdcp_,
s1ap_interface_rrc* s1ap_,
gtpu_interface_rrc* gtpu_)
{
phy = phy_;
mac = mac_;
@ -67,7 +67,10 @@ void rrc::init(const rrc_cfg_t& cfg_,
// Loads the PRACH root sequence
cfg.sibs[1].sib2().rr_cfg_common.prach_cfg.root_seq_idx = cfg.cell_list[0].root_seq_idx;
nof_si_messages = generate_sibs();
if (generate_sibs() != SRSRAN_SUCCESS) {
logger.error("Couldn't generate SIBs.");
return false;
}
config_mac();
// Check valid inactivity timeout config
@ -84,6 +87,8 @@ void rrc::init(const rrc_cfg_t& cfg_,
logger.info("Inactivity timeout: %d ms", cfg.inactivity_timeout_ms);
running = true;
return SRSRAN_SUCCESS;
}
void rrc::stop()
@ -764,7 +769,9 @@ void rrc::config_mac()
* Before packing the message, it patches the cell specific params of
* the SIB, including the cellId and the PRACH config index.
*
* @return The number of SIBs messages per CC
* The number of generates SIB messages is stored in the class member nof_si_messages
*
* @return SRSRAN_SUCCESS on success, SRSRAN_ERROR on failure
*/
uint32_t rrc::generate_sibs()
{
@ -809,9 +816,14 @@ uint32_t rrc::generate_sibs()
// Pack payload for all messages
for (uint32_t msg_index = 0; msg_index < nof_messages; msg_index++) {
srsran::unique_byte_buffer_t sib_buffer = srsran::make_byte_buffer();
if (sib_buffer == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return SRSRAN_ERROR;
}
asn1::bit_ref bref(sib_buffer->msg, sib_buffer->get_tailroom());
if (msg[msg_index].pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
logger.error("Failed to pack SIB message %d", msg_index);
return SRSRAN_ERROR;
}
sib_buffer->N_bytes = bref.distance_bytes();
cell_ctxt->sib_buffer.push_back(std::move(sib_buffer));
@ -827,7 +839,9 @@ uint32_t rrc::generate_sibs()
}
}
return nof_messages;
nof_si_messages = nof_messages;
return SRSRAN_SUCCESS;
}
void rrc::configure_mbsfn_sibs()

15
srsenb/src/stack/rrc/rrc_mobility.cc
View File

@ -329,6 +329,10 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
hoprep_r8.ue_radio_access_cap_info[0].rat_type = asn1::rrc::rat_type_e::eutra;
srsran::unique_byte_buffer_t buffer = srsran::make_byte_buffer();
if (buffer == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return false;
}
asn1::bit_ref bref(buffer->msg, buffer->get_tailroom());
if (rrc_ue->eutra_capabilities.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
logger.error("Failed to pack UE EUTRA Capability");
@ -368,6 +372,10 @@ bool rrc::ue::rrc_mobility::start_ho_preparation(uint32_t target_eci,
/*** pack HO Preparation Info into an RRC container buffer ***/
srsran::unique_byte_buffer_t buffer = srsran::make_byte_buffer();
if (buffer == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return false;
}
asn1::bit_ref bref(buffer->msg, buffer->get_tailroom());
if (hoprep.pack(bref) == asn1::SRSASN_ERROR_ENCODE_FAIL) {
Error("Failed to pack HO preparation msg");
@ -711,7 +719,12 @@ void rrc::ue::rrc_mobility::handle_ho_requested(idle_st& s, const ho_req_rx_ev&
/* Prepare Handover Command to be sent via S1AP */
srsran::unique_byte_buffer_t ho_cmd_pdu = srsran::make_byte_buffer();
asn1::bit_ref bref2{ho_cmd_pdu->msg, ho_cmd_pdu->get_tailroom()};
if (ho_cmd_pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
trigger(srsran::failure_ev{});
return;
}
asn1::bit_ref bref2{ho_cmd_pdu->msg, ho_cmd_pdu->get_tailroom()};
if (dl_dcch_msg.pack(bref2) != asn1::SRSASN_SUCCESS) {
logger.error("Failed to pack HandoverCommand");
trigger(srsran::failure_ev{});

36
srsenb/src/stack/rrc/rrc_nr.cc
View File

@ -21,13 +21,13 @@ namespace srsenb {
rrc_nr::rrc_nr(srsran::timer_handler* timers_) : logger(srslog::fetch_basic_logger("RRC")), timers(timers_) {}
void rrc_nr::init(const rrc_nr_cfg_t& cfg_,
phy_interface_stack_nr* phy_,
mac_interface_rrc_nr* mac_,
rlc_interface_rrc_nr* rlc_,
pdcp_interface_rrc_nr* pdcp_,
ngap_interface_rrc_nr* ngap_,
gtpu_interface_rrc_nr* gtpu_)
int rrc_nr::init(const rrc_nr_cfg_t& cfg_,
phy_interface_stack_nr* phy_,
mac_interface_rrc_nr* mac_,
rlc_interface_rrc_nr* rlc_,
pdcp_interface_rrc_nr* pdcp_,
ngap_interface_rrc_nr* ngap_,
gtpu_interface_rrc_nr* gtpu_)
{
phy = phy_;
mac = mac_;
@ -46,7 +46,11 @@ void rrc_nr::init(const rrc_nr_cfg_t& cfg_,
// derived
slot_dur_ms = 1;
nof_si_messages = generate_sibs();
if (generate_sibs() != SRSRAN_SUCCESS) {
logger.error("Couldn't generate SIB messages.");
return SRSRAN_ERROR;
}
config_mac();
// add dummy user
@ -67,6 +71,8 @@ void rrc_nr::init(const rrc_nr_cfg_t& cfg_,
logger.info("Started");
running = true;
return SRSRAN_SUCCESS;
}
void rrc_nr::stop()
@ -198,7 +204,7 @@ void rrc_nr::config_mac()
mac->cell_cfg(&sched_cfg);
}
uint32_t rrc_nr::generate_sibs()
int32_t rrc_nr::generate_sibs()
{
// MIB packing
bcch_bch_msg_s mib_msg;
@ -206,6 +212,10 @@ uint32_t rrc_nr::generate_sibs()
mib = cfg.mib;
{
srsran::unique_byte_buffer_t mib_buf = srsran::make_byte_buffer();
if (mib_buf == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return SRSRAN_ERROR;
}
asn1::bit_ref bref(mib_buf->msg, mib_buf->get_tailroom());
mib_msg.pack(bref);
mib_buf->N_bytes = bref.distance_bytes();
@ -240,6 +250,10 @@ uint32_t rrc_nr::generate_sibs()
// Pack payload for all messages
for (uint32_t msg_index = 0; msg_index < nof_messages + 1; msg_index++) {
srsran::unique_byte_buffer_t sib = srsran::make_byte_buffer();
if (sib == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return SRSRAN_ERROR;
}
asn1::bit_ref bref(sib->msg, sib->get_tailroom());
msg[msg_index].pack(bref);
sib->N_bytes = bref.distance_bytes();
@ -249,7 +263,9 @@ uint32_t rrc_nr::generate_sibs()
log_rrc_message("SIB payload", Tx, sib_buffer.back().get(), msg[msg_index]);
}
return sib_buffer.size() - 1;
nof_si_messages = sib_buffer.size() - 1;
return SRSRAN_SUCCESS;
}
/*******************************************************************************

8
srsenb/src/stack/rrc/rrc_ue.cc
View File

@ -201,6 +201,10 @@ void rrc::ue::parse_ul_dcch(uint32_t lcid, srsran::unique_byte_buffer_t pdu)
srsran::unique_byte_buffer_t original_pdu = std::move(pdu);
pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
parent->logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
transaction_id = 0;
@ -748,6 +752,10 @@ bool rrc::ue::handle_ue_cap_info(ue_cap_info_s* msg)
if (eutra_capabilities_unpacked) {
srsran::unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
parent->logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return false;
}
asn1::bit_ref bref2{pdu->msg, pdu->get_tailroom()};
msg->pack(bref2);
asn1::rrc::ue_radio_access_cap_info_s ue_rat_caps;

6
srsenb/test/rrc/rrc_nr_test.cc
View File

@ -47,7 +47,7 @@ int test_sib_generation()
rrc_nr_cfg_t rrc_cfg = rrc_obj.update_default_cfg(default_cfg);
auto& sched_elem = rrc_cfg.sib1.si_sched_info.sched_info_list[0];
rrc_obj.init(rrc_cfg, nullptr, &mac_obj, &rlc_obj, &pdcp_obj, nullptr, nullptr);
TESTASSERT(rrc_obj.init(rrc_cfg, nullptr, &mac_obj, &rlc_obj, &pdcp_obj, nullptr, nullptr) == SRSRAN_SUCCESS);
TESTASSERT(test_cell_cfg(mac_obj.cellcfgobj) == SRSRAN_SUCCESS);
// TEMP tests
@ -73,7 +73,7 @@ int test_rrc_setup()
// set cfg
rrc_nr_cfg_t default_cfg = {};
rrc_nr_cfg_t rrc_cfg = rrc_obj.update_default_cfg(default_cfg);
rrc_obj.init(rrc_cfg, nullptr, &mac_obj, &rlc_obj, &pdcp_obj, nullptr, nullptr);
TESTASSERT(rrc_obj.init(rrc_cfg, nullptr, &mac_obj, &rlc_obj, &pdcp_obj, nullptr, nullptr) == SRSRAN_SUCCESS);
for (uint32_t n = 0; n < 2; ++n) {
uint32_t timeout = 5500;
@ -92,5 +92,5 @@ int main()
TESTASSERT(srsenb::test_sib_generation() == SRSRAN_SUCCESS);
TESTASSERT(srsenb::test_rrc_setup() == SRSRAN_SUCCESS);
return 0;
return SRSRAN_SUCCESS;
}

4
srsepc/src/mbms-gw/mbms-gw.cc
View File

@ -229,6 +229,10 @@ void mbms_gw::run_thread()
// Mark the thread as running
m_running = true;
srsran::unique_byte_buffer_t msg = srsran::make_byte_buffer();
if (msg == nullptr) {
m_logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
uint8_t seq = 0;
while (m_running) {

4
srsepc/src/mme/mme.cc
View File

@ -89,6 +89,10 @@ void mme::stop()
void mme::run_thread()
{
srsran::unique_byte_buffer_t pdu = srsran::make_byte_buffer("mme::run_thread");
if (pdu == nullptr) {
m_s1ap_logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
uint32_t sz = SRSRAN_MAX_BUFFER_SIZE_BYTES - SRSRAN_BUFFER_HEADER_OFFSET;
struct sockaddr_in enb_addr;

2
srsue/hdr/stack/mac_nr/mux_nr.h
View File

@ -25,7 +25,7 @@ public:
explicit mux_nr(srslog::basic_logger& logger);
~mux_nr(){};
void reset();
void init();
int32_t init();
void step();

4
srsue/src/phy/nr/cc_worker.cc
View File

@ -217,6 +217,10 @@ bool cc_worker::work_dl()
if (phy->get_dl_pending_grant(dl_slot_cfg.idx, pdsch_cfg, ack_resource, pid)) {
// Get data buffer
srsran::unique_byte_buffer_t data = srsran::make_byte_buffer();
if (data == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return false;
}
data->N_bytes = pdsch_cfg.grant.tb[0].tbs / 8U;
// Get soft-buffer from MAC

16
srsue/src/stack/mac_nr/mac_nr.cc
View File

@ -19,8 +19,6 @@ namespace srsue {
mac_nr::mac_nr(srsran::ext_task_sched_handle task_sched_) :
task_sched(task_sched_), logger(srslog::fetch_basic_logger("MAC")), proc_ra(logger), mux(logger), pcap(nullptr)
{
tx_buffer = srsran::make_byte_buffer();
rlc_buffer = srsran::make_byte_buffer();
}
mac_nr::~mac_nr()
@ -39,7 +37,10 @@ int mac_nr::init(const mac_nr_args_t& args_, phy_interface_mac_nr* phy_, rlc_int
proc_ra.init(phy, this, &task_sched);
mux.init();
if (mux.init() != SRSRAN_SUCCESS) {
logger.error("Couldn't initialize mux unit.");
return SRSRAN_ERROR;
}
if (srsran_softbuffer_tx_init_guru(&softbuffer_tx, SRSRAN_SCH_NR_MAX_NOF_CB_LDPC, SRSRAN_LDPC_MAX_LEN_ENCODED_CB) <
SRSRAN_SUCCESS) {
@ -47,6 +48,15 @@ int mac_nr::init(const mac_nr_args_t& args_, phy_interface_mac_nr* phy_, rlc_int
return SRSRAN_ERROR;
}
tx_buffer = srsran::make_byte_buffer();
if (tx_buffer == nullptr) {
return SRSRAN_ERROR;
}
rlc_buffer = srsran::make_byte_buffer();
if (rlc_buffer == nullptr) {
return SRSRAN_ERROR;
}
started = true;
return SRSRAN_SUCCESS;

11
srsue/src/stack/mac_nr/mux_nr.cc
View File

@ -15,12 +15,17 @@
namespace srsue {
mux_nr::mux_nr(srslog::basic_logger& logger_) : logger(logger_)
mux_nr::mux_nr(srslog::basic_logger& logger_) : logger(logger_){};
int32_t mux_nr::init()
{
msg3_buff = srsran::make_byte_buffer();
};
if (msg3_buff == nullptr) {
return SRSRAN_ERROR;
}
void mux_nr::init() {}
return SRSRAN_SUCCESS;
}
void mux_nr::msg3_flush()
{

12
srsue/src/stack/rrc/rrc.cc
View File

@ -1533,8 +1533,8 @@ void rrc::send_ul_ccch_msg(const ul_ccch_msg_s& msg)
{
// Reset and reuse sdu buffer if provided
unique_byte_buffer_t pdcp_buf = srsran::make_byte_buffer();
if (not pdcp_buf.get()) {
logger.error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().");
if (pdcp_buf == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -1565,8 +1565,8 @@ void rrc::send_ul_dcch_msg(uint32_t lcid, const ul_dcch_msg_s& msg)
{
// Reset and reuse sdu buffer if provided
unique_byte_buffer_t pdcp_buf = srsran::make_byte_buffer();
if (not pdcp_buf.get()) {
logger.error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().");
if (pdcp_buf == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -1681,8 +1681,8 @@ void rrc::parse_dl_dcch(uint32_t lcid, unique_byte_buffer_t pdu)
switch (dl_dcch_msg.msg.c1().type().value) {
case dl_dcch_msg_type_c::c1_c_::types::dl_info_transfer:
pdu = srsran::make_byte_buffer();
if (!pdu.get()) {
logger.error("Fatal error: out of buffers in pool");
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
pdu->N_bytes = c1->dl_info_transfer().crit_exts.c1().dl_info_transfer_r8().ded_info_type.ded_info_nas().size();

4
srsue/src/stack/rrc/rrc_procedures.cc
View File

@ -1033,12 +1033,12 @@ srsran::proc_outcome_t rrc::connection_reconf_no_ho_proc::react(const bool& conf
srsran::unique_byte_buffer_t nas_pdu;
for (auto& pdu : rx_recfg.ded_info_nas_list) {
nas_pdu = srsran::make_byte_buffer();
if (nas_pdu.get()) {
if (nas_pdu != nullptr) {
memcpy(nas_pdu->msg, pdu.data(), pdu.size());
nas_pdu->N_bytes = pdu.size();
rrc_ptr->nas->write_pdu(RB_ID_SRB1, std::move(nas_pdu));
} else {
rrc_ptr->logger.error("Fatal Error: Couldn't allocate PDU in %s.", __FUNCTION__);
rrc_ptr->logger.error("Couldn't allocate PDU in %s.", __FUNCTION__);
return proc_outcome_t::error;
}
}

2
srsue/src/stack/upper/gw.cc
View File

@ -247,7 +247,7 @@ void gw::run_thread()
srsran::unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in run_thread().");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}

50
srsue/src/stack/upper/nas.cc
View File

@ -317,7 +317,7 @@ void nas::start_attach_request(srsran::establishment_cause_t cause_)
// Start attach request
unique_byte_buffer_t msg = srsran::make_byte_buffer();
if (msg == nullptr) {
logger.warning("Couldn't allocate buffer for Attach request.\n");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -359,6 +359,10 @@ void nas::start_service_request(srsran::establishment_cause_t cause_)
// Start service request
unique_byte_buffer_t msg = srsran::make_byte_buffer();
if (msg == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
gen_service_request(msg);
if (not rrc->connection_request(cause_, std::move(msg))) {
logger.error("Error starting RRC connection");
@ -1857,7 +1861,7 @@ void nas::send_security_mode_reject(uint8_t cause)
{
unique_byte_buffer_t msg = srsran::make_byte_buffer();
if (!msg) {
logger.error("Fatal Error: Couldn't allocate PDU in send_security_mode_reject().");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -1878,7 +1882,7 @@ void nas::send_attach_request()
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in %s().", __FUNCTION__);
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
gen_attach_request(pdu);
@ -1889,7 +1893,7 @@ void nas::send_detach_request(bool switch_off)
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in %s().", __FUNCTION__);
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -1969,6 +1973,10 @@ void nas::send_attach_complete(const uint8_t& transaction_id_, const uint8_t& ep
// Pack entire message
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
liblte_mme_pack_attach_complete_msg(
&attach_complete, current_sec_hdr, ctxt.tx_count, (LIBLTE_BYTE_MSG_STRUCT*)pdu.get());
// Write NAS pcap
@ -1993,7 +2001,7 @@ void nas::send_detach_accept()
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in %s().", __FUNCTION__);
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -2018,7 +2026,7 @@ void nas::send_authentication_response(const uint8_t* res, const size_t res_len)
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in send_authentication_response().");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -2049,7 +2057,7 @@ void nas::send_authentication_failure(const uint8_t cause, const uint8_t* auth_f
{
unique_byte_buffer_t msg = srsran::make_byte_buffer();
if (!msg) {
logger.error("Fatal Error: Couldn't allocate PDU in send_authentication_failure().");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -2097,7 +2105,7 @@ void nas::send_identity_response(const uint8 id_type)
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in send_identity_response().");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -2121,7 +2129,7 @@ void nas::send_service_request()
{
unique_byte_buffer_t msg = srsran::make_byte_buffer();
if (!msg) {
logger.error("Fatal Error: Couldn't allocate PDU in send_service_request().");
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -2240,8 +2248,8 @@ void nas::send_esm_information_response(const uint8 proc_transaction_id)
}
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (!pdu) {
logger.error("Fatal Error: Couldn't allocate PDU in %s.", __FUNCTION__);
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
@ -2271,6 +2279,10 @@ void nas::send_activate_dedicated_eps_bearer_context_accept(const uint8_t& proc_
const uint8_t& eps_bearer_id)
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
LIBLTE_MME_ACTIVATE_DEDICATED_EPS_BEARER_CONTEXT_ACCEPT_MSG_STRUCT accept = {};
@ -2305,6 +2317,10 @@ void nas::send_activate_dedicated_eps_bearer_context_accept(const uint8_t& proc_
void nas::send_deactivate_eps_bearer_context_accept(const uint8_t& proc_transaction_id, const uint8_t& eps_bearer_id)
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
LIBLTE_MME_DEACTIVATE_EPS_BEARER_CONTEXT_ACCEPT_MSG_STRUCT accept = {};
@ -2339,6 +2355,10 @@ void nas::send_deactivate_eps_bearer_context_accept(const uint8_t& proc_transact
void nas::send_modify_eps_bearer_context_accept(const uint8_t& proc_transaction_id, const uint8_t& eps_bearer_id)
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
LIBLTE_MME_MODIFY_EPS_BEARER_CONTEXT_ACCEPT_MSG_STRUCT accept = {};
@ -2373,6 +2393,10 @@ void nas::send_modify_eps_bearer_context_accept(const uint8_t& proc_transaction_
void nas::send_activate_test_mode_complete()
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
if (liblte_mme_pack_activate_test_mode_complete_msg(
(LIBLTE_BYTE_MSG_STRUCT*)pdu.get(), current_sec_hdr, ctxt.tx_count)) {
@ -2398,6 +2422,10 @@ void nas::send_activate_test_mode_complete()
void nas::send_close_ue_test_loop_complete()
{
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate PDU in %s().", __FUNCTION__);
return;
}
if (liblte_mme_pack_close_ue_test_loop_complete_msg(
(LIBLTE_BYTE_MSG_STRUCT*)pdu.get(), current_sec_hdr, ctxt.tx_count)) {

1
srsue/test/mac_nr/proc_ra_nr_test.cc
View File

@ -123,6 +123,7 @@ int main()
grant.pid = 0x0123;
uint8_t mac_dl_rar_pdu[] = {0x40, 0x06, 0x68, 0x03, 0x21, 0x46, 0x46, 0x02, 0x00, 0x00, 0x00};
grant.tb[0] = srsran::make_byte_buffer();
TESTASSERT(grant.tb[0] != nullptr);
grant.tb[0].get()->append_bytes(mac_dl_rar_pdu, sizeof(mac_dl_rar_pdu));
proc_ra_nr.handle_rar_pdu(grant);

4
srsue/test/ttcn3/hdr/ttcn3_drb_interface.h
View File

@ -120,6 +120,10 @@ private:
// pack into byte buffer
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate buffer in %s().", __FUNCTION__);
return;
}
pdu->N_bytes = len;
memcpy(pdu->msg, payload, pdu->N_bytes);

11
srsue/test/ttcn3/hdr/ttcn3_srb_interface.h
View File

@ -109,6 +109,10 @@ private:
// pack into byte buffer
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate buffer in %s().", __FUNCTION__);
return;
}
pdu->N_bytes = len;
memcpy(pdu->msg, payload, pdu->N_bytes);
@ -129,6 +133,10 @@ private:
// pack into byte buffer
unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
logger.error("Couldn't allocate buffer in %s().", __FUNCTION__);
return;
}
pdu->N_bytes = len;
memcpy(pdu->msg, payload, pdu->N_bytes);
@ -154,9 +162,6 @@ private:
ss_srb_interface* syssim = nullptr;
byte_buffer_pool* pool = nullptr;
// struct sctp_sndrcvinfo sri = {};
// struct sockaddr_in client_addr;
};
#endif // SRSUE_TTCN3_SRB_INTERFACE_H

8
srsue/test/ttcn3/hdr/ttcn3_sys_interface.h
View File

@ -194,6 +194,10 @@ private:
payload_ptr += 2;
unique_byte_buffer_t sib = srsran::make_byte_buffer();
if (sib == nullptr) {
logger.error("Couldn't allocate buffer in %s().", __FUNCTION__);
return;
}
memcpy(sib->msg, payload_ptr, tb_len);
payload_ptr += tb_len;
sib->N_bytes = tb_len;
@ -695,6 +699,10 @@ private:
payload_ptr += 2;
unique_byte_buffer_t pch = srsran::make_byte_buffer();
if (pch == nullptr) {
logger.error("Couldn't allocate buffer in %s().", __FUNCTION__);
return;
}
memcpy(pch->msg, payload_ptr, tb_len);
payload_ptr += tb_len;
pch->N_bytes = tb_len;

9
srsue/test/upper/nas_test.cc
View File

@ -226,6 +226,7 @@ int security_command_test()
// push auth request PDU to NAS to generate security context
byte_buffer_pool* pool = byte_buffer_pool::get_instance();
unique_byte_buffer_t tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, auth_request_pdu, sizeof(auth_request_pdu));
tmp->N_bytes = sizeof(auth_request_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -235,6 +236,7 @@ int security_command_test()
// reuse buffer for security mode command
tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, sec_mode_command_pdu, sizeof(sec_mode_command_pdu));
tmp->N_bytes = sizeof(sec_mode_command_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -296,6 +298,7 @@ int mme_attach_request_test()
// finally push attach accept
byte_buffer_pool* pool = byte_buffer_pool::get_instance();
unique_byte_buffer_t tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, attach_accept_pdu, sizeof(attach_accept_pdu));
tmp->N_bytes = sizeof(attach_accept_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -345,6 +348,7 @@ int esm_info_request_test()
// push ESM info request PDU to NAS to generate response
unique_byte_buffer_t tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, esm_info_req_pdu, sizeof(esm_info_req_pdu));
tmp->N_bytes = sizeof(esm_info_req_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -383,6 +387,7 @@ int dedicated_eps_bearer_test()
// push dedicated EPS bearer PDU to NAS
unique_byte_buffer_t tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, activate_dedicated_eps_bearer_pdu, sizeof(activate_dedicated_eps_bearer_pdu));
tmp->N_bytes = sizeof(activate_dedicated_eps_bearer_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -394,6 +399,7 @@ int dedicated_eps_bearer_test()
// add default EPS beaerer
unique_byte_buffer_t attach_with_default_bearer = srsran::make_byte_buffer();
TESTASSERT(attach_with_default_bearer != nullptr);
memcpy(attach_with_default_bearer->msg, attach_accept_pdu, sizeof(attach_accept_pdu));
attach_with_default_bearer->N_bytes = sizeof(attach_accept_pdu);
nas.write_pdu(LCID, std::move(attach_with_default_bearer));
@ -404,6 +410,7 @@ int dedicated_eps_bearer_test()
// push dedicated bearer activation and check that it was added
tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, activate_dedicated_eps_bearer_pdu, sizeof(activate_dedicated_eps_bearer_pdu));
tmp->N_bytes = sizeof(activate_dedicated_eps_bearer_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -412,6 +419,7 @@ int dedicated_eps_bearer_test()
// tear-down dedicated bearer
tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, deactivate_eps_bearer_pdu, sizeof(deactivate_eps_bearer_pdu));
tmp->N_bytes = sizeof(deactivate_eps_bearer_pdu);
nas.write_pdu(LCID, std::move(tmp));
@ -420,6 +428,7 @@ int dedicated_eps_bearer_test()
// try to tear-down dedicated bearer again
tmp = srsran::make_byte_buffer();
TESTASSERT(tmp != nullptr);
memcpy(tmp->msg, deactivate_eps_bearer_pdu, sizeof(deactivate_eps_bearer_pdu));
tmp->N_bytes = sizeof(deactivate_eps_bearer_pdu);
nas.write_pdu(LCID, std::move(tmp));

10
srsue/test/upper/rrc_meas_test.cc
View File

@ -135,6 +135,9 @@ public:
}
pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
return;
}
asn1::bit_ref bref(pdu->msg, pdu->get_tailroom());
dlsch_msg.pack(bref);
pdu->N_bytes = bref.distance_bytes();
@ -299,6 +302,9 @@ public:
void send_ccch_msg(dl_ccch_msg_s& dl_ccch_msg)
{
srsran::unique_byte_buffer_t pdu = srsran::make_byte_buffer();
if (pdu == nullptr) {
return;
}
asn1::bit_ref bref(pdu->msg, pdu->get_tailroom());
dl_ccch_msg.pack(bref);
@ -311,7 +317,9 @@ public:
void send_dcch_msg(dl_dcch_msg_s& dl_dcch_msg)
{
srsran::unique_byte_buffer_t pdu = srsran::make_byte_buffer();
;
if (pdu == nullptr) {
return;
}
asn1::bit_ref bref(pdu->msg, pdu->get_tailroom());
dl_dcch_msg.pack(bref);
bref.align_bytes_zero();

15
srsue/test/upper/tft_test.cc
View File

@ -106,10 +106,15 @@ int tft_filter_test_ipv6_combined()
srslog::basic_logger& logger = srslog::fetch_basic_logger("TFT");
srsran::unique_byte_buffer_t ip_msg1, ip_msg2, ip_msg3, ip_msg4, ip_msg5;
ip_msg1 = make_byte_buffer();
TESTASSERT(ip_msg1 != nullptr);
ip_msg2 = make_byte_buffer();
TESTASSERT(ip_msg2 != nullptr);
ip_msg3 = make_byte_buffer();
TESTASSERT(ip_msg3 != nullptr);
ip_msg4 = make_byte_buffer();
TESTASSERT(ip_msg4 != nullptr);
ip_msg5 = make_byte_buffer();
TESTASSERT(ip_msg5 != nullptr);
// Set IP test message
ip_msg1->N_bytes = sizeof(ipv6_matched_packet);
@ -164,7 +169,9 @@ int tft_filter_test_single_local_port()
srsran::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer();
TESTASSERT(ip_msg1 != nullptr);
ip_msg2 = make_byte_buffer();
TESTASSERT(ip_msg2 != nullptr);
// Filter length: 3 bytes
// Filter type: Single local port
@ -208,7 +215,9 @@ int tft_filter_test_single_remote_port()
srsran::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer();
TESTASSERT(ip_msg1 != nullptr);
ip_msg2 = make_byte_buffer();
TESTASSERT(ip_msg2 != nullptr);
// Filter length: 3 bytes
// Filter type: Single remote port
@ -252,7 +261,9 @@ int tft_filter_test_ipv4_local_addr()
srsran::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer();
TESTASSERT(ip_msg1 != nullptr);
ip_msg2 = make_byte_buffer();
TESTASSERT(ip_msg2 != nullptr);
// Filter length: 9 bytes
// Filter type: IPv4 local address
@ -299,7 +310,9 @@ int tft_filter_test_ipv4_remote_addr()
srsran::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer();
TESTASSERT(ip_msg1 != nullptr);
ip_msg2 = make_byte_buffer();
TESTASSERT(ip_msg2 != nullptr);
// Filter length: 5 bytes
// Filter type: IPv4 local address
@ -345,7 +358,9 @@ int tft_filter_test_ipv4_tos()
srsran::unique_byte_buffer_t ip_msg1, ip_msg2;
ip_msg1 = make_byte_buffer();
TESTASSERT(ip_msg1 != nullptr);
ip_msg2 = make_byte_buffer();
TESTASSERT(ip_msg2 != nullptr);
// Filter length: 3 bytes
// Filter type: Type of service