Code refactor for UERadioCapabilityInfoIndication

src/amf-app/amf_n2.cpp

@@ -878,13 +878,7 @@ void amf_n2::handle_itti_message(itti_initial_context_setup_request& itti_msg) {
   if (itti_msg.is_sr or itti_msg.is_pdu_exist) {
     // Set UE RAdio Capability if available
     if (gc->ue_radio_cap_ind) {
-      bstring ueCapability = gc->ue_radio_cap_ind;
-      uint8_t* uecap       = (uint8_t*) calloc(1, blength(ueCapability) + 1);
-      uint8_t* buf_tmp     = (uint8_t*) bdata(ueCapability);
-      if (buf_tmp != nullptr) memcpy(uecap, buf_tmp, blength(ueCapability));
-      uecap[blength(ueCapability)] = '\0';
-      msg->setUERadioCapability(uecap, (size_t) blength(ueCapability));
-      free(uecap);
+      msg->setUERadioCapability(gc->ue_radio_cap_ind);
     }
 
     if (itti_msg.is_sr)

src/common/conversions.cpp

@@ -407,3 +407,9 @@ bool conv::check_bstring(const bstring& b_str) {
     return false;
   return true;
 }
+
+//------------------------------------------------------------------------------
+bool conv::check_octet_string(const OCTET_STRING_t& octet_str) {
+  if (!octet_str.buf or (octet_str.size == 0)) return false;
+  return true;
+}

src/common/conversions.hpp

@@ -83,6 +83,8 @@ class conv {
   // TODO: bitstring_2_int32
   static bool octet_string_copy(
       OCTET_STRING_t& destination, const OCTET_STRING_t& source);
+
   static bool check_bstring(const bstring& b_str);
+  static bool check_octet_string(const OCTET_STRING_t& octet_str);
 };
 #endif /* FILE_CONVERSIONS_HPP_SEEN */

src/ngap/ngapIEs/UERadioCapability.cpp

@@ -21,44 +21,44 @@
 
 #include "UERadioCapability.hpp"
 
+#include "conversions.hpp"
+
 namespace ngap {
 
 //------------------------------------------------------------------------------
-UERadioCapability::UERadioCapability() {
-  buffer_ = nullptr;
-  size_   = -1;
-}
+UERadioCapability::UERadioCapability() {}
 
 //------------------------------------------------------------------------------
 UERadioCapability::~UERadioCapability() {}
 
 //------------------------------------------------------------------------------
 bool UERadioCapability::encode(Ngap_UERadioCapability_t& ueRadioCapability) {
-  int ret = OCTET_STRING_fromBuf(&ueRadioCapability, buffer_, size_);
-  if (ret != 0) return false;
-  return true;
+  return conv::octet_string_copy(ueRadioCapability, ue_radio_capability_);
 }
 
 //------------------------------------------------------------------------------
 bool UERadioCapability::decode(Ngap_UERadioCapability_t& ueRadioCapability) {
-  buffer_ = (char*) ueRadioCapability.buf;
-  size_   = ueRadioCapability.size;
-  return true;
+  return conv::octet_string_copy(ue_radio_capability_, ueRadioCapability);
+}
+
+//------------------------------------------------------------------------------
+bool UERadioCapability::set(const OCTET_STRING_t& capability) {
+  return conv::octet_string_copy(ue_radio_capability_, capability);
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapability::get(uint8_t*& buffer, size_t& size) {
-  buffer = (uint8_t*) buffer_;
-  size   = size_;
-  if (!buffer_) return false;
-  if (size_ < 0) return false;
+bool UERadioCapability::get(OCTET_STRING_t& capability) {
+  return conv::octet_string_copy(capability, ue_radio_capability_);
+}
 
-  return true;
+//------------------------------------------------------------------------------
+bool UERadioCapability::set(const bstring& capability) {
+  return conv::bstring_2_octet_string(capability, ue_radio_capability_);
 }
 
 //------------------------------------------------------------------------------
-void UERadioCapability::set(uint8_t* buffer, size_t size) {
-  buffer_ = (char*) buffer;
-  size_   = size;
+bool UERadioCapability::get(bstring& capability) {
+  return conv::octet_string_2_bstring(ue_radio_capability_, capability);
 }
+
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapability.hpp

@@ -22,6 +22,8 @@
 #ifndef _UE_RADIO_CAPABILITY_H_
 #define _UE_RADIO_CAPABILITY_H_
 
+#include "bstrlib.h"
+
 extern "C" {
 #include "Ngap_UERadioCapability.h"
 }
@@ -35,12 +37,15 @@ class UERadioCapability {
 
   bool encode(Ngap_UERadioCapability_t& ueRadioCapability);
   bool decode(Ngap_UERadioCapability_t& ueRadioCapability);
-  bool get(uint8_t*& buffer, size_t& size);
-  void set(uint8_t* buffer, size_t size);
+
+  bool set(const OCTET_STRING_t& capability);
+  bool get(OCTET_STRING_t& capability);
+
+  bool set(const bstring& capability);
+  bool get(bstring& capability);
 
  private:
-  char* buffer_;
-  size_t size_;
+  OCTET_STRING_t ue_radio_capability_;
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapabilityForPaging.cpp

@@ -39,7 +39,7 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging(
     ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR =
         (Ngap_UERadioCapabilityForPagingOfNR_t*) calloc(
             1, sizeof(Ngap_UERadioCapabilityForPagingOfNR_t));
-    if (!ueRadioCapabilityForPagingOfNR->encode2UERadioCapabilityForPagingOfNR(
+    if (!ueRadioCapabilityForPagingOfNR->encode(
             ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
       return false;
   }
@@ -47,9 +47,8 @@ bool UERadioCapabilityForPaging::encode2UERadioCapabilityForPaging(
     ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA =
         (Ngap_UERadioCapabilityForPagingOfEUTRA_t*) calloc(
             1, sizeof(Ngap_UERadioCapabilityForPagingOfEUTRA_t));
-    if (!ueRadioCapabilityForPagingOfEUTRA
-             ->encode2UERadioCapabilityForPagingOfEUTRA(
-                 ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
+    if (!ueRadioCapabilityForPagingOfEUTRA->encode(
+            ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
       return false;
   }
 
@@ -61,16 +60,14 @@ bool UERadioCapabilityForPaging::decodefromUERadioCapabilityForPaging(
     Ngap_UERadioCapabilityForPaging_t* ueRadioCapabilityForPaging) {
   if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR) {
     ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR();
-    if (!ueRadioCapabilityForPagingOfNR
-             ->decodefromUERadioCapabilityForPagingOfNR(
-                 ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
+    if (!ueRadioCapabilityForPagingOfNR->decode(
+            ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfNR))
       return false;
   }
   if (ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA) {
     ueRadioCapabilityForPagingOfEUTRA = new UERadioCapabilityForPagingOfEUTRA();
-    if (!ueRadioCapabilityForPagingOfEUTRA
-             ->decodefromUERadioCapabilityForPagingOfEUTRA(
-                 ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
+    if (!ueRadioCapabilityForPagingOfEUTRA->decode(
+            ueRadioCapabilityForPaging->uERadioCapabilityForPagingOfEUTRA))
       return false;
   }
 

src/ngap/ngapIEs/UERadioCapabilityForPaging.hpp

@@ -48,8 +48,9 @@ class UERadioCapabilityForPaging {
       UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA);
 
  private:
-  UERadioCapabilityForPagingOfNR* ueRadioCapabilityForPagingOfNR;
-  UERadioCapabilityForPagingOfEUTRA* ueRadioCapabilityForPagingOfEUTRA;
+  UERadioCapabilityForPagingOfNR* ueRadioCapabilityForPagingOfNR;  // Optional
+  UERadioCapabilityForPagingOfEUTRA*
+      ueRadioCapabilityForPagingOfEUTRA;  // Optional
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapabilityForPagingOfEUTRA.cpp

@@ -21,54 +21,50 @@
 
 #include "UERadioCapabilityForPagingOfEUTRA.hpp"
 
+#include "conversions.hpp"
+
 namespace ngap {
 
 //------------------------------------------------------------------------------
-UERadioCapabilityForPagingOfEUTRA::UERadioCapabilityForPagingOfEUTRA() {
-  EUTRAbuffer       = NULL;
-  sizeofEUTRAbuffer = -1;
-}
+UERadioCapabilityForPagingOfEUTRA::UERadioCapabilityForPagingOfEUTRA() {}
 
 //------------------------------------------------------------------------------
 UERadioCapabilityForPagingOfEUTRA::~UERadioCapabilityForPagingOfEUTRA() {}
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPagingOfEUTRA::
-    encode2UERadioCapabilityForPagingOfEUTRA(
-        Ngap_UERadioCapabilityForPagingOfEUTRA_t*
-            ueRadioCapabilityForPagingOfEUTRA) {
-  int ret;
-  ret = OCTET_STRING_fromBuf(
-      ueRadioCapabilityForPagingOfEUTRA, EUTRAbuffer, sizeofEUTRAbuffer);
-  if (ret != 0) return false;
-  return true;
+bool UERadioCapabilityForPagingOfEUTRA::encode(
+    Ngap_UERadioCapabilityForPagingOfEUTRA_t*
+        ueRadioCapabilityForPagingOfEUTRA) {
+  return conv::octet_string_copy(
+      *ueRadioCapabilityForPagingOfEUTRA, ue_radio_capability_);
+}
+
+//------------------------------------------------------------------------------
+bool UERadioCapabilityForPagingOfEUTRA::decode(
+    Ngap_UERadioCapabilityForPagingOfEUTRA_t*
+        ueRadioCapabilityForPagingOfEUTRA) {
+  return conv::octet_string_copy(
+      ue_radio_capability_, *ueRadioCapabilityForPagingOfEUTRA);
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPagingOfEUTRA::
-    decodefromUERadioCapabilityForPagingOfEUTRA(
-        Ngap_UERadioCapabilityForPagingOfEUTRA_t*
-            ueRadioCapabilityForPagingOfEUTRA) {
-  EUTRAbuffer       = (char*) ueRadioCapabilityForPagingOfEUTRA->buf;
-  sizeofEUTRAbuffer = ueRadioCapabilityForPagingOfEUTRA->size;
-  return true;
+bool UERadioCapabilityForPagingOfEUTRA::set(const OCTET_STRING_t& capability) {
+  return conv::octet_string_copy(ue_radio_capability_, capability);
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPagingOfEUTRA::getUERadioCapabilityForPagingOfEUTRA(
-    uint8_t*& buffer, size_t& size) {
-  buffer = (uint8_t*) EUTRAbuffer;
-  size   = sizeofEUTRAbuffer;
-  if (!EUTRAbuffer) return false;
-  if (sizeofEUTRAbuffer < 0) return false;
+bool UERadioCapabilityForPagingOfEUTRA::get(OCTET_STRING_t& capability) {
+  return conv::octet_string_copy(capability, ue_radio_capability_);
+}
 
-  return true;
+//------------------------------------------------------------------------------
+bool UERadioCapabilityForPagingOfEUTRA::set(const bstring& capability) {
+  return conv::bstring_2_octet_string(capability, ue_radio_capability_);
 }
 
 //------------------------------------------------------------------------------
-void UERadioCapabilityForPagingOfEUTRA::setUERadioCapabilityForPagingOfEUTRA(
-    uint8_t* buffer, size_t size) {
-  EUTRAbuffer       = (char*) buffer;
-  sizeofEUTRAbuffer = size;
+bool UERadioCapabilityForPagingOfEUTRA::get(bstring& capability) {
+  return conv::octet_string_2_bstring(ue_radio_capability_, capability);
 }
+
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapabilityForPagingOfEUTRA.hpp

@@ -19,8 +19,10 @@
  *      contact@openairinterface.org
  */
 
-#ifndef _UERADIOCAPABILITYFORPAGINGOFEUTRA_H_
-#define _UERADIOCAPABILITYFORPAGINGOFEUTRA_H_
+#ifndef _UE_RADIO_CAPABILITY_FOR_PAGING_OF_EUTRA_H_
+#define _UE_RADIO_CAPABILITY_FOR_PAGING_OF_EUTRA_H_
+
+#include "bstrlib.h"
 
 extern "C" {
 #include "Ngap_UERadioCapabilityForPagingOfEUTRA.h"
@@ -33,18 +35,19 @@ class UERadioCapabilityForPagingOfEUTRA {
   UERadioCapabilityForPagingOfEUTRA();
   virtual ~UERadioCapabilityForPagingOfEUTRA();
 
-  bool encode2UERadioCapabilityForPagingOfEUTRA(
-      Ngap_UERadioCapabilityForPagingOfEUTRA_t*
-          ueRadioCapabilityForPagingOfEUTRA);
-  bool decodefromUERadioCapabilityForPagingOfEUTRA(
-      Ngap_UERadioCapabilityForPagingOfEUTRA_t*
-          ueRadioCapabilityForPagingOfEUTRA);
-  bool getUERadioCapabilityForPagingOfEUTRA(uint8_t*& buffer, size_t& size);
-  void setUERadioCapabilityForPagingOfEUTRA(uint8_t* buffer, size_t size);
+  bool encode(Ngap_UERadioCapabilityForPagingOfEUTRA_t*
+                  ueRadioCapabilityForPagingOfEUTRA);
+  bool decode(Ngap_UERadioCapabilityForPagingOfEUTRA_t*
+                  ueRadioCapabilityForPagingOfEUTRA);
+
+  bool set(const OCTET_STRING_t& capability);
+  bool get(OCTET_STRING_t& capability);
+
+  bool set(const bstring& capability);
+  bool get(bstring& capability);
 
  private:
-  char* EUTRAbuffer;
-  size_t sizeofEUTRAbuffer;
+  OCTET_STRING_t ue_radio_capability_;
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapabilityForPagingOfNR.cpp

@@ -21,50 +21,48 @@
 
 #include "UERadioCapabilityForPagingOfNR.hpp"
 
+#include "conversions.hpp"
+
 namespace ngap {
 
 //------------------------------------------------------------------------------
-UERadioCapabilityForPagingOfNR::UERadioCapabilityForPagingOfNR() {
-  nRbuffer       = NULL;
-  sizeofnRbuffer = -1;
-}
+UERadioCapabilityForPagingOfNR::UERadioCapabilityForPagingOfNR() {}
 
 //------------------------------------------------------------------------------
 UERadioCapabilityForPagingOfNR::~UERadioCapabilityForPagingOfNR() {}
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPagingOfNR::encode2UERadioCapabilityForPagingOfNR(
+bool UERadioCapabilityForPagingOfNR::encode(
     Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR) {
-  int ret;
-  ret = OCTET_STRING_fromBuf(
-      ueRadioCapabilityForPagingOfNR, nRbuffer, sizeofnRbuffer);
-  if (ret != 0) return false;
-  return true;
+  return conv::octet_string_copy(
+      *ueRadioCapabilityForPagingOfNR, ue_radio_capability_);
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPagingOfNR::decodefromUERadioCapabilityForPagingOfNR(
+bool UERadioCapabilityForPagingOfNR::decode(
     Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR) {
-  nRbuffer       = (char*) ueRadioCapabilityForPagingOfNR->buf;
-  sizeofnRbuffer = ueRadioCapabilityForPagingOfNR->size;
-  return true;
+  return conv::octet_string_copy(
+      ue_radio_capability_, *ueRadioCapabilityForPagingOfNR);
+}
+
+//------------------------------------------------------------------------------
+bool UERadioCapabilityForPagingOfNR::set(const OCTET_STRING_t& capability) {
+  return conv::octet_string_copy(ue_radio_capability_, capability);
 }
 
 //------------------------------------------------------------------------------
-bool UERadioCapabilityForPagingOfNR::getUERadioCapabilityForPagingOfNR(
-    uint8_t*& buffer, size_t& size) {
-  buffer = (uint8_t*) nRbuffer;
-  size   = sizeofnRbuffer;
-  if (!nRbuffer) return false;
-  if (sizeofnRbuffer < 0) return false;
+bool UERadioCapabilityForPagingOfNR::get(OCTET_STRING_t& capability) {
+  return conv::octet_string_copy(capability, ue_radio_capability_);
+}
 
-  return true;
+//------------------------------------------------------------------------------
+bool UERadioCapabilityForPagingOfNR::set(const bstring& capability) {
+  return conv::bstring_2_octet_string(capability, ue_radio_capability_);
 }
 
 //------------------------------------------------------------------------------
-void UERadioCapabilityForPagingOfNR::setUERadioCapabilityForPagingOfNR(
-    uint8_t* buffer, size_t size) {
-  nRbuffer       = (char*) buffer;
-  sizeofnRbuffer = size;
+bool UERadioCapabilityForPagingOfNR::get(bstring& capability) {
+  return conv::octet_string_2_bstring(ue_radio_capability_, capability);
 }
+
 }  // namespace ngap

src/ngap/ngapIEs/UERadioCapabilityForPagingOfNR.hpp

@@ -19,8 +19,10 @@
  *      contact@openairinterface.org
  */
 
-#ifndef _UERADIOCAPABILITYFORPAGINGOFNR_H_
-#define _UERADIOCAPABILITYFORPAGINGOFNR_H_
+#ifndef _UE_RADIO_CAPABILITY_FOR_PAGING_OF_NR_H_
+#define _UE_RADIO_CAPABILITY_FOR_PAGING_OF_NR_H_
+
+#include "bstrlib.h"
 
 extern "C" {
 #include "Ngap_UERadioCapabilityForPagingOfNR.h"
@@ -33,16 +35,19 @@ class UERadioCapabilityForPagingOfNR {
   UERadioCapabilityForPagingOfNR();
   virtual ~UERadioCapabilityForPagingOfNR();
 
-  bool encode2UERadioCapabilityForPagingOfNR(
+  bool encode(
       Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR);
-  bool decodefromUERadioCapabilityForPagingOfNR(
+  bool decode(
       Ngap_UERadioCapabilityForPagingOfNR_t* ueRadioCapabilityForPagingOfNR);
-  bool getUERadioCapabilityForPagingOfNR(uint8_t*& buffer, size_t& size);
-  void setUERadioCapabilityForPagingOfNR(uint8_t* buffer, size_t size);
+
+  bool set(const OCTET_STRING_t& capability);
+  bool get(OCTET_STRING_t& capability);
+
+  bool set(const bstring& capability);
+  bool get(bstring& capability);
 
  private:
-  char* nRbuffer;
-  size_t sizeofnRbuffer;
+  OCTET_STRING_t ue_radio_capability_;
 };
 
 }  // namespace ngap

src/ngap/ngapMsgs/InitialContextSetupRequest.cpp

@@ -560,9 +560,9 @@ bool InitialContextSetupRequestMsg::getNasPdu(bstring& pdu) {
 
 //------------------------------------------------------------------------------
 void InitialContextSetupRequestMsg::setUERadioCapability(
-    uint8_t* buffer, size_t size) {
+    const bstring& ue_radio_capability) {
   UERadioCapability tmp = {};
-  tmp.set(buffer, size);
+  tmp.set(ue_radio_capability);
   ueRadioCapability = std::optional<UERadioCapability>(tmp);
 
   Ngap_InitialContextSetupRequestIEs_t* ie =
@@ -587,9 +587,9 @@ void InitialContextSetupRequestMsg::setUERadioCapability(
 
 //------------------------------------------------------------------------------
 void InitialContextSetupRequestMsg::getUERadioCapability(
-    uint8_t* buffer, size_t& size) {
+    bstring& ue_radio_capability) {
   if (!ueRadioCapability.has_value()) return;
-  ueRadioCapability.value().get(buffer, size);
+  ueRadioCapability.value().get(ue_radio_capability);
 }
 
 //------------------------------------------------------------------------------

src/ngap/ngapMsgs/InitialContextSetupRequest.hpp

@@ -100,8 +100,8 @@ class InitialContextSetupRequestMsg : public NgapUEMessage {
   void setSecurityKey(uint8_t* key);   // 256bits
   bool getSecurityKey(uint8_t*& key);  // 256bits
 
-  void setUERadioCapability(uint8_t* buf, size_t size);
-  void getUERadioCapability(uint8_t* buf, size_t& size);
+  void setUERadioCapability(const bstring& ue_radio_capability);
+  void getUERadioCapability(bstring& ue_radio_capability);
 
   void setNasPdu(const bstring& pdu);
   bool getNasPdu(bstring& pdu);

src/ngap/ngapMsgs/UERadioCapabilityInfoIndication.cpp

@@ -21,6 +21,7 @@
 
 #include "UERadioCapabilityInfoIndication.hpp"
 
+#include "conversions.hpp"
 #include "logger.hpp"
 
 extern "C" {
@@ -101,7 +102,7 @@ void UeRadioCapabilityInfoIndicationMsg::setRanUeNgapId(
 //------------------------------------------------------------------------------
 void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability(
     const OCTET_STRING_t& capability) {
-  ueRadioCapability = capability;
+  ueRadioCapability.set(capability);
 
   Ngap_UERadioCapabilityInfoIndicationIEs_t* ie =
       (Ngap_UERadioCapabilityInfoIndicationIEs_t*) calloc(
@@ -111,16 +112,13 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability(
   ie->value.present =
       Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapability;
 
-  int ret = OCTET_STRING_fromBuf(
-      &ie->value.choice.UERadioCapability, (char*) ueRadioCapability.buf,
-      ueRadioCapability.size);
-  if (!ret) {
+  if (!ueRadioCapability.encode(ie->value.choice.UERadioCapability)) {
     Logger::ngap().error("Encode NGAP UERadioCapability IE error");
     free_wrapper((void**) &ie);
     return;
   }
 
-  ret = ASN_SEQUENCE_ADD(
+  int ret = ASN_SEQUENCE_ADD(
       &ueRadioCapabilityInfoIndicationIEs->protocolIEs.list, ie);
   if (ret != 0) Logger::ngap().error("Encode NGAP UERadioCapability IE error");
 }
@@ -128,27 +126,27 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapability(
 //------------------------------------------------------------------------------
 void UeRadioCapabilityInfoIndicationMsg::getUERadioCapability(
     OCTET_STRING_t& capability) {
-  capability = ueRadioCapability;
+  ueRadioCapability.get(capability);
 }
 
 //------------------------------------------------------------------------------
 void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
-    uint8_t* nr, size_t sizeofnr, uint8_t* eutra, size_t sizeofeutra) {
+    const OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
+    const OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra) {
   if (!ueRadioCapabilityForPaging)
     ueRadioCapabilityForPaging = new UERadioCapabilityForPaging();
   UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR = nullptr;
   UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA =
       nullptr;
-  if (nr && sizeofnr > 0) {
+  if (conv::check_octet_string(ue_radio_capability_for_paging_of_nr)) {
     m_ueRadioCapabilityForPagingOfNR = new UERadioCapabilityForPagingOfNR();
-    m_ueRadioCapabilityForPagingOfNR->setUERadioCapabilityForPagingOfNR(
-        nr, sizeofnr);
+    m_ueRadioCapabilityForPagingOfNR->set(ue_radio_capability_for_paging_of_nr);
   }
-  if (eutra && sizeofeutra > 0) {
+  if (conv::check_octet_string(ue_radio_capability_for_paging_of_eutra)) {
     m_ueRadioCapabilityForPagingOfEUTRA =
         new UERadioCapabilityForPagingOfEUTRA();
-    m_ueRadioCapabilityForPagingOfEUTRA->setUERadioCapabilityForPagingOfEUTRA(
-        eutra, sizeofeutra);
+    m_ueRadioCapabilityForPagingOfEUTRA->set(
+        ue_radio_capability_for_paging_of_eutra);
   }
   ueRadioCapabilityForPaging->setUERadioCapabilityForPaging(
       m_ueRadioCapabilityForPagingOfNR, m_ueRadioCapabilityForPagingOfEUTRA);
@@ -177,7 +175,8 @@ void UeRadioCapabilityInfoIndicationMsg::setUERadioCapabilityForPaging(
 
 //------------------------------------------------------------------------------
 bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging(
-    uint8_t*& nr, size_t& sizeofnr, uint8_t*& eutra, size_t& sizeofeutra) {
+    OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
+    OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra) {
   if (!ueRadioCapabilityForPaging) return false;
   UERadioCapabilityForPagingOfNR* m_ueRadioCapabilityForPagingOfNR;
   UERadioCapabilityForPagingOfEUTRA* m_ueRadioCapabilityForPagingOfEUTRA;
@@ -187,13 +186,13 @@ bool UeRadioCapabilityInfoIndicationMsg::getUERadioCapabilityForPaging(
     return false;
 
   if (m_ueRadioCapabilityForPagingOfNR) {
-    if (!m_ueRadioCapabilityForPagingOfNR->getUERadioCapabilityForPagingOfNR(
-            nr, sizeofnr))
+    if (!m_ueRadioCapabilityForPagingOfNR->get(
+            ue_radio_capability_for_paging_of_nr))
       return false;
   }
   if (m_ueRadioCapabilityForPagingOfEUTRA) {
-    if (!m_ueRadioCapabilityForPagingOfEUTRA
-             ->getUERadioCapabilityForPagingOfEUTRA(eutra, sizeofeutra))
+    if (!m_ueRadioCapabilityForPagingOfEUTRA->get(
+            ue_radio_capability_for_paging_of_eutra))
       return false;
   }
 
@@ -268,9 +267,9 @@ bool UeRadioCapabilityInfoIndicationMsg::decodeFromPdu(
             ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i]
                     ->value.present ==
                 Ngap_UERadioCapabilityInfoIndicationIEs__value_PR_UERadioCapability) {
-          ueRadioCapability =
+          ueRadioCapability.set(
               ueRadioCapabilityInfoIndicationIEs->protocolIEs.list.array[i]
-                  ->value.choice.UERadioCapability;
+                  ->value.choice.UERadioCapability);
         } else {
           Logger::ngap().error("Decoded NGAP UERadioCapability IE error");
           return false;

src/ngap/ngapMsgs/UERadioCapabilityInfoIndication.hpp

@@ -24,6 +24,7 @@
 
 #include "UERadioCapabilityForPaging.hpp"
 #include "NgapUEMessage.hpp"
+#include "UERadioCapability.hpp"
 
 extern "C" {
 #include "Ngap_UERadioCapabilityInfoIndication.h"
@@ -49,15 +50,17 @@ class UeRadioCapabilityInfoIndicationMsg : public NgapUEMessage {
   void getUERadioCapability(OCTET_STRING_t& capability);
 
   void setUERadioCapabilityForPaging(
-      uint8_t* nr, size_t sizeofnr, uint8_t* eutra, size_t sizeofeutra);
+      const OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
+      const OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra);
   bool getUERadioCapabilityForPaging(
-      uint8_t*& nr, size_t& sizeofnr, uint8_t*& eutra, size_t& sizeofeutra);
+      OCTET_STRING_t& ue_radio_capability_for_paging_of_nr,
+      OCTET_STRING_t& ue_radio_capability_for_paging_of_eutra);
 
  private:
   Ngap_UERadioCapabilityInfoIndication_t* ueRadioCapabilityInfoIndicationIEs;
   // AMF_UE_NGAP_ID //Mandatory
   // RAN_UE_NGAP_ID //Mandatory
-  OCTET_STRING_t ueRadioCapability;                        // Mandatory
+  UERadioCapability ueRadioCapability;                     // Mandatory
   UERadioCapabilityForPaging* ueRadioCapabilityForPaging;  // Optional
 };