Code refactor for PduSessionResourceSetupRequest

src/ngap/ngapIEs/NAS-PDU.cpp

@@ -25,19 +25,13 @@
 namespace ngap {
 
 //------------------------------------------------------------------------------
-NAS_PDU::NAS_PDU() {
-  // buffer_ = nullptr;
-  // size_   = -1;
-  pdu_.buf  = nullptr;
-  pdu_.size = -1;
-}
+NAS_PDU::NAS_PDU() {}
 
 //------------------------------------------------------------------------------
 NAS_PDU::~NAS_PDU() {}
 
 //------------------------------------------------------------------------------
 bool NAS_PDU::encode(Ngap_NAS_PDU_t& nas_pdu) {
-  if (!pdu_.buf) return false;
   return conv::bstring_2_octet_string(pdu_bstring, nas_pdu);
 }
 

src/ngap/ngapIEs/NAS-PDU.hpp

@@ -50,7 +50,6 @@ class NAS_PDU {
   bool set(const NAS_PDU& nas_pdu);
 
  private:
-  OCTET_STRING_t pdu_;
   bstring pdu_bstring;
 };
 

src/ngap/ngapIEs/PDUSessionResourceSetupItemSUReq.cpp

@@ -29,74 +29,82 @@ namespace ngap {
 
 //------------------------------------------------------------------------------
 PDUSessionResourceSetupItemSUReq::PDUSessionResourceSetupItemSUReq() {
-  nAS_PDU = nullptr;
+  nas_pdu_ = std::nullopt;
 }
 
 //------------------------------------------------------------------------------
 PDUSessionResourceSetupItemSUReq::~PDUSessionResourceSetupItemSUReq() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceSetupItemSUReq::setPDUSessionResourceSetupItemSUReq(
-    const PDUSessionID& m_pDUSessionID, NAS_PDU* m_nAS_PDU,
-    const S_NSSAI& m_s_NSSAI,
-    const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
-  pDUSessionID = m_pDUSessionID;
-  nAS_PDU      = m_nAS_PDU;
-  s_NSSAI      = m_s_NSSAI;
-  pDUSessionResourceSetupRequestTransfer =
-      m_pDUSessionResourceSetupRequestTransfer;
+void PDUSessionResourceSetupItemSUReq::set(
+    const PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
+    const S_NSSAI& s_nssai,
+    const OCTET_STRING_t& pdu_session_resource_setup_request_transfer) {
+  pdu_session_id_ = pdu_session_id;
+  nas_pdu_        = nas_pdu;
+  s_nssai_        = s_nssai;
+  pdu_session_resource_setup_request_transfer_ =
+      pdu_session_resource_setup_request_transfer;
 }
 
 //------------------------------------------------------------------------------
-void PDUSessionResourceSetupItemSUReq::getPDUSessionResourceSetupItemSUReq(
-    PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI& m_s_NSSAI,
-    OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer) {
-  m_pDUSessionID = pDUSessionID;
-  m_nAS_PDU      = nAS_PDU;
-  m_s_NSSAI      = s_NSSAI;
-  m_pDUSessionResourceSetupRequestTransfer =
-      pDUSessionResourceSetupRequestTransfer;
+void PDUSessionResourceSetupItemSUReq::get(
+    PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
+    S_NSSAI& s_nssai,
+    OCTET_STRING_t& pdu_session_resource_setup_request_transfer) {
+  pdu_session_id = pdu_session_id_;
+  nas_pdu        = nas_pdu_;
+  s_nssai        = s_nssai_;
+  pdu_session_resource_setup_request_transfer =
+      pdu_session_resource_setup_request_transfer_;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceSetupItemSUReq::encode2PDUSessionResourceSetupItemSUReq(
-    Ngap_PDUSessionResourceSetupItemSUReq_t* pduSessionResourceSetupItemSUReq) {
-  if (!pDUSessionID.encode(pduSessionResourceSetupItemSUReq->pDUSessionID))
+bool PDUSessionResourceSetupItemSUReq::encode(
+    Ngap_PDUSessionResourceSetupItemSUReq_t*
+        pdu_session_resource_setup_item_su_req) {
+  if (!pdu_session_id_.encode(
+          pdu_session_resource_setup_item_su_req->pDUSessionID))
     return false;
-  if (nAS_PDU) {
+  if (nas_pdu_.has_value()) {
     Ngap_NAS_PDU_t* naspdu =
         (Ngap_NAS_PDU_t*) calloc(1, sizeof(Ngap_NAS_PDU_t));
     if (!naspdu) return false;
-    if (!nAS_PDU->encode(*naspdu)) {
+    if (!nas_pdu_.value().encode(*naspdu)) {
       free_wrapper((void**) &naspdu);
       return false;
     }
-    pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU = naspdu;
+    pdu_session_resource_setup_item_su_req->pDUSessionNAS_PDU = naspdu;
   }
-  if (!s_NSSAI.encode(&pduSessionResourceSetupItemSUReq->s_NSSAI)) return false;
-  pduSessionResourceSetupItemSUReq->pDUSessionResourceSetupRequestTransfer =
-      pDUSessionResourceSetupRequestTransfer;
+  if (!s_nssai_.encode(&pdu_session_resource_setup_item_su_req->s_NSSAI))
+    return false;
+  pdu_session_resource_setup_item_su_req
+      ->pDUSessionResourceSetupRequestTransfer =
+      pdu_session_resource_setup_request_transfer_;
 
   return true;
 }
 
 //------------------------------------------------------------------------------
-bool PDUSessionResourceSetupItemSUReq::
-    decodefromPDUSessionResourceSetupItemSUReq(
-        Ngap_PDUSessionResourceSetupItemSUReq_t*
-            pduSessionResourceSetupItemSUReq) {
-  if (!pDUSessionID.decode(pduSessionResourceSetupItemSUReq->pDUSessionID))
+bool PDUSessionResourceSetupItemSUReq::decode(
+    Ngap_PDUSessionResourceSetupItemSUReq_t*
+        pdu_session_resource_setup_item_su_req) {
+  if (!pdu_session_id_.decode(
+          pdu_session_resource_setup_item_su_req->pDUSessionID))
+    return false;
+  if (!s_nssai_.decode(&pdu_session_resource_setup_item_su_req->s_NSSAI))
     return false;
-  if (!s_NSSAI.decode(&pduSessionResourceSetupItemSUReq->s_NSSAI)) return false;
 
-  if (pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU) {
-    nAS_PDU = new NAS_PDU();
-    if (!nAS_PDU->decode(*pduSessionResourceSetupItemSUReq->pDUSessionNAS_PDU))
+  if (pdu_session_resource_setup_item_su_req->pDUSessionNAS_PDU) {
+    NAS_PDU tmp = {};
+    if (!tmp.decode(*pdu_session_resource_setup_item_su_req->pDUSessionNAS_PDU))
       return false;
+    nas_pdu_ = std::optional<NAS_PDU>(tmp);
   }
 
-  pDUSessionResourceSetupRequestTransfer =
-      pduSessionResourceSetupItemSUReq->pDUSessionResourceSetupRequestTransfer;
+  pdu_session_resource_setup_request_transfer_ =
+      pdu_session_resource_setup_item_su_req
+          ->pDUSessionResourceSetupRequestTransfer;
 
   return true;
 }

src/ngap/ngapIEs/PDUSessionResourceSetupItemSUReq.hpp

@@ -26,6 +26,8 @@
 #include "PDUSessionID.hpp"
 #include "S-NSSAI.hpp"
 
+#include <optional>
+
 extern "C" {
 #include "Ngap_PDUSessionResourceSetupItemSUReq.h"
 }
@@ -37,27 +39,25 @@ class PDUSessionResourceSetupItemSUReq {
   PDUSessionResourceSetupItemSUReq();
   virtual ~PDUSessionResourceSetupItemSUReq();
 
-  void setPDUSessionResourceSetupItemSUReq(
-      const PDUSessionID& m_pDUSessionID, NAS_PDU* m_nAS_PDU,
-      const S_NSSAI& m_s_NSSAI,
-      const OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
-  void getPDUSessionResourceSetupItemSUReq(
-      PDUSessionID& m_pDUSessionID, NAS_PDU*& m_nAS_PDU, S_NSSAI& m_s_NSSAI,
-      OCTET_STRING_t& m_pDUSessionResourceSetupRequestTransfer);
+  void set(
+      const PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
+      const S_NSSAI& s_nssai,
+      const OCTET_STRING_t& pdu_session_resource_setup_request_transfer);
+  void get(
+      PDUSessionID& pdu_session_id, std::optional<NAS_PDU>& nas_pdu,
+      S_NSSAI& s_nssai,
+      OCTET_STRING_t& pdu_session_resource_setup_request_transfer);
 
-  bool encode2PDUSessionResourceSetupItemSUReq(
-      Ngap_PDUSessionResourceSetupItemSUReq_t*
-          pduSessionResourceSetupItemSUReq);
-  bool decodefromPDUSessionResourceSetupItemSUReq(
-      Ngap_PDUSessionResourceSetupItemSUReq_t*
-          pduSessionResourceSetupItemSUReq);
+  bool encode(Ngap_PDUSessionResourceSetupItemSUReq_t*
+                  pdu_session_resource_setup_item_su_req);
+  bool decode(Ngap_PDUSessionResourceSetupItemSUReq_t*
+                  pdu_session_resource_setup_item_su_req);
 
  private:
-  PDUSessionID pDUSessionID;                              // Mandatory
-  NAS_PDU* nAS_PDU;                                       // Optional
-  S_NSSAI s_NSSAI;                                        // Mandatory
-  OCTET_STRING_t pDUSessionResourceSetupRequestTransfer;  // Mandatory
-  // TODO: UE Aggregate Maximum Bit Rate (Optional)
+  PDUSessionID pdu_session_id_;                                 // Mandatory
+  std::optional<NAS_PDU> nas_pdu_;                              // Optional
+  S_NSSAI s_nssai_;                                             // Mandatory
+  OCTET_STRING_t pdu_session_resource_setup_request_transfer_;  // Mandatory
 };
 
 }  // namespace ngap

src/ngap/ngapIEs/PDUSessionResourceSetupListSUReq.cpp

@@ -49,7 +49,7 @@ bool PDUSessionResourceSetupListSUReq::encode2PDUSessionResourceSetupListSUReq(
         (Ngap_PDUSessionResourceSetupItemSUReq_t*) calloc(
             1, sizeof(Ngap_PDUSessionResourceSetupItemSUReq_t));
     if (!request) return false;
-    if (!item.encode2PDUSessionResourceSetupItemSUReq(request)) return false;
+    if (!item.encode(request)) return false;
     if (ASN_SEQUENCE_ADD(&pduSessionResourceSetupListSUReq->list, request) != 0)
       return false;
   }
@@ -64,8 +64,7 @@ bool PDUSessionResourceSetupListSUReq::
             pduSessionResourceSetupListSUReq) {
   for (int i = 0; i < pduSessionResourceSetupListSUReq->list.count; i++) {
     PDUSessionResourceSetupItemSUReq item = {};
-    if (!item.decodefromPDUSessionResourceSetupItemSUReq(
-            pduSessionResourceSetupListSUReq->list.array[i]))
+    if (!item.decode(pduSessionResourceSetupListSUReq->list.array[i]))
       return false;
     itemSUReqList.push_back(item);
   }

src/ngap/ngapMsgs/PduSessionResourceModifyRequest.cpp

@@ -101,7 +101,7 @@ void PduSessionResourceModifyRequestMsg::setRanUeNgapId(
 
 //------------------------------------------------------------------------------
 void PduSessionResourceModifyRequestMsg::setRanPagingPriority(
-    const uint8_t& priority) {
+    const uint32_t& priority) {
   if (!ranPagingPriority) ranPagingPriority = new RANPagingPriority();
 
   ranPagingPriority->set(priority);

src/ngap/ngapMsgs/PduSessionResourceModifyRequest.hpp

@@ -43,7 +43,7 @@ class PduSessionResourceModifyRequestMsg : public NgapUEMessage {
   void setRanUeNgapId(const uint32_t& id) override;
   bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
 
-  void setRanPagingPriority(const uint8_t& priority);
+  void setRanPagingPriority(const uint32_t& priority);
   int getRanPagingPriority();
 
   void setNasPdu(const bstring& pdu);

src/ngap/ngapMsgs/PduSessionResourceReleaseCommand.cpp

@@ -103,7 +103,7 @@ void PduSessionResourceReleaseCommandMsg::setRanUeNgapId(
 
 //------------------------------------------------------------------------------
 void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
-    const uint8_t& priority) {
+    const uint32_t& priority) {
   RANPagingPriority tmp = {};
   tmp.set(priority);
   ranPagingPriority = std::optional<RANPagingPriority>(tmp);
@@ -131,7 +131,7 @@ void PduSessionResourceReleaseCommandMsg::setRanPagingPriority(
 
 //------------------------------------------------------------------------------
 bool PduSessionResourceReleaseCommandMsg::getRanPagingPriority(
-    uint8_t& priority) {
+    uint32_t& priority) {
   if (!ranPagingPriority.has_value()) return false;
   priority = ranPagingPriority.value().get();
   return true;

src/ngap/ngapMsgs/PduSessionResourceReleaseCommand.hpp

@@ -43,8 +43,8 @@ class PduSessionResourceReleaseCommandMsg : public NgapUEMessage {
   void setRanUeNgapId(const uint32_t& id) override;
   bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
 
-  void setRanPagingPriority(const uint8_t& priority);
-  bool getRanPagingPriority(uint8_t& priority);
+  void setRanPagingPriority(const uint32_t& priority);
+  bool getRanPagingPriority(uint32_t& priority);
 
   void setNasPdu(const bstring& pdu);
   bool getNasPdu(bstring& pdu);

src/ngap/ngapMsgs/PduSessionResourceSetupRequest.hpp

@@ -27,6 +27,8 @@
 #include "UEAggregateMaxBitRate.hpp"
 #include "NgapUEMessage.hpp"
 
+#include <optional>
+
 extern "C" {
 #include "Ngap_InitialContextSetupRequest.h"
 }
@@ -44,8 +46,8 @@ class PduSessionResourceSetupRequestMsg : public NgapUEMessage {
   void setRanUeNgapId(const uint32_t& id) override;
   bool decodeFromPdu(Ngap_NGAP_PDU_t* ngapMsgPdu) override;
 
-  void setRanPagingPriority(const uint8_t& priority);
-  int getRanPagingPriority();
+  void setRanPagingPriority(const uint32_t& priority);
+  bool getRanPagingPriority(uint32_t& priority);
 
   void setNasPdu(const bstring& pdu);
   bool getNasPdu(bstring& pdu);
@@ -56,17 +58,18 @@ class PduSessionResourceSetupRequestMsg : public NgapUEMessage {
       std::vector<PDUSessionResourceSetupRequestItem_t>& list);
 
   void setUEAggregateMaxBitRate(
-      const long& bit_rate_downlink, const long& bit_rate_uplink);
-  void getUEAggregateMaxBitRate(long& bit_rate_downlink, long& bit_rate_uplink);
+      const uint64_t& bit_rate_downlink, const uint64_t& bit_rate_uplink);
+  bool getUEAggregateMaxBitRate(
+      uint64_t& bit_rate_downlink, uint64_t& bit_rate_uplink) const;
 
  private:
   Ngap_PDUSessionResourceSetupRequest_t* pduSessionResourceSetupRequestIEs;
 
-  RANPagingPriority* ranPagingPriority;  // Optional
-  NAS_PDU* nasPdu;                       // Optional
+  std::optional<RANPagingPriority> ranPagingPriority;  // Optional
+  std::optional<NAS_PDU> nasPdu;                       // Optional
   PDUSessionResourceSetupListSUReq
-      pduSessionResourceSetupRequestList;        // Mandatory
-  UEAggregateMaxBitRate* uEAggregateMaxBitRate;  // Optional
+      pduSessionResourceSetupRequestList;                      // Mandatory
+  std::optional<UEAggregateMaxBitRate> uEAggregateMaxBitRate;  // Optional
 };
 
 }  // namespace ngap