Code refactor for HandoverRequest

src/amf-app/amf_n2.cpp

@@ -1585,8 +1585,7 @@ bool amf_n2::handle_itti_message(itti_handover_required& itti_msg) {
   Authentication_5gaka::handover_ncc_derive_knh(
       ulcount, 0x01, kamf, kgnb, knh, unc->ncc);
   bstring knh_bs = blk2bstr(knh, 32);
-  handover_request->setSecurityContext(
-      unc->ncc /*NCC count*/, (uint8_t*) bdata(knh_bs));
+  handover_request->setSecurityContext(unc->ncc /*NCC count*/, knh_bs);
 
   string supi = "imsi-" + nc->imsi;
   Logger::amf_n2().debug(

src/common/conversions.cpp

@@ -268,6 +268,46 @@ bool conv::bstring_2_octet_string(
   return true;
 }
 
+//------------------------------------------------------------------------------
+bool conv::octet_string_2_bit_string(
+    const OCTET_STRING_t& octet_str, BIT_STRING_t& bit_str,
+    const uint8_t& bits_unused) {
+  if (!check_octet_string(octet_str)) return false;
+
+  bit_str.buf = (uint8_t*) calloc(octet_str.size + 1, sizeof(uint8_t));
+  if (!bit_str.buf) return false;
+
+  memcpy(bit_str.buf, octet_str.buf, octet_str.size);
+  ((uint8_t*) bit_str.buf)[octet_str.size] = '\0';
+  bit_str.bits_unused                      = bits_unused;
+
+  return true;
+}
+
+//------------------------------------------------------------------------------
+bool conv::bstring_2_bit_string(const bstring& b_str, BIT_STRING_t& bit_str) {
+  OCTET_STRING_t octet_str;
+  bstring_2_octet_string(b_str, octet_str);
+  octet_string_2_bit_string(octet_str, bit_str, 0);
+  /*
+
+    int size = blength(b_str);
+    if (!b_str or size <= 0) return false;
+    if (!bdata(b_str)) return false;
+
+    bit_str.buf = (uint8_t*) calloc(size + 1, sizeof(uint8_t));
+    if (!bit_str.buf) return false;
+
+    if (check_bstring (b_str)) memcpy((void*) bit_str.buf, (char*)octet_str.buf,
+    blength(b_str));
+    ((uint8_t*) bit_str.buf)[size] = '\0';
+    bit_str.size                   = size;
+
+          bit_str.bits_unused            = 0;
+  */
+  return true;
+}
+
 //------------------------------------------------------------------------------
 bool conv::sd_string_to_int(const std::string& sd_str, uint32_t& sd) {
   sd = SD_NO_VALUE;

src/common/conversions.hpp

@@ -32,6 +32,7 @@
 
 extern "C" {
 #include "OCTET_STRING.h"
+#include "BIT_STRING.h"
 #include "dynamic_memory_check.h"
 }
 
@@ -67,6 +68,10 @@ class conv {
       const OCTET_STRING_t& octet_str, bstring& b_str);
   static bool bstring_2_octet_string(
       const bstring& b_str, OCTET_STRING_t& octet_str);
+  static bool octet_string_2_bit_string(
+      const OCTET_STRING_t& octet_str, BIT_STRING_t& bit_str,
+      const uint8_t& bits_unused);
+  static bool bstring_2_bit_string(const bstring& b_str, BIT_STRING_t& bit_str);
   static bool sd_string_to_int(const std::string& sd_str, uint32_t& sd);
   static bool string_to_int(
       const std::string& str, uint32_t& value, const uint8_t& base);

src/ngap/ngapIEs/MobilityRestrictionList.cpp

@@ -21,9 +21,6 @@
 
 #include "MobilityRestrictionList.hpp"
 
-#include <iostream>
-
-using namespace std;
 namespace ngap {
 //------------------------------------------------------------------------------
 MobilityRestrictionList::MobilityRestrictionList() {}

src/ngap/ngapIEs/MobilityRestrictionList.hpp

@@ -35,8 +35,8 @@ class MobilityRestrictionList {
   void setPLMN(const PlmnId& sPlmn);
   void getPLMN(PlmnId& sPlmn);
 
-  bool encode(Ngap_MobilityRestrictionList_t* mobilityrestrictionlist);
-  bool decode(Ngap_MobilityRestrictionList_t* mobilityrestrictionlist);
+  bool encode(Ngap_MobilityRestrictionList_t* mobility_restriction_list);
+  bool decode(Ngap_MobilityRestrictionList_t* mobility_restriction_list);
 
  private:
   PlmnId servingPLMN;  // Mandatory

src/ngap/ngapIEs/PDUSessionResourceSetupItemHOReq.cpp

@@ -21,57 +21,55 @@
 
 #include "PDUSessionResourceSetupItemHOReq.hpp"
 
-#include <iostream>
-using namespace std;
-
 namespace ngap {
-PDUSessionResourceSetupItemHOReq::PDUSessionResourceSetupItemHOReq() {
-  pDUSessionID = NULL;
-  s_NSSAI      = NULL;
-}
+
+//------------------------------------------------------------------------------
+PDUSessionResourceSetupItemHOReq::PDUSessionResourceSetupItemHOReq()
+    : PDUSessionResourceItem() {}
+
+//------------------------------------------------------------------------------
 PDUSessionResourceSetupItemHOReq::~PDUSessionResourceSetupItemHOReq() {}
 
-void PDUSessionResourceSetupItemHOReq::setPDUSessionResourceSetupItemHOReq(
-    PDUSessionID* m_pDUSessionID, S_NSSAI* m_s_NSSAI,
-    OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer) {
-  pDUSessionID = m_pDUSessionID;
-  s_NSSAI      = m_s_NSSAI;
-  pDUSessionResourceSetupRequestTransfer =
-      m_pDUSessionResourceSetupRequestTransfer;
+//------------------------------------------------------------------------------
+void PDUSessionResourceSetupItemHOReq::set(
+    const PDUSessionID& pdu_session_id, const S_NSSAI& s_nssai,
+    const OCTET_STRING_t& handover_request_transfer) {
+  PDUSessionResourceItem::set(pdu_session_id, handover_request_transfer);
+  s_NSSAI = s_nssai;
 }
-bool PDUSessionResourceSetupItemHOReq::encode2PDUSessionResourceSetupItemHOReq(
-    Ngap_PDUSessionResourceSetupItemHOReq_t* pduSessionResourceSetupItemHOReq) {
-  if (!pDUSessionID->encode(pduSessionResourceSetupItemHOReq->pDUSessionID))
-    return false;
-  if (!s_NSSAI->encode(&pduSessionResourceSetupItemHOReq->s_NSSAI))
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceSetupItemHOReq::get(
+    PDUSessionID& pdu_session_id, S_NSSAI& s_nssai,
+    OCTET_STRING_t& handover_request_transfer) {
+  PDUSessionResourceItem::get(pdu_session_id, handover_request_transfer);
+  s_nssai = s_NSSAI;
+}
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceSetupItemHOReq::encode(
+    Ngap_PDUSessionResourceSetupItemHOReq_t* resource_setup_item) {
+  if (!PDUSessionResourceItem::encode(
+          resource_setup_item->pDUSessionID,
+          resource_setup_item->handoverRequestTransfer))
     return false;
-  pduSessionResourceSetupItemHOReq->handoverRequestTransfer =
-      pDUSessionResourceSetupRequestTransfer;
+
+  if (!s_NSSAI.encode(&resource_setup_item->s_NSSAI)) return false;
 
   return true;
 }
-bool PDUSessionResourceSetupItemHOReq::
-    decodefromPDUSessionResourceSetupItemHOReq(
-        Ngap_PDUSessionResourceSetupItemHOReq_t*
-            pduSessionResourceSetupItemHOReq) {
-  if (pDUSessionID == nullptr) pDUSessionID = new PDUSessionID();
-  s_NSSAI = new S_NSSAI();
-  if (!pDUSessionID->decode(pduSessionResourceSetupItemHOReq->pDUSessionID))
-    return false;
-  if (!s_NSSAI->decode(&pduSessionResourceSetupItemHOReq->s_NSSAI))
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceSetupItemHOReq::decode(
+    Ngap_PDUSessionResourceSetupItemHOReq_t* resource_setup_item) {
+  if (!PDUSessionResourceItem::decode(
+          resource_setup_item->pDUSessionID,
+          resource_setup_item->handoverRequestTransfer))
     return false;
-  pDUSessionResourceSetupRequestTransfer =
-      pduSessionResourceSetupItemHOReq->handoverRequestTransfer;
+
+  if (!s_NSSAI.decode(&resource_setup_item->s_NSSAI)) return false;
 
   return true;
 }
-void PDUSessionResourceSetupItemHOReq::getPDUSessionResourceSetupItemHOReq(
-    PDUSessionID*& m_pDUSessionID, S_NSSAI*& m_s_NSSAI,
-    OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
-  m_pDUSessionID = pDUSessionID;
-  m_s_NSSAI      = s_NSSAI;
-  m_pDUSessionResourceSetupRequestTransfer =
-      pDUSessionResourceSetupRequestTransfer;
-}
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceSetupItemHOReq.hpp

@@ -19,11 +19,10 @@
  *      contact@openairinterface.org
  */
 
-#ifndef _PDUSESSIONRESOURCESETUPITEMHOREQ_H_
-#define _PDUSESSIONRESOURCESETUPITEMHOREQ_H_
+#ifndef _PDU_SESSION_RESOURCE_SETUP_ITEM_HO_REQ_H_
+#define _PDU_SESSION_RESOURCE_SETUP_ITEM_HO_REQ_H_
 
-#include "NAS-PDU.hpp"
-#include "PDUSessionID.hpp"
+#include "PDUSessionResourceItem.hpp"
 #include "PDUSessionResourceSetupRequestTransfer.hpp"
 #include "S-NSSAI.hpp"
 
@@ -33,29 +32,27 @@ extern "C" {
 
 namespace ngap {
 
-class PDUSessionResourceSetupItemHOReq {
+class PDUSessionResourceSetupItemHOReq : public PDUSessionResourceItem {
  public:
   PDUSessionResourceSetupItemHOReq();
   virtual ~PDUSessionResourceSetupItemHOReq();
 
-  void setPDUSessionResourceSetupItemHOReq(
-      PDUSessionID* m_pDUSessionID, S_NSSAI* m_s_NSSAI,
-      OCTET_STRING_t m_pDUSessionResourceSetupRequestTransfer);
-  void getPDUSessionResourceSetupItemHOReq(
-      PDUSessionID*& m_pDUSessionID, S_NSSAI*& m_s_NSSAI,
-      OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
+  void set(
+      const PDUSessionID& pdu_session_id, const S_NSSAI& s_nssai,
+      const OCTET_STRING_t& handover_request_transfer);
+  void get(
+      PDUSessionID& pdu_session_id, S_NSSAI& s_nssai,
+      OCTET_STRING_t& handover_request_transfer);
 
-  bool encode2PDUSessionResourceSetupItemHOReq(
-      Ngap_PDUSessionResourceSetupItemHOReq_t*
-          pduSessionResourceSetupItemHOReq);
-  bool decodefromPDUSessionResourceSetupItemHOReq(
-      Ngap_PDUSessionResourceSetupItemHOReq_t*
-          pduSessionResourceSetupItemHOReq);
+  bool encode(Ngap_PDUSessionResourceSetupItemHOReq_t*
+                  pduSessionResourceSetupItemHOReq);
+  bool decode(Ngap_PDUSessionResourceSetupItemHOReq_t*
+                  pduSessionResourceSetupItemHOReq);
 
  private:
-  PDUSessionID* pDUSessionID;
-  S_NSSAI* s_NSSAI;
-  OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;
+  // PDUSessionID - Mandatory;
+  S_NSSAI s_NSSAI;  // Mandatory
+  // Handover Request Transfer - Mandatory
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceSetupListHOReq.cpp

@@ -21,60 +21,49 @@
 
 #include "PDUSessionResourceSetupListHOReq.hpp"
 
-#include <iostream>
-using namespace std;
-
 namespace ngap {
-PDUSessionResourceSetupListHOReq::PDUSessionResourceSetupListHOReq() {
-  pduSessionResourceSetupItemHOReq      = NULL;
-  numofpduSessionResourceSetupItemHOReq = 0;
-}
+
+//------------------------------------------------------------------------------
+PDUSessionResourceSetupListHOReq::PDUSessionResourceSetupListHOReq() {}
+
+//------------------------------------------------------------------------------
 PDUSessionResourceSetupListHOReq::~PDUSessionResourceSetupListHOReq() {}
 
-void PDUSessionResourceSetupListHOReq::setPDUSessionResourceSetupListHOReq(
-    PDUSessionResourceSetupItemHOReq* m_pduSessionResourceSetupItemHOReq,
-    int num) {
-  pduSessionResourceSetupItemHOReq      = m_pduSessionResourceSetupItemHOReq;
-  numofpduSessionResourceSetupItemHOReq = num;
+//------------------------------------------------------------------------------
+void PDUSessionResourceSetupListHOReq::set(
+    const std::vector<PDUSessionResourceSetupItemHOReq>& list) {
+  list_ = list;
+}
+
+//------------------------------------------------------------------------------
+void PDUSessionResourceSetupListHOReq::get(
+    std::vector<PDUSessionResourceSetupItemHOReq>& list) {
+  list = list_;
 }
-bool PDUSessionResourceSetupListHOReq::encode2PDUSessionResourceSetupListHOReq(
-    Ngap_PDUSessionResourceSetupListHOReq_t* pduSessionResourceSetupListHOReq) {
-  for (int i = 0; i < numofpduSessionResourceSetupItemHOReq; i++) {
+
+//------------------------------------------------------------------------------
+bool PDUSessionResourceSetupListHOReq::encode(
+    Ngap_PDUSessionResourceSetupListHOReq_t* resource_list) {
+  for (auto item : list_) {
     Ngap_PDUSessionResourceSetupItemHOReq_t* request =
         (Ngap_PDUSessionResourceSetupItemHOReq_t*) calloc(
             1, sizeof(Ngap_PDUSessionResourceSetupItemHOReq_t));
     if (!request) return false;
-    if (!pduSessionResourceSetupItemHOReq[i]
-             .encode2PDUSessionResourceSetupItemHOReq(request))
-      return false;
-    if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListHOReq->list, request) != 0)
-      return false;
+    if (!item.encode(request)) return false;
+    if (ASN_SEQUENCE_ADD(&resource_list->list, request) != 0) return false;
   }
-
   return true;
 }
-bool PDUSessionResourceSetupListHOReq::
-    decodefromPDUSessionResourceSetupListHOReq(
-        Ngap_PDUSessionResourceSetupListHOReq_t*
-            pduSessionResourceSetupListHOReq) {
-  numofpduSessionResourceSetupItemHOReq =
-      pduSessionResourceSetupListHOReq->list.count;
-  pduSessionResourceSetupItemHOReq = new PDUSessionResourceSetupItemHOReq
-      [numofpduSessionResourceSetupItemHOReq]();
-  for (int i = 0; i < numofpduSessionResourceSetupItemHOReq; i++) {
-    if (!pduSessionResourceSetupItemHOReq[i]
-             .decodefromPDUSessionResourceSetupItemHOReq(
-                 pduSessionResourceSetupListHOReq->list.array[i]))
-      return false;
-  }
 
+//------------------------------------------------------------------------------
+bool PDUSessionResourceSetupListHOReq::decode(
+    Ngap_PDUSessionResourceSetupListHOReq_t* resource_list) {
+  for (int i = 0; i < resource_list->list.count; i++) {
+    PDUSessionResourceSetupItemHOReq item = {};
+    if (!item.decode(resource_list->list.array[i])) return false;
+    list_.push_back(item);
+  }
   return true;
 }
-void PDUSessionResourceSetupListHOReq::getPDUSessionResourceSetupListHOReq(
-    PDUSessionResourceSetupItemHOReq*& m_pduSessionResourceSetupItemHOReq,
-    int& num) {
-  m_pduSessionResourceSetupItemHOReq = pduSessionResourceSetupItemHOReq;
-  num                                = numofpduSessionResourceSetupItemHOReq;
-}
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceSetupListHOReq.hpp

@@ -19,11 +19,13 @@
  *      contact@openairinterface.org
  */
 
-#ifndef _PDUSESSIONRESOURCESETUPLISTHOREQ_H_
-#define _PDUSESSIONRESOURCESETUPLISTHOREQ_H_
+#ifndef PDU_SESSION_RESOURCE_SETUP_LIST_HO_REQ_H_
+#define PDU_SESSION_RESOURCE_SETUP_LIST_HO_REQ_H_
 
 #include "PDUSessionResourceSetupItemHOReq.hpp"
 
+#include <vector>
+
 extern "C" {
 #include "Ngap_PDUSessionResourceSetupListHOReq.h"
 }
@@ -35,23 +37,16 @@ class PDUSessionResourceSetupListHOReq {
   PDUSessionResourceSetupListHOReq();
   virtual ~PDUSessionResourceSetupListHOReq();
 
-  void setPDUSessionResourceSetupListHOReq(
-      PDUSessionResourceSetupItemHOReq* m_pduSessionResourceSetupItemHOReq,
-      int num);
-  void getPDUSessionResourceSetupListHOReq(
-      PDUSessionResourceSetupItemHOReq*& m_pduSessionResourceSetupItemHOReq,
-      int& num);
+  void set(const std::vector<PDUSessionResourceSetupItemHOReq>& list);
+  void get(std::vector<PDUSessionResourceSetupItemHOReq>& list);
 
-  bool encode2PDUSessionResourceSetupListHOReq(
-      Ngap_PDUSessionResourceSetupListHOReq_t*
-          pduSessionResourceSetupListHOReq);
-  bool decodefromPDUSessionResourceSetupListHOReq(
-      Ngap_PDUSessionResourceSetupListHOReq_t*
-          pduSessionResourceSetupListHOReq);
+  bool encode(Ngap_PDUSessionResourceSetupListHOReq_t*
+                  pduSessionResourceSetupListHOReq);
+  bool decode(Ngap_PDUSessionResourceSetupListHOReq_t*
+                  pduSessionResourceSetupListHOReq);
 
  private:
-  PDUSessionResourceSetupItemHOReq* pduSessionResourceSetupItemHOReq;
-  int numofpduSessionResourceSetupItemHOReq;
+  std::vector<PDUSessionResourceSetupItemHOReq> list_;
 };
 
 }  // namespace ngap

src/ngap/ngapMsgs/HandoverRequest.cpp

@@ -20,6 +20,8 @@
  */
 
 #include "HandoverRequest.hpp"
+
+#include "conversions.hpp"
 #include "logger.hpp"
 
 extern "C" {
@@ -30,7 +32,7 @@ namespace ngap {
 
 //------------------------------------------------------------------------------
 HandoverRequest::HandoverRequest() : NgapMessage() {
-  mobilityRestrictionList = nullptr;
+  mobilityRestrictionList = std::nullopt;
   handoverRequestIEs      = nullptr;
 
   setMessageType(NgapMessageType::HANDOVER_REQUEST);
@@ -103,7 +105,24 @@ bool HandoverRequest::decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) {
           return false;
         }
       } break;
-
+        // TODO: Cause
+        // TODO: UEAggregateMaxBitRate
+        // TODO: Core Network Assistance Information for RRC INACTIVE
+        // TODO:  UESecurityCapabilities ueSecurityCapabilities
+        // TODO: Ngap_SecurityContext_t securityContext
+        // TODO: New Security Context Indicator
+        // TODO: NASC - NAS-PDU
+        // TODO: PDUSessionResourceSetupListHOReq
+        // TODO: AllowedNSSAI
+        // TODO: Trace Activation
+        // TODO: Masked IMEISV
+        // TODO: SourceToTarget_TransparentContainer
+        // TODO: MobilityRestrictionList
+        // TODO: Location Reporting Request Type
+        // TODO: RRC Inactive Transition Report Request
+        // TODO: GUAMI
+        // TODO: Redirection for Voice EPS Fallback
+        // TODO: CN Assisted RAN Parameters Tuning
       default: {
         Logger::ngap().error("Decode NGAP HandoverRequest PDU error");
         return false;
@@ -203,14 +222,14 @@ void HandoverRequest::setUESecurityCapabilities(
 
 //------------------------------------------------------------------------------
 void HandoverRequest::setGUAMI(
-    const PlmnId& m_plmnId, const AMFRegionID& m_aMFRegionID,
-    const AMFSetID& m_aMFSetID, const AMFPointer& m_aMFPointer) {
+    const PlmnId& plmnId, const AMFRegionID& aMFRegionID,
+    const AMFSetID& aMFSetID, const AMFPointer& aMFPointer) {
   Ngap_HandoverRequestIEs_t* ie =
       (Ngap_HandoverRequestIEs_t*) calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id            = Ngap_ProtocolIE_ID_id_GUAMI;
   ie->criticality   = Ngap_Criticality_reject;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_GUAMI;
-  guami.setGUAMI(m_plmnId, m_aMFRegionID, m_aMFSetID, m_aMFPointer);
+  guami.setGUAMI(plmnId, aMFRegionID, aMFSetID, aMFPointer);
   guami.encode2GUAMI(&(ie->value.choice.GUAMI));
 
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
@@ -257,10 +276,8 @@ void HandoverRequest::setAllowedNSSAI(std::vector<S_NSSAI>& list) {
 }
 
 //------------------------------------------------------------------------------
-void HandoverRequest::setSecurityContext(const long& count, uint8_t* buffer) {
-  SecurityKey securitykey;
-  securitykey.setSecurityKey(buffer);
-  securitykey.encode(securityContext.nextHopNH);
+void HandoverRequest::setSecurityContext(const long& count, bstring& nh) {
+  conv::bstring_2_bit_string(nh, securityContext.nextHopNH);
   securityContext.nextHopChainingCount = count;
 
   Ngap_HandoverRequestIEs_t* ie =
@@ -276,22 +293,22 @@ void HandoverRequest::setSecurityContext(const long& count, uint8_t* buffer) {
 //------------------------------------------------------------------------------
 void HandoverRequest::setPduSessionResourceSetupList(
     const std::vector<PDUSessionResourceSetupRequestItem_t>& list) {
-  PDUSessionResourceSetupItemHOReq* m_pduSessionResourceSetupItemHOReq =
-      new PDUSessionResourceSetupItemHOReq[list.size()]();
+  std::vector<PDUSessionResourceSetupItemHOReq> resource_setup_list;
 
   for (int i = 0; i < list.size(); i++) {
-    PDUSessionID* m_pDUSessionID = new PDUSessionID();
-    m_pDUSessionID->set(list[i].pduSessionId);
-    S_NSSAI* m_s_NSSAI = new S_NSSAI();
-    m_s_NSSAI->setSst(list[i].s_nssai.sst);
-    if (list[i].s_nssai.sd.size()) m_s_NSSAI->setSd(list[i].s_nssai.sd);
-    m_pduSessionResourceSetupItemHOReq[i].setPDUSessionResourceSetupItemHOReq(
-        m_pDUSessionID, m_s_NSSAI,
+    PDUSessionResourceSetupItemHOReq resource_setup_item = {};
+    PDUSessionID pdu_session_id                          = {};
+    pdu_session_id.set(list[i].pduSessionId);
+    S_NSSAI s_nssai = {};
+    s_nssai.setSst(list[i].s_nssai.sst);
+    if (list[i].s_nssai.sd.size()) s_nssai.setSd(list[i].s_nssai.sd);
+    resource_setup_item.set(
+        pdu_session_id, s_nssai,
         list[i].pduSessionResourceSetupRequestTransfer);
+    resource_setup_list.push_back(resource_setup_item);
   }
 
-  pDUSessionResourceSetupList.setPDUSessionResourceSetupListHOReq(
-      m_pduSessionResourceSetupItemHOReq, list.size());
+  pDUSessionResourceSetupList.set(resource_setup_list);
 
   Ngap_HandoverRequestIEs_t* ie =
       (Ngap_HandoverRequestIEs_t*) calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
@@ -300,7 +317,7 @@ void HandoverRequest::setPduSessionResourceSetupList(
   ie->value.present =
       Ngap_HandoverRequestIEs__value_PR_PDUSessionResourceSetupListHOReq;
 
-  int ret = pDUSessionResourceSetupList.encode2PDUSessionResourceSetupListHOReq(
+  int ret = pDUSessionResourceSetupList.encode(
       &ie->value.choice.PDUSessionResourceSetupListHOReq);
   if (!ret) {
     Logger::ngap().error("Encode PDUSessionResourceSetupListSUReq IE error");
@@ -316,7 +333,7 @@ void HandoverRequest::setPduSessionResourceSetupList(
 //------------------------------------------------------------------------------
 void HandoverRequest::setSourceToTarget_TransparentContainer(
     const OCTET_STRING_t& sourceTotarget) {
-  SourceToTarget_TransparentContainer = sourceTotarget;
+  conv::octet_string_copy(SourceToTarget_TransparentContainer, sourceTotarget);
   Ngap_HandoverRequestIEs_t* ie =
       (Ngap_HandoverRequestIEs_t*) calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id          = Ngap_ProtocolIE_ID_id_SourceToTarget_TransparentContainer;
@@ -330,17 +347,19 @@ void HandoverRequest::setSourceToTarget_TransparentContainer(
 }
 
 //------------------------------------------------------------------------------
-void HandoverRequest::setMobilityRestrictionList(const PlmnId& m_plmnId) {
-  if (!mobilityRestrictionList) {
-    mobilityRestrictionList = new MobilityRestrictionList();
-  }
+void HandoverRequest::setMobilityRestrictionList(const PlmnId& plmn_id) {
+  MobilityRestrictionList tmp = {};
+  tmp.setPLMN(plmn_id);
+  mobilityRestrictionList = std::optional<MobilityRestrictionList>(tmp);
+
   Ngap_HandoverRequestIEs_t* ie =
       (Ngap_HandoverRequestIEs_t*) calloc(1, sizeof(Ngap_HandoverRequestIEs_t));
   ie->id            = Ngap_ProtocolIE_ID_id_MobilityRestrictionList;
   ie->criticality   = Ngap_Criticality_ignore;
   ie->value.present = Ngap_HandoverRequestIEs__value_PR_MobilityRestrictionList;
-  mobilityRestrictionList->setPLMN(m_plmnId);
-  mobilityRestrictionList->encode(&(ie->value.choice.MobilityRestrictionList));
+
+  mobilityRestrictionList.value().encode(
+      &(ie->value.choice.MobilityRestrictionList));
   int ret = ASN_SEQUENCE_ADD(&handoverRequestIEs->protocolIEs.list, ie);
   if (ret != 0) Logger::ngap().error("Encode MobilityRestrictionList IE error");
 }

src/ngap/ngapMsgs/HandoverRequest.hpp

@@ -69,7 +69,7 @@ class HandoverRequest : public NgapMessage {
       const uint16_t& eUTRAIntegrityProtectionAlgs);
   // TODO: getUESecurityCapabilities
 
-  void setSecurityContext(const long& count, uint8_t* buffer);
+  void setSecurityContext(const long& count, bstring& nh);
   // TODO: getSecurityContext
 
   void setPduSessionResourceSetupList(
@@ -84,8 +84,8 @@ class HandoverRequest : public NgapMessage {
   // TODO: getAllowedNSSAI
 
   void setGUAMI(
-      const PlmnId& m_plmnId, const AMFRegionID& m_aMFRegionID,
-      const AMFSetID& m_aMFSetID, const AMFPointer& m_aMFPointer);
+      const PlmnId& plmnId, const AMFRegionID& aMFRegionID,
+      const AMFSetID& aMFSetID, const AMFPointer& aMFPointer);
   void setGUAMI(
       const std::string& mcc, const std::string& mnc,
       const std::string& regionId, const std::string& setId,
@@ -108,12 +108,13 @@ class HandoverRequest : public NgapMessage {
   // New Security Context Indicator (TODO: Optional)
   // NASC - NAS-PDU (TODO: Optional)
   PDUSessionResourceSetupListHOReq pDUSessionResourceSetupList;  // Mandatory
-  Ngap_AllowedNSSAI_t allowedNSSAI;                              // Mandatory
+  Ngap_AllowedNSSAI_t allowedNSSAI;  // TODO: Mandatory
   // Trace Activation (TODO: Optional)
   // Masked IMEISV  (TODO: Optional)
   Ngap_SourceToTarget_TransparentContainer_t
-      SourceToTarget_TransparentContainer;           // TODO: Mandatory
-  MobilityRestrictionList* mobilityRestrictionList;  // Optional
+      SourceToTarget_TransparentContainer;  // TODO: Mandatory
+  std::optional<MobilityRestrictionList>
+      mobilityRestrictionList;  // TODO: Optional
   // Location Reporting Request Type (TODO: Optional)
   // RRC Inactive Transition Report Request (TODO: Optional)
   GUAMI guami;  // Mandatory