Update PDU Session Identity2

src/nas/common/NasIeHeader.hpp

@@ -52,7 +52,7 @@
 #include "NssaiInclusionMode.hpp"
 #include "NasKeySetIdentifier.hpp"
 #include "Non_3GPP_NW_Provided_Policies.hpp"
-#include "PDU_Session_Identity_2.hpp"
+#include "PduSessionIdentity2.hpp"
 #include "PDU_Session_Reactivation_Result.hpp"
 #include "PDU_Session_Reactivation_Result_Error_Cause.hpp"
 #include "PLMN_List.hpp"

src/nas/ies/PDU_Session_Identity_2.cpp → src/nas/ies/PduSessionIdentity2.cpp

@@ -19,84 +19,84 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "PDU_Session_Identity_2.hpp"
+#include "PduSessionIdentity2.hpp"
 
 #include "logger.hpp"
 using namespace nas;
 
 //------------------------------------------------------------------------------
-PDU_Session_Identity_2::PDU_Session_Identity_2(uint8_t iei) {
-  _iei   = iei;
+PduSessionIdentity2::PduSessionIdentity2(uint8_t iei) : Type3NasIe(iei) {
   _value = 0;
+  SetIeName(kPduSessionIdentity2IeName);
 }
 
 //------------------------------------------------------------------------------
-PDU_Session_Identity_2::PDU_Session_Identity_2(
-    const uint8_t iei, uint8_t value) {
-  _iei   = iei;
+PduSessionIdentity2::PduSessionIdentity2(const uint8_t iei, uint8_t value)
+    : Type3NasIe(iei) {
   _value = value;
+  SetIeName(kPduSessionIdentity2IeName);
 }
 
 //------------------------------------------------------------------------------
-PDU_Session_Identity_2::PDU_Session_Identity_2() {
-  _iei   = 0;
+PduSessionIdentity2::PduSessionIdentity2() : Type3NasIe() {
   _value = 0;
+  SetIeName(kPduSessionIdentity2IeName);
 }
 
 //------------------------------------------------------------------------------
-PDU_Session_Identity_2::~PDU_Session_Identity_2() {}
+PduSessionIdentity2::~PduSessionIdentity2() {}
 
 //------------------------------------------------------------------------------
-void PDU_Session_Identity_2::SetValue(uint8_t value) {
+void PduSessionIdentity2::SetValue(uint8_t value) {
   _value = value;
 }
 
 //------------------------------------------------------------------------------
-uint8_t PDU_Session_Identity_2::GetValue() {
+uint8_t PduSessionIdentity2::GetValue() {
   return _value;
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Identity_2::Encode(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("encoding PDU_Session_Identity_2 iei(0x%x)", _iei);
-  if (len < 2) {
-    Logger::nas_mm().error("len is less than 2");
-    return 0;
+int PduSessionIdentity2::Encode(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding %s", GetIeName().c_str());
+
+  if (len < kPduSessionIdentity2Length) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kPduSessionIdentity2Length);
+    return KEncodeDecodeError;
   }
   int encoded_size = 0;
-  if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) = _value;
-    encoded_size++;
-  } else {
-    //	*(buf + encoded_size) = length - 1; encoded_size++;
-    //	*(buf + encoded_size) = _value; encoded_size++; encoded_size++;
-  }
+
+  // IEI
+  encoded_size += Type3NasIe::Encode(buf + encoded_size, len);
+  // Value
+  ENCODE_U8(buf + encoded_size, _value, encoded_size);
+
   Logger::nas_mm().debug(
-      "encoded PDU_Session_Identity_2 len(%d)", encoded_size);
+      "Encoded %s, len (%d)", GetIeName().c_str(), encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int PDU_Session_Identity_2::Decode(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding PDU_Session_Identity_2 iei(0x%x)", *buf);
-  int decoded_size = 0;
-  if (is_option) {
-    decoded_size++;
+int PduSessionIdentity2::Decode(uint8_t* buf, int len, bool is_iei) {
+  Logger::nas_mm().debug("Decoding %s", GetIeName().c_str());
+
+  if (len < kPduSessionIdentity2Length) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kPduSessionIdentity2Length);
+    return KEncodeDecodeError;
   }
-  _value = 0x00;
-  _value = *(buf + decoded_size);
-  decoded_size++;
-  Logger::nas_mm().debug("decoded PDU_Session_Identity_2 value(0x%x)", _value);
+
+  int decoded_size = 0;
+  // IEI and Length
+  decoded_size += Type3NasIe::Decode(buf + decoded_size, len, true);
+
+  DECODE_U8(buf + decoded_size, _value, decoded_size);
+
+  Logger::nas_mm().debug("Decoded value 0x%x", _value);
   Logger::nas_mm().debug(
-      "decoded PDU_Session_Identity_2 len(%d)", decoded_size);
+      "Decoded %s, len (%d)", GetIeName().c_str(), decoded_size);
   return decoded_size;
 }

src/nas/ies/PDU_Session_Identity_2.hpp → src/nas/ies/PduSessionIdentity2.hpp

@@ -19,33 +19,28 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
+#ifndef _PDU_SESSION_IDENTITY_2_H_
+#define _PDU_SESSION_IDENTITY_2_H_
 
-#ifndef ___PDU_Session_Identity_2_H_
-#define ___PDU_Session_Identity_2_H_
+#include "Type3NasIe.hpp"
 
-#include <stdint.h>
+constexpr uint8_t kPduSessionIdentity2Length = 2;
+constexpr auto kPduSessionIdentity2IeName    = "PDU Session Identity 2";
 
 namespace nas {
 
-class PDU_Session_Identity_2 {
+class PduSessionIdentity2 : public Type3NasIe {
  public:
-  PDU_Session_Identity_2();
-  PDU_Session_Identity_2(uint8_t iei);
-  PDU_Session_Identity_2(const uint8_t iei, uint8_t value);
-  ~PDU_Session_Identity_2();
+  PduSessionIdentity2();
+  PduSessionIdentity2(uint8_t iei);
+  PduSessionIdentity2(const uint8_t iei, uint8_t value);
+  ~PduSessionIdentity2();
   int Encode(uint8_t* buf, int len);
   int Decode(uint8_t* buf, int len, bool is_option);
   void SetValue(uint8_t value);
   uint8_t GetValue();
 
  private:
-  uint8_t _iei;
   uint8_t _value;
 };
 }  // namespace nas

src/nas/msgs/DLNASTransport.cpp

@@ -74,7 +74,7 @@ void DLNASTransport::SetPayloadContainer(uint8_t* buf, int len) {
 
 //------------------------------------------------------------------------------
 void DLNASTransport::SetPduSessionId(uint8_t value) {
-  ie_pdu_session_identity_2 = new PDU_Session_Identity_2(0x12, value);
+  ie_pdu_session_identity_2 = new PduSessionIdentity2(0x12, value);
 }
 
 //------------------------------------------------------------------------------
@@ -195,7 +195,7 @@ int DLNASTransport::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) {
     switch (octet) {
       case 0x12: {
         Logger::nas_mm().debug("Decoding IEI (0x12)");
-        ie_pdu_session_identity_2 = new PDU_Session_Identity_2();
+        ie_pdu_session_identity_2 = new PduSessionIdentity2();
         decoded_size += ie_pdu_session_identity_2->Decode(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);

src/nas/msgs/DLNASTransport.hpp

@@ -50,7 +50,7 @@ class DLNASTransport {
   NasMmPlainHeader* plain_header;
   PayloadContainerType* ie_payload_container_type;
   Payload_Container* ie_payload_container;
-  PDU_Session_Identity_2* ie_pdu_session_identity_2;
+  PduSessionIdentity2* ie_pdu_session_identity_2;
   Additional_Information* ie_additional_information;
   _5GMM_Cause* ie_5gmm_cause;
   GprsTimer3* ie_back_off_timer_value;

src/nas/msgs/ULNASTransport.cpp

@@ -77,7 +77,7 @@ void ULNASTransport::GetPayloadContainer(
 //------------------------------------------------------------------------------
 void ULNASTransport::SetPduSessionIdentity2(uint8_t value) {
   ie_pdu_session_identity_2 =
-      std::make_optional<PDU_Session_Identity_2>(0x12, value);
+      std::make_optional<PduSessionIdentity2>(0x12, value);
 }
 
 //------------------------------------------------------------------------------
@@ -92,7 +92,7 @@ uint8_t ULNASTransport::GetPduSessionId() {
 //------------------------------------------------------------------------------
 void ULNASTransport::SetOldPduSessionIdentity2(uint8_t value) {
   ie_old_pdu_session_identity_2 =
-      std::make_optional<PDU_Session_Identity_2>(0x59, value);
+      std::make_optional<PduSessionIdentity2>(0x59, value);
 }
 
 //------------------------------------------------------------------------------
@@ -398,26 +398,26 @@ int ULNASTransport::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) {
     switch (octet) {
       case 0x12: {
         Logger::nas_mm().debug("Decoding IEI (0x12)");
-        PDU_Session_Identity_2 ie_pdu_session_identity_2_tmp = {};
+        PduSessionIdentity2 ie_pdu_session_identity_2_tmp = {};
         if ((decoded_result = ie_pdu_session_identity_2_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError)
           return decoded_result;
         decoded_size += decoded_result;
-        ie_pdu_session_identity_2 = std::optional<PDU_Session_Identity_2>(
-            ie_pdu_session_identity_2_tmp);
+        ie_pdu_session_identity_2 =
+            std::optional<PduSessionIdentity2>(ie_pdu_session_identity_2_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);
       } break;
       case 0x59: {
         Logger::nas_mm().debug("Decoding IEI (0x59)");
-        PDU_Session_Identity_2 ie_old_pdu_session_identity_2_tmp = {};
+        PduSessionIdentity2 ie_old_pdu_session_identity_2_tmp = {};
         if ((decoded_result = ie_old_pdu_session_identity_2_tmp.Decode(
                  buf + decoded_size, len - decoded_size, true)) ==
             KEncodeDecodeError)
           return decoded_result;
         decoded_size += decoded_result;
-        ie_old_pdu_session_identity_2 = std::optional<PDU_Session_Identity_2>(
+        ie_old_pdu_session_identity_2 = std::optional<PduSessionIdentity2>(
             ie_old_pdu_session_identity_2_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI (0x%x)", octet);

src/nas/msgs/ULNASTransport.hpp

@@ -68,13 +68,12 @@ class ULNASTransport : public NasMmPlainHeader {
   PayloadContainerType ie_payload_container_type;  // Mandatory
   Payload_Container ie_payload_container;          // Mandatory
 
-  std::optional<PDU_Session_Identity_2> ie_pdu_session_identity_2;  // Optional
-  std::optional<PDU_Session_Identity_2>
-      ie_old_pdu_session_identity_2;                                // Optional
-  std::optional<Request_Type> ie_request_type;                      // Optional
-  std::optional<S_NSSAI> ie_s_nssai;                                // Optional
-  std::optional<DNN> ie_dnn;                                        // Optional
-  std::optional<Additional_Information> ie_additional_information;  // Optional
+  std::optional<PduSessionIdentity2> ie_pdu_session_identity_2;      // Optional
+  std::optional<PduSessionIdentity2> ie_old_pdu_session_identity_2;  // Optional
+  std::optional<Request_Type> ie_request_type;                       // Optional
+  std::optional<S_NSSAI> ie_s_nssai;                                 // Optional
+  std::optional<DNN> ie_dnn;                                         // Optional
+  std::optional<Additional_Information> ie_additional_information;   // Optional
   std::optional<MA_PDU_Session_Information>
       ie_ma_pdu_session_information;  // Optional
   std::optional<Release_Assistance_Indication>