Skip to content

O
OpenXG-AMF
Commit 0a4b4ef1 authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN
Browse files
Options

Code refactor for UEStatus

parent 8107d450
Show whitespace changes
Inline Side-by-side
Showing with 190 additions and 172 deletions
src/nas/common/NasIeHeader.hpp
View file @ 0a4b4ef1
......@@ -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
View file @ 0a4b4ef1
......@@ -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 {
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;
}
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 {
int encoded_size = 0;
octet = (iei << 4) | (SPRTI << 1) | RAAI;
*buf = octet;
Logger::nas_mm().debug("Encoded MICO_Indication IE (len: 1 octet)");
return 1;
}
}
return 1;
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;
} else {
uint8_t octet = (*buf);
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 {
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;
}
"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
View file @ 0a4b4ef1
......@@ -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
View file @ 0a4b4ef1
......@@ -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) {
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) {
UEStatus::UEStatus(const uint8_t iei, bool n1, bool s1) {
_iei = iei;
length = 1;
S1 = s1;
N1 = n1;
}
//------------------------------------------------------------------------------
UE_Status::UE_Status() {
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
View file @ 0a4b4ef1
......@@ -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
View file @ 0a4b4ef1
......@@ -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
View file @ 0a4b4ef1
......@@ -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
View file @ 0a4b4ef1
......@@ -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
View file @ 0a4b4ef1
......@@ -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,9 +972,10 @@ 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);
ie_ue_status = std::optional<UEStatus>(ie_ue_status_tmp);
octet = *(buf + decoded_size);
Logger::nas_mm().debug("Next IEI 0x%x", octet);
} break;
......
src/nas/msgs/RegistrationRequest.hpp
View file @ 0a4b4ef1
......@@ -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
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment