Update PDU Session Status

src/nas/common/Ie_Const.hpp

@@ -98,6 +98,7 @@ constexpr uint8_t kT3502Value = 0x16;
 
 constexpr uint8_t kEquivalentPlmns = 0x4A;
 
+constexpr uint8_t kIeiPduSessionStatus = 0x50;
 constexpr uint8_t kIei5gsUpdateType    = 0x53;
 constexpr uint8_t kT3346Value          = 0x5f;
 

src/nas/ies/PDUSessionStatus.cpp

@@ -23,80 +23,72 @@
 
 #include "3gpp_24.501.hpp"
 #include "common_defs.h"
+#include "Ie_Const.hpp"
 #include "logger.hpp"
 
 using namespace nas;
 
 //------------------------------------------------------------------------------
-PDUSessionStatus::PDUSessionStatus(uint8_t iei) {
-  _iei   = iei;
+PDUSessionStatus::PDUSessionStatus() : Type4NasIe(kIeiPduSessionStatus) {
   _value = 0;
-  length = 2;
+  SetLengthIndicator(2);
+  SetIeName(kPduSessionStatusIeName);
 }
 
 //------------------------------------------------------------------------------
-PDUSessionStatus::PDUSessionStatus(const uint8_t iei, uint16_t value) {
-  _iei   = iei;
+PDUSessionStatus::PDUSessionStatus(uint16_t value)
+    : Type4NasIe(kIeiPduSessionStatus) {
   _value = value;
-  length = 2;  // Lengh of IE contents
-}
-
-//------------------------------------------------------------------------------
-PDUSessionStatus::PDUSessionStatus() {
-  _iei   = 0;
-  _value = 0;
-  length = 2;
+  SetLengthIndicator(2);
+  SetIeName(kPduSessionStatusIeName);
 }
 
 //------------------------------------------------------------------------------
 PDUSessionStatus::~PDUSessionStatus() {}
 
 //------------------------------------------------------------------------------
-void PDUSessionStatus::setValue(uint8_t iei, uint16_t value) {
-  _iei   = iei;
+void PDUSessionStatus::SetValue(uint16_t value) {
   _value = value;
 }
 
 //------------------------------------------------------------------------------
-uint16_t PDUSessionStatus::getValue() {
+uint16_t PDUSessionStatus::GetValue() const {
   return _value;
 }
 
 //------------------------------------------------------------------------------
-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 PDUSessionStatus::Encode(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
 
   int encoded_size = 0;
-  if (_iei) {
-    ENCODE_U8(buf + encoded_size, _iei, encoded_size);
-  }
+  // IEI and Length
+  int encoded_header_size = Type4NasIe::Encode(buf + encoded_size, len);
+  if (encoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  encoded_size += encoded_header_size;
 
-  ENCODE_U8(buf + encoded_size, length, encoded_size);
+  // Value
   ENCODE_U16(buf + encoded_size, _value, encoded_size);
 
-  Logger::nas_mm().debug("Encoded PDUSessionStatus, len %d", encoded_size);
+  Logger::nas_mm().debug(
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int PDUSessionStatus::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("Decoding PDUSessionStatus");
+int PDUSessionStatus::Decode(uint8_t* buf, int len, bool is_iei) {
+  Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
 
   int decoded_size = 0;
-  if (is_option) {
-    DECODE_U8(buf + decoded_size, _iei, decoded_size);
-  }
-  DECODE_U8(buf + decoded_size, length, decoded_size);
+
+  // IEI and Length
+  int decoded_header_size = Type4NasIe::Decode(buf + decoded_size, len, is_iei);
+  if (decoded_header_size == KEncodeDecodeError) return KEncodeDecodeError;
+  decoded_size += decoded_header_size;
+
   DECODE_U16(buf + decoded_size, _value, decoded_size);
 
   Logger::nas_mm().debug(
-      "Decoded PDUSessionStatus value 0x%x, len %d", _value, decoded_size);
+      "Decoded %s, value 0x%x len %d", GetIeName().c_str(), _value,
+      decoded_size);
   return decoded_size;
 }

src/nas/ies/PDUSessionStatus.hpp

@@ -19,30 +19,31 @@
  *      contact@openairinterface.org
  */
 
-#ifndef __PDU_Session_Status_H_
-#define __PDU_Session_Status_H_
+#ifndef _PDU_SESSION_STATUS_H_
+#define _PDU_SESSION_STATUS_H_
 
+#include "Type4NasIe.hpp"
 #include <stdint.h>
 
 constexpr uint8_t kPduSessionStatusMinimumLength = 4;
 constexpr uint8_t kPduSessionStatusMaximumLength = 34;
+constexpr auto kPduSessionStatusIeName           = "PDU Session Status";
 
 namespace nas {
 
-class PDUSessionStatus {
+class PDUSessionStatus : Type4NasIe {
  public:
   PDUSessionStatus();
-  PDUSessionStatus(uint8_t iei);
-  PDUSessionStatus(const uint8_t iei, uint16_t value);
+  PDUSessionStatus(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);
-  uint16_t getValue();
+
+  void SetValue(uint16_t value);
+  uint16_t GetValue() const;
+
+  int Encode(uint8_t* buf, int len);
+  int Decode(uint8_t* buf, int len, bool is_iei);
 
  private:
-  uint8_t _iei;
-  uint8_t length;
   uint16_t _value;
   // TODO: spare
 };

src/nas/msgs/RegistrationAccept.cpp

@@ -170,7 +170,7 @@ void RegistrationAccept::set_5GS_Network_Feature_Support(
 
 //------------------------------------------------------------------------------
 void RegistrationAccept::setPDU_session_status(uint16_t value) {
-  ie_PDU_session_status = new PDUSessionStatus(0x50, value);
+  ie_PDU_session_status = new PDUSessionStatus(value);
 }
 
 //------------------------------------------------------------------------------
@@ -384,7 +384,7 @@ int RegistrationAccept::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_PDU_session_status) {
     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->Encode(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -713,10 +713,10 @@ int RegistrationAccept::decodeFromBuffer(uint8_t* buf, int len) {
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
-      case 0x50: {
+      case kIeiPduSessionStatus: {
         Logger::nas_mm().debug("Decoding IEI (0x50)");
         ie_PDU_session_status = new PDUSessionStatus();
-        decoded_size += ie_PDU_session_status->decodeFromBuffer(
+        decoded_size += ie_PDU_session_status->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);

src/nas/msgs/RegistrationRequest.cpp

@@ -306,13 +306,13 @@ bool RegistrationRequest::getUplinkDataStatus(uint16_t& value) {
 
 //------------------------------------------------------------------------------
 void RegistrationRequest::setPDUSessionStatus(uint16_t value) {
-  ie_PDU_session_status = std::make_optional<PDUSessionStatus>(0x50, value);
+  ie_PDU_session_status = std::make_optional<PDUSessionStatus>(value);
 }
 
 //------------------------------------------------------------------------------
 uint16_t RegistrationRequest::getPduSessionStatus() {
   if (ie_PDU_session_status.has_value()) {
-    return ie_PDU_session_status.value().getValue();
+    return ie_PDU_session_status.value().GetValue();
   } else {
     return 0;
   }
@@ -660,7 +660,7 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
   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.value().encode2Buffer(
+    if (int size = ie_PDU_session_status.value().Encode(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -965,10 +965,10 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
 
       } break;
-      case 0x50: {
-        Logger::nas_mm().debug("Decoding IEI (0x50)");
+      case kIeiPduSessionStatus: {
+        Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiPduSessionStatus);
         PDUSessionStatus ie_PDU_session_status_tmp;
-        decoded_size += ie_PDU_session_status_tmp.decodeFromBuffer(
+        decoded_size += ie_PDU_session_status_tmp.Decode(
             buf + decoded_size, len - decoded_size, true);
         ie_PDU_session_status =
             std::optional<PDUSessionStatus>(ie_PDU_session_status_tmp);

src/nas/msgs/RegistrationRequest.hpp

@@ -157,8 +157,8 @@ class RegistrationRequest : public NasMmPlainHeader {
   std::optional<_5GSTrackingAreaIdentity>
       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
   std::optional<MICOIndication> ie_MICO_indication;       // Optional
   std::optional<UEStatus> ie_ue_status;                   // 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 PDUSessionStatus(0x50, value);
+  ie_PDU_session_status = new PDUSessionStatus(value);
 }
 
 //------------------------------------------------------------------------------
@@ -71,8 +71,8 @@ int ServiceAccept::encode2Buffer(uint8_t* buf, int len) {
   if (!(plain_header->encode2Buffer(buf, len))) return -1;
   encoded_size += 3;
   if (ie_PDU_session_status)
-    encoded_size += ie_PDU_session_status->encode2Buffer(
-        buf + encoded_size, len - encoded_size);
+    encoded_size +=
+        ie_PDU_session_status->Encode(buf + encoded_size, len - encoded_size);
   if (ie_session_reactivation_result)
     encoded_size += ie_session_reactivation_result->encode2Buffer(
         buf + encoded_size, len - encoded_size);

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 PDUSessionStatus(0x50, value);
+  ie_PDU_session_status = new PDUSessionStatus(value);
 }
 
 //------------------------------------------------------------------------------
@@ -150,8 +150,8 @@ int ServiceRequest::encode2Buffer(uint8_t* buf, int len) {
   if (!ie_PDU_session_status) {
     Logger::nas_mm().warn("IE ie_PDU_session_status is not available");
   } else {
-    size = ie_PDU_session_status->encode2Buffer(
-        buf + encoded_size, len - encoded_size);
+    size =
+        ie_PDU_session_status->Encode(buf + encoded_size, len - encoded_size);
     if (size != 0) {
       encoded_size += size;
     } else {
@@ -215,10 +215,11 @@ int ServiceRequest::decodeFromBuffer(
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
-      case 0x50: {
-        Logger::nas_mm().debug("Decoding ie_PDU_session_status (IEI: 0x50)");
+      case kIeiPduSessionStatus: {
+        Logger::nas_mm().debug(
+            "Decoding ie_PDU_session_status (IEI 0x%x)", kIeiPduSessionStatus);
         ie_PDU_session_status = new PDUSessionStatus();
-        decoded_size += ie_PDU_session_status->decodeFromBuffer(
+        decoded_size += ie_PDU_session_status->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
@@ -270,7 +271,7 @@ uint16_t ServiceRequest::getUplinkDataStatus() {
 //------------------------------------------------------------------------------
 uint16_t ServiceRequest::getPduSessionStatus() {
   if (ie_PDU_session_status) {
-    return ie_PDU_session_status->getValue();
+    return ie_PDU_session_status->GetValue();
   } else {
     return 0;
   }