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

lib/include/srsran/common/basic_pnf.h

@@ -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));
     }

lib/src/common/basic_vnf.cc

@@ -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;
     }
   }
 

lib/src/upper/pdcp_entity_lte.cc

@@ -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;
+      if (fwd_sdu != nullptr) {
-      fwd_sdus.emplace(sdu.sdu->md.pdcp_sn, std::move(fwd_sdu));
+        *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;

lib/test/asn1/srsran_asn1_nas_test.cc

@@ -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;
 

lib/test/common/byte_buffer_queue_test.cc

@@ -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));

lib/test/common/choice_type_test.cc

@@ -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);

lib/test/upper/pdcp_lte_test_discard_sdu.cc

@@ -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);
 

srsenb/hdr/stack/rrc/rrc.h

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

srsenb/hdr/stack/rrc/rrc_nr.h

@@ -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,
+  int32_t init(const rrc_nr_cfg_t&     cfg,
-            phy_interface_stack_nr* phy,
+               phy_interface_stack_nr* phy,
-            mac_interface_rrc_nr*   mac,
+               mac_interface_rrc_nr*   mac,
-            rlc_interface_rrc_nr*   rlc,
+               rlc_interface_rrc_nr*   rlc,
-            pdcp_interface_rrc_nr*  pdcp,
+               pdcp_interface_rrc_nr*  pdcp,
-            ngap_interface_rrc_nr*  ngap_,
+               ngap_interface_rrc_nr*  ngap_,
-            gtpu_interface_rrc_nr*  gtpu);
+               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;
 

srsenb/src/stack/enb_stack_lte.cc

@@ -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;

srsenb/src/stack/mac/mac_nr.cc

@@ -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;

srsenb/src/stack/rrc/rrc.cc

@@ -40,13 +40,13 @@ rrc::rrc(srsran::task_sched_handle task_sched_) :
 
 rrc::~rrc() {}
 
-void rrc::init(const rrc_cfg_t&       cfg_,
+int32_t rrc::init(const rrc_cfg_t&       cfg_,
-               phy_interface_rrc_lte* phy_,
+                  phy_interface_rrc_lte* phy_,
-               mac_interface_rrc*     mac_,
+                  mac_interface_rrc*     mac_,
-               rlc_interface_rrc*     rlc_,
+                  rlc_interface_rrc*     rlc_,
-               pdcp_interface_rrc*    pdcp_,
+                  pdcp_interface_rrc*    pdcp_,
-               s1ap_interface_rrc*    s1ap_,
+                  s1ap_interface_rrc*    s1ap_,
-               gtpu_interface_rrc*    gtpu_)
+                  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()

srsenb/src/stack/rrc/rrc_mobility.cc

@@ -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{});

srsenb/src/stack/rrc/rrc_nr.cc

@@ -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_,
+int rrc_nr::init(const rrc_nr_cfg_t&     cfg_,
-                  phy_interface_stack_nr* phy_,
+                 phy_interface_stack_nr* phy_,
-                  mac_interface_rrc_nr*   mac_,
+                 mac_interface_rrc_nr*   mac_,
-                  rlc_interface_rrc_nr*   rlc_,
+                 rlc_interface_rrc_nr*   rlc_,
-                  pdcp_interface_rrc_nr*  pdcp_,
+                 pdcp_interface_rrc_nr*  pdcp_,
-                  ngap_interface_rrc_nr*  ngap_,
+                 ngap_interface_rrc_nr*  ngap_,
-                  gtpu_interface_rrc_nr*  gtpu_)
+                 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;
 }
 
 /*******************************************************************************

srsenb/src/stack/rrc/rrc_ue.cc

@@ -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;

srsenb/test/rrc/rrc_nr_test.cc

@@ -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;
 }

srsepc/src/mbms-gw/mbms-gw.cc

@@ -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) {

srsepc/src/mme/mme.cc

@@ -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;

srsue/hdr/stack/mac_nr/mux_nr.h

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

srsue/src/phy/nr/cc_worker.cc

@@ -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

srsue/src/stack/mac_nr/mac_nr.cc

@@ -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;

srsue/src/stack/mac_nr/mux_nr.cc

@@ -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()
 {

srsue/src/stack/rrc/rrc.cc

@@ -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()) {
+  if (pdcp_buf == nullptr) {
-    logger.error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().");
+    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()) {
+  if (pdcp_buf == nullptr) {
-    logger.error("Fatal Error: Couldn't allocate PDU in byte_align_and_pack().");
+    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()) {
+      if (pdu == nullptr) {
-        logger.error("Fatal error: out of buffers in pool");
+        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();

srsue/src/stack/rrc/rrc_procedures.cc

@@ -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;
     }
   }

srsue/src/stack/upper/gw.cc

@@ -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;
   }
 

srsue/src/stack/upper/nas.cc

@@ -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) {
+  if (pdu == nullptr) {
-    logger.error("Fatal Error: Couldn't allocate PDU in %s.", __FUNCTION__);
+    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)) {

srsue/test/mac_nr/proc_ra_nr_test.cc

@@ -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);
 

srsue/test/ttcn3/hdr/ttcn3_drb_interface.h

@@ -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);
 

srsue/test/ttcn3/hdr/ttcn3_srb_interface.h

@@ -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

srsue/test/ttcn3/hdr/ttcn3_sys_interface.h

@@ -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;

srsue/test/upper/nas_test.cc

@@ -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));

srsue/test/upper/rrc_meas_test.cc

@@ -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();

srsue/test/upper/tft_test.cc

@@ -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