Commit 0952db8d authored by Tien Thinh NGUYEN's avatar Tien Thinh NGUYEN

Code cleanup for Service Request

parent 5fd4ea92
...@@ -919,9 +919,9 @@ void amf_n1::service_request_handle( ...@@ -919,9 +919,9 @@ void amf_n1::service_request_handle(
amf_app_inst->set_supi_2_ue_context(supi, uc); amf_app_inst->set_supi_2_ue_context(supi, uc);
// Get PDU session status from Service Request // Get PDU session status from Service Request
uint16_t pdu_session_status = uint16_t pdu_session_status = 0;
(uint16_t) service_request->getPduSessionStatus(); if (!service_request->GetPduSessionStatus(pdu_session_status) or
if (pdu_session_status == 0) { (pdu_session_status == 0)) {
// Get PDU Session Status from NAS Message Container if available // Get PDU Session Status from NAS Message Container if available
bstring plain_msg = nullptr; bstring plain_msg = nullptr;
if (service_request->GetNasMessageContainer(plain_msg)) { if (service_request->GetNasMessageContainer(plain_msg)) {
...@@ -950,17 +950,19 @@ void amf_n1::service_request_handle( ...@@ -950,17 +950,19 @@ void amf_n1::service_request_handle(
nullptr, (uint8_t*) bdata(plain_msg), blength(plain_msg)); nullptr, (uint8_t*) bdata(plain_msg), blength(plain_msg));
bdestroy_wrapper(&plain_msg); bdestroy_wrapper(&plain_msg);
if (service_request_nas->getPduSessionStatus() > 0) { if (!service_request_nas->GetPduSessionStatus(pdu_session_status)) {
pdu_session_status = Logger::nas_mm().debug("IE PDU Session Status is not present");
(uint16_t) service_request_nas->getPduSessionStatus();
} }
/*
// Trigger UE Connectivity Status Notify // Trigger UE Connectivity Status Notify
Logger::amf_n1().debug( Logger::amf_n1().debug(
"Signal the UE Connectivity Status Event notification for SUPI " "Signal the UE Connectivity Status Event notification
for SUPI "
"%s", "%s",
supi.c_str()); supi.c_str());
event_sub.ue_connectivity_state(supi, CM_CONNECTED, 1); event_sub.ue_connectivity_state(supi, CM_CONNECTED, 1);
*/
} break; } break;
default: default:
...@@ -1017,7 +1019,7 @@ void amf_n1::service_request_handle( ...@@ -1017,7 +1019,7 @@ void amf_n1::service_request_handle(
std::shared_ptr<pdu_session_context> psc = {}; std::shared_ptr<pdu_session_context> psc = {};
service_accept->SetPduSessionStatus(service_request->getPduSessionStatus()); service_accept->SetPduSessionStatus(pdu_session_status);
service_accept->SetPduSessionReactivationResult(0x0000); service_accept->SetPduSessionReactivationResult(0x0000);
uint8_t pdu_session_id = pdu_session_to_be_activated.at(0); uint8_t pdu_session_id = pdu_session_to_be_activated.at(0);
......
...@@ -30,8 +30,8 @@ using namespace nas; ...@@ -30,8 +30,8 @@ using namespace nas;
ServiceRequest::ServiceRequest() ServiceRequest::ServiceRequest()
: NasMmPlainHeader(EPD_5GS_MM_MSG, SERVICE_REQUEST) { : NasMmPlainHeader(EPD_5GS_MM_MSG, SERVICE_REQUEST) {
ie_uplink_data_status = std::nullopt; ie_uplink_data_status = std::nullopt;
ie_PDU_session_status = std::nullopt; ie_pdu_session_status = std::nullopt;
ie_allowed_PDU_session_status = std::nullopt; ie_allowed_pdu_session_status = std::nullopt;
ie_nas_message_container = std::nullopt; ie_nas_message_container = std::nullopt;
} }
...@@ -45,43 +45,117 @@ void ServiceRequest::SetHeader(uint8_t security_header_type) { ...@@ -45,43 +45,117 @@ void ServiceRequest::SetHeader(uint8_t security_header_type) {
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::SetNgKsi(uint8_t tsc, uint8_t key_set_id) { void ServiceRequest::SetNgKsi(uint8_t tsc, uint8_t key_set_id) {
ie_ngKSI.Set(false); // 4 lower bits ie_ng_ksi.Set(false); // 4 lower bits
ie_ngKSI.SetNasKeyIdentifier(key_set_id); ie_ng_ksi.SetNasKeyIdentifier(key_set_id);
ie_ngKSI.SetTypeOfSecurityContext(tsc); ie_ng_ksi.SetTypeOfSecurityContext(tsc);
}
//------------------------------------------------------------------------------
void ServiceRequest::GetNgKsi(uint8_t& ng_ksi) const {
ng_ksi =
(ie_ng_ksi.GetTypeOfSecurityContext()) | ie_ng_ksi.GetNasKeyIdentifier();
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::SetServiceType(uint8_t value) { void ServiceRequest::SetServiceType(uint8_t value) {
ie_service_type.Set(true, value); ie_service_type.Set(true, value); // 4 higher bit
}
//------------------------------------------------------------------------------
void ServiceRequest::GetServiceType(uint8_t& value) {
ie_service_type.GetValue(value);
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::Set5gSTmsi( void ServiceRequest::Set5gSTmsi(
uint16_t amf_set_id, uint8_t amf_pointer, string tmsi) { uint16_t amf_set_id, uint8_t amf_pointer, std::string tmsi) {
ie_5g_s_tmsi.Set5gSTmsi(amf_set_id, amf_pointer, tmsi); ie_5g_s_tmsi.Set5gSTmsi(amf_set_id, amf_pointer, tmsi);
} }
//------------------------------------------------------------------------------
bool ServiceRequest::Get5gSTmsi(
uint16_t& amf_set_id, uint8_t& amf_pointer, string& tmsi) const {
return ie_5g_s_tmsi.Get5gSTmsi(amf_set_id, amf_pointer, tmsi);
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::SetUplinkDataStatus(uint16_t value) { void ServiceRequest::SetUplinkDataStatus(uint16_t value) {
ie_uplink_data_status = std::make_optional<UplinkDataStatus>(value); ie_uplink_data_status = std::make_optional<UplinkDataStatus>(value);
} }
//------------------------------------------------------------------------------
bool ServiceRequest::GetUplinkDataStatus(uint16_t& value) const {
if (ie_uplink_data_status.has_value()) {
value = ie_uplink_data_status.value().GetValue();
return true;
} else {
return false;
}
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::SetPduSessionStatus(uint16_t value) { void ServiceRequest::SetPduSessionStatus(uint16_t value) {
ie_PDU_session_status = std::make_optional<PDUSessionStatus>(value); ie_pdu_session_status = std::make_optional<PDUSessionStatus>(value);
}
//------------------------------------------------------------------------------
bool ServiceRequest::GetPduSessionStatus(uint16_t& value) const {
if (ie_pdu_session_status.has_value()) {
value = ie_pdu_session_status.value().GetValue();
return true;
} else {
return false;
}
}
//------------------------------------------------------------------------------
std::optional<uint16_t> ServiceRequest::GetPduSessionStatus() const {
if (ie_pdu_session_status.has_value()) {
return std::optional<uint16_t>(ie_pdu_session_status.value().GetValue());
}
return std::nullopt;
} }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::SetAllowedPduSessionStatus(uint16_t value) { void ServiceRequest::SetAllowedPduSessionStatus(uint16_t value) {
ie_allowed_PDU_session_status = ie_allowed_pdu_session_status =
std::make_optional<AllowedPDUSessionStatus>(value); std::make_optional<AllowedPDUSessionStatus>(value);
} }
//------------------------------------------------------------------------------
bool ServiceRequest::GetAllowedPduSessionStatus(uint16_t& value) const {
if (ie_allowed_pdu_session_status.has_value()) {
value = ie_allowed_pdu_session_status.value().GetValue();
return true;
} else {
return false;
}
}
//------------------------------------------------------------------------------
std::optional<uint16_t> ServiceRequest::GetAllowedPduSessionStatus() const {
if (ie_allowed_pdu_session_status.has_value()) {
return std::optional<uint16_t>(
ie_allowed_pdu_session_status.value().GetValue());
}
return std::nullopt;
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
void ServiceRequest::SetNasMessageContainer(bstring value) { void ServiceRequest::SetNasMessageContainer(bstring value) {
ie_nas_message_container = std::make_optional<NasMessageContainer>(value); ie_nas_message_container = std::make_optional<NasMessageContainer>(value);
} }
//------------------------------------------------------------------------------
bool ServiceRequest::GetNasMessageContainer(bstring& nas) const {
if (ie_nas_message_container.has_value()) {
ie_nas_message_container.value().GetValue(nas);
return true;
} else {
return false;
}
}
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
int ServiceRequest::Encode(uint8_t* buf, int len) { int ServiceRequest::Encode(uint8_t* buf, int len) {
Logger::nas_mm().debug("Encoding ServiceRequest message..."); Logger::nas_mm().debug("Encoding ServiceRequest message...");
...@@ -98,13 +172,13 @@ int ServiceRequest::Encode(uint8_t* buf, int len) { ...@@ -98,13 +172,13 @@ int ServiceRequest::Encode(uint8_t* buf, int len) {
encoded_size += encoded_ie_size; encoded_size += encoded_ie_size;
// ngKSI and Service Type // ngKSI and Service Type
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) { if (size == KEncodeDecodeError) {
Logger::nas_mm().error("Encoding ie_ngKSI error"); Logger::nas_mm().error("Encoding NgKSI error");
return KEncodeDecodeError; return KEncodeDecodeError;
} }
if (size != 0) { if (size != 0) {
Logger::nas_mm().error("Encoding ie_ngKSI error"); Logger::nas_mm().error("Encoding NgKSI error");
return KEncodeDecodeError; return KEncodeDecodeError;
} }
...@@ -140,29 +214,29 @@ int ServiceRequest::Encode(uint8_t* buf, int len) { ...@@ -140,29 +214,29 @@ int ServiceRequest::Encode(uint8_t* buf, int len) {
} }
// PDU session status // PDU session status
if (!ie_PDU_session_status.has_value()) { if (!ie_pdu_session_status.has_value()) {
Logger::nas_mm().warn("IE ie_PDU_session_status is not available"); Logger::nas_mm().warn("IE ie_pdu_session_status is not available");
} else { } else {
size = ie_PDU_session_status.value().Encode( size = ie_pdu_session_status.value().Encode(
buf + encoded_size, len - encoded_size); buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) { if (size != KEncodeDecodeError) {
encoded_size += size; encoded_size += size;
} else { } else {
Logger::nas_mm().error("Encoding ie_PDU_session_status error"); Logger::nas_mm().error("Encoding ie_pdu_session_status error");
return KEncodeDecodeError; return KEncodeDecodeError;
} }
} }
// Allowed PDU session status // Allowed PDU session status
if (!ie_allowed_PDU_session_status.has_value()) { if (!ie_allowed_pdu_session_status.has_value()) {
Logger::nas_mm().warn("IE ie_allowed_PDU_session_status is not available"); Logger::nas_mm().warn("IE ie_allowed_pdu_session_status is not available");
} else { } else {
size = ie_allowed_PDU_session_status.value().Encode( size = ie_allowed_pdu_session_status.value().Encode(
buf + encoded_size, len - encoded_size); buf + encoded_size, len - encoded_size);
if (size != KEncodeDecodeError) { if (size != KEncodeDecodeError) {
encoded_size += size; encoded_size += size;
} else { } else {
Logger::nas_mm().error("Encoding ie_allowed_PDU_session_status error"); Logger::nas_mm().error("Encoding ie_allowed_pdu_session_status error");
return KEncodeDecodeError; return KEncodeDecodeError;
} }
} }
...@@ -202,7 +276,7 @@ int ServiceRequest::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) { ...@@ -202,7 +276,7 @@ int ServiceRequest::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) {
// ngKSI + Service type // ngKSI + Service type
decoded_result = 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) return KEncodeDecodeError; if (decoded_result == KEncodeDecodeError) return KEncodeDecodeError;
decoded_result = ie_service_type.Decode( decoded_result = ie_service_type.Decode(
buf + decoded_size, len - decoded_size, true, false); buf + decoded_size, len - decoded_size, true, false);
...@@ -234,31 +308,31 @@ int ServiceRequest::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) { ...@@ -234,31 +308,31 @@ int ServiceRequest::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) {
case kIeiPduSessionStatus: { case kIeiPduSessionStatus: {
Logger::nas_mm().debug( Logger::nas_mm().debug(
"Decoding ie_PDU_session_status (IEI 0x%x)", kIeiPduSessionStatus); "Decoding ie_pdu_session_status (IEI 0x%x)", kIeiPduSessionStatus);
PDUSessionStatus ie_PDU_session_status_tmp = {}; PDUSessionStatus ie_pdu_session_status_tmp = {};
if ((decoded_result = ie_PDU_session_status_tmp.Decode( if ((decoded_result = ie_pdu_session_status_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) == buf + decoded_size, len - decoded_size, true)) ==
KEncodeDecodeError) KEncodeDecodeError)
return decoded_result; return decoded_result;
decoded_size += decoded_result; decoded_size += decoded_result;
ie_PDU_session_status = ie_pdu_session_status =
std::optional<PDUSessionStatus>(ie_PDU_session_status_tmp); std::optional<PDUSessionStatus>(ie_pdu_session_status_tmp);
octet = *(buf + decoded_size); octet = *(buf + decoded_size);
Logger::nas_mm().debug("Next IEI (0x%x)", octet); Logger::nas_mm().debug("Next IEI (0x%x)", octet);
} break; } break;
case kIeiAllowedPduSessionStatus: { case kIeiAllowedPduSessionStatus: {
Logger::nas_mm().debug( Logger::nas_mm().debug(
"Decoding ie_allowed_PDU_session_status, IEI 0x%x", "Decoding ie_allowed_pdu_session_status, IEI 0x%x",
kIeiAllowedPduSessionStatus); kIeiAllowedPduSessionStatus);
AllowedPDUSessionStatus ie_allowed_PDU_session_status_tmp = {}; AllowedPDUSessionStatus ie_allowed_pdu_session_status_tmp = {};
if ((decoded_result = ie_allowed_PDU_session_status_tmp.Decode( if ((decoded_result = ie_allowed_pdu_session_status_tmp.Decode(
buf + decoded_size, len - decoded_size, true)) == buf + decoded_size, len - decoded_size, true)) ==
KEncodeDecodeError) KEncodeDecodeError)
return decoded_result; return decoded_result;
decoded_size += decoded_result; decoded_size += decoded_result;
ie_allowed_PDU_session_status = std::optional<AllowedPDUSessionStatus>( ie_allowed_pdu_session_status = std::optional<AllowedPDUSessionStatus>(
ie_allowed_PDU_session_status_tmp); ie_allowed_pdu_session_status_tmp);
octet = *(buf + decoded_size); octet = *(buf + decoded_size);
Logger::nas_mm().debug("Next IEI (0x%x)", octet); Logger::nas_mm().debug("Next IEI (0x%x)", octet);
} break; } break;
...@@ -289,60 +363,3 @@ int ServiceRequest::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) { ...@@ -289,60 +363,3 @@ int ServiceRequest::Decode(NasMmPlainHeader* header, uint8_t* buf, int len) {
"Decoded ServiceRequest message len (%d)", decoded_size); "Decoded ServiceRequest message len (%d)", decoded_size);
return decoded_size; return decoded_size;
} }
//------------------------------------------------------------------------------
bool ServiceRequest::GetNgKSI(uint8_t& ng_ksi) {
ng_ksi =
(ie_ngKSI.GetTypeOfSecurityContext()) | ie_ngKSI.GetNasKeyIdentifier();
return true;
}
//------------------------------------------------------------------------------
uint16_t ServiceRequest::GetUplinkDataStatus() {
if (ie_uplink_data_status) {
return ie_uplink_data_status->GetValue();
} else {
return -1;
}
}
//------------------------------------------------------------------------------
uint16_t ServiceRequest::GetPduSessionStatus() {
if (ie_PDU_session_status) {
return ie_PDU_session_status->GetValue();
} else {
return 0;
}
}
//------------------------------------------------------------------------------
uint16_t ServiceRequest::GetAllowedPduSessionStatus() {
if (ie_allowed_PDU_session_status) {
return ie_allowed_PDU_session_status->GetValue();
} else {
return 0;
}
}
//------------------------------------------------------------------------------
bool ServiceRequest::GetNasMessageContainer(bstring& nas) {
if (ie_nas_message_container) {
ie_nas_message_container->GetValue(nas);
return true;
} else {
return false;
}
}
//------------------------------------------------------------------------------
uint8_t ServiceRequest::GetServiceType() {
uint8_t value = 0;
ie_service_type.GetValue(value);
return value;
}
//------------------------------------------------------------------------------
bool ServiceRequest::Get5gSTmsi(
uint16_t& amf_set_id, uint8_t& amf_pointer, string& tmsi) {
return ie_5g_s_tmsi.Get5gSTmsi(amf_set_id, amf_pointer, tmsi);
}
...@@ -38,35 +38,38 @@ class ServiceRequest : public NasMmPlainHeader { ...@@ -38,35 +38,38 @@ class ServiceRequest : public NasMmPlainHeader {
int Decode(NasMmPlainHeader* header, uint8_t* buf, int len); int Decode(NasMmPlainHeader* header, uint8_t* buf, int len);
void SetNgKsi(uint8_t tsc, uint8_t key_set_id); void SetNgKsi(uint8_t tsc, uint8_t key_set_id);
bool GetNgKSI(uint8_t& ng_ksi); void GetNgKsi(uint8_t& ng_ksi) const;
void SetServiceType(uint8_t value); void SetServiceType(uint8_t value);
uint8_t GetServiceType(); void GetServiceType(uint8_t& value);
void Set5gSTmsi(uint16_t amf_set_id, uint8_t amf_pointer, string tmsi); void Set5gSTmsi(uint16_t amf_set_id, uint8_t amf_pointer, std::string tmsi);
bool Get5gSTmsi(uint16_t& amf_set_id, uint8_t& amf_pointer, string& tmsi); bool Get5gSTmsi(
uint16_t& amf_set_id, uint8_t& amf_pointer, std::string& tmsi) const;
void SetUplinkDataStatus(uint16_t value); void SetUplinkDataStatus(uint16_t value);
uint16_t GetUplinkDataStatus(); bool GetUplinkDataStatus(uint16_t& value) const;
void SetPduSessionStatus(uint16_t value); void SetPduSessionStatus(uint16_t value);
uint16_t GetPduSessionStatus(); bool GetPduSessionStatus(uint16_t& value) const;
std::optional<uint16_t> GetPduSessionStatus() const;
void SetAllowedPduSessionStatus(uint16_t value); void SetAllowedPduSessionStatus(uint16_t value);
uint16_t GetAllowedPduSessionStatus(); bool GetAllowedPduSessionStatus(uint16_t& value) const;
std::optional<uint16_t> GetAllowedPduSessionStatus() const;
void SetNasMessageContainer(bstring value); void SetNasMessageContainer(bstring value);
bool GetNasMessageContainer(bstring& nas); bool GetNasMessageContainer(bstring& nas) const;
private: private:
NasKeySetIdentifier ie_ngKSI; // Mandatory NasKeySetIdentifier ie_ng_ksi; // Mandatory
ServiceType ie_service_type; // Mandatory ServiceType ie_service_type; // Mandatory
_5GSMobileIdentity ie_5g_s_tmsi; // Mandatory _5GSMobileIdentity ie_5g_s_tmsi; // Mandatory
std::optional<UplinkDataStatus> ie_uplink_data_status; // Optional std::optional<UplinkDataStatus> ie_uplink_data_status; // Optional
std::optional<PDUSessionStatus> ie_PDU_session_status; // Optional std::optional<PDUSessionStatus> ie_pdu_session_status; // Optional
std::optional<AllowedPDUSessionStatus> std::optional<AllowedPDUSessionStatus>
ie_allowed_PDU_session_status; // Optional ie_allowed_pdu_session_status; // Optional
std::optional<NasMessageContainer> ie_nas_message_container; // Optional std::optional<NasMessageContainer> ie_nas_message_container; // 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