Commit 7c791424 authored by Tien-Thinh Nguyen's avatar Tien-Thinh Nguyen

Merge branch 'nas_cleanup_v1' into 'develop'

Cleanup NAS messages

See merge request oai/cn5g/oai-cn5g-amf!182
parents 76d32382 2ca0e5d8
......@@ -367,17 +367,18 @@ void amf_app::handle_itti_message(
//------------------------------------------------------------------------------
void amf_app::handle_itti_message(
itti_nas_signalling_establishment_request& itti_msg) {
long amf_ue_ngap_id = 0;
long amf_ue_ngap_id = INVALID_AMF_UE_NGAP_ID;
std::shared_ptr<ue_context> uc = {};
// Generate amf_ue_ngap_id
// Generate amf_ue_ngap_id if necessary
if ((amf_ue_ngap_id = itti_msg.amf_ue_ngap_id) == INVALID_AMF_UE_NGAP_ID) {
amf_ue_ngap_id = generate_amf_ue_ngap_id();
}
string ue_context_key =
// Get UE context, if the context doesn't exist, create a new one
std::string ue_context_key =
conv::get_ue_context_key(itti_msg.ran_ue_ngap_id, amf_ue_ngap_id);
if (!is_ran_amf_id_2_ue_context(ue_context_key)) {
if (!ran_amf_id_2_ue_context(ue_context_key, uc)) {
Logger::amf_app().debug(
"No existing UE Context, Create a new one with ran_amf_id %s",
ue_context_key.c_str());
......@@ -397,53 +398,47 @@ void amf_app::handle_itti_message(
amf_n2_inst->set_amf_ue_ngap_id_2_ue_ngap_context(amf_ue_ngap_id, unc);
}
// Create UE Context and store related information information
if (uc == nullptr) {
Logger::amf_app().error(
"Failed to create ue_context with ran_amf_id %s",
ue_context_key.c_str());
} else {
uc->cgi = itti_msg.cgi;
uc->tai = itti_msg.tai;
if (itti_msg.rrc_cause != -1)
uc->rrc_estb_cause = (e_Ngap_RRCEstablishmentCause) itti_msg.rrc_cause;
if (itti_msg.ueCtxReq == -1)
uc->isUeContextRequest = false;
else
uc->isUeContextRequest = true;
uc->ran_ue_ngap_id = itti_msg.ran_ue_ngap_id;
uc->amf_ue_ngap_id = amf_ue_ngap_id;
std::string guti;
bool is_guti_valid = false;
if (itti_msg.is_5g_s_tmsi_present) {
guti = itti_msg.tai.mcc + itti_msg.tai.mnc + amf_cfg.guami.regionID +
itti_msg._5g_s_tmsi;
is_guti_valid = true;
Logger::amf_app().debug("Receiving GUTI %s", guti.c_str());
}
// Store related information
uc->cgi = itti_msg.cgi;
uc->tai = itti_msg.tai;
if (itti_msg.rrc_cause != -1)
uc->rrc_estb_cause = (e_Ngap_RRCEstablishmentCause) itti_msg.rrc_cause;
if (itti_msg.ueCtxReq == -1)
uc->isUeContextRequest = false;
else
uc->isUeContextRequest = true;
uc->ran_ue_ngap_id = itti_msg.ran_ue_ngap_id;
uc->amf_ue_ngap_id = amf_ue_ngap_id;
// Send NAS PDU to task_amf_n1 for further processing
std::shared_ptr<itti_uplink_nas_data_ind> itti_n1_msg =
std::make_shared<itti_uplink_nas_data_ind>(TASK_AMF_APP, TASK_AMF_N1);
itti_n1_msg->amf_ue_ngap_id = amf_ue_ngap_id;
itti_n1_msg->ran_ue_ngap_id = itti_msg.ran_ue_ngap_id;
itti_n1_msg->is_nas_signalling_estab_req = true;
itti_n1_msg->nas_msg = itti_msg.nas_buf;
itti_n1_msg->mcc = itti_msg.tai.mcc;
itti_n1_msg->mnc = itti_msg.tai.mnc;
itti_n1_msg->is_guti_valid = is_guti_valid;
if (is_guti_valid) {
itti_n1_msg->guti = guti;
}
std::string guti = {};
bool is_guti_valid = false;
if (itti_msg.is_5g_s_tmsi_present) {
guti = itti_msg.tai.mcc + itti_msg.tai.mnc + amf_cfg.guami.regionID +
itti_msg._5g_s_tmsi;
is_guti_valid = true;
Logger::amf_app().debug("Receiving GUTI %s", guti.c_str());
}
int ret = itti_inst->send_msg(itti_n1_msg);
if (0 != ret) {
Logger::amf_app().error(
"Could not send ITTI message %s to task TASK_AMF_N1",
itti_n1_msg->get_msg_name());
}
// Send NAS PDU to task_amf_n1 for further processing
std::shared_ptr<itti_uplink_nas_data_ind> itti_n1_msg =
std::make_shared<itti_uplink_nas_data_ind>(TASK_AMF_APP, TASK_AMF_N1);
itti_n1_msg->amf_ue_ngap_id = amf_ue_ngap_id;
itti_n1_msg->ran_ue_ngap_id = itti_msg.ran_ue_ngap_id;
itti_n1_msg->is_nas_signalling_estab_req = true;
itti_n1_msg->nas_msg = itti_msg.nas_buf;
itti_n1_msg->mcc = itti_msg.tai.mcc;
itti_n1_msg->mnc = itti_msg.tai.mnc;
itti_n1_msg->is_guti_valid = is_guti_valid;
if (is_guti_valid) {
itti_n1_msg->guti = guti;
}
int ret = itti_inst->send_msg(itti_n1_msg);
if (0 != ret) {
Logger::amf_app().error(
"Could not send ITTI message %s to task TASK_AMF_N1",
itti_n1_msg->get_msg_name());
}
}
......
This diff is collapsed.
......@@ -487,15 +487,6 @@ class amf_n1 {
const uint16_t pdu_session_status,
std::vector<uint8_t>& pdu_session_to_be_activated);
/*
* Initialize Registration Accept with default parameters
* @param [std::unique_ptr<nas::RegistrationAccept>&] registration_accept:
* Pointer to the Registration Accept message
* @return void
*/
void initialize_registration_accept(
std::unique_ptr<nas::RegistrationAccept>& registration_accept);
/*
* Initialize Registration Accept with the parameters from NAS context
* @param [std::unique_ptr<nas::RegistrationAccept>&] registration_accept:
......
......@@ -617,9 +617,10 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
gc->next_sctp_stream += 1;
if (gc->next_sctp_stream >= gc->instreams) gc->next_sctp_stream = 1;
unc->gnb_assoc_id = init_ue_msg.assoc_id;
NrCgi_t cgi = {};
Tai_t tai = {};
// User Location Info NR (Mandatory)
NrCgi_t cgi = {};
Tai_t tai = {};
if (init_ue_msg.initUeMsg->getUserLocationInfoNR(cgi, tai)) {
itti_msg->cgi = cgi;
itti_msg->tai = tai;
......@@ -629,13 +630,11 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
return;
}
if (init_ue_msg.initUeMsg->getRRCEstablishmentCause() == -1) {
Logger::amf_n2().warn("IE RRCEstablishmentCause not present");
itti_msg->rrc_cause = -1; // not present, TODO with optional
} else {
itti_msg->rrc_cause = init_ue_msg.initUeMsg->getRRCEstablishmentCause();
}
// RCC Establishment Cause (Mandatory)
itti_msg->rrc_cause = init_ue_msg.initUeMsg->getRRCEstablishmentCause();
// UE Context Request (Optional)
// TODO: use std::optional
if (init_ue_msg.initUeMsg->getUeContextRequest() == -1) {
Logger::amf_n2().warn("IE UeContextRequest not present");
itti_msg->ueCtxReq = -1; // not present, TODO with optional
......@@ -643,6 +642,7 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
itti_msg->ueCtxReq = init_ue_msg.initUeMsg->getUeContextRequest();
}
// 5G-S-TMSI (Optional)
std::string _5g_s_tmsi = {};
if (!init_ue_msg.initUeMsg->get5GS_TMSI(_5g_s_tmsi)) {
itti_msg->is_5g_s_tmsi_present = false;
......@@ -656,8 +656,9 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
unc->s_setid, unc->s_pointer, unc->s_tmsi);
}
// NAS PDU (Mandatory)
if (!init_ue_msg.initUeMsg->getNasPdu(itti_msg->nas_buf)) {
Logger::amf_n2().error("Missing IE NAS-PDU");
Logger::amf_n2().error("Missing mandatory IE NAS-PDU");
return;
}
......
......@@ -150,7 +150,7 @@ static const std::vector<std::string> nas_ciphering_algorithm_list_e2str = {
/************************** cause value for 5g mobility management(Annex A)
* ********************************/
#define _5GMM_CAUSE_ILLEGAL_UE 3
#define _5GMM_CAUSE_SYNCH_FAILURE 0b00010101
#define _5GMM_CAUSE_SYNCH_FAILURE 0b00010101 // 21
#define _5GMM_CAUSE_IMPLICITLY_DE_REGISTERED 10
#define _5GMM_CAUSE_UE_IDENTITY_CANNOT_BE_DERIVED 9
#define _5GMM_CAUSE_NGKSI_ALREADY_IN_USE 0b01000111 // 71
......
......@@ -98,6 +98,7 @@ constexpr uint8_t kIeiReleaseAssistanceIndication = 0x0F; // F-(4 higher bits)
constexpr uint8_t kIei5gmmCapability = 0x10;
constexpr uint8_t kIeiUeUsageSetting = 0x18;
constexpr uint8_t kIeiS1UeSecurityCapability = 0x19;
constexpr uint8_t kIeiAuthenticationParameterAutn = 0x20;
constexpr uint8_t kIeiAuthenticationParameterRand = 0x21;
constexpr uint8_t kIei5gsNetworkFeatureSupport = 0x21;
......
......@@ -46,10 +46,10 @@ class _5GSRegistrationType : public Type1NasIeFormatTv {
void set(const bool& follow_on_req, const uint8_t& type, const uint8_t& iei);
void set(const bool& follow_on_req, const uint8_t& type);
void setFollowOnReq(const bool is);
void setFollowOnReq(bool is);
bool isFollowOnReq();
void setRegType(const uint8_t type);
void setRegType(uint8_t type);
uint8_t getRegType();
private:
......
......@@ -37,7 +37,8 @@ EapMessage::EapMessage(uint8_t iei) : Type6NasIe(iei), eap_() {
}
//------------------------------------------------------------------------------
EapMessage::EapMessage(const uint8_t iei, bstring eap) : Type6NasIe(iei) {
EapMessage::EapMessage(const uint8_t iei, const bstring& eap)
: Type6NasIe(iei) {
eap_ = bstrcpy(eap);
SetLengthIndicator(blength(eap));
}
......
......@@ -34,8 +34,8 @@ class EapMessage : public Type6NasIe {
public:
EapMessage();
EapMessage(uint8_t iei);
EapMessage(bstring eap);
EapMessage(uint8_t iei, bstring eap);
EapMessage(const bstring& eap);
EapMessage(uint8_t iei, const bstring& eap);
~EapMessage();
static std::string GetIeName() { return kEapMessageIeName; }
......
......@@ -48,7 +48,7 @@ LadnIndication::LadnIndication(const std::vector<bstring>& ladn)
LadnIndication::~LadnIndication() {}
//------------------------------------------------------------------------------
void LadnIndication::GetValue(std::vector<bstring>& ladn) {
void LadnIndication::GetValue(std::vector<bstring>& ladn) const {
ladn.assign(LADN.begin(), LADN.end());
}
......
......@@ -39,7 +39,7 @@ class LadnIndication : Type6NasIe {
static std::string GetIeName() { return kLadnIndicationIeName; }
// void SetValue(const std::vector<bstring>& ladn);
void GetValue(std::vector<bstring>& ladn);
void GetValue(std::vector<bstring>& ladn) const;
int Encode(uint8_t* buf, int len);
int Decode(uint8_t* buf, int len, bool is_option);
......
......@@ -81,7 +81,7 @@ S_NSSAI::S_NSSAI(std::optional<uint8_t> iei, SNSSAI_s snssai) {
S_NSSAI::~S_NSSAI() {}
//------------------------------------------------------------------------------
void S_NSSAI::getValue(SNSSAI_t& snssai) {
void S_NSSAI::getValue(SNSSAI_t& snssai) const {
uint8_t len = {0};
// SST
snssai.sst = sst_;
......
......@@ -43,7 +43,7 @@ class S_NSSAI : public Type4NasIe {
int Encode(uint8_t* buf, int len);
int Decode(uint8_t* buf, int len, const bool is_option = true);
void getValue(SNSSAI_t& snssai);
void getValue(SNSSAI_t& snssai) const;
void SetSNSSAI(
std::optional<int8_t> iei, uint8_t sst, std::optional<int32_t> sd,
......
......@@ -41,7 +41,7 @@ void ServiceType::SetValue(uint8_t value) {
}
//------------------------------------------------------------------------------
void ServiceType::GetValue(uint8_t& value) {
void ServiceType::GetValue(uint8_t& value) const {
value = service_type_value_;
}
......
......@@ -40,7 +40,7 @@ class ServiceType : public Type1NasIe {
// int Decode(uint8_t* nuf, int len, bool is_iei, bool is_high);
void SetValue(uint8_t value);
void GetValue(uint8_t& value);
void GetValue(uint8_t& value) const;
private:
void SetValue() override;
......
......@@ -85,7 +85,7 @@ void _5GSDeregistrationType::set(_5gs_deregistration_type_t type) {
}
//------------------------------------------------------------------------------
void _5GSDeregistrationType::get(_5gs_deregistration_type_t& type) {
void _5GSDeregistrationType::get(_5gs_deregistration_type_t& type) const {
type.switch_off = u1.bf.switch_off;
type.re_registration_required = u1.bf.re_registration_required;
type.access_type = u1.bf.access_type;
......@@ -98,7 +98,7 @@ void _5GSDeregistrationType::set(uint8_t type) {
}
//------------------------------------------------------------------------------
void _5GSDeregistrationType::get(uint8_t& type) {
void _5GSDeregistrationType::get(uint8_t& type) const {
type = u1.b;
}
......
......@@ -48,13 +48,13 @@ class _5GSDeregistrationType : public Type1NasIeFormatTv {
// int Encode(uint8_t* buf, int len);
void set(_5gs_deregistration_type_t type);
void get(_5gs_deregistration_type_t& type);
void get(_5gs_deregistration_type_t& type) const;
void set(uint8_t value);
void get(uint8_t& value);
void get(uint8_t& value) const;
void set(uint8_t iei, uint8_t value);
void get(uint8_t& iei, uint8_t value);
void get(uint8_t& iei, uint8_t value) const;
private:
void setValue();
......
......@@ -72,22 +72,22 @@ void _5gsUpdateType::SetSms(uint8_t value) {
}
//------------------------------------------------------------------------------
uint8_t _5gsUpdateType::GetEpsPnbCiot() {
uint8_t _5gsUpdateType::GetEpsPnbCiot() const {
return eps_pnb_ciot_;
}
//------------------------------------------------------------------------------
uint8_t _5gsUpdateType::Get5gsPnbCiot() {
uint8_t _5gsUpdateType::Get5gsPnbCiot() const {
return _5gs_pnb_ciot_;
}
//------------------------------------------------------------------------------
bool _5gsUpdateType::GetNgRan() {
bool _5gsUpdateType::GetNgRan() const {
return ng_ran_;
}
//------------------------------------------------------------------------------
bool _5gsUpdateType::GetSms() {
bool _5gsUpdateType::GetSms() const {
return sms_;
}
......
......@@ -42,10 +42,10 @@ class _5gsUpdateType : public Type4NasIe {
void Set5gsPnbCiot(uint8_t value);
void SetNgRan(uint8_t value);
void SetSms(uint8_t value);
uint8_t GetEpsPnbCiot();
uint8_t Get5gsPnbCiot();
bool GetNgRan();
bool GetSms();
uint8_t GetEpsPnbCiot() const;
uint8_t Get5gsPnbCiot() const;
bool GetNgRan() const;
bool GetSms() const;
int Encode(uint8_t* buf, int len);
int Decode(uint8_t* buf, int len, bool is_option);
......
......@@ -21,9 +21,6 @@
#include "AuthenticationFailure.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -46,7 +43,7 @@ void AuthenticationFailure::Set5gmmCause(uint8_t value) {
}
//------------------------------------------------------------------------------
uint8_t AuthenticationFailure::Get5GMmCause() {
uint8_t AuthenticationFailure::Get5gmmCause() const {
return ie_5gmm_cause.GetValue();
}
......@@ -101,11 +98,11 @@ int AuthenticationFailure::Encode(uint8_t* buf, int len) {
encoded_size += encoded_ie_size;
int size = ie_5gmm_cause.Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_5gmm_cause error");
Logger::nas_mm().error(
"Encoding %s error", _5gmmCause::GetIeName().c_str());
return KEncodeDecodeError;
}
......@@ -120,7 +117,8 @@ int AuthenticationFailure::Encode(uint8_t* buf, int len) {
encoded_size += size;
} else {
Logger::nas_mm().error(
"Encoding ie_authentication_failure_parameter error");
"Encoding %s error",
AuthenticationFailureParameter::GetIeName().c_str());
return KEncodeDecodeError;
}
}
......@@ -148,8 +146,11 @@ int AuthenticationFailure::Decode(uint8_t* buf, int len) {
// 5GMM Cause
if ((decoded_result = ie_5gmm_cause.Decode(
buf + decoded_size, len - decoded_size, false)) ==
KEncodeDecodeError)
KEncodeDecodeError) {
Logger::nas_mm().error(
"Decoding %s error", _5gmmCause::GetIeName().c_str());
return KEncodeDecodeError;
}
decoded_size += decoded_result;
Logger::nas_mm().debug("Decoded_size (%d)", decoded_size);
......@@ -161,7 +162,8 @@ int AuthenticationFailure::Decode(uint8_t* buf, int len) {
Logger::nas_mm().debug("IEI 0x%x", octet);
switch (octet) {
case kIeiAuthenticationFailureParameter: {
Logger::nas_mm().debug("Decoding IEI (0x30)");
Logger::nas_mm().debug(
"Decoding IEI 0x%x", kIeiAuthenticationFailureParameter);
AuthenticationFailureParameter ie_authentication_failure_parameter_tmp =
{};
if ((decoded_result = ie_authentication_failure_parameter_tmp.Decode(
......
......@@ -37,7 +37,7 @@ class AuthenticationFailure : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void Set5gmmCause(uint8_t value);
uint8_t Get5GMmCause();
uint8_t Get5gmmCause() const;
// void SetAuthenticationFailureParameter(const uint8_t
// (&value)[kAuthenticationFailureParameterContentLength]); bool
......
......@@ -21,9 +21,6 @@
#include "AuthenticationReject.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -68,7 +65,8 @@ int AuthenticationReject::Encode(uint8_t* buf, int len) {
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_eap_message error");
Logger::nas_mm().error(
"Encoding %s error", EapMessage::GetIeName().c_str());
return KEncodeDecodeError;
}
}
......
......@@ -21,9 +21,6 @@
#include "AuthenticationRequest.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -44,9 +41,9 @@ void AuthenticationRequest::SetHeader(uint8_t security_header_type) {
//------------------------------------------------------------------------------
void AuthenticationRequest::SetNgKsi(uint8_t tsc, uint8_t key_set_id) {
ie_ngKSI.Set(false); // 4 lower bits
ie_ngKSI.SetNasKeyIdentifier(key_set_id);
ie_ngKSI.SetTypeOfSecurityContext(tsc);
ie_ng_ksi.Set(false); // 4 lower bits
ie_ng_ksi.SetNasKeyIdentifier(key_set_id);
ie_ng_ksi.SetTypeOfSecurityContext(tsc);
}
//------------------------------------------------------------------------------
......@@ -55,7 +52,7 @@ void AuthenticationRequest::SetAbba(uint8_t length, uint8_t* value) {
}
//------------------------------------------------------------------------------
void AuthenticationRequest::setAuthentication_Parameter_RAND(
void AuthenticationRequest::SetAuthenticationParameterRand(
uint8_t value[kAuthenticationParameterRandValueLength]) {
ie_authentication_parameter_rand =
std::make_optional<Authentication_Parameter_RAND>(
......@@ -63,7 +60,7 @@ void AuthenticationRequest::setAuthentication_Parameter_RAND(
}
//------------------------------------------------------------------------------
void AuthenticationRequest::setAuthentication_Parameter_AUTN(
void AuthenticationRequest::SetAuthenticationParameterAutn(
uint8_t value[kAuthenticationParameterAutnValueLength]) {
ie_authentication_parameter_autn =
std::make_optional<Authentication_Parameter_AUTN>(
......@@ -71,7 +68,7 @@ void AuthenticationRequest::setAuthentication_Parameter_AUTN(
}
//------------------------------------------------------------------------------
void AuthenticationRequest::SetEapMessage(bstring eap) {
void AuthenticationRequest::SetEapMessage(const bstring& eap) {
ie_eap_message = std::make_optional<EapMessage>(kIeiEapMessage, eap);
}
......@@ -89,7 +86,7 @@ int AuthenticationRequest::Encode(uint8_t* buf, int len) {
}
encoded_size += encoded_ie_size;
int size = ie_ngKSI.Encode(buf + encoded_size, len - encoded_size);
int size = ie_ng_ksi.Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
......@@ -98,7 +95,7 @@ int AuthenticationRequest::Encode(uint8_t* buf, int len) {
return KEncodeDecodeError;
}
// Spare half octet
encoded_size++; // 1/2 octet + 1/2 octet from ie_ngKSI
encoded_size++; // 1/2 octet + 1/2 octet from ie_ng_ksi
// ABBA
size = ie_abba.Encode(buf + encoded_size, len - encoded_size);
......@@ -181,7 +178,7 @@ int AuthenticationRequest::Decode(uint8_t* buf, int len) {
decoded_size += decoded_result;
// NgKSI
decoded_result = ie_ngKSI.Decode(
decoded_result = ie_ng_ksi.Decode(
buf + decoded_size, len - decoded_size, false,
false); // length 1/2, low position
if (decoded_result == KEncodeDecodeError) {
......@@ -190,7 +187,7 @@ int AuthenticationRequest::Decode(uint8_t* buf, int len) {
return KEncodeDecodeError;
}
decoded_size += decoded_result;
decoded_size++; // 1/2 octet from ie_ngKSI, 1/2 from Spare half octet
decoded_size++; // 1/2 octet from ie_ng_ksi, 1/2 from Spare half octet
// ABBA
decoded_result =
......
......@@ -37,15 +37,24 @@ class AuthenticationRequest : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
void SetEapMessage(bstring eap);
// TODO: Get
void SetEapMessage(const bstring& eap);
// TODO: Get
void SetAbba(uint8_t length, uint8_t* value);
void setAuthentication_Parameter_RAND(
// TODO: Get
void SetAuthenticationParameterRand(
uint8_t value[kAuthenticationParameterRandValueLength]);
void setAuthentication_Parameter_AUTN(
// TODO: Get
void SetAuthenticationParameterAutn(
uint8_t value[kAuthenticationParameterAutnValueLength]);
// TODO: Get
public:
NasKeySetIdentifier ie_ngKSI; // Mandatory
NasKeySetIdentifier ie_ng_ksi; // Mandatory
// Spare half octet (will be processed together with NgKSI)
ABBA ie_abba; // Mandatory
......
......@@ -21,9 +21,6 @@
#include "AuthenticationResponse.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -49,7 +46,8 @@ void AuthenticationResponse::SetAuthenticationResponseParameter(
}
//------------------------------------------------------------------------------
bool AuthenticationResponse::GetAuthenticationResponseParameter(bstring& para) {
bool AuthenticationResponse::GetAuthenticationResponseParameter(
bstring& para) const {
if (ie_authentication_response_parameter.has_value()) {
ie_authentication_response_parameter.value().GetValue(para);
return true;
......@@ -64,7 +62,7 @@ void AuthenticationResponse::SetEapMessage(const bstring& eap) {
}
//------------------------------------------------------------------------------
bool AuthenticationResponse::GetEapMessage(bstring& eap) {
bool AuthenticationResponse::GetEapMessage(bstring& eap) const {
if (ie_eap_message.has_value()) {
ie_eap_message.value().GetValue(eap);
return true;
......
......@@ -37,10 +37,10 @@ class AuthenticationResponse : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void SetAuthenticationResponseParameter(const bstring& para);
bool GetAuthenticationResponseParameter(bstring& para);
bool GetAuthenticationResponseParameter(bstring& para) const;
void SetEapMessage(const bstring& eap);
bool GetEapMessage(bstring& eap);
bool GetEapMessage(bstring& eap) const;
public:
std::optional<AuthenticationResponseParameter>
......
......@@ -21,9 +21,6 @@
#include "AuthenticationResult.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -42,9 +39,9 @@ void AuthenticationResult::SetHeader(uint8_t security_header_type) {
//------------------------------------------------------------------------------
void AuthenticationResult::SetNgKsi(uint8_t tsc, uint8_t key_set_id) {
ie_ngKSI.Set(false); // 4 lower bits
ie_ngKSI.SetTypeOfSecurityContext(tsc);
ie_ngKSI.SetNasKeyIdentifier(key_set_id);
ie_ng_ksi.Set(false); // 4 lower bits
ie_ng_ksi.SetTypeOfSecurityContext(tsc);
ie_ng_ksi.SetNasKeyIdentifier(key_set_id);
}
//------------------------------------------------------------------------------
......@@ -53,7 +50,7 @@ void AuthenticationResult::SetAbba(uint8_t length, uint8_t* value) {
}
//------------------------------------------------------------------------------
void AuthenticationResult::SetEapMessage(bstring eap) {
void AuthenticationResult::SetEapMessage(const bstring& eap) {
ie_eap_message.SetValue(eap);
}
......@@ -72,7 +69,7 @@ int AuthenticationResult::Encode(uint8_t* buf, int len) {
encoded_size += encoded_ie_size;
// ngKSI
int size = ie_ngKSI.Encode(buf + encoded_size, len - encoded_size);
int size = ie_ng_ksi.Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
......@@ -81,7 +78,7 @@ int AuthenticationResult::Encode(uint8_t* buf, int len) {
return KEncodeDecodeError;
}
// Spare half octet
encoded_size++; // 1/2 octet + 1/2 octet from ie_ngKSI
encoded_size++; // 1/2 octet + 1/2 octet from ie_ng_ksi
// EAP message
size = ie_eap_message.Encode(buf + encoded_size, len - encoded_size);
......@@ -126,7 +123,7 @@ int AuthenticationResult::Decode(uint8_t* buf, int len) {
// NAS key set identifier
decoded_result =
ie_ngKSI.Decode(buf + decoded_size, len - decoded_size, false, false);
ie_ng_ksi.Decode(buf + decoded_size, len - decoded_size, false, false);
if (decoded_result == KEncodeDecodeError) {
Logger::nas_mm().error(
"Decoding %s error", NasKeySetIdentifier::GetIeName().c_str());
......@@ -154,7 +151,7 @@ int AuthenticationResult::Decode(uint8_t* buf, int len) {
while ((octet != 0x0)) {
switch (octet) {
case kIeiAbba: {
Logger::nas_mm().debug("Decoding IEI (0x38)");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiAbba);
ABBA ie_abba_tmp = {};
if ((decoded_result = ie_abba_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......
......@@ -39,16 +39,16 @@ class AuthenticationResult : public NasMmPlainHeader {
void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
// TODO: Get
void SetEapMessage(bstring eap);
void SetEapMessage(const bstring& eap);
// TODO: Get
void SetAbba(uint8_t length, uint8_t* value);
// TODO: Get
public:
NasKeySetIdentifier ie_ngKSI; // Mandatory (1/2 lower octet)
EapMessage ie_eap_message; // Mandatory
std::optional<ABBA> ie_abba; // Optional
NasKeySetIdentifier ie_ng_ksi; // Mandatory (1/2 lower octet)
EapMessage ie_eap_message; // Mandatory
std::optional<ABBA> ie_abba; // Optional
};
} // namespace nas
......
......@@ -21,10 +21,6 @@
#include "ConfigurationUpdateCommand.hpp"
#include "3gpp_24.501.hpp"
#include "String2Value.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -43,50 +39,52 @@ void ConfigurationUpdateCommand::SetHeader(uint8_t security_header_type) {
}
//------------------------------------------------------------------------------
void ConfigurationUpdateCommand::setFullNameForNetwork(
void ConfigurationUpdateCommand::SetFullNameForNetwork(
const NetworkName& name) {
full_name_for_network = std::optional<NetworkName>(name);
}
//------------------------------------------------------------------------------
void ConfigurationUpdateCommand::setFullNameForNetwork(
void ConfigurationUpdateCommand::SetFullNameForNetwork(
const std::string& text_string) {
NetworkName full_name_for_network_tmp;
full_name_for_network_tmp.setIEI(kIeiFullNameForNetwork);
full_name_for_network_tmp.setCodingScheme(0);
full_name_for_network_tmp.setAddCI(0);
full_name_for_network_tmp.setNumberOfSpareBits(0x07); // TODO:
full_name_for_network_tmp.setNumberOfSpareBits(
0x07); // TODO: remove hardcoded value
full_name_for_network_tmp.setTextString(text_string);
full_name_for_network = std::optional<NetworkName>(full_name_for_network_tmp);
}
//------------------------------------------------------------------------------
void ConfigurationUpdateCommand::getFullNameForNetwork(
void ConfigurationUpdateCommand::GetFullNameForNetwork(
std::optional<NetworkName>& name) const {
name = full_name_for_network;
}
//------------------------------------------------------------------------------
void ConfigurationUpdateCommand::setShortNameForNetwork(
void ConfigurationUpdateCommand::SetShortNameForNetwork(
const std::string& text_string) {
NetworkName short_name_for_network_tmp;
short_name_for_network_tmp.setIEI(kIeiShortNameForNetwork); // TODO
short_name_for_network_tmp.setCodingScheme(0);
short_name_for_network_tmp.setAddCI(0);
short_name_for_network_tmp.setNumberOfSpareBits(0x07); // TODO
short_name_for_network_tmp.setNumberOfSpareBits(
0x07); // TODO: remove hardcoded value
short_name_for_network_tmp.setTextString(text_string);
short_name_for_network =
std::optional<NetworkName>(short_name_for_network_tmp);
}
//------------------------------------------------------------------------------
void ConfigurationUpdateCommand::setShortNameForNetwork(
void ConfigurationUpdateCommand::SetShortNameForNetwork(
const NetworkName& name) {
short_name_for_network = std::optional<NetworkName>(name);
}
//------------------------------------------------------------------------------
void ConfigurationUpdateCommand::getShortNameForNetwork(
void ConfigurationUpdateCommand::GetShortNameForNetwork(
NetworkName& name) const {}
//------------------------------------------------------------------------------
......
......@@ -22,11 +22,8 @@
#ifndef CONFIGURATION_UPDATE_COMMAND_H_
#define CONFIGURATION_UPDATE_COMMAND_H_
#include <bstrlib.h>
#include <stdint.h>
#include <string>
#include "NasIeHeader.hpp"
namespace nas {
class ConfigurationUpdateCommand : public NasMmPlainHeader {
......@@ -36,15 +33,15 @@ class ConfigurationUpdateCommand : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void GetSecurityHeaderType(uint8_t security_header_type);
bool verifyHeader();
bool VerifyHeader();
void setFullNameForNetwork(const NetworkName& name);
void setFullNameForNetwork(const std::string& text_string);
void getFullNameForNetwork(std::optional<NetworkName>& name) const;
void SetFullNameForNetwork(const NetworkName& name);
void SetFullNameForNetwork(const std::string& text_string);
void GetFullNameForNetwork(std::optional<NetworkName>& name) const;
void setShortNameForNetwork(const NetworkName& name);
void setShortNameForNetwork(const std::string& text_string);
void getShortNameForNetwork(NetworkName& name) const;
void SetShortNameForNetwork(const NetworkName& name);
void SetShortNameForNetwork(const std::string& text_string);
void GetShortNameForNetwork(NetworkName& name) const;
int Encode(uint8_t* buf, int len);
int Decode(uint8_t* buf, int len);
......
......@@ -21,9 +21,7 @@
#include "DLNASTransport.hpp"
#include "3gpp_24.501.hpp"
#include "bstrlib.h"
#include "logger.hpp"
using namespace nas;
......@@ -51,7 +49,7 @@ void DLNASTransport::SetPayloadContainerType(uint8_t value) {
//------------------------------------------------------------------------------
void DLNASTransport::SetPayloadContainer(
std::vector<PayloadContainerEntry> content) {
const std::vector<PayloadContainerEntry>& content) {
ie_payload_container.SetValue(content);
}
......@@ -235,7 +233,7 @@ int DLNASTransport::Decode(uint8_t* buf, int len) {
while ((octet != 0x0)) {
switch (octet) {
case kIeiPduSessionId: {
Logger::nas_mm().debug("Decoding IEI (0x12)");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiPduSessionId);
PduSessionIdentity2 ie_pdu_session_identity_2_tmp = {};
if ((decoded_result = ie_pdu_session_identity_2_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......@@ -252,7 +250,7 @@ int DLNASTransport::Decode(uint8_t* buf, int len) {
} break;
case kIeiAdditionalInformation: {
Logger::nas_mm().debug("Decoding IEI (0x24)");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiAdditionalInformation);
AdditionalInformation ie_additional_information_tmp = {};
if ((decoded_result = ie_additional_information_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......@@ -269,7 +267,7 @@ int DLNASTransport::Decode(uint8_t* buf, int len) {
} break;
case kIei5gmmCause: {
Logger::nas_mm().debug("Decoding IEI (0x58)");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIei5gmmCause);
_5gmmCause ie_5gmm_cause_tmp = {};
if ((decoded_result = ie_5gmm_cause_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......@@ -285,7 +283,7 @@ int DLNASTransport::Decode(uint8_t* buf, int len) {
} break;
case kIeiGprsTimer3BackOffTimer: {
Logger::nas_mm().debug("Decoding IEI (0x37)");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiGprsTimer3BackOffTimer);
GprsTimer3 ie_back_off_timer_value_tmp(kIeiGprsTimer3BackOffTimer);
if ((decoded_result = ie_back_off_timer_value_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......
......@@ -38,7 +38,7 @@ class DLNASTransport : public NasMmPlainHeader {
void SetPayloadContainerType(uint8_t value);
void SetPayloadContainer(std::vector<PayloadContainerEntry> content);
void SetPayloadContainer(const std::vector<PayloadContainerEntry>& content);
void SetPayloadContainer(uint8_t* buf, int len);
void SetPduSessionId(uint8_t value);
......
......@@ -21,10 +21,6 @@
#include "DeregistrationAccept.hpp"
#include "3gpp_24.501.hpp"
#include "String2Value.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......
......@@ -21,12 +21,7 @@
#include "DeregistrationRequest.hpp"
#include <string>
#include "3gpp_24.501.hpp"
#include "conversions.hpp"
#include "logger.hpp"
#include "String2Value.hpp"
using namespace nas;
......@@ -49,45 +44,45 @@ void DeregistrationRequest::SetHeader(uint8_t security_header_type) {
}
//------------------------------------------------------------------------------
void DeregistrationRequest::setDeregistrationType(uint8_t dereg_type) {
void DeregistrationRequest::SetDeregistrationType(uint8_t dereg_type) {
ie_deregistrationtype.set(dereg_type);
}
//------------------------------------------------------------------------------
void DeregistrationRequest::setDeregistrationType(
_5gs_deregistration_type_t type) {
void DeregistrationRequest::SetDeregistrationType(
const _5gs_deregistration_type_t& type) {
ie_deregistrationtype.set(type);
}
//------------------------------------------------------------------------------
void DeregistrationRequest::SetNgKsi(uint8_t tsc, uint8_t key_set_id) {
ie_ngKSI.Set(true); // high position
ie_ngKSI.SetTypeOfSecurityContext(tsc);
ie_ngKSI.SetNasKeyIdentifier(key_set_id);
ie_ng_ksi.Set(true); // high position
ie_ng_ksi.SetTypeOfSecurityContext(tsc);
ie_ng_ksi.SetNasKeyIdentifier(key_set_id);
}
//------------------------------------------------------------------------------
void DeregistrationRequest::getDeregistrationType(uint8_t& dereg_type) {
void DeregistrationRequest::GetDeregistrationType(uint8_t& dereg_type) const {
ie_deregistrationtype.get(dereg_type);
}
//------------------------------------------------------------------------------
void DeregistrationRequest::getDeregistrationType(
_5gs_deregistration_type_t& type) {
void DeregistrationRequest::GetDeregistrationType(
_5gs_deregistration_type_t& type) const {
ie_deregistrationtype.get(type);
}
//------------------------------------------------------------------------------
bool DeregistrationRequest::getngKSI(uint8_t& ng_ksi) {
bool DeregistrationRequest::GetNgKsi(uint8_t& ng_ksi) const {
ng_ksi =
(ie_ngKSI.GetTypeOfSecurityContext()) | ie_ngKSI.GetNasKeyIdentifier();
(ie_ng_ksi.GetTypeOfSecurityContext()) | ie_ng_ksi.GetNasKeyIdentifier();
return true;
}
//------------------------------------------------------------------------------
void DeregistrationRequest::SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, const string msin) {
const string& mcc, const string& mnc, const string& routing_ind,
uint8_t protection_sch_id, const string& msin) {
if (protection_sch_id != NULL_SCHEME) {
Logger::nas_mm().error(
"Encoding SUCI and SUPI format for IMSI error, please choose correct "
......@@ -95,23 +90,24 @@ void DeregistrationRequest::SetSuciSupiFormatImsi(
return;
} else {
ie_5gs_mobility_id.SetSuciWithSupiImsi(
mcc, mnc, routingInd, protection_sch_id, msin);
mcc, mnc, routing_ind, protection_sch_id, msin);
}
}
//------------------------------------------------------------------------------
void DeregistrationRequest::getMobilityIdentityType(uint8_t& type) {
void DeregistrationRequest::GetMobilityIdentityType(uint8_t& type) const {
type = ie_5gs_mobility_id.GetTypeOfIdentity();
}
//------------------------------------------------------------------------------
bool DeregistrationRequest::getSuciSupiFormatImsi(nas::SUCI_imsi_t& imsi) {
bool DeregistrationRequest::GetSuciSupiFormatImsi(
nas::SUCI_imsi_t& imsi) const {
ie_5gs_mobility_id.GetSuciWithSupiImsi(imsi);
return true;
}
//------------------------------------------------------------------------------
std::string DeregistrationRequest::Get5gGuti() {
std::string DeregistrationRequest::Get5gGuti() const {
std::optional<nas::_5G_GUTI_t> guti = std::nullopt;
ie_5gs_mobility_id.Get5gGuti(guti);
if (!guti.has_value()) return {};
......@@ -127,8 +123,10 @@ std::string DeregistrationRequest::Get5gGuti() {
//------------------------------------------------------------------------------
void DeregistrationRequest::SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, uint8_t hnpki, const string msin) {}
const string& mcc, const string& mnc, const string& routing_ind,
uint8_t protection_sch_id, uint8_t hnpki, const string& msin) {
// TODO:
}
//------------------------------------------------------------------------------
void DeregistrationRequest::Set5gGuti() {}
......@@ -169,7 +167,7 @@ int DeregistrationRequest::Encode(uint8_t* buf, int len) {
return KEncodeDecodeError;
}
size = ie_ngKSI.Encode(buf + encoded_size, len - encoded_size);
size = ie_ng_ksi.Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size++; // 1/2 octet for Deregistration Type, 1/2 for ngKSI
} else {
......@@ -216,7 +214,7 @@ int DeregistrationRequest::Decode(uint8_t* buf, int len) {
"Decoding %s error", _5GSDeregistrationType::GetIeName().c_str());
return KEncodeDecodeError;
}
decoded_result = ie_ngKSI.Decode(
decoded_result = ie_ng_ksi.Decode(
buf + decoded_size, len - decoded_size, true, false); // 4 higher bits
if (decoded_result == KEncodeDecodeError) {
Logger::nas_mm().error(
......
......@@ -37,28 +37,28 @@ class DeregistrationRequest : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void setDeregistrationType(uint8_t dereg_type);
void getDeregistrationType(uint8_t& dereg_type);
void SetDeregistrationType(uint8_t dereg_type);
void GetDeregistrationType(uint8_t& dereg_type) const;
void setDeregistrationType(_5gs_deregistration_type_t type);
void getDeregistrationType(_5gs_deregistration_type_t& type);
void SetDeregistrationType(const _5gs_deregistration_type_t& type);
void GetDeregistrationType(_5gs_deregistration_type_t& type) const;
void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
bool getngKSI(uint8_t& ng_ksi);
bool GetNgKsi(uint8_t& ng_ksi) const;
void setMobilityIdentityType(uint8_t type);
void getMobilityIdentityType(uint8_t& type);
void SetMobilityIdentityType(uint8_t type);
void GetMobilityIdentityType(uint8_t& type) const;
void SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, const string msin);
const string& mcc, const string& mnc, const string& routing_ind,
uint8_t protection_sch_id, const string& msin);
void SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, uint8_t hnpki, const string msin);
bool getSuciSupiFormatImsi(nas::SUCI_imsi_t& imsi);
const string& mcc, const string& mnc, const string& routing_ind,
uint8_t protection_sch_id, uint8_t hnpki, const string& msin);
bool GetSuciSupiFormatImsi(nas::SUCI_imsi_t& imsi) const;
void Set5gGuti();
std::string Get5gGuti();
std::string Get5gGuti() const;
void SetImeiImeisv();
// TODO: Get
......@@ -68,7 +68,7 @@ class DeregistrationRequest : public NasMmPlainHeader {
public:
_5GSDeregistrationType ie_deregistrationtype; // Mandatory
NasKeySetIdentifier ie_ngKSI; // Mandatory
NasKeySetIdentifier ie_ng_ksi; // Mandatory
_5GSMobileIdentity ie_5gs_mobility_id; // Mandatory
};
......
......@@ -21,9 +21,6 @@
#include "IdentityRequest.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -40,12 +37,12 @@ void IdentityRequest::SetHeader(uint8_t security_header_type) {
//------------------------------------------------------------------------------
void IdentityRequest::Set5gsIdentityType(uint8_t value) {
_5gs_identity_type_.SetValue(value);
ie_5gs_identity_type.SetValue(value);
}
//------------------------------------------------------------------------------
int IdentityRequest::Encode(uint8_t* buf, int len) {
Logger::nas_mm().debug("encoding IdentityRequest message");
Logger::nas_mm().debug("Encoding IdentityRequest message");
int encoded_size = 0;
int encoded_ie_size = 0;
......@@ -57,8 +54,8 @@ int IdentityRequest::Encode(uint8_t* buf, int len) {
}
encoded_size += encoded_ie_size;
int size = _5gs_identity_type_.Encode(buf + encoded_size, len - encoded_size);
int size =
ie_5gs_identity_type.Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
......@@ -90,8 +87,8 @@ int IdentityRequest::Decode(uint8_t* buf, int len) {
}
decoded_size += decoded_result;
decoded_result =
_5gs_identity_type_.Decode(buf + decoded_size, len - decoded_size, false);
decoded_result = ie_5gs_identity_type.Decode(
buf + decoded_size, len - decoded_size, false);
if (decoded_result == KEncodeDecodeError) {
Logger::nas_mm().error(
"Decoding %s error", _5gsIdentityType::GetIeName().c_str());
......
......@@ -40,7 +40,7 @@ class IdentityRequest : public NasMmPlainHeader {
// TODO: Get
public:
_5gsIdentityType _5gs_identity_type_; // Mandatory
_5gsIdentityType ie_5gs_identity_type; // Mandatory
};
} // namespace nas
......
......@@ -21,9 +21,6 @@
#include "IdentityResponse.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -45,8 +42,9 @@ void IdentityResponse::Get5gsMobileIdentity(
}
//------------------------------------------------------------------------------
void IdentityResponse::SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, const string msin) {
const std::string& mcc, const std::string& mnc,
const std::string& routing_ind, uint8_t protection_sch_id,
const std::string& msin) {
if (protection_sch_id != NULL_SCHEME) {
Logger::nas_mm().error(
"Encoding suci and supi format for imsi error, please choose right "
......@@ -54,14 +52,15 @@ void IdentityResponse::SetSuciSupiFormatImsi(
return;
} else {
ie_mobile_identity.SetSuciWithSupiImsi(
mcc, mnc, routingInd, protection_sch_id, msin);
mcc, mnc, routing_ind, protection_sch_id, msin);
}
}
//------------------------------------------------------------------------------
void IdentityResponse::SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, uint8_t hnpki, const string msin) {
const std::string& mcc, const std::string& mnc,
const std::string& routingInd, uint8_t protection_sch_id, uint8_t hnpki,
const std::string& msin) {
// TODO:
}
......@@ -82,7 +81,7 @@ void IdentityResponse::Set5gSTmsi() {
//------------------------------------------------------------------------------
int IdentityResponse::Encode(uint8_t* buf, int len) {
Logger::nas_mm().debug("encoding IdentityResponse message");
Logger::nas_mm().debug("Encoding IdentityResponse message");
int encoded_size = 0;
int encoded_ie_size = 0;
......
......@@ -39,11 +39,13 @@ class IdentityResponse : public NasMmPlainHeader {
void Get5gsMobileIdentity(_5GSMobileIdentity& mobile_identity) const;
void SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, const string msin);
const std::string& mcc, const std::string& mnc,
const std::string& routing_ind, uint8_t protection_sch_id,
const std::string& msin);
void SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, uint8_t hnpki, const string msin);
const std::string& mcc, const std::string& mnc,
const std::string& routing_ind, uint8_t protection_sch_id, uint8_t hnpki,
const std::string& msin);
void Set5gGuti();
void SetImeiImeisv();
......
......@@ -27,49 +27,48 @@
using namespace nas;
//------------------------------------------------------------------------------
NasMmPlainHeader::NasMmPlainHeader(const uint8_t& epd) : epd_(epd) {}
NasMmPlainHeader::NasMmPlainHeader(uint8_t epd) : epd_(epd) {}
//------------------------------------------------------------------------------
NasMmPlainHeader::NasMmPlainHeader(const uint8_t& epd, const uint8_t& msg_type)
NasMmPlainHeader::NasMmPlainHeader(uint8_t epd, uint8_t msg_type)
: epd_(epd), msg_type_(msg_type) {}
//------------------------------------------------------------------------------
NasMmPlainHeader::~NasMmPlainHeader() {}
//------------------------------------------------------------------------------
void NasMmPlainHeader::SetEpd(const uint8_t epd) {
void NasMmPlainHeader::SetEpd(uint8_t epd) {
epd_.Set(epd);
}
//------------------------------------------------------------------------------
uint8_t NasMmPlainHeader::GetEpd() {
uint8_t NasMmPlainHeader::GetEpd() const {
return epd_.Get();
}
//------------------------------------------------------------------------------
void NasMmPlainHeader::SetSecurityHeaderType(const uint8_t type) {
void NasMmPlainHeader::SetSecurityHeaderType(uint8_t type) {
secu_header_type_.Set(type);
}
//------------------------------------------------------------------------------
uint8_t NasMmPlainHeader::GetSecurityHeaderType() {
uint8_t NasMmPlainHeader::GetSecurityHeaderType() const {
return secu_header_type_.Get();
}
//------------------------------------------------------------------------------
void NasMmPlainHeader::SetMessageType(const uint8_t type) {
void NasMmPlainHeader::SetMessageType(uint8_t type) {
msg_type_.Set(type);
}
//------------------------------------------------------------------------------
uint8_t NasMmPlainHeader::GetMessageType() {
uint8_t NasMmPlainHeader::GetMessageType() const {
return msg_type_.Get();
}
//------------------------------------------------------------------------------
void NasMmPlainHeader::SetHeader(
const uint8_t& epd, const uint8_t& security_header_type,
const uint8_t& msg_type) {
uint8_t epd, uint8_t security_header_type, uint8_t msg_type) {
epd_.Set(epd);
secu_header_type_.Set(security_header_type);
msg_type_.Set(msg_type);
......@@ -94,7 +93,8 @@ void NasMmPlainHeader::GetMessageName(std::string& name) const {
int NasMmPlainHeader::Encode(uint8_t* buf, int len) {
Logger::nas_mm().debug("Encoding NasMmPlainHeader");
if (len < kNasMmPlainHeaderLength) {
Logger::nas_mm().error("buffer length is less than 3 octets");
Logger::nas_mm().error(
"Buffer length is less than %d octets", kNasMmPlainHeaderLength);
return KEncodeDecodeError;
} else {
uint32_t encoded_size = 0;
......@@ -132,7 +132,8 @@ int NasMmPlainHeader::Decode(const uint8_t* const buf, int len) {
int decoded_size = 0;
if (len < kNasMmPlainHeaderLength) {
Logger::nas_mm().error("Buffer length is less than 3 octets");
Logger::nas_mm().error(
"Buffer length is less than %d octets", kNasMmPlainHeaderLength);
return KEncodeDecodeError;
}
......
......@@ -22,6 +22,7 @@
#ifndef _NAS_MM_PLAIN_HEADER_H_
#define _NAS_MM_PLAIN_HEADER_H_
#include "3gpp_24.501.hpp"
#include "ExtendedProtocolDiscriminator.hpp"
#include "NasMessageType.hpp"
#include "SecurityHeaderType.hpp"
......@@ -33,13 +34,11 @@ namespace nas {
class NasMmPlainHeader {
public:
NasMmPlainHeader(){};
NasMmPlainHeader(const uint8_t& epd);
NasMmPlainHeader(const uint8_t& epd, const uint8_t& msg_type);
NasMmPlainHeader(uint8_t epd);
NasMmPlainHeader(uint8_t epd, uint8_t msg_type);
virtual ~NasMmPlainHeader();
void SetHeader(
const uint8_t& epd, const uint8_t& security_header_type,
const uint8_t& msg_type);
void SetHeader(uint8_t epd, uint8_t security_header_type, uint8_t msg_type);
void SetMessageName(const std::string& name);
std::string GetMessageName() const;
void GetMessageName(std::string& name) const;
......@@ -47,14 +46,14 @@ class NasMmPlainHeader {
int Encode(uint8_t* buf, int len);
int Decode(const uint8_t* const buf, int len);
void SetEpd(const uint8_t epd);
uint8_t GetEpd();
void SetEpd(uint8_t epd);
uint8_t GetEpd() const;
void SetSecurityHeaderType(const uint8_t type);
uint8_t GetSecurityHeaderType();
void SetSecurityHeaderType(uint8_t type);
uint8_t GetSecurityHeaderType() const;
void SetMessageType(const uint8_t type);
uint8_t GetMessageType();
void SetMessageType(uint8_t type);
uint8_t GetMessageType() const;
private:
ExtendedProtocolDiscriminator epd_; // Mandatory
......
This diff is collapsed.
......@@ -33,28 +33,28 @@ class RegistrationAccept : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void GetSecurityHeaderType(uint8_t security_header_type); // TODO
bool verifyHeader(); // TODO
bool VerifyHeader(); // TODO
int Encode(uint8_t* buf, int len);
int Decode(uint8_t* buf, int len);
void Set5gsRegistrationResult(
bool emergency, bool nssaa, bool sms, const uint8_t& value);
bool emergency, bool nssaa, bool sms, uint8_t value);
// TODO: Get
// 5GSMobileIdentity
void SetSuciSupiFormatImsi(
const std::string& mcc, const std::string& mnc,
const std::string& routingInd, const uint8_t& protection_sch_id,
const std::string& routing_ind, uint8_t protection_sch_id,
const std::string& msin);
void SetSuciSupiFormatImsi(
const std::string& mcc, const std::string& mnc,
const std::string& routingInd, const uint8_t& protection_sch_id,
const std::string& routing_ind, uint8_t protection_sch_id,
const uint8_t& hnpki, const std::string& msin);
void Set5gGuti(
const std::string& mcc, const std::string& mnc,
const std::string& amfRegionId, const std::string& amfSetId,
const std::string& amfPointer, const uint32_t& tmsi);
const std::string& amf_region_id, const std::string& amf_set_id,
const std::string& amf_pointer, uint32_t tmsi);
void SetImeiImeisv(); // TODO:
void Set5gSTmsi(); // TODO:
// TODO: Get
......@@ -63,12 +63,15 @@ class RegistrationAccept : public NasMmPlainHeader {
void SetEquivalentPlmns(const std::vector<nas_plmn_t>& list);
// TODO: Get
void setTaiList(std::vector<p_tai_t> tai_list);
void SetTaiList(const std::vector<p_tai_t>& tai_list);
// TODO: Get
void SetAllowedNssai(const std::vector<struct SNSSAI_s>& nssai);
// TODO: Get
void SetRejectedNssai(const std::vector<Rejected_SNSSAI>& nssai);
// TODO: Get
void SetConfiguredNssai(const std::vector<struct SNSSAI_s>& nssai);
// TODO: Get
......@@ -110,7 +113,7 @@ class RegistrationAccept : public NasMmPlainHeader {
void SetSorTransparentContainer(uint8_t header, const uint8_t (&value)[16]);
// TODO: Get
void SetEapMessage(bstring eap);
void SetEapMessage(const bstring& eap);
// TODO: Get
void SetNssaiInclusionMode(uint8_t value);
......@@ -139,10 +142,10 @@ class RegistrationAccept : public NasMmPlainHeader {
void SetT3324Value(uint8_t unit, uint8_t value);
// TODO: Get
void SetUeRadioCapabilityId(bstring value);
void SetUeRadioCapabilityId(const bstring& value);
// TODO: Get
void SetPendingNssai(std::vector<struct SNSSAI_s> nssai);
void SetPendingNssai(const std::vector<struct SNSSAI_s>& nssai);
// TODO: Get
public:
......@@ -156,21 +159,20 @@ class RegistrationAccept : public NasMmPlainHeader {
std::optional<NSSAI> ie_configured_nssai; // Optional
std::optional<_5GS_Network_Feature_Support>
ie_5gs_network_feature_support; // Optional
std::optional<PDUSessionStatus> ie_PDU_session_status; // Optional
std::optional<PDUSessionStatus> ie_pdu_session_status; // Optional
std::optional<PDU_Session_Reactivation_Result>
ie_pdu_session_reactivation_result; // Optional
std::optional<PDU_Session_Reactivation_Result_Error_Cause>
ie_pdu_session_reactivation_result_error_cause; // Optional
// TODO: std::optional<LadnInformation> ie_ladn_information; //
// Optional
std::optional<MicoIndication> ie_MICO_indication; // Optional
std::optional<MicoIndication> ie_mico_indication; // Optional
std::optional<NetworkSlicingIndication>
ie_network_slicing_indication; // Optional
// TODO: Service Area List
std::optional<GprsTimer3> ie_T3512_value; // Optional
std::optional<GprsTimer2>
ie_Non_3GPP_de_registration_timer_value; // Optional
std::optional<GprsTimer2> ie_T3502_value; // Optional
std::optional<GprsTimer3> ie_t3512_value; // Optional
std::optional<GprsTimer2> ie_non_3gpp_deregistration_timer_value; // Optional
std::optional<GprsTimer2> ie_t3502_value; // Optional
// TODO: Emergency number list
// TODO: Extended emergency number list
std::optional<SorTransparentContainer>
......@@ -185,9 +187,9 @@ class RegistrationAccept : public NasMmPlainHeader {
ie_eps_bearer_context_status; // Optional
std::optional<Extended_DRX_Parameters>
ie_extended_drx_parameters; // Optional
std::optional<GprsTimer3> ie_T3447_value; // Optional
std::optional<GprsTimer3> ie_T3448_value; // Optional
std::optional<GprsTimer3> ie_T3324_value; // Optional
std::optional<GprsTimer3> ie_t3447_value; // Optional
std::optional<GprsTimer3> ie_t3448_value; // Optional
std::optional<GprsTimer3> ie_t3324_value; // Optional
std::optional<UeRadioCapabilityId>
ie_ue_radio_capability_id; // Release 16.4.1
// TODO: UE radio capability ID deletion indication
......
......@@ -21,9 +21,6 @@
#include "RegistrationComplete.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......
......@@ -41,7 +41,7 @@ class RegistrationComplete {
public:
NasMmPlainHeader* plain_header;
SorTransparentContainer* ie_sor_transparent_container;
SorTransparentContainer* ie_sor_transparent_container; // Optional
};
} // namespace nas
......
......@@ -21,17 +21,14 @@
#include "RegistrationReject.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
RegistrationReject::RegistrationReject()
: NasMmPlainHeader(EPD_5GS_MM_MSG, REGISTRATION_REJECT) {
Logger::nas_mm().debug("Initiating RegistrationReject");
ie_T3346_value = std::nullopt;
ie_T3502_value = std::nullopt;
ie_t3346_value = std::nullopt;
ie_t3502_value = std::nullopt;
ie_eap_message = std::nullopt;
ie_rejected_nssai = std::nullopt;
}
......@@ -50,17 +47,17 @@ void RegistrationReject::Set5gmmCause(uint8_t value) {
}
//------------------------------------------------------------------------------
void RegistrationReject::setGPRS_Timer_2_3346(uint8_t value) {
ie_T3346_value = std::make_optional<GprsTimer2>(kT3346Value, value);
void RegistrationReject::SetT3346(uint8_t value) {
ie_t3346_value = std::make_optional<GprsTimer2>(kT3346Value, value);
}
//------------------------------------------------------------------------------
void RegistrationReject::setGPRS_Timer_2_3502(uint8_t value) {
ie_T3502_value = std::make_optional<GprsTimer2>(kT3502Value, value);
void RegistrationReject::SetT3502(uint8_t value) {
ie_t3502_value = std::make_optional<GprsTimer2>(kT3502Value, value);
}
//------------------------------------------------------------------------------
void RegistrationReject::SetEapMessage(bstring eap) {
void RegistrationReject::SetEapMessage(const bstring& eap) {
ie_eap_message = std::make_optional<EapMessage>(kIeiEapMessage, eap);
}
......@@ -85,53 +82,76 @@ int RegistrationReject::Encode(uint8_t* buf, int len) {
encoded_size += encoded_ie_size;
// 5GMM Cause
if (int size = ie_5gmm_cause.Encode(buf + encoded_size, len - encoded_size)) {
int size = ie_5gmm_cause.Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_5gmm_cause error");
Logger::nas_mm().error(
"Encoding %s error", _5gmmCause::GetIeName().c_str());
return KEncodeDecodeError;
}
if (!ie_T3346_value.has_value()) {
Logger::nas_mm().warn("IE ie_T3346_value is not available");
// Timer 3346
if (!ie_t3346_value.has_value()) {
Logger::nas_mm().debug(
"IE %s is not available", GprsTimer2::GetIeName().c_str());
} else {
if (int size = ie_T3346_value.value().Encode(
buf + encoded_size, len - encoded_size)) {
size =
ie_t3346_value.value().Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_T3346_value error");
return 0;
Logger::nas_mm().error(
"Encoding %s error", GprsTimer2::GetIeName().c_str());
return KEncodeDecodeError;
}
}
if (!ie_T3502_value.has_value()) {
Logger::nas_mm().warn("IE ie_T3502_value is not available");
// Timer T3502
if (!ie_t3502_value.has_value()) {
Logger::nas_mm().debug(
"IE %s is not available", GprsTimer2::GetIeName().c_str());
} else {
if (int size = ie_T3502_value.value().Encode(
buf + encoded_size, len - encoded_size)) {
size =
ie_t3502_value.value().Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_T3502_value error");
return 0;
Logger::nas_mm().error(
"Encoding %s error", GprsTimer2::GetIeName().c_str());
return KEncodeDecodeError;
}
}
// EAP Message
if (!ie_eap_message.has_value()) {
Logger::nas_mm().warn("IE ie_eap_message is not available");
Logger::nas_mm().debug(
"IE %s is not available", EapMessage::GetIeName().c_str());
} else {
if (int size = ie_eap_message.value().Encode(
buf + encoded_size, len - encoded_size)) {
size =
ie_eap_message.value().Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_eap_message error");
return 0;
Logger::nas_mm().error(
"Encoding %s error", EapMessage::GetIeName().c_str());
return KEncodeDecodeError;
}
}
// Rejected NSSAI
if (!ie_rejected_nssai.has_value()) {
Logger::nas_mm().warn("IE ie_rejected_nssai is not available");
Logger::nas_mm().debug(
"IE %s is not available", Rejected_NSSAI::GetIeName().c_str());
} else {
if (int size = ie_rejected_nssai.value().Encode(
buf + encoded_size, len - encoded_size)) {
size = ie_rejected_nssai.value().Encode(
buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_rejected_nssai error");
Logger::nas_mm().error(
"Encoding %s error", Rejected_NSSAI::GetIeName().c_str());
return KEncodeDecodeError;
}
}
Logger::nas_mm().debug(
......@@ -140,8 +160,7 @@ int RegistrationReject::Encode(uint8_t* buf, int len) {
}
//------------------------------------------------------------------------------
int RegistrationReject::Decode(
NasMmPlainHeader* header, uint8_t* buf, int len) {
int RegistrationReject::Decode(uint8_t* buf, int len) {
Logger::nas_mm().debug("Decoding RegistrationReject message");
int decoded_size = 0;
int decoded_result = 0;
......@@ -158,48 +177,64 @@ int RegistrationReject::Decode(
decoded_size +=
ie_5gmm_cause.Decode(buf + decoded_size, len - decoded_size, false);
Logger::nas_mm().debug("Decoded_size (%d)", decoded_size);
uint8_t octet = *(buf + decoded_size);
// Decode other IEs
uint8_t octet = 0x00;
DECODE_U8_VALUE(buf + decoded_size, octet);
Logger::nas_mm().debug("First option IEI (0x%x)", octet);
while ((octet != 0x0)) {
Logger::nas_mm().debug("IEI 0x%x", octet);
switch (octet) {
case kT3346Value: {
Logger::nas_mm().debug("Decoding IEI 0x5F: T3346 Value");
GprsTimer2 ie_T3346_value_tmp(kT3346Value);
decoded_size += ie_T3346_value_tmp.Decode(
buf + decoded_size, len - decoded_size, true);
ie_T3346_value = std::optional<GprsTimer2>(ie_T3346_value_tmp);
octet = *(buf + decoded_size);
Logger::nas_mm().debug("Decoding IEI 0x%x", kT3346Value);
GprsTimer2 ie_t3346_value_tmp(kT3346Value);
if ((decoded_result = ie_t3346_value_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
KEncodeDecodeError)
return KEncodeDecodeError;
decoded_size += decoded_result;
ie_t3346_value = std::optional<GprsTimer2>(ie_t3346_value_tmp);
DECODE_U8_VALUE(buf + decoded_size, octet);
Logger::nas_mm().debug("Next IEI (0x%x)", octet);
} break;
case kT3502Value: {
Logger::nas_mm().debug("Decoding IEI 0x16: T3502 Value");
GprsTimer2 ie_T3502_value_tmp(kT3502Value);
decoded_size += ie_T3502_value_tmp.Decode(
buf + decoded_size, len - decoded_size, true);
ie_T3502_value = std::optional<GprsTimer2>(ie_T3502_value_tmp);
octet = *(buf + decoded_size);
Logger::nas_mm().debug("Decoding IEI 0x%x", kT3502Value);
GprsTimer2 ie_t3502_value_tmp(kT3502Value);
if ((decoded_result = ie_t3502_value_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
KEncodeDecodeError)
return KEncodeDecodeError;
decoded_size += decoded_result;
ie_t3502_value = std::optional<GprsTimer2>(ie_t3502_value_tmp);
DECODE_U8_VALUE(buf + decoded_size, octet);
Logger::nas_mm().debug("Next IEI (0x%x)", octet);
} break;
case kIeiEapMessage: {
Logger::nas_mm().debug("Decoding IEI 0x78: EAP Message");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiEapMessage);
EapMessage ie_eap_message_tmp = {};
decoded_size += ie_eap_message_tmp.Decode(
buf + decoded_size, len - decoded_size, true);
if ((decoded_result = ie_eap_message_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
KEncodeDecodeError)
return KEncodeDecodeError;
decoded_size += decoded_result;
ie_eap_message = std::optional<EapMessage>(ie_eap_message_tmp);
octet = *(buf + decoded_size);
DECODE_U8_VALUE(buf + decoded_size, octet);
Logger::nas_mm().debug("Next IEI (0x%x)", octet);
} break;
case kIeiRejectedNssaiRr: {
Logger::nas_mm().debug("Decoding IEI 0x69: Rejected NSSAI");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiRejectedNssaiRr);
Rejected_NSSAI ie_rejected_nssai_tmp(kIeiRejectedNssaiRr);
decoded_size += ie_rejected_nssai_tmp.Decode(
buf + decoded_size, len - decoded_size, true);
if ((decoded_result = ie_rejected_nssai_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
KEncodeDecodeError)
return KEncodeDecodeError;
decoded_size += decoded_result;
ie_rejected_nssai =
std::optional<Rejected_NSSAI>(ie_rejected_nssai_tmp);
octet = *(buf + decoded_size);
DECODE_U8_VALUE(buf + decoded_size, octet);
Logger::nas_mm().debug("Next IEI (0x%x)", octet);
} break;
default: {
......
......@@ -33,28 +33,30 @@ class RegistrationReject : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void GetSecurityHeaderType(uint8_t security_header_type);
bool verifyHeader();
bool VerifyHeader();
int Encode(uint8_t* buf, int len);
int Decode(NasMmPlainHeader* header, uint8_t* buf, int len);
int Decode(uint8_t* buf, int len);
void Set5gmmCause(uint8_t value);
// TODO: Get
void setGPRS_Timer_2_3346(uint8_t value);
void SetT3346(uint8_t value);
// TODO: Get
void setGPRS_Timer_2_3502(uint8_t value);
void SetT3502(uint8_t value);
// TOGO: Get
void SetEapMessage(bstring eap);
void SetEapMessage(const bstring& eap);
// TODO: Get
void SetRejectedNssai(const std::vector<Rejected_SNSSAI>& nssai);
// TODO: Get
public:
_5gmmCause ie_5gmm_cause; // Mandatory
std::optional<GprsTimer2> ie_T3346_value; // Optional
std::optional<GprsTimer2> ie_T3502_value; // Optional
std::optional<GprsTimer2> ie_t3346_value; // Optional
std::optional<GprsTimer2> ie_t3502_value; // Optional
std::optional<EapMessage> ie_eap_message; // Optional
std::optional<Rejected_NSSAI> ie_rejected_nssai; // Release 16.4.1
};
......
This diff is collapsed.
......@@ -25,8 +25,6 @@
#include "NasIeHeader.hpp"
#include <bstrlib.h>
#include <stdint.h>
#include <string>
#include <vector>
using namespace std;
......@@ -42,128 +40,130 @@ class RegistrationRequest : public NasMmPlainHeader {
void SetHeader(uint8_t security_header_type);
void GetSecurityHeaderType(uint8_t security_header_type);
bool verifyHeader();
bool VerifyHeader();
void set5gsRegistrationType(bool is_for, uint8_t type);
bool get5gsRegistrationType(bool& is_for, uint8_t& reg_type /*3bits*/);
void Set5gsRegistrationType(bool is_for, uint8_t type);
bool Get5gsRegistrationType(bool& is_for, uint8_t& reg_type);
void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
bool getngKSI(uint8_t& ng_ksi);
bool GetNgKsi(uint8_t& ng_ksi) const;
uint8_t getMobileIdentityType();
uint8_t GetMobileIdentityType() const;
// TODO: SetMobileIdentityType(uint8_t);
void SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, const string msin);
const std::string& mcc, const std::string& mnc,
const std::string& routing_ind, uint8_t protection_sch_id,
const std::string& msin);
void SetSuciSupiFormatImsi(
const string mcc, const string mnc, const string routingInd,
uint8_t protection_sch_id, uint8_t hnpki, const string msin);
bool getSuciSupiFormatImsi(nas::SUCI_imsi_t& imsi);
const std::string& mcc, const std::string& mnc,
const std::string& routing_ind, uint8_t protection_sch_id, uint8_t hnpki,
const std::string& msin);
bool GetSuciSupiFormatImsi(nas::SUCI_imsi_t& imsi) const;
void Set5gGuti();
std::string Get5gGuti();
std::string Get5gGuti() const;
void SetImeiImeisv();
void Set5gSTmsi();
void 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);
bool getAdditionalGuti(nas::_5G_GUTI_t& guti);
void SetAdditionalGuti(
const std::string& mcc, const std::string& mnc, uint8_t amf_region_id,
uint8_t amf_set_id, uint8_t amf_pointer, const std::string& _5g_tmsi);
bool GetAdditionalGuti(nas::_5G_GUTI_t& guti) const;
void setNonCurrentNativeNasKSI(uint8_t tsc, uint8_t key_set_id);
bool getNonCurrentNativeNasKSI(uint8_t& value) const;
void SetNonCurrentNativeNasKSI(uint8_t tsc, uint8_t key_set_id);
bool GetNonCurrentNativeNasKSI(uint8_t& value) const;
void set5GMMCapability(uint8_t value);
bool get5GMMCapability(uint8_t& value);
void Set5gmmCapability(uint8_t value);
bool Get5gmmCapability(uint8_t& value) const;
void setUESecurityCapability(uint8_t g_EASel, uint8_t g_IASel);
void setUESecurityCapability(
uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia);
bool getUeSecurityCapability(uint8_t& ea, uint8_t& ia);
void SetUeSecurityCapability(uint8_t ea, uint8_t ia);
void SetUeSecurityCapability(
uint8_t ea, uint8_t ia, uint8_t eea, uint8_t eia);
bool GetUeSecurityCapability(uint8_t& ea, uint8_t& ia) const;
// TODO: use std::optional for optional fields eea,eia
bool getUeSecurityCapability(
uint8_t& ea, uint8_t& ia, uint8_t& eea, uint8_t& eia);
bool GetUeSecurityCapability(
uint8_t& ea, uint8_t& ia, uint8_t& eea, uint8_t& eia) const;
void setRequestedNSSAI(std::vector<struct SNSSAI_s> nssai);
bool getRequestedNssai(std::vector<struct SNSSAI_s>& nssai);
void SetRequestedNssai(const std::vector<struct SNSSAI_s>& nssai);
bool GetRequestedNssai(std::vector<struct SNSSAI_s>& nssai) const;
void setUENetworkCapability(uint8_t g_EEASel, uint8_t g_EIASel);
bool getS1UeNetworkCapability(uint8_t& eea, uint8_t& eia);
void SetUeNetworkCapability(uint8_t eea, uint8_t eia);
bool GetS1UeNetworkCapability(uint8_t& eea, uint8_t& eia) const;
void setUplinkDataStatus(const uint16_t& value);
bool getUplinkDataStatus(uint16_t& value);
void SetUplinkDataStatus(uint16_t value);
bool GetUplinkDataStatus(uint16_t& value) const;
void setLastVisitedRegisteredTAI(
const std::string& mcc, const std::string mnc, const uint32_t& tac);
void SetLastVisitedRegisteredTai(
const std::string& mcc, const std::string& mnc, uint32_t tac);
// TODO: Getter
void setPDUSessionStatus(uint16_t value);
uint16_t getPduSessionStatus();
void SetPduSessionStatus(uint16_t value);
uint16_t GetPduSessionStatus() const;
void setMICOIndication(bool sprti, bool raai);
bool getMicoIndication(uint8_t& sprti, uint8_t& raai);
void SetMicoIndication(bool sprti, bool raai);
bool GetMicoIndication(uint8_t& sprti, uint8_t& raai) const;
void setUEStatus(bool n1, bool s1);
bool getUeStatus(uint8_t& n1ModeReg, uint8_t& s1ModeReg);
void SetUeStatus(bool n1, bool s1);
bool GetUeStatus(uint8_t& n1_mode, uint8_t& s1_mode) const;
void setAllowedPDUSessionStatus(uint16_t value);
uint16_t getAllowedPduSessionStatus();
void SetAllowedPduSessionStatus(uint16_t value);
uint16_t GetAllowedPduSessionStatus() const;
void setUES_Usage_Setting(bool ues_usage_setting);
uint8_t getUEsUsageSetting();
void SetUeUsageSetting(bool ues_usage_setting);
uint8_t GetUeUsageSetting() const;
void Set5gsDrxParameters(uint8_t value);
uint8_t get5GSDrxParameters();
uint8_t Get5gsDrxParameters() const;
void setEPS_NAS_Message_Container(bstring value);
void SetEpsNasMessageContainer(const bstring& value);
void setLADN_Indication(std::vector<bstring> ladnValue);
bool getLadnIndication(std::vector<bstring>& ladnValue);
void SetLadnIndication(const std::vector<bstring>& ladn_value);
bool GetLadnIndication(std::vector<bstring>& ladn_value) const;
void SetPayloadContainerType(uint8_t value);
uint8_t GetPayloadContainerType();
uint8_t GetPayloadContainerType() const;
void SetPayloadContainer(std::vector<PayloadContainerEntry> content);
bool GetPayloadContainer(std::vector<PayloadContainerEntry>& content);
void SetPayloadContainer(const std::vector<PayloadContainerEntry>& content);
bool GetPayloadContainer(std::vector<PayloadContainerEntry>& content) const;
void SetNetworkSlicingIndication(bool dcni, bool nssci);
bool getNetworkSlicingIndication(uint8_t& dcni, uint8_t& nssci);
bool GetNetworkSlicingIndication(uint8_t& dcni, uint8_t& nssci) const;
void set_5GS_Update_Type(
void Set5gsUpdateType(
uint8_t eps_pnb_ciot, uint8_t _5gs_pnb_ciot, bool ng_ran, bool sms);
bool get5GSUpdateType(
bool Get5gsUpdateType(
uint8_t& eps_pnb_ciot, uint8_t& _5gs_pnb_ciot, bool& ng_ran_rcu,
bool& sms_requested);
bool& sms_requested) const;
void SetNasMessageContainer(bstring value);
bool GetNasMessageContainer(bstring& nas);
void SetNasMessageContainer(const bstring& value);
bool GetNasMessageContainer(bstring& nas) const;
bool getEpsNasMessageContainer(bstring& epsNas);
// bool getEpsNasMessageContainer(bstring& epsNas);
bool GetEpsNasMessageContainer(bstring& eps_nas) const;
// bool GetEpsNasMessageContainer(bstring& eps_nas);
void SetEpsBearerContextsStatus(uint16_t value);
bool getEpsBearerContextStatus(uint16_t& value);
bool GetEpsBearerContextStatus(uint16_t& value) const;
public:
_5GSRegistrationType ie_5gs_registration_type; // Mandatory
NasKeySetIdentifier ie_ngKSI; // Mandatory
NasKeySetIdentifier ie_ng_ksi; // Mandatory
_5GSMobileIdentity ie_5gs_mobile_identity; // Mandatory
std::optional<NasKeySetIdentifier> ie_non_current_native_nas_ksi; // Optional
std::optional<_5GMMCapability> ie_5g_mm_capability; // Optional
std::optional<UESecurityCapability> ie_ue_security_capability; // Optional
std::optional<NSSAI> ie_requested_NSSAI; // Optional
std::optional<NSSAI> ie_requested_nssai; // Optional
std::optional<_5GSTrackingAreaIdentity>
ie_last_visited_registered_TAI; // Optional
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<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
ie_allowed_pdu_session_status; // Optional
std::optional<UEUsageSetting> ie_ues_usage_setting; // Optional
std::optional<_5GS_DRX_Parameters> ie_5gs_drx_parameters; // Optional
std::optional<EPS_NAS_Message_Container>
......
This diff is collapsed.
......@@ -42,10 +42,10 @@ class SecurityModeCommand : public NasMmPlainHeader {
void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
// TODO: Get
void SetUeSecurityCapability(uint8_t g_EASel, uint8_t g_IASel);
void SetUeSecurityCapability(uint8_t ea, uint8_t ia);
// TODO: Get
void SetUeSecurityCapability(
uint8_t g_EASel, uint8_t g_IASel, uint8_t eea, uint8_t eia);
uint8_t ea, uint8_t ia, uint8_t eea, uint8_t eia);
// TODO: Get
void SetImeisvRequest(uint8_t value);
......@@ -63,19 +63,19 @@ class SecurityModeCommand : public NasMmPlainHeader {
void SetAbba(uint8_t length, uint8_t* value);
// TODO: Get
void SetS1UeSecurityCapability(uint8_t g_EEASel, uint8_t g_EIASel);
void SetS1UeSecurityCapability(uint8_t eea, uint8_t eia);
// TODO: Get
public:
NasSecurityAlgorithms ie_selected_nas_security_algorithms; // Mandatory
NasKeySetIdentifier ie_ngKSI; // Mandatory
NasKeySetIdentifier ie_ng_ksi; // Mandatory
UESecurityCapability ie_ue_security_capability; // Mandatory
std::optional<ImeisvRequest> ie_imeisv_request; // Optional
std::optional<EpsNasSecurityAlgorithms>
ie_eps_nas_security_algorithms; // Optional
std::optional<Additional5gSecurityInformation>
ie_additional_5G_security_information; // Optional
ie_additional_5g_security_information; // Optional
std::optional<EapMessage> ie_eap_message; // Optional
std::optional<ABBA> ie_abba; // Optional
std::optional<S1UeSecurityCapability>
......
......@@ -21,10 +21,6 @@
#include "SecurityModeComplete.hpp"
#include "3gpp_24.501.hpp"
#include "Ie_Const.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -44,7 +40,7 @@ void SecurityModeComplete::SetHeader(uint8_t security_header_type) {
}
//------------------------------------------------------------------------------
void SecurityModeComplete::SetImeisv(IMEISV_t imeisv) {
void SecurityModeComplete::SetImeisv(const IMEISV_t& imeisv) {
ie_imeisv =
std::make_optional<_5GSMobileIdentity>(kIei5gsMobileIdentityImeiSv);
// ie_imeisv->SetIei(kIei5gsMobileIdentityImeiSv);
......@@ -52,12 +48,12 @@ void SecurityModeComplete::SetImeisv(IMEISV_t imeisv) {
}
//------------------------------------------------------------------------------
void SecurityModeComplete::SetNasMessageContainer(bstring value) {
void SecurityModeComplete::SetNasMessageContainer(const bstring& value) {
ie_nas_message_container = std::make_optional<NasMessageContainer>(value);
}
//------------------------------------------------------------------------------
void SecurityModeComplete::SetNonImeisv(IMEISV_t imeisv) {
void SecurityModeComplete::SetNonImeisv(const IMEISV_t& imeisv) {
ie_non_imeisvpei =
std::make_optional<_5GSMobileIdentity>(kIei5gsMobileIdentityNonImeiSvPei);
// ie_non_imeisvpei->SetIei(kIei5gsMobileIdentityNonImeiSvPei);
......@@ -109,46 +105,52 @@ int SecurityModeComplete::Encode(uint8_t* buf, int len) {
encoded_size += encoded_ie_size;
if (!ie_imeisv.has_value()) {
Logger::nas_mm().warn("IE ie_imeisv is not available");
Logger::nas_mm().debug(
"IE %s is not available", _5GSMobileIdentity::GetIeName().c_str());
} else {
int size = ie_imeisv.value().Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_imeisv error");
Logger::nas_mm().error(
"Encoding %s error", _5GSMobileIdentity::GetIeName().c_str());
return KEncodeDecodeError;
}
}
if (!ie_nas_message_container.has_value()) {
Logger::nas_mm().warn("IE ie_nas_message_container is not available");
Logger::nas_mm().debug(
"IE %s is not available", NasMessageContainer::GetIeName().c_str());
} else {
int size = ie_nas_message_container.value().Encode(
buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_nas_message_container error");
Logger::nas_mm().error(
"Encoding %s error", NasMessageContainer::GetIeName().c_str());
return KEncodeDecodeError;
}
}
if (!ie_non_imeisvpei.has_value()) {
Logger::nas_mm().warn("IE ie_non_imeisvpei is not available");
Logger::nas_mm().debug(
"IE %s is not available", _5GSMobileIdentity::GetIeName().c_str());
} else {
int size =
ie_non_imeisvpei.value().Encode(buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) {
encoded_size += size;
} else {
Logger::nas_mm().error("Encoding ie_non_imeisvpei error");
Logger::nas_mm().error(
"Encoding %s error", _5GSMobileIdentity::GetIeName().c_str());
return KEncodeDecodeError;
}
}
Logger::nas_mm().debug(
"Encoded SecurityModeComplete message len (%d)", encoded_size);
return 1;
return encoded_size;
}
//------------------------------------------------------------------------------
......@@ -169,11 +171,13 @@ int SecurityModeComplete::Decode(uint8_t* buf, int len) {
// while ((octet != 0x0)) {
while (len - decoded_size > 0) {
uint8_t octet = *(buf + decoded_size);
uint8_t octet = 0x00;
DECODE_U8_VALUE(buf + decoded_size, octet);
Logger::nas_mm().debug("Optional IEI (0x%x)", octet);
switch (octet) {
case kIei5gsMobileIdentityImeiSv: {
Logger::nas_mm().debug("Decoding IEI (0x77)");
Logger::nas_mm().debug(
"Decoding IEI 0x%x", kIei5gsMobileIdentityImeiSv);
_5GSMobileIdentity ie_imeisv_tmp = {};
if ((decoded_result = ie_imeisv_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......@@ -184,7 +188,7 @@ int SecurityModeComplete::Decode(uint8_t* buf, int len) {
} break;
case kIeiNasMessageContainer: {
Logger::nas_mm().debug("Decoding IEI (0x71)");
Logger::nas_mm().debug("Decoding IEI 0x%x", kIeiNasMessageContainer);
NasMessageContainer ie_nas_message_container_tmp = {};
if ((decoded_result = ie_nas_message_container_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......@@ -196,7 +200,8 @@ int SecurityModeComplete::Decode(uint8_t* buf, int len) {
} break;
case kIei5gsMobileIdentityNonImeiSvPei: {
Logger::nas_mm().debug("Decoding IEI (0x78)");
Logger::nas_mm().debug(
"Decoding IEI 0x%x", kIei5gsMobileIdentityNonImeiSvPei);
_5GSMobileIdentity ie_non_imeisvpei_tmp = {};
if ((decoded_result = ie_non_imeisvpei_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) ==
......
......@@ -36,13 +36,13 @@ class SecurityModeComplete : public NasMmPlainHeader {
int Encode(uint8_t* buf, int len);
int Decode(uint8_t* buf, int len);
void SetImeisv(IMEISV_t imeisv);
void SetImeisv(const IMEISV_t& imeisv);
bool GetImeisv(IMEISV_t& imeisv) const;
void SetNasMessageContainer(bstring value);
void SetNasMessageContainer(const bstring& value);
bool GetNasMessageContainer(bstring& nas) const;
void SetNonImeisv(IMEISV_t imeisv);
void SetNonImeisv(const IMEISV_t& imeisv);
bool GetNonImeisv(IMEISV_t& imeisv) const;
public:
......
......@@ -21,9 +21,6 @@
#include "SecurityModeReject.hpp"
#include "3gpp_24.501.hpp"
#include "logger.hpp"
using namespace nas;
//------------------------------------------------------------------------------
......@@ -45,7 +42,7 @@ void SecurityModeReject::Set5gmmCause(uint8_t value) {
//------------------------------------------------------------------------------
int SecurityModeReject::Encode(uint8_t* buf, int len) {
Logger::nas_mm().debug("encoding SecurityModeReject message");
Logger::nas_mm().debug("Encoding SecurityModeReject message");
int encoded_size = 0;
int encoded_ie_size = 0;
......@@ -58,20 +55,24 @@ int SecurityModeReject::Encode(uint8_t* buf, int len) {
encoded_size += encoded_ie_size;
// 5GMM Cause
if (int size = ie_5gmm_cause.Encode(buf + encoded_size, len - encoded_size)) {
encoded_size += size;
encoded_ie_size =
ie_5gmm_cause.Encode(buf + encoded_size, len - encoded_size);
if (encoded_ie_size != KEncodeDecodeError) {
encoded_size += encoded_ie_size;
} else {
Logger::nas_mm().error("Encoding ie_5gmm_cause error");
Logger::nas_mm().error(
"Encoding %s error", _5gmmCause::GetIeName().c_str());
return KEncodeDecodeError;
}
Logger::nas_mm().debug(
"encoded SecurityModeReject message len(%d)", encoded_size);
"Encoded SecurityModeReject message len(%d)", encoded_size);
return encoded_size;
}
//------------------------------------------------------------------------------
int SecurityModeReject::Decode(uint8_t* buf, int len) {
Logger::nas_mm().debug("decoding SecurityModeReject message");
Logger::nas_mm().debug("Decoding SecurityModeReject message");
int decoded_size = 0;
int decoded_result = 0;
......@@ -89,11 +90,12 @@ int SecurityModeReject::Decode(uint8_t* buf, int len) {
if (decoded_result != KEncodeDecodeError) {
decoded_size += decoded_result;
} else {
Logger::nas_mm().error("Encoding ie_payload_container error");
Logger::nas_mm().error(
"Decoding %s error", _5gmmCause::GetIeName().c_str());
return KEncodeDecodeError;
}
Logger::nas_mm().debug(
"decoded SecurityModeReject message len(%d)", decoded_size);
"Decoded SecurityModeReject message len(%d)", decoded_size);
return decoded_size;
}
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
......@@ -20,12 +20,8 @@
*/
#ifndef _SERVICE_REJECT_H_
#define _SERVICE_REJECT_H_
#include <stdint.h>
#include <string>
#include "NasIeHeader.hpp"
namespace nas {
......@@ -58,10 +54,10 @@ class ServiceReject : public NasMmPlainHeader {
private:
_5gmmCause ie_5gmm_cause; // Mandatory
std::optional<PDUSessionStatus> ie_PDU_session_status; // Optional
std::optional<GprsTimer2> ie_T3346_value; // Optional
std::optional<PDUSessionStatus> ie_pdu_session_status; // Optional
std::optional<GprsTimer2> ie_t3346_value; // Optional
std::optional<EapMessage> ie_eap_message; // Optional
std::optional<GprsTimer3> ie_T3448_value; // Optional
std::optional<GprsTimer3> ie_t3448_value; // Optional
};
} // namespace nas
......
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
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