Code refactoring for PduSessionResourceModifyRequest

src/amf-app/amf_n2.cpp

@@ -1076,8 +1076,12 @@ void amf_n2::handle_itti_message(
 
   conv::bstring_2_octet_string(
       itti_msg.n2sm, item.pduSessionResourceModifyRequestTransfer);
-  item.s_nssai.sd  = itti_msg.s_NSSAI.getSd();
-  item.s_nssai.sst = itti_msg.s_NSSAI.getSst();
+  S_Nssai tmp  = {};
+  tmp.sd       = itti_msg.s_NSSAI.getSd();
+  tmp.sst      = itti_msg.s_NSSAI.getSst();
+  item.s_nssai = std::optional<S_Nssai>(tmp);
+  // item.s_nssai.sd  = itti_msg.s_NSSAI.getSd();
+  // item.s_nssai.sst = itti_msg.s_NSSAI.getSst();
 
   // TODO:
   uint8_t* nas_pdu = (uint8_t*) calloc(1, blength(itti_msg.nas) + 1);

src/ngap/ngapIEs/NgapIEsStruct.hpp

@@ -22,6 +22,7 @@
 #ifndef _NGAPIESSTRUCT_H_
 #define _NGAPIESSTRUCT_H_
 
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -117,7 +118,7 @@ typedef struct {
   uint8_t pduSessionId;
   uint8_t* pduSessionNAS_PDU;
   size_t sizeofpduSessionNAS_PDU;
-  S_Nssai s_nssai;
+  std::optional<S_Nssai> s_nssai;
   OCTET_STRING_t pduSessionResourceModifyRequestTransfer;
 } PDUSessionResourceModifyRequestItem_t;
 

src/ngap/ngapIEs/PDUSessionResourceModifyItemModReq.cpp

@@ -25,42 +25,44 @@ namespace ngap {
 
 //------------------------------------------------------------------------------
 PDUSessionResourceModifyItemModReq::PDUSessionResourceModifyItemModReq() {
-  nAS_PDU = nullptr;
-  s_NSSAI = nullptr;
+  nas_pdu_ = std::nullopt;
+  s_nssai_ = std::nullopt;
 }
 
 //------------------------------------------------------------------------------
 PDUSessionResourceModifyItemModReq::~PDUSessionResourceModifyItemModReq() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceModifyItemModReq::setPDUSessionResourceModifyItemModReq(
-    const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU,
-    const OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
-    const S_NSSAI& m_s_NSSAI) {
-  pDUSessionID     = m_pDUSessionID;
+void PDUSessionResourceModifyItemModReq::set(
+    const PDUSessionID& pdu_session_id, const std::optional<NAS_PDU>& nas_pdu,
+    const OCTET_STRING_t& pdu_session_resource_modify_request_transfer,
+    const std::optional<S_NSSAI>& s_nssai) {
+  pdu_session_id_ = pdu_session_id;
+  if (nas_pdu.has_value()) {
     uint8_t* nas_buf = nullptr;
     size_t nas_len   = 0;
-  m_nAS_PDU.get(nas_buf, nas_len);
-  if (!nAS_PDU) nAS_PDU = new NAS_PDU();
-  nAS_PDU->set(nas_buf, nas_len);
-  pDUSessionResourceModifyRequestTransfer =
-      m_pDUSessionResourceModifyRequestTransfer;
-  s_NSSAI->setSd(m_s_NSSAI.getSd());
-  s_NSSAI->setSst(m_s_NSSAI.getSst());
+    nas_pdu.value().get(nas_buf, nas_len);
+    NAS_PDU tmp = {};
+    tmp.set(nas_buf, nas_len);
+    nas_pdu_ = std::optional<NAS_PDU>(tmp);
+  }
+
+  pdu_session_resource_modify_request_transfer_ =
+      pdu_session_resource_modify_request_transfer;
+  s_nssai_ = s_nssai;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceModifyItemModReq::
-    encode2PDUSessionResourceModifyItemModReq(
+bool PDUSessionResourceModifyItemModReq::encode(
     Ngap_PDUSessionResourceModifyItemModReq_t&
         pduSessionResourceModifyItemModReq) {
-  if (!pDUSessionID.encode(pduSessionResourceModifyItemModReq.pDUSessionID))
+  if (!pdu_session_id_.encode(pduSessionResourceModifyItemModReq.pDUSessionID))
     return false;
-  if (nAS_PDU) {
+  if (nas_pdu_.has_value()) {
     pduSessionResourceModifyItemModReq.nAS_PDU =
         (Ngap_NAS_PDU_t*) calloc(1, sizeof(Ngap_NAS_PDU_t));
     if (!pduSessionResourceModifyItemModReq.nAS_PDU) return false;
-    if (!nAS_PDU->encode(*pduSessionResourceModifyItemModReq.nAS_PDU)) {
+    if (!nas_pdu_.value().encode(*pduSessionResourceModifyItemModReq.nAS_PDU)) {
       if (pduSessionResourceModifyItemModReq.nAS_PDU != nullptr)
         free(pduSessionResourceModifyItemModReq.nAS_PDU);
       return false;
@@ -68,26 +70,25 @@ bool PDUSessionResourceModifyItemModReq::
   }
 
   pduSessionResourceModifyItemModReq.pDUSessionResourceModifyRequestTransfer =
-      pDUSessionResourceModifyRequestTransfer;
+      pdu_session_resource_modify_request_transfer_;
 
   return true;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceModifyItemModReq::
-    decodefromPDUSessionResourceModifyItemModReq(
+bool PDUSessionResourceModifyItemModReq::decode(
     Ngap_PDUSessionResourceModifyItemModReq_t&
         pduSessionResourceModifyItemModReq) {
-  if (!pDUSessionID.decode(pduSessionResourceModifyItemModReq.pDUSessionID))
+  if (!pdu_session_id_.decode(pduSessionResourceModifyItemModReq.pDUSessionID))
     return false;
 
   if (pduSessionResourceModifyItemModReq.nAS_PDU) {
-    nAS_PDU = new NAS_PDU();
-    if (!nAS_PDU->decode(*pduSessionResourceModifyItemModReq.nAS_PDU))
-      return false;
+    NAS_PDU tmp = {};
+    if (!tmp.decode(*pduSessionResourceModifyItemModReq.nAS_PDU)) return false;
+    nas_pdu_ = std::optional<NAS_PDU>(tmp);
   }
 
-  pDUSessionResourceModifyRequestTransfer =
+  pdu_session_resource_modify_request_transfer_ =
       pduSessionResourceModifyItemModReq
           .pDUSessionResourceModifyRequestTransfer;
 
@@ -95,15 +96,24 @@ bool PDUSessionResourceModifyItemModReq::
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceModifyItemModReq::getPDUSessionResourceModifyItemModReq(
-    PDUSessionID& m_pDUSessionID, NAS_PDU& m_nAS_PDU,
-    OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
-    S_NSSAI& m_s_NSSAI) {
-  m_pDUSessionID = pDUSessionID;
-  m_nAS_PDU      = *nAS_PDU;
-  m_pDUSessionResourceModifyRequestTransfer =
-      pDUSessionResourceModifyRequestTransfer;
-  m_s_NSSAI = *s_NSSAI;
+void PDUSessionResourceModifyItemModReq::get(
+    PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
+    OCTET_STRING_t& pdu_session_resource_modify_request_transfer,
+    std::optional<S_NSSAI>& s_nssai) {
+  pdu_session_id = pdu_session_id_;
+  nas_pdu        = *nas_pdu_;
+  if (nas_pdu_.has_value()) {
+    NAS_PDU tmp      = {};
+    uint8_t* nas_buf = nullptr;
+    size_t nas_len   = 0;
+    nas_pdu_.value().get(nas_buf, nas_len);
+    tmp.set(nas_buf, nas_len);
+    nas_pdu = std::optional<NAS_PDU>(tmp);
+  }
+
+  pdu_session_resource_modify_request_transfer =
+      pdu_session_resource_modify_request_transfer_;
+  s_nssai = s_nssai_;
 }
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyItemModReq.hpp

@@ -26,6 +26,8 @@
 #include "PDUSessionID.hpp"
 #include "S-NSSAI.hpp"
 
+#include <optional>
+
 extern "C" {
 #include "Ngap_PDUSessionResourceModifyItemModReq.h"
 }
@@ -37,27 +39,25 @@ class PDUSessionResourceModifyItemModReq {
   PDUSessionResourceModifyItemModReq();
   virtual ~PDUSessionResourceModifyItemModReq();
 
-  void setPDUSessionResourceModifyItemModReq(
-      const PDUSessionID& m_pDUSessionID, const NAS_PDU& m_nAS_PDU,
-      const OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
-      const S_NSSAI& m_s_NSSAI);
-  void getPDUSessionResourceModifyItemModReq(
-      PDUSessionID& m_pDUSessionID, NAS_PDU& m_nAS_PDU,
-      OCTET_STRING_t& m_pDUSessionResourceModifyRequestTransfer,
-      S_NSSAI& m_s_NSSAI);
+  void set(
+      const PDUSessionID& pdu_session_id, const std::optional<NAS_PDU>& nas_pdu,
+      const OCTET_STRING_t& pdu_session_resource_modify_request_transfer,
+      const std::optional<S_NSSAI>& s_nssai);
+  void get(
+      PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
+      OCTET_STRING_t& pdu_session_resource_modify_request_transfer,
+      std::optional<S_NSSAI>& s_nssai);
 
-  bool encode2PDUSessionResourceModifyItemModReq(
-      Ngap_PDUSessionResourceModifyItemModReq_t&
+  bool encode(Ngap_PDUSessionResourceModifyItemModReq_t&
                   pduSessionResourceModifyItemModReq);
-  bool decodefromPDUSessionResourceModifyItemModReq(
-      Ngap_PDUSessionResourceModifyItemModReq_t&
+  bool decode(Ngap_PDUSessionResourceModifyItemModReq_t&
                   pduSessionResourceModifyItemModReq);
 
  private:
-  PDUSessionID pDUSessionID;                               // Mandatory
-  NAS_PDU* nAS_PDU;                                        // Optional
-  OCTET_STRING_t pDUSessionResourceModifyRequestTransfer;  // Mandatory
-  S_NSSAI* s_NSSAI;                                        // Optional
+  PDUSessionID pdu_session_id_;                                  // Mandatory
+  std::optional<NAS_PDU> nas_pdu_;                               // Optional
+  OCTET_STRING_t pdu_session_resource_modify_request_transfer_;  // Mandatory
+  std::optional<S_NSSAI> s_nssai_;                               // Optional
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyListModReq.cpp

@@ -21,9 +21,6 @@
 
 #include "PDUSessionResourceModifyListModReq.hpp"
 
-#include <iostream>
-using namespace std;
-
 namespace ngap {
 
 //------------------------------------------------------------------------------
@@ -33,26 +30,24 @@ PDUSessionResourceModifyListModReq::PDUSessionResourceModifyListModReq() {}
 PDUSessionResourceModifyListModReq::~PDUSessionResourceModifyListModReq() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceModifyListModReq::setPDUSessionResourceModifyListModReq(
-    const std::vector<PDUSessionResourceModifyItemModReq>&
-        m_pduSessionResourceModifyListModReq) {
-  pduSessionResourceModifyListModReq = m_pduSessionResourceModifyListModReq;
+void PDUSessionResourceModifyListModReq::set(
+    const std::vector<PDUSessionResourceModifyItemModReq>& list) {
+  item_list_ = list;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceModifyListModReq::
-    encode2PDUSessionResourceModifyListModReq(
+bool PDUSessionResourceModifyListModReq::encode(
     Ngap_PDUSessionResourceModifyListModReq_t&
-            m_pduSessionResourceModifyListModReq) {
-  for (auto pdu : pduSessionResourceModifyListModReq) {
-    Ngap_PDUSessionResourceModifyItemModReq_t* request =
+        pdu_session_resource_modify_list_mod_req) {
+  for (auto pdu : item_list_) {
+    Ngap_PDUSessionResourceModifyItemModReq_t* item =
         (Ngap_PDUSessionResourceModifyItemModReq_t*) calloc(
             1, sizeof(Ngap_PDUSessionResourceModifyItemModReq_t));
 
-    if (!request) return false;
-    if (!pdu.encode2PDUSessionResourceModifyItemModReq(*request)) return false;
-    if (ASN_SEQUENCE_ADD(&m_pduSessionResourceModifyListModReq.list, request) !=
-        0)
+    if (!item) return false;
+    if (!pdu.encode(*item)) return false;
+    if (ASN_SEQUENCE_ADD(
+            &pdu_session_resource_modify_list_mod_req.list, item) != 0)
       return false;
   }
 
@@ -60,31 +55,27 @@ bool PDUSessionResourceModifyListModReq::
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceModifyListModReq::
-    decodefromPDUSessionResourceModifyListModReq(
+bool PDUSessionResourceModifyListModReq::decode(
     Ngap_PDUSessionResourceModifyListModReq_t&
-            pduSessionResourceSetupListSUReq) {
-  uint32_t numberofPDUSessions = pduSessionResourceSetupListSUReq.list.count;
+        pdu_session_resource_modify_list_mod_req) {
+  uint32_t numberofPDUSessions =
+      pdu_session_resource_modify_list_mod_req.list.count;
 
   for (int i = 0; i < numberofPDUSessions; i++) {
-    PDUSessionResourceModifyItemModReq pduSessionResourceModifyItemModReq = {};
+    PDUSessionResourceModifyItemModReq item = {};
 
-    if (!pduSessionResourceModifyItemModReq
-             .decodefromPDUSessionResourceModifyItemModReq(
-                 *pduSessionResourceSetupListSUReq.list.array[i]))
+    if (!item.decode(*pdu_session_resource_modify_list_mod_req.list.array[i]))
       return false;
-    pduSessionResourceModifyListModReq.push_back(
-        pduSessionResourceModifyItemModReq);
+    item_list_.push_back(item);
   }
 
   return true;
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceModifyListModReq::getPDUSessionResourceModifyListModReq(
-    std::vector<PDUSessionResourceModifyItemModReq>&
-        m_pduSessionResourceModifyListModReq) {
-  m_pduSessionResourceModifyListModReq = pduSessionResourceModifyListModReq;
+void PDUSessionResourceModifyListModReq::get(
+    std::vector<PDUSessionResourceModifyItemModReq>& list) {
+  list = item_list_;
 }
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceModifyListModReq.hpp

@@ -36,22 +36,15 @@ class PDUSessionResourceModifyListModReq {
   PDUSessionResourceModifyListModReq();
   virtual ~PDUSessionResourceModifyListModReq();
 
-  void setPDUSessionResourceModifyListModReq(
-      const std::vector<PDUSessionResourceModifyItemModReq>&
-          m_pduSessionResourceModifyListModReq);
-  void getPDUSessionResourceModifyListModReq(
-      std::vector<PDUSessionResourceModifyItemModReq>&
-          m_pduSessionResourceModifyListModReq);
-  bool encode2PDUSessionResourceModifyListModReq(
-      Ngap_PDUSessionResourceModifyListModReq_t&
-          m_pduSessionResourceModifyListModReq);
-  bool decodefromPDUSessionResourceModifyListModReq(
-      Ngap_PDUSessionResourceModifyListModReq_t&
-          m_pduSessionResourceModifyListModReq);
+  void set(const std::vector<PDUSessionResourceModifyItemModReq>& list);
+  void get(std::vector<PDUSessionResourceModifyItemModReq>& list);
+  bool encode(Ngap_PDUSessionResourceModifyListModReq_t&
+                  pdu_session_resource_modify_list_mod_req);
+  bool decode(Ngap_PDUSessionResourceModifyListModReq_t&
+                  pdu_session_resource_modify_list_mod_req);
 
  private:
-  std::vector<PDUSessionResourceModifyItemModReq>
-      pduSessionResourceModifyListModReq;
+  std::vector<PDUSessionResourceModifyItemModReq> item_list_;
 };
 
 }  // namespace ngap

src/ngap/ngapMsgs/PduSessionResourceModifyRequest.cpp

@@ -144,20 +144,23 @@ void PduSessionResourceModifyRequestMsg::setPduSessionResourceModifyRequestList(
     if (list[i].pduSessionNAS_PDU) {
       nAS_PDU.set(list[i].pduSessionNAS_PDU, list[i].sizeofpduSessionNAS_PDU);
     }
-    S_NSSAI s_NSSAI = {};
-    s_NSSAI.setSd(list[i].s_nssai.sd);
-    s_NSSAI.setSst(list[i].s_nssai.sst);
+    std::optional<S_NSSAI> s_NSSAI = std::nullopt;
+    if (list[i].s_nssai.has_value()) {
+      S_NSSAI tmp = {};
+      tmp.setSd(list[i].s_nssai.value().sd);
+      tmp.setSst(list[i].s_nssai.value().sst);
+      s_NSSAI = std::optional<S_NSSAI>(tmp);
+    }
 
     PDUSessionResourceModifyItemModReq item = {};
 
-    item.setPDUSessionResourceModifyItemModReq(
+    item.set(
         pDUSessionID, nAS_PDU, list[i].pduSessionResourceModifyRequestTransfer,
         s_NSSAI);
     m_pduSessionResourceModifyItemModReq.push_back(item);
   }
 
-  pduSessionResourceModifyList.setPDUSessionResourceModifyListModReq(
-      m_pduSessionResourceModifyItemModReq);
+  pduSessionResourceModifyList.set(m_pduSessionResourceModifyItemModReq);
 
   Ngap_PDUSessionResourceModifyRequestIEs_t* ie =
       (Ngap_PDUSessionResourceModifyRequestIEs_t*) calloc(
@@ -167,8 +170,7 @@ void PduSessionResourceModifyRequestMsg::setPduSessionResourceModifyRequestList(
   ie->value.present =
       Ngap_PDUSessionResourceModifyRequestIEs__value_PR_PDUSessionResourceModifyListModReq;
 
-  int ret =
-      pduSessionResourceModifyList.encode2PDUSessionResourceModifyListModReq(
+  int ret = pduSessionResourceModifyList.encode(
       ie->value.choice.PDUSessionResourceModifyListModReq);
   if (!ret) {
     Logger::ngap().error(
@@ -190,26 +192,31 @@ bool PduSessionResourceModifyRequestMsg::getPduSessionResourceModifyRequestList(
   std::vector<PDUSessionResourceModifyItemModReq>
       m_pduSessionResourceModifyItemModReq;
   int num = 0;
-  pduSessionResourceModifyList.getPDUSessionResourceModifyListModReq(
-      m_pduSessionResourceModifyItemModReq);
+  pduSessionResourceModifyList.get(m_pduSessionResourceModifyItemModReq);
 
   for (int i = 0; i < m_pduSessionResourceModifyItemModReq.size(); i++) {
-    PDUSessionResourceModifyRequestItem_t request = {};
+    PDUSessionResourceModifyRequestItem_t request = {
+        .pduSessionNAS_PDU = nullptr, .sizeofpduSessionNAS_PDU = 0};
 
     PDUSessionID pDUSessionID      = {};
-    NAS_PDU nAS_PDU           = {};
-    S_NSSAI s_NSSAI           = {};
+    std::optional<NAS_PDU> nAS_PDU = std::nullopt;
+    std::optional<S_NSSAI> s_NSSAI = std::nullopt;
 
-    m_pduSessionResourceModifyItemModReq[i]
-        .getPDUSessionResourceModifyItemModReq(
-            pDUSessionID, nAS_PDU,
-            request.pduSessionResourceModifyRequestTransfer, s_NSSAI);
+    m_pduSessionResourceModifyItemModReq[i].get(
+        pDUSessionID, nAS_PDU, request.pduSessionResourceModifyRequestTransfer,
+        s_NSSAI);
 
     pDUSessionID.get(request.pduSessionId);
+    if (nAS_PDU.has_value())
+      nAS_PDU.value().get(
+          request.pduSessionNAS_PDU, request.sizeofpduSessionNAS_PDU);
+    if (s_NSSAI.has_value()) {
+      S_Nssai tmp = {};
+      s_NSSAI.value().getSd(tmp.sd);
+      s_NSSAI.value().getSst(tmp.sst);
+      request.s_nssai = std::optional<S_Nssai>(tmp);
+    }
 
-    nAS_PDU.get(request.pduSessionNAS_PDU, request.sizeofpduSessionNAS_PDU);
-    s_NSSAI.getSd(request.s_nssai.sd);
-    s_NSSAI.getSst(request.s_nssai.sst);
     list.push_back(request);
   }
 
@@ -304,10 +311,8 @@ bool PduSessionResourceModifyRequestMsg::decodeFromPdu(
             pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
                     ->value.present ==
                 Ngap_PDUSessionResourceModifyRequestIEs__value_PR_PDUSessionResourceModifyListModReq) {
-          if (!pduSessionResourceModifyList
-                   .decodefromPDUSessionResourceModifyListModReq(
-                       pduSessionResourceModifyRequestIEs->protocolIEs.list
-                           .array[i]
+          if (!pduSessionResourceModifyList.decode(
+                  pduSessionResourceModifyRequestIEs->protocolIEs.list.array[i]
                       ->value.choice.PDUSessionResourceModifyListModReq)) {
             Logger::ngap().error(
                 "Decoded NGAP PDUSessionResourceModifyListModReq IE error");