Code refactor for UE's Usage Setting

src/nas/common/NasIeHeader.hpp

@@ -29,7 +29,7 @@
 #include "ABBA.hpp"
 #include "Additional_5G_Security_Information.hpp"
 #include "Additional_Information.hpp"
-#include "Allowed_PDU_Session_Status.hpp"
+#include "AllowedPDUSessionStatus.hpp"
 #include "Authentication_Failure_Parameter.hpp"
 #include "Authentication_Parameter_AUTN.hpp"
 #include "Authentication_Parameter_RAND.hpp"
@@ -66,7 +66,7 @@
 #include "S_NSSAI.hpp"
 #include "ServiceType.hpp"
 #include "UENetworkCapability.hpp"
-#include "UES_Usage_Setting.hpp"
+#include "UEUsageSetting.hpp"
 #include "UESecurityCapability.hpp"
 #include "UE_Radio_Capability_ID.hpp"
 #include "UplinkDataStatus.hpp"

src/nas/ies/Allowed_PDU_Session_Status.cpp → src/nas/ies/AllowedPDUSessionStatus.cpp

@@ -19,27 +19,23 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "Allowed_PDU_Session_Status.hpp"
+#include "AllowedPDUSessionStatus.hpp"
 
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
+
 using namespace nas;
 
 //------------------------------------------------------------------------------
-Allowed_PDU_Session_Status::Allowed_PDU_Session_Status(uint8_t iei) {
+AllowedPDUSessionStatus::AllowedPDUSessionStatus(uint8_t iei) {
   _iei   = iei;
   length = 0;
   _value = 0;
 }
 
 //------------------------------------------------------------------------------
-Allowed_PDU_Session_Status::Allowed_PDU_Session_Status(
+AllowedPDUSessionStatus::AllowedPDUSessionStatus(
     const uint8_t iei, uint16_t value) {
   _iei   = iei;
   _value = value;
@@ -47,66 +43,59 @@ Allowed_PDU_Session_Status::Allowed_PDU_Session_Status(
 }
 
 //------------------------------------------------------------------------------
-Allowed_PDU_Session_Status::Allowed_PDU_Session_Status()
+AllowedPDUSessionStatus::AllowedPDUSessionStatus()
     : _iei(), length(), _value() {}
 
 //------------------------------------------------------------------------------
-Allowed_PDU_Session_Status::~Allowed_PDU_Session_Status() {}
+AllowedPDUSessionStatus::~AllowedPDUSessionStatus() {}
 
 //------------------------------------------------------------------------------
-void Allowed_PDU_Session_Status::setValue(uint8_t iei, uint16_t value) {
+void AllowedPDUSessionStatus::setValue(uint8_t iei, uint16_t value) {
   _iei   = iei;
   _value = value;
 }
-uint16_t Allowed_PDU_Session_Status::getValue() {
+uint16_t AllowedPDUSessionStatus::getValue() {
   return _value;
 }
 
 //------------------------------------------------------------------------------
-int Allowed_PDU_Session_Status::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("encoding Allowed_PDU_Session_Status iei(0x%x)", _iei);
-  if (len < length) {
-    Logger::nas_mm().error("len is less than %d", length);
-    return 0;
+int AllowedPDUSessionStatus::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding AllowedPDUSessionStatus (IEI 0x%x)", _iei);
+
+  if ((len < kAllowedPDUSessionStatusMinimumLength) or (len < length + 2)) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kAllowedPDUSessionStatusMinimumLength);
+    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);
   }
+
+  ENCODE_U8(buf + encoded_size, length, encoded_size);
+  ENCODE_U16(buf + encoded_size, _value, encoded_size);
+
   Logger::nas_mm().debug(
-      "encoded Allowed_PDU_Session_Status len(%d)", encoded_size);
+      "Encoded AllowedPDUSessionStatus (len %d)", encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int Allowed_PDU_Session_Status::decodeFromBuffer(
+int AllowedPDUSessionStatus::decodeFromBuffer(
     uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding Allowed_PDU_Session_Status iei(0x%x)", *buf);
+  Logger::nas_mm().debug("Decoding AllowedPDUSessionStatus");
   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++;
-  _value |= *(buf + decoded_size);
-  decoded_size++;
-  _value |= (*(buf + decoded_size)) << 8;
-  decoded_size++;
+  DECODE_U8(buf + decoded_size, length, decoded_size);
+  DECODE_U16(buf + decoded_size, _value, decoded_size);
+
   Logger::nas_mm().debug(
-      "decoded Allowed_PDU_Session_Status value(0x%4x)", _value);
+      "Decoded AllowedPDUSessionStatus (value 0x%4x)", _value);
   Logger::nas_mm().debug(
-      "decoded Allowed_PDU_Session_Status len(%d)", decoded_size);
+      "Decoded AllowedPDUSessionStatus (len %d)", decoded_size);
   return decoded_size;
 }

src/nas/ies/Allowed_PDU_Session_Status.hpp → src/nas/ies/AllowedPDUSessionStatus.hpp

@@ -19,26 +19,22 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#ifndef __Allowed_PDU_Session_Status_H_
-#define __Allowed_PDU_Session_Status_H_
+#ifndef _ALLOWED_PDU_SESSION_STATUS_H_
+#define _ALLOWED_PDU_SESSION_STATUS_H_
 
 #include <stdint.h>
 
+constexpr uint8_t kAllowedPDUSessionStatusMinimumLength = 4;
+constexpr uint8_t kAllowedPDUSessionStatusMaximumLength = 34;
+
 namespace nas {
 
-class Allowed_PDU_Session_Status {
+class AllowedPDUSessionStatus {
  public:
-  Allowed_PDU_Session_Status();
-  Allowed_PDU_Session_Status(uint8_t iei);
-  Allowed_PDU_Session_Status(const uint8_t iei, uint16_t value);
-  ~Allowed_PDU_Session_Status();
+  AllowedPDUSessionStatus();
+  AllowedPDUSessionStatus(uint8_t iei);
+  AllowedPDUSessionStatus(const uint8_t iei, uint16_t value);
+  ~AllowedPDUSessionStatus();
   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 Allowed_PDU_Session_Status {
   uint8_t _iei;
   uint8_t length;
   uint16_t _value;
+  // TODO: spare
 };
 
 }  // namespace nas

src/nas/ies/UES_Usage_Setting.cpp → src/nas/ies/UEUsageSetting.cpp

@@ -19,90 +19,86 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "UES_Usage_Setting.hpp"
+#include "UEUsageSetting.hpp"
 
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
+
 using namespace nas;
 
 //------------------------------------------------------------------------------
-UES_Usage_Setting::UES_Usage_Setting(uint8_t iei) {
+UEUsageSetting::UEUsageSetting(uint8_t iei) {
   _iei               = iei;
   _ues_usage_setting = false;
 }
 
 //------------------------------------------------------------------------------
-UES_Usage_Setting::UES_Usage_Setting(
-    const uint8_t iei, bool ues_usage_setting) {
+UEUsageSetting::UEUsageSetting(const uint8_t iei, bool ues_usage_setting) {
   _iei               = iei;
   _ues_usage_setting = ues_usage_setting;
 }
 
 //------------------------------------------------------------------------------
-UES_Usage_Setting::UES_Usage_Setting() {
+UEUsageSetting::UEUsageSetting() {
   _iei               = 0;
   _ues_usage_setting = false;
 }
 
 //------------------------------------------------------------------------------
-UES_Usage_Setting::~UES_Usage_Setting() {}
+UEUsageSetting::~UEUsageSetting() {}
 
 //------------------------------------------------------------------------------
-void UES_Usage_Setting::setValue(bool value) {
+void UEUsageSetting::setValue(bool value) {
   _ues_usage_setting = value;
 }
 
 //------------------------------------------------------------------------------
-bool UES_Usage_Setting::getValue() {
+bool UEUsageSetting::getValue() {
   return _ues_usage_setting;
 }
 
 //------------------------------------------------------------------------------
-int UES_Usage_Setting::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("encoding UES_Usage_Setting iei(0x%x)", _iei);
-  if (len < 3) {
-    //	Logger::nas_mm().error("len is less than %d", length);
-    return 0;
+int UEUsageSetting::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding UEUsageSetting (iei 0x%x)", _iei);
+
+  if ((len < kUEUsageSettingLength) or (len < length + 2)) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kUEUsageSettingLength);
+    return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
   if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    Logger::nas_mm().debug(
-        "encoded UES_Usage_Setting len(%d)", *(buf + encoded_size - 1));
-    *(buf + encoded_size) = 1;
-    encoded_size++;
-    *(buf + encoded_size) = 0x01 & _ues_usage_setting;
-    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 UES_Usage_Setting len(%d)", encoded_size);
+
+  ENCODE_U8(buf + encoded_size, length, encoded_size);
+  ENCODE_U8(buf + encoded_size, 0x01 & _ues_usage_setting, encoded_size);
+
+  Logger::nas_mm().debug("Encoded UEUsageSetting (len %d)", encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int UES_Usage_Setting::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding UES_Usage_Setting iei(0x%x)", *buf);
+int UEUsageSetting::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+  Logger::nas_mm().debug("Decoding UEUsageSetting");
+
   int decoded_size = 0;
   if (is_option) {
-    decoded_size++;
+    DECODE_U8(buf + decoded_size, _iei, decoded_size);
   }
-  _ues_usage_setting = 0x00;
-  //	length = *(buf + decoded_size);
-  decoded_size++;
-  _ues_usage_setting = *(buf + decoded_size) & 0x01;
-  decoded_size++;
+  DECODE_U8(buf + decoded_size, length, decoded_size);
+  uint8_t octet = 0;
+  DECODE_U8(buf + decoded_size, octet, decoded_size);
+
+  _ues_usage_setting = octet & 0x01;
+
   Logger::nas_mm().debug(
-      "decoded UES_Usage_Setting _ues_usage_setting(0x%x),iei(0x%x)",
-      _ues_usage_setting, _iei);
-  Logger::nas_mm().debug("decoded UES_Usage_Setting len(%d)", decoded_size);
+      "Decoded UE's Usage Setting, UE's Usage Setting 0x%x, IEI 0x%x, decoded "
+      "len %d",
+      _ues_usage_setting, _iei, decoded_size);
+
   return decoded_size;
 }

src/nas/ies/UES_Usage_Setting.hpp → src/nas/ies/UEUsageSetting.hpp

@@ -19,26 +19,21 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#ifndef __UES_Usage_Setting_H_
-#define __UES_Usage_Setting_H_
+#ifndef _UES_USAGE_SETTING_H_
+#define _UES_USAGE_SETTING_H_
 
 #include <stdint.h>
 
+constexpr uint8_t kUEUsageSettingLength = 3;
+
 namespace nas {
 
-class UES_Usage_Setting {
+class UEUsageSetting {
  public:
-  UES_Usage_Setting();
-  UES_Usage_Setting(uint8_t iei);
-  UES_Usage_Setting(const uint8_t iei, bool ues_usage_setting);
-  ~UES_Usage_Setting();
+  UEUsageSetting();
+  UEUsageSetting(uint8_t iei);
+  UEUsageSetting(const uint8_t iei, bool ues_usage_setting);
+  ~UEUsageSetting();
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
   void setValue(bool value);
@@ -46,6 +41,7 @@ class UES_Usage_Setting {
 
  private:
   uint8_t _iei;
+  uint8_t length;
   bool _ues_usage_setting;
 };
 }  // namespace nas

src/nas/msgs/RegistrationRequest.cpp

@@ -40,8 +40,8 @@ RegistrationRequest::RegistrationRequest()
   ie_PDU_session_status          = std::nullopt;
   ie_MICO_indication             = std::nullopt;
   ie_ue_status                   = std::nullopt;
-  ie_additional_guti             = nullptr;
-  ie_allowed_PDU_session_status  = nullptr;
+  ie_additional_guti             = std::nullopt;
+  ie_allowed_PDU_session_status  = std::nullopt;
   ie_ues_usage_setting           = nullptr;
   ie_5gs_drx_parameters          = nullptr;
   ie_eps_nas_message_container   = nullptr;
@@ -136,24 +136,20 @@ std::string RegistrationRequest::get_5g_guti() {
 void RegistrationRequest::setAdditional_GUTI_SUCI_SUPI_format_IMSI(
     const string mcc, const string mnc, uint8_t amf_region_id,
     uint8_t amf_set_id, uint8_t amf_pointer, const string _5g_tmsi) {
-  /*if (amf_pointer&0x80) {
-   Logger::nas_mm().error("encoding suci and supi format for imsi error, please
-   choose right interface"); return;
-   }
-   else {*/
-  ie_additional_guti = new _5GSMobileIdentity();
-  ie_additional_guti->setIEI(0x77);
+  _5GSMobileIdentity ie_additional_guti_tmp = {};
+  ie_additional_guti_tmp.setIEI(0x77);
   uint32_t tmsi = fromString<uint32_t>(_5g_tmsi);
-  ie_additional_guti->set5GGUTI(
+  ie_additional_guti_tmp.set5GGUTI(
       mcc, mnc, amf_region_id, amf_set_id, amf_pointer, tmsi);
-  //}
+  ie_additional_guti =
+      std::optional<_5GSMobileIdentity>(ie_additional_guti_tmp);
 }
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getAdditionalGuti(nas::_5G_GUTI_t& guti) {
-  if (ie_additional_guti) {
+  if (ie_additional_guti.has_value()) {
     std::optional<nas::_5G_GUTI_t> guti = std::nullopt;
-    ie_additional_guti->get5GGUTI(guti);
+    ie_additional_guti.value().get5GGUTI(guti);
     if (!guti.has_value()) return false;
     return true;
   } else {
@@ -355,14 +351,15 @@ bool RegistrationRequest::getUeStatus(uint8_t& n1ModeReg, uint8_t& s1ModeReg) {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setAllowed_PDU_Session_Status(uint16_t value) {
-  ie_allowed_PDU_session_status = new Allowed_PDU_Session_Status(0x25, value);
+void RegistrationRequest::setAllowedPDUSessionStatus(uint16_t value) {
+  ie_allowed_PDU_session_status = std::make_optional<AllowedPDUSessionStatus>(
+      0x25, value);  // TODO: remove hardcoded value
 }
 
 //------------------------------------------------------------------------------
 uint16_t RegistrationRequest::getAllowedPduSessionStatus() {
-  if (ie_allowed_PDU_session_status) {
-    return ie_allowed_PDU_session_status->getValue();
+  if (ie_allowed_PDU_session_status.has_value()) {
+    return ie_allowed_PDU_session_status.value().getValue();
   } else {
     return 0;
   }
@@ -370,7 +367,7 @@ uint16_t RegistrationRequest::getAllowedPduSessionStatus() {
 
 //------------------------------------------------------------------------------
 void RegistrationRequest::setUES_Usage_Setting(bool ues_usage_setting) {
-  ie_ues_usage_setting = new UES_Usage_Setting(0x18, ues_usage_setting);
+  ie_ues_usage_setting = new UEUsageSetting(0x18, ues_usage_setting);
 }
 
 //------------------------------------------------------------------------------
@@ -691,10 +688,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
       return 0;
     }
   }
-  if (!ie_additional_guti) {
+  if (!ie_additional_guti.has_value()) {
     Logger::nas_mm().warn("IE ie_additional_guti- is not available");
   } else {
-    if (int size = ie_additional_guti->encode2Buffer(
+    if (int size = ie_additional_guti.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -702,10 +699,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
       return 0;
     }
   }
-  if (!ie_allowed_PDU_session_status) {
+  if (!ie_allowed_PDU_session_status.has_value()) {
     Logger::nas_mm().warn("IE ie_allowed_PDU_session_status is not available");
   } else {
-    if (int size = ie_allowed_PDU_session_status->encode2Buffer(
+    if (int size = ie_allowed_PDU_session_status.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -981,25 +978,29 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
       } break;
       case 0x77: {
         Logger::nas_mm().debug("Decoding IEI (0x77)");
-        ie_additional_guti = new _5GSMobileIdentity();
-        decoded_size += ie_additional_guti->decodeFromBuffer(
+        _5GSMobileIdentity ie_additional_guti_tmp = {};
+        decoded_size += ie_additional_guti_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_additional_guti =
+            std::optional<_5GSMobileIdentity>(ie_additional_guti_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
 
       } break;
       case 0x25: {
         Logger::nas_mm().debug("Decoding IEI(0x25)");
-        ie_allowed_PDU_session_status = new Allowed_PDU_Session_Status();
-        decoded_size += ie_allowed_PDU_session_status->decodeFromBuffer(
+        AllowedPDUSessionStatus ie_allowed_PDU_session_status_tmp = {};
+        decoded_size += ie_allowed_PDU_session_status_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_allowed_PDU_session_status = std::optional<AllowedPDUSessionStatus>(
+            ie_allowed_PDU_session_status_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
 
       } break;
       case 0x18: {
         Logger::nas_mm().debug("Decoding IEI(0x18)");
-        ie_ues_usage_setting = new UES_Usage_Setting();
+        ie_ues_usage_setting = new UEUsageSetting();
         decoded_size += ie_ues_usage_setting->decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);

src/nas/msgs/RegistrationRequest.hpp

@@ -107,7 +107,7 @@ class RegistrationRequest : public NasMmPlainHeader {
   void setUEStatus(bool n1, bool s1);
   bool getUeStatus(uint8_t& n1ModeReg, uint8_t& s1ModeReg);
 
-  void setAllowed_PDU_Session_Status(uint16_t value);
+  void setAllowedPDUSessionStatus(uint16_t value);
   uint16_t getAllowedPduSessionStatus();
 
   void setUES_Usage_Setting(bool ues_usage_setting);
@@ -164,10 +164,11 @@ class RegistrationRequest : public NasMmPlainHeader {
   std::optional<PDUSessionStatus> ie_PDU_session_status;           // Optional
   std::optional<MICOIndication> ie_MICO_indication;                // Optional
   std::optional<UEStatus> ie_ue_status;                            // Optional
+  std::optional<_5GSMobileIdentity> ie_additional_guti;            // Optional
+  std::optional<AllowedPDUSessionStatus>
+      ie_allowed_PDU_session_status;  // Optional
 
-  _5GSMobileIdentity* ie_additional_guti;                     // Optional
-  Allowed_PDU_Session_Status* ie_allowed_PDU_session_status;  // Optional
-  UES_Usage_Setting* ie_ues_usage_setting;                    // Optional
+  UEUsageSetting* ie_ues_usage_setting;                       // Optional
   _5GS_DRX_arameters* ie_5gs_drx_parameters;                  // Optional
   EPS_NAS_Message_Container* ie_eps_nas_message_container;    // Optional
   LADN_Indication* ie_ladn_indication;                        // Optional

src/nas/msgs/ServiceRequest.cpp

@@ -84,7 +84,7 @@ void ServiceRequest::setPDU_session_status(uint16_t value) {
 
 //------------------------------------------------------------------------------
 void ServiceRequest::setAllowed_PDU_Session_Status(uint16_t value) {
-  ie_allowed_PDU_session_status = new Allowed_PDU_Session_Status(0x25, value);
+  ie_allowed_PDU_session_status = new AllowedPDUSessionStatus(0x25, value);
 }
 
 //------------------------------------------------------------------------------
@@ -225,7 +225,7 @@ int ServiceRequest::decodeFromBuffer(
       case 0x25: {
         Logger::nas_mm().debug(
             "Decoding ie_allowed_PDU_session_status (IEI: 0x25)");
-        ie_allowed_PDU_session_status = new Allowed_PDU_Session_Status();
+        ie_allowed_PDU_session_status = new AllowedPDUSessionStatus();
         decoded_size += ie_allowed_PDU_session_status->decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);

src/nas/msgs/ServiceRequest.hpp

@@ -71,7 +71,7 @@ class ServiceRequest {
   _5GSMobileIdentity* ie_5g_s_tmsi;
   UplinkDataStatus* ie_uplink_data_status;
   PDUSessionStatus* ie_PDU_session_status;
-  Allowed_PDU_Session_Status* ie_allowed_PDU_session_status;
+  AllowedPDUSessionStatus* ie_allowed_PDU_session_status;
   NAS_Message_Container* ie_nas_message_container;
 };