Code refactor for UEStatus

src/nas/common/NasIeHeader.hpp

@@ -20,7 +20,9 @@
  */
 
 #include "../ies/5GSMobileIdentity.hpp"
+#include "../ies/MICOIndication.hpp"
 #include "../ies/PDUSessionStatus.hpp"
+#include "../ies/UEStatus.hpp"
 #include "NasMmPlainHeader.hpp"
 #include "5GMMCapability.hpp"
 #include "5GSRegistrationType.hpp"
@@ -43,7 +45,6 @@
 #include "IMEISV_Request.hpp"
 #include "LADN_Indication.hpp"
 #include "MA_PDU_Session_Information.hpp"
-#include "MICO_Indication.hpp"
 #include "NAS_Message_Container.hpp"
 #include "NAS_Security_Algorithms.hpp"
 #include "NSSAI.hpp"
@@ -68,7 +69,6 @@
 #include "UES_Usage_Setting.hpp"
 #include "UESecurityCapability.hpp"
 #include "UE_Radio_Capability_ID.hpp"
-#include "UE_Status.hpp"
 #include "UplinkDataStatus.hpp"
 #include "_5GMM_Cause.hpp"
 #include "_5GSDeregistrationType.hpp"

src/nas/ies/MICO_Indication.cpp → src/nas/ies/MICOIndication.cpp

@@ -19,99 +19,104 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "MICO_Indication.hpp"
-
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
+#include "MICOIndication.hpp"
+
 using namespace nas;
 
 //------------------------------------------------------------------------------
-MICO_Indication::MICO_Indication(const uint8_t _iei, bool sprti, bool raai) {
+MICOIndication::MICOIndication(const uint8_t _iei, bool sprti, bool raai) {
   iei   = _iei;
   RAAI  = raai;
   SPRTI = sprti;
 }
 
 //------------------------------------------------------------------------------
-MICO_Indication::MICO_Indication(bool sprti, bool raai) {
+MICOIndication::MICOIndication(bool sprti, bool raai) {
   this->iei   = 0;
   this->RAAI  = raai;
   this->SPRTI = sprti;
 }
 
 //------------------------------------------------------------------------------
-MICO_Indication::MICO_Indication() {}
+MICOIndication::MICOIndication() {
+  iei   = 0;
+  RAAI  = false;
+  SPRTI = false;
+}
 
 //------------------------------------------------------------------------------
-MICO_Indication::~MICO_Indication(){};
+MICOIndication::~MICOIndication(){};
 
 //------------------------------------------------------------------------------
-int MICO_Indication::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("Encoding MICO_Indication IE iei (0x%x)", iei);
-  if (len < 1) {
-    Logger::nas_mm().error("Len is less than one");
-    return -1;
-  } else {
-    uint8_t octet = 0;
-    if (!(iei & 0x0f)) {
-      // octet = (0x0f) & ((tsc << 3) | key_id);
-      //*buf = octet;
-      // Logger::nas_mm().debug("encoded NasKeySetIdentifier IE(len(1/2
-      // octet))"); return 0;
-    } else {
-      octet = (iei << 4) | (SPRTI << 1) | RAAI;
-      *buf  = octet;
-      Logger::nas_mm().debug("Encoded MICO_Indication IE (len: 1 octet)");
-      return 1;
-    }
+int MICOIndication::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding MICOIndication IE ( IEI 0x%x)", iei);
+
+  if (len < kMICOIndicationIELength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kMICOIndicationIELength);
+    return KEncodeDecodeError;
   }
-  return 1;
+
+  uint8_t octet    = 0;
+  int encoded_size = 0;
+
+  octet = (iei << 4) | (SPRTI << 1) | RAAI;
+  ENCODE_U8(buf + encoded_size, octet, encoded_size);
+
+  Logger::nas_mm().debug(
+      "Encoded MICOIndication IE (len: %d octet)", encoded_size);
+
+  return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int MICO_Indication::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("Decoding MICO_Indication IE");
-  if (len < 1) {
-    Logger::nas_mm().error("Len is less than one");
-    return 0;
+int MICOIndication::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+  Logger::nas_mm().debug("Decoding MICOIndication IE");
+  if (len < kMICOIndicationIELength) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kMICOIndicationIELength);
+    return KEncodeDecodeError;
+  }
+
+  uint8_t octet    = 0;
+  int decoded_size = 0;
+
+  DECODE_U8(buf + decoded_size, octet, decoded_size);
+  if (is_option) {
+    iei = (octet & 0xf0) >> 4;
   } else {
-    uint8_t octet = (*buf);
-    if (is_option) {
-      iei = (octet & 0xf0) >> 4;
-    } else {
-      iei = 0;
-    }
-    SPRTI = octet & 0x02;
-    RAAI  = octet & 0x01;
-    Logger::nas_mm().debug(
-        "decoded MICO_Indication iei (0x%x) sprti (0x%x) raai (0x%x)", iei,
-        SPRTI, RAAI);
-    return 1;
+    iei = 0;
   }
+
+  SPRTI = octet & 0x02;
+  RAAI  = octet & 0x01;
+  Logger::nas_mm().debug(
+      "Decoded MICOIndication IEI 0x%x, SPRTI 0x%x, RAAI 0x%x", iei, SPRTI,
+      RAAI);
+  return decoded_size;
 }
 
 //------------------------------------------------------------------------------
-void MICO_Indication::setSPRTI(bool value) {
+void MICOIndication::setSPRTI(bool value) {
   SPRTI = value;
 }
 
 //------------------------------------------------------------------------------
-void MICO_Indication::setRAAI(bool value) {
+void MICOIndication::setRAAI(bool value) {
   RAAI = value;
 }
 
 //------------------------------------------------------------------------------
-bool MICO_Indication::getSPRTI() {
+bool MICOIndication::getSPRTI() {
   return SPRTI;
 }
 
 //------------------------------------------------------------------------------
-bool MICO_Indication::getRAAI() {
+bool MICOIndication::getRAAI() {
   return RAAI;
 }

src/nas/ies/MICO_Indication.hpp → src/nas/ies/MICOIndication.hpp

@@ -24,14 +24,16 @@
 
 #include <stdint.h>
 
+constexpr uint8_t kMICOIndicationIELength = 1;
+
 namespace nas {
 
-class MICO_Indication {
+class MICOIndication {
  public:
-  MICO_Indication();
-  MICO_Indication(const uint8_t _iei, bool sprti, bool raai);
-  MICO_Indication(bool sprti, bool raai);
-  ~MICO_Indication();
+  MICOIndication();
+  MICOIndication(const uint8_t _iei, bool sprti, bool raai);
+  MICOIndication(bool sprti, bool raai);
+  ~MICOIndication();
 
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option);

src/nas/ies/UE_Status.cpp → src/nas/ies/UEStatus.cpp

@@ -19,100 +19,108 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#include "UE_Status.hpp"
-
+#include "3gpp_24.501.hpp"
+#include "common_defs.h"
 #include "logger.hpp"
+#include "UEStatus.hpp"
+
 using namespace nas;
 
 //------------------------------------------------------------------------------
-UE_Status::UE_Status(uint8_t iei) {
-  _iei = iei;
-  S1   = false;
-  N1   = false;
+UEStatus::UEStatus(uint8_t iei) {
+  _iei   = iei;
+  length = 1;
+  S1     = false;
+  N1     = false;
 }
 
 //------------------------------------------------------------------------------
-UE_Status::UE_Status(const uint8_t iei, bool n1, bool s1) {
-  _iei = iei;
-  S1   = s1;
-  N1   = n1;
+UEStatus::UEStatus(const uint8_t iei, bool n1, bool s1) {
+  _iei   = iei;
+  length = 1;
+  S1     = s1;
+  N1     = n1;
 }
 
 //------------------------------------------------------------------------------
-UE_Status::UE_Status() {
-  _iei = 0;
-  S1   = false;
-  N1   = false;
+UEStatus::UEStatus() {
+  _iei   = 0;
+  length = 1;
+  S1     = false;
+  N1     = false;
 }
 
 //------------------------------------------------------------------------------
-UE_Status::~UE_Status() {}
+UEStatus::~UEStatus() {}
 
 //------------------------------------------------------------------------------
-void UE_Status::setS1(bool value) {
+void UEStatus::setS1(bool value) {
   S1 = value;
 }
 
 //------------------------------------------------------------------------------
-void UE_Status::setN1(bool value) {
+void UEStatus::setN1(bool value) {
   N1 = value;
 }
 
 //------------------------------------------------------------------------------
-bool UE_Status::getS1() {
+bool UEStatus::getS1() {
   return S1;
 }
 
 //------------------------------------------------------------------------------
-bool UE_Status::getN1() {
+bool UEStatus::getN1() {
   return N1;
 }
 
 //------------------------------------------------------------------------------
-int UE_Status::encode2Buffer(uint8_t* buf, int len) {
-  Logger::nas_mm().debug("encoding UE_Status iei(0x%x)", _iei);
-  if (len < 3) {
-    //	Logger::nas_mm().error("len is less than %d", length);
-    return 0;
+int UEStatus::encode2Buffer(uint8_t* buf, int len) {
+  Logger::nas_mm().debug("Encoding UE Status (IEI 0x%x)", _iei);
+
+  if ((len < kUEStatusIELength) or (len < length + 2)) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kUEStatusIELength);
+    return KEncodeDecodeError;
   }
+
   int encoded_size = 0;
   if (_iei) {
-    *(buf + encoded_size) = _iei;
-    encoded_size++;
-    *(buf + encoded_size) = 3 - 2;
-    encoded_size++;
-    *(buf + encoded_size) = 0x00 | S1 | N1 << 1;
-    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 UE_Status len(%d)", encoded_size);
+
+  ENCODE_U8(buf + encoded_size, length, encoded_size);
+
+  uint8_t octet = 0x03 & (S1 | (N1 << 1));
+  ENCODE_U8(buf + encoded_size, octet, encoded_size);
+
+  Logger::nas_mm().debug("Encoded UE Status ( len %d)", encoded_size);
   return encoded_size;
 }
 
 //------------------------------------------------------------------------------
-int UE_Status::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
-  Logger::nas_mm().debug("decoding UE_Status iei(0x%x)", *buf);
+int UEStatus::decodeFromBuffer(uint8_t* buf, int len, bool is_option) {
+  Logger::nas_mm().debug("Decoding UE Status");
+
+  if ((len < kUEStatusIELength) or (len < length + 2)) {
+    Logger::nas_mm().error(
+        "Buffer length is less than the minimum length of this IE (%d octet)",
+        kUEStatusIELength);
+    return KEncodeDecodeError;
+  }
+
   int decoded_size = 0;
   if (is_option) {
-    decoded_size++;
+    DECODE_U8(buf + decoded_size, _iei, decoded_size);
   }
-  S1 = 0;
-  N1 = 0;
-  // length = *(buf + decoded_size);
-  decoded_size++;
-  N1 = *(buf + decoded_size) & 0x02;
-  S1 = *(buf + decoded_size) & 0x01;
-  decoded_size++;
-  Logger::nas_mm().debug("decoded UE_Status N1(0x%x) S1(0x%x)", N1, S1);
-  Logger::nas_mm().debug("decoded UE_Status len(%d)", decoded_size);
+  DECODE_U8(buf + decoded_size, length, decoded_size);
+
+  uint8_t octet = 0;
+  DECODE_U8(buf + decoded_size, octet, decoded_size);
+
+  N1 = octet & 0x02;
+  S1 = octet & 0x01;
+  Logger::nas_mm().debug(
+      "Decoded UE Status, N1 0x%x, S1 0x%x, len %d", N1, S1, decoded_size);
   return decoded_size;
 }

src/nas/ies/UE_Status.hpp → src/nas/ies/UEStatus.hpp

@@ -19,35 +19,34 @@
  *      contact@openairinterface.org
  */
 
-/*! \file
- \brief
- \author  Keliang DU, BUPT
- \date 2020
- \email: contact@openairinterface.org
- */
-
-#ifndef __UE_Status_H_
-#define __UE_Status_H_
+#ifndef _UE_Status_H_
+#define _UE_Status_H_
 
 #include <stdint.h>
 
+constexpr uint8_t kUEStatusIELength = 3;
+
 namespace nas {
 
-class UE_Status {
+class UEStatus {
  public:
-  UE_Status();
-  UE_Status(uint8_t iei);
-  UE_Status(const uint8_t iei, bool n1, bool s1);
-  ~UE_Status();
+  UEStatus();
+  UEStatus(uint8_t iei);
+  UEStatus(const uint8_t iei, bool n1, bool s1);
+  ~UEStatus();
+
   int encode2Buffer(uint8_t* buf, int len);
   int decodeFromBuffer(uint8_t* buf, int len, bool is_option);
+
   void setN1(bool value);
-  void setS1(bool value);
   bool getN1();
+
+  void setS1(bool value);
   bool getS1();
 
  private:
   uint8_t _iei;
+  uint8_t length;
   bool N1;
   bool S1;
 };

src/nas/ies/_5GS_DRX_arameters.cpp

@@ -95,7 +95,7 @@ int _5GS_DRX_arameters::decodeFromBuffer(
   decoded_size++;
   _value = *(buf + decoded_size) & 0x0f;
   decoded_size++;
-  Logger::nas_mm().debug("decoded _5GS_DRX_arameters DRX value(0x%x)", _value);
-  Logger::nas_mm().debug("decoded UE_Status len(%d)", decoded_size);
+  Logger::nas_mm().debug("decoded _5GS_DRX_Parameters DRX value(0x%x)", _value);
+  Logger::nas_mm().debug("decoded _5GS_DRX_Parameters len(%d)", decoded_size);
   return decoded_size;
 }

src/nas/msgs/RegistrationAccept.cpp

@@ -174,7 +174,7 @@ void RegistrationAccept::setPDU_session_reactivation_result_error_cause(
 
 //------------------------------------------------------------------------------
 void RegistrationAccept::setMICO_Indication(bool sprti, bool raai) {
-  ie_MICO_indicationl = new MICO_Indication(0x0B, sprti, raai);
+  ie_MICO_indicationl = new MICOIndication(0x0B, sprti, raai);
 }
 
 //------------------------------------------------------------------------------
@@ -628,7 +628,7 @@ int RegistrationAccept::decodeFromBuffer(
     switch ((octet & 0xf0) >> 4) {
       case 0xB: {
         Logger::nas_mm().debug("Decoding IEI (0xB)");
-        ie_MICO_indicationl = new MICO_Indication();
+        ie_MICO_indicationl = new MICOIndication();
         decoded_size += ie_MICO_indicationl->decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
         octet = *(buf + decoded_size);

src/nas/msgs/RegistrationAccept.hpp

@@ -97,7 +97,7 @@ class RegistrationAccept {
   PDU_Session_Reactivation_Result* ie_pdu_session_reactivation_result;
   PDU_Session_Reactivation_Result_Error_Cause*
       ie_pdu_session_reactivation_result_error_cause;
-  MICO_Indication* ie_MICO_indicationl;
+  MICOIndication* ie_MICO_indicationl;
   Network_Slicing_Indication* ie_network_slicing_indication;
   GPRS_Timer_3* ie_T3512_value;
   GPRS_Timer_2* ie_Non_3GPP_de_registration_timer_value;

src/nas/msgs/RegistrationRequest.cpp

@@ -38,8 +38,8 @@ RegistrationRequest::RegistrationRequest()
   ie_uplink_data_status          = std::nullopt;
   ie_last_visited_registered_TAI = std::nullopt;
   ie_PDU_session_status          = std::nullopt;
-  ie_MICO_indicationl            = nullptr;
-  ie_ue_status                   = nullptr;
+  ie_MICO_indication             = std::nullopt;
+  ie_ue_status                   = std::nullopt;
   ie_additional_guti             = nullptr;
   ie_allowed_PDU_session_status  = nullptr;
   ie_ues_usage_setting           = nullptr;
@@ -195,7 +195,7 @@ bool RegistrationRequest::getNonCurrentNativeNasKSI(uint8_t& value) const {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::set5G_MM_capability(uint8_t value) {
+void RegistrationRequest::set5GMMCapability(uint8_t value) {
   ie_5g_mm_capability = std::make_optional<_5GMMCapability>(0x10, value);
 }
 
@@ -209,14 +209,14 @@ bool RegistrationRequest::get5GMMCapability(uint8_t& value) {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setUE_Security_Capability(
+void RegistrationRequest::setUESecurityCapability(
     uint8_t g_EASel, uint8_t g_IASel) {
   ie_ue_security_capability =
       std::make_optional<UESecurityCapability>(0x2E, g_EASel, g_IASel);
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setUE_Security_Capability(
+void RegistrationRequest::setUESecurityCapability(
     uint8_t g_EASel, uint8_t g_IASel, uint8_t EEASel, uint8_t EIASel) {
   ie_ue_security_capability = std::make_optional<UESecurityCapability>(
       0x2E, g_EASel, g_IASel, EEASel, EIASel);
@@ -252,7 +252,7 @@ bool RegistrationRequest::getUeSecurityCapability(
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setRequested_NSSAI(
+void RegistrationRequest::setRequestedNSSAI(
     std::vector<struct SNSSAI_s> nssai) {
   ie_requested_NSSAI = std::make_optional<NSSAI>(0x2F, nssai);
 }
@@ -269,7 +269,7 @@ bool RegistrationRequest::getRequestedNssai(
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setLast_Visited_Registered_TAI(
+void RegistrationRequest::setLastVisitedRegisteredTAI(
     const std::string& mcc, const std::string mnc, const uint32_t& tac) {
   ie_last_visited_registered_TAI =
       std::make_optional<_5GSTrackingAreaIdentity>(0, mcc, mnc, tac);
@@ -294,7 +294,7 @@ bool RegistrationRequest::getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia) {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setUplink_data_status(const uint16_t& value) {
+void RegistrationRequest::setUplinkDataStatus(const uint16_t& value) {
   ie_uplink_data_status = std::make_optional<UplinkDataStatus>(0x40, value);
 }
 
@@ -309,7 +309,7 @@ bool RegistrationRequest::getUplinkDataStatus(uint16_t& value) {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setPDU_session_status(uint16_t value) {
+void RegistrationRequest::setPDUSessionStatus(uint16_t value) {
   ie_PDU_session_status = std::make_optional<PDUSessionStatus>(0x50, value);
 }
 
@@ -323,15 +323,15 @@ uint16_t RegistrationRequest::getPduSessionStatus() {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setMICO_Indication(bool sprti, bool raai) {
-  ie_MICO_indicationl = new MICO_Indication(0x0B, sprti, raai);
+void RegistrationRequest::setMICOIndication(bool sprti, bool raai) {
+  ie_MICO_indication = std::make_optional<MICOIndication>(0x0B, sprti, raai);
 }
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getMicoIndication(uint8_t& sprti, uint8_t& raai) {
-  if (ie_PDU_session_status.has_value()) {
-    sprti = ie_MICO_indicationl->getSPRTI();
-    raai  = ie_MICO_indicationl->getRAAI();
+  if (ie_MICO_indication.has_value()) {
+    sprti = ie_MICO_indication.value().getSPRTI();
+    raai  = ie_MICO_indication.value().getRAAI();
     return true;
   } else {
     return false;
@@ -339,15 +339,15 @@ bool RegistrationRequest::getMicoIndication(uint8_t& sprti, uint8_t& raai) {
 }
 
 //------------------------------------------------------------------------------
-void RegistrationRequest::setUE_Status(bool n1, bool s1) {
-  ie_ue_status = new UE_Status(0x2B, n1, s1);
+void RegistrationRequest::setUEStatus(bool n1, bool s1) {
+  ie_ue_status = std::make_optional<UEStatus>(0x2B, n1, s1);
 }
 
 //------------------------------------------------------------------------------
 bool RegistrationRequest::getUeStatus(uint8_t& n1ModeReg, uint8_t& s1ModeReg) {
-  if (ie_ue_status) {
-    n1ModeReg = ie_ue_status->getN1();
-    s1ModeReg = ie_ue_status->getS1();
+  if (ie_ue_status.has_value()) {
+    n1ModeReg = ie_ue_status.value().getN1();
+    s1ModeReg = ie_ue_status.value().getS1();
     return true;
   } else {
     return false;
@@ -669,10 +669,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
       return 0;
     }
   }
-  if (!ie_MICO_indicationl) {
+  if (!ie_MICO_indication.has_value()) {
     Logger::nas_mm().warn("IE ie_MICO_indicationl is not available");
   } else {
-    if (int size = ie_MICO_indicationl->encode2Buffer(
+    if (int size = ie_MICO_indication.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -680,10 +680,10 @@ int RegistrationRequest::encode2Buffer(uint8_t* buf, int len) {
       return 0;
     }
   }
-  if (!ie_ue_status) {
+  if (!ie_ue_status.has_value()) {
     Logger::nas_mm().warn("IE ie_ue_status is not available");
   } else {
-    if (int size = ie_ue_status->encode2Buffer(
+    if (int size = ie_ue_status.value().encode2Buffer(
             buf + encoded_size, len - encoded_size)) {
       encoded_size += size;
     } else {
@@ -864,9 +864,11 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
       } break;
       case 0xB: {
         Logger::nas_mm().debug("Decoding IEI (0xB)");
-        ie_MICO_indicationl = new MICO_Indication();
-        decoded_size += ie_MICO_indicationl->decodeFromBuffer(
+        MICOIndication ie_MICO_indication_tmp = {};
+        decoded_size += ie_MICO_indication_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
+        ie_MICO_indication =
+            std::optional<MICOIndication>(ie_MICO_indication_tmp);
         octet = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
@@ -970,10 +972,11 @@ int RegistrationRequest::decodeFromBuffer(uint8_t* buf, int len) {
       } break;
       case 0x2B: {
         Logger::nas_mm().debug("Decoding IEI (0x2B)");
-        ie_ue_status = new UE_Status();
-        decoded_size += ie_ue_status->decodeFromBuffer(
+        UEStatus ie_ue_status_tmp = {};
+        decoded_size += ie_ue_status_tmp.decodeFromBuffer(
             buf + decoded_size, len - decoded_size, true);
-        octet = *(buf + decoded_size);
+        ie_ue_status = std::optional<UEStatus>(ie_ue_status_tmp);
+        octet        = *(buf + decoded_size);
         Logger::nas_mm().debug("Next IEI 0x%x", octet);
       } break;
       case 0x77: {

src/nas/msgs/RegistrationRequest.hpp

@@ -75,35 +75,36 @@ class RegistrationRequest : public NasMmPlainHeader {
   void setNonCurrentNativeNasKSI(uint8_t tsc, uint8_t key_set_id);
   bool getNonCurrentNativeNasKSI(uint8_t& value) const;
 
-  void set5G_MM_capability(uint8_t value);
+  void set5GMMCapability(uint8_t value);
   bool get5GMMCapability(uint8_t& value);
 
-  void setUE_Security_Capability(uint8_t g_EASel, uint8_t g_IASel);
-  void setUE_Security_Capability(
+  void setUESecurityCapability(uint8_t g_EASel, uint8_t g_IASel);
+  void setUESecurityCapability(
       uint8_t g_EASel, uint8_t g_IASel, uint8_t EEASel, uint8_t EIASel);
   bool getUeSecurityCapability(uint8_t& ea, uint8_t& ia);
   bool getUeSecurityCapability(
       uint8_t& ea, uint8_t& ia, uint8_t& eea, uint8_t& eia);
 
-  void setRequested_NSSAI(std::vector<struct SNSSAI_s> nssai);
+  void setRequestedNSSAI(std::vector<struct SNSSAI_s> nssai);
   bool getRequestedNssai(std::vector<struct SNSSAI_s>& nssai);
 
   void setUENetworkCapability(uint8_t g_EEASel, uint8_t g_EIASel);
   bool getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia);
 
-  void setUplink_data_status(const uint16_t& value);
+  void setUplinkDataStatus(const uint16_t& value);
   bool getUplinkDataStatus(uint16_t& value);
 
-  void setLast_Visited_Registered_TAI(
+  void setLastVisitedRegisteredTAI(
       const std::string& mcc, const std::string mnc, const uint32_t& tac);
+  // TODO: Getter
 
-  void setPDU_session_status(uint16_t value);
+  void setPDUSessionStatus(uint16_t value);
   uint16_t getPduSessionStatus();
 
-  void setMICO_Indication(bool sprti, bool raai);
+  void setMICOIndication(bool sprti, bool raai);
   bool getMicoIndication(uint8_t& sprti, uint8_t& raai);
 
-  void setUE_Status(bool n1, bool s1);
+  void setUEStatus(bool n1, bool s1);
   bool getUeStatus(uint8_t& n1ModeReg, uint8_t& s1ModeReg);
 
   void setAllowed_PDU_Session_Status(uint16_t value);
@@ -161,9 +162,9 @@ class RegistrationRequest : public NasMmPlainHeader {
   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
 
-  MICO_Indication* ie_MICO_indicationl;                       // Optional
-  UE_Status* ie_ue_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