Code refactor for PDUSessionStaus

src/nas/common/NasIeHeader.hpp

@@ -20,6 +20,7 @@
  */
 
 #include "../ies/5GSMobileIdentity.hpp"
+#include "../ies/PDUSessionStatus.hpp"
 #include "NasMmPlainHeader.hpp"
 #include "5GMMCapability.hpp"
 #include "5GSRegistrationType.hpp"
@@ -53,7 +54,6 @@
 #include "PDU_Session_Identity_2.hpp"
 #include "PDU_Session_Reactivation_Result.hpp"
 #include "PDU_Session_Reactivation_Result_Error_Cause.hpp"
-#include "PDU_Session_Status.hpp"
 #include "PLMN_List.hpp"
 #include "Payload_Container.hpp"
 #include "Payload_Container_Type.hpp"

src/nas/ies/MICO_Indication.hpp

@@ -19,13 +19,6 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #ifndef _MICO_Indication_H
 #define _MICO_Indication_H
 

src/nas/ies/PDU_Session_Status.cpp → src/nas/ies/PDUSessionStatus.cpp

@@ -19,93 +19,84 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "PDU_Session_Status.hpp"
+#include "PDUSessionStatus.hpp"
 
+#include "3gpp_24.501.hpp"
 #include "common_defs.h"
 #include "logger.hpp"
+
 using namespace nas;
 
 //------------------------------------------------------------------------------
-PDU_Session_Status::PDU_Session_Status(uint8_t iei) {
+PDUSessionStatus::PDUSessionStatus(uint8_t iei) {
   _iei   = iei;
   _value = 0;
-  length = 0;
+  length = 2;
 }
 
 //------------------------------------------------------------------------------
-PDU_Session_Status::PDU_Session_Status(const uint8_t iei, uint16_t value) {
+PDUSessionStatus::PDUSessionStatus(const uint8_t iei, uint16_t value) {
   _iei   = iei;
   _value = value;
-  length = 4;
+  length = 2;  // Lengh of IE contents
 }
 
 //------------------------------------------------------------------------------
-PDU_Session_Status::PDU_Session_Status() {
+PDUSessionStatus::PDUSessionStatus() {
   _iei   = 0;
   _value = 0;
-  length = 0;
+  length = 2;
 }
 
 //------------------------------------------------------------------------------
-PDU_Session_Status::~PDU_Session_Status() {}
+PDUSessionStatus::~PDUSessionStatus() {}
 
 //------------------------------------------------------------------------------
-void PDU_Session_Status::setValue(uint8_t iei, uint16_t value) {
+void PDUSessionStatus::setValue(uint8_t iei, uint16_t value) {
   _iei   = iei;
   _value = value;
 }
 
 //------------------------------------------------------------------------------
-uint16_t PDU_Session_Status::getValue() {
+uint16_t PDUSessionStatus::getValue() {
   return _value;
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Status::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("encoding PDU_Session_Status iei(0x%x)", _iei);
-  if (len < length) {
-    Logger::nas_mm().error("len is less than %d", length);
-    return 0;
+int PDUSessionStatus::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding PDUSessionStatus");
+
+  if ((len < kPduSessionStatusMinimumLength) or (len < length + 2)) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kPduSessionStatusMinimumLength);
+    return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
   if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) = length - 2;
-    encoded_size++;
-    *(buf + encoded_size) = (_value & 0x00ff);
-    encoded_size++;
-    *(buf + encoded_size) = (_value & 0xff00) >> 8;
-    encoded_size++;
-  } else {
-    //*(buf + encoded_size) = length - 1; encoded_size++;
-    //*(buf + encoded_size) = _value; encoded_size++; encoded_size++;
+    ENCODE_U8(buf + encoded_size, _iei, encoded_size);
   }
-  Logger::nas_mm().debug("encoded PDU_Session_Status len(%d)", encoded_size);
+
+  ENCODE_U8(buf + encoded_size, length, encoded_size);
+  ENCODE_U16(buf + encoded_size, _value, encoded_size);
+
+  Logger::nas_mm().debug("Encoded PDUSessionStatus, len %d", encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Status::decodeFromBuffer(
-    uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding PDU_Session_Status iei(0x%x)", *buf);
+int PDUSessionStatus::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+  Logger::nas_mm().debug("Decoding PDUSessionStatus");
+
   int decoded_size = 0;
   if (is_option) {
-    decoded_size++;
+    DECODE_U8(buf + decoded_size, _iei, decoded_size);
   }
-
-  _value = 0x0000;
-  length = *(buf + decoded_size);
-  decoded_size++;
+  DECODE_U8(buf + decoded_size, length, decoded_size);
   DECODE_U16(buf + decoded_size, _value, decoded_size);
-  Logger::nas_mm().debug("decoded PDU_Session_Status value (0x%x)", _value);
-  Logger::nas_mm().debug("decoded PDU_Session_Status len(%d)", decoded_size);
+
+  Logger::nas_mm().debug(
+      "Decoded PDUSessionStatus value 0x%x, len %d", _value, decoded_size);
   return decoded_size;
 }

src/nas/ies/PDU_Session_Status.hpp → src/nas/ies/PDUSessionStatus.hpp

@@ -19,26 +19,22 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
 #ifndef __PDU_Session_Status_H_
 #define __PDU_Session_Status_H_
 
 #include <stdint.h>
 
+constexpr uint8_t kPduSessionStatusMinimumLength = 4;
+constexpr uint8_t kPduSessionStatusMaximumLength = 34;
+
 namespace nas {
 
-class PDU_Session_Status {
+class PDUSessionStatus {
  public:
-  PDU_Session_Status();
-  PDU_Session_Status(uint8_t iei);
-  PDU_Session_Status(const uint8_t iei, uint16_t value);
-  ~PDU_Session_Status();
+  PDUSessionStatus();
+  PDUSessionStatus(uint8_t iei);
+  PDUSessionStatus(const uint8_t iei, uint16_t value);
+  ~PDUSessionStatus();
   void setValue(uint8_t iei, uint16_t value);
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
@@ -48,6 +44,7 @@ class PDU_Session_Status {
   uint8_t _iei;
   uint8_t length;
   uint16_t _value;
+  // TODO: spare
 };
 
 }  // namespace nas

src/nas/msgs/RegistrationAccept.cpp

@@ -156,7 +156,7 @@ void RegistrationAccept::set_5GS_Network_Feature_Support(
 
 //------------------------------------------------------------------------------
 void RegistrationAccept::setPDU_session_status(uint16_t value) {
-  ie_PDU_session_status = new PDU_Session_Status(0x50, value);
+  ie_PDU_session_status = new PDUSessionStatus(0x50, value);
 }
 
 //------------------------------------------------------------------------------
@@ -702,7 +702,7 @@ int RegistrationAccept::decodeFromBuffer(
       } break;
       case 0x50: {
         Logger::nas_mm().debug("Decoding IEI (0x50)");
-        ie_PDU_session_status = new PDU_Session_Status();
+        ie_PDU_session_status = new PDUSessionStatus();
         decoded_size += ie_PDU_session_status->decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);

src/nas/msgs/RegistrationAccept.hpp

@@ -93,7 +93,7 @@ class RegistrationAccept {
   Rejected_NSSAI* ie_rejected_nssai;
   NSSAI* ie_configured_nssai;
   _5GS_Network_Feature_Support* ie_5gs_network_feature_support;
-  PDU_Session_Status* ie_PDU_session_status;
+  PDUSessionStatus* ie_PDU_session_status;
   PDU_Session_Reactivation_Result* ie_pdu_session_reactivation_result;
   PDU_Session_Reactivation_Result_Error_Cause*
       ie_pdu_session_reactivation_result_error_cause;

src/nas/msgs/RegistrationRequest.cpp

@@ -37,7 +37,7 @@ RegistrationRequest::RegistrationRequest()
   ie_s1_ue_network_capability    = std::nullopt;
   ie_uplink_data_status          = std::nullopt;
   ie_last_visited_registered_TAI = std::nullopt;
-  ie_PDU_session_status          = nullptr;
+  ie_PDU_session_status          = std::nullopt;
   ie_MICO_indicationl            = nullptr;
   ie_ue_status                   = nullptr;
   ie_additional_guti             = nullptr;
@@ -310,13 +310,13 @@ bool RegistrationRequest::getUplinkDataStatus(uint16_t& value) {
 
 //------------------------------------------------------------------------------
 void RegistrationRequest::setPDU_session_status(uint16_t value) {
-  ie_PDU_session_status = new PDU_Session_Status(0x50, value);
+  ie_PDU_session_status = std::make_optional<PDUSessionStatus>(0x50, value);
 }
 
 //------------------------------------------------------------------------------
 uint16_t RegistrationRequest::getPduSessionStatus() {
-  if (ie_PDU_session_status) {
-    return ie_PDU_session_status->getValue();
+  if (ie_PDU_session_status.has_value()) {
+    return ie_PDU_session_status.value().getValue();
   } else {
     return 0;
   }
@@ -329,7 +329,7 @@ void RegistrationRequest::setMICO_Indication(bool sprti, bool raai) {
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getMicoIndication(uint8_t& sprti, uint8_t& raai) {
-  if (ie_PDU_session_status) {
+  if (ie_PDU_session_status.has_value()) {
     sprti = ie_MICO_indicationl->getSPRTI();
     raai  = ie_MICO_indicationl->getRAAI();
     return true;
@@ -658,10 +658,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
       return 0;
     }
   }
-  if (!ie_PDU_session_status) {
+  if (!ie_PDU_session_status.has_value()) {
     Logger::nas_mm().warn("IE ie_PDU_session_status is not available");
   } else {
-    if (int size = ie_PDU_session_status->encode2Buffer(
+    if (int size = ie_PDU_session_status.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -960,9 +960,11 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
       } break;
       case 0x50: {
         Logger::nas_mm().debug("Decoding IEI (0x50)");
-        ie_PDU_session_status = new PDU_Session_Status();
-        decoded_size += ie_PDU_session_status->decodeFromBuffer(
+        PDUSessionStatus ie_PDU_session_status_tmp;
+        decoded_size += ie_PDU_session_status_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_PDU_session_status =
+            std::optional<PDUSessionStatus>(ie_PDU_session_status_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;

src/nas/msgs/RegistrationRequest.hpp

@@ -160,8 +160,8 @@ class RegistrationRequest : public NasMmPlainHeader {
       ie_last_visited_registered_TAI;                              // Optional
   std::optional<UENetworkCapability> ie_s1_ue_network_capability;  // Optional
   std::optional<UplinkDataStatus> ie_uplink_data_status;           // Optional
+  std::optional<PDUSessionStatus> ie_PDU_session_status;           // Optional
 
-  PDU_Session_Status* ie_PDU_session_status;                  // Optional
   MICO_Indication* ie_MICO_indicationl;                       // Optional
   UE_Status* ie_ue_status;                                    // Optional
   _5GSMobileIdentity* ie_additional_guti;                     // Optional

src/nas/msgs/ServiceAccept.cpp

@@ -52,7 +52,7 @@ void ServiceAccept::setHeader(uint8_t security_header_type) {
 
 //------------------------------------------------------------------------------
 void ServiceAccept::setPDU_session_status(uint16_t value) {
-  ie_PDU_session_status = new PDU_Session_Status(0x50, value);
+  ie_PDU_session_status = new PDUSessionStatus(0x50, value);
 }
 
 //------------------------------------------------------------------------------

src/nas/msgs/ServiceAccept.hpp

@@ -50,7 +50,7 @@ class ServiceAccept {
 
  private:
   NasMmPlainHeader* plain_header;
-  PDU_Session_Status* ie_PDU_session_status;
+  PDUSessionStatus* ie_PDU_session_status;
   PDU_Session_Reactivation_Result* ie_session_reactivation_result;
 };
 

src/nas/msgs/ServiceRequest.cpp

@@ -79,7 +79,7 @@ void ServiceRequest::setUplink_data_status(uint16_t value) {
 
 //------------------------------------------------------------------------------
 void ServiceRequest::setPDU_session_status(uint16_t value) {
-  ie_PDU_session_status = new PDU_Session_Status(0x50, value);
+  ie_PDU_session_status = new PDUSessionStatus(0x50, value);
 }
 
 //------------------------------------------------------------------------------
@@ -216,7 +216,7 @@ int ServiceRequest::decodeFromBuffer(
       } break;
       case 0x50: {
         Logger::nas_mm().debug("Decoding ie_PDU_session_status (IEI: 0x50)");
-        ie_PDU_session_status = new PDU_Session_Status();
+        ie_PDU_session_status = new PDUSessionStatus();
         decoded_size += ie_PDU_session_status->decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);

src/nas/msgs/ServiceRequest.hpp

@@ -70,7 +70,7 @@ class ServiceRequest {
   ServiceType* ie_service_type;
   _5GSMobileIdentity* ie_5g_s_tmsi;
   UplinkDataStatus* ie_uplink_data_status;
-  PDU_Session_Status* ie_PDU_session_status;
+  PDUSessionStatus* ie_PDU_session_status;
   Allowed_PDU_Session_Status* ie_allowed_PDU_session_status;
   NAS_Message_Container* ie_nas_message_container;
 };