Commit f4b85dff authored by Tien-Thinh Nguyen's avatar Tien-Thinh Nguyen

Merge branch 'ue_context_refactor' into 'develop'

Ue context refactor

See merge request oai/cn5g/oai-cn5g-amf!193
parents 260bff8c aff1b842
......@@ -407,9 +407,9 @@ void amf_app::handle_itti_message(
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;
uc->is_ue_context_request = false;
else
uc->isUeContextRequest = true;
uc->is_ue_context_request = true;
uc->ran_ue_ngap_id = itti_msg.ran_ue_ngap_id;
uc->amf_ue_ngap_id = amf_ue_ngap_id;
......@@ -584,7 +584,7 @@ void amf_app::handle_itti_message(itti_sbi_n1_message_notification& itti_msg) {
uc->rrc_estb_cause = (e_Ngap_RRCEstablishmentCause) rrc_cause;
}
// ueContextRequest
uc->isUeContextRequest = registration_context.isUeContextRequest();
uc->is_ue_context_request = registration_context.isUeContextRequest();
// Step 4. Create UE NGAP Context if necessary
// Create/Update UE NGAP Context
......
......@@ -814,8 +814,8 @@ void amf_config::display() {
smf_pool[i].fqdn :
smf_pool[i].ipv4.c_str();
Logger::config().info(
" SMF_INSTANCE_ID %d (%s:%s, version %s) is selected: %s",
smf_pool[i].id, smf_info.c_str(), smf_pool[i].port.c_str(),
" SMF_INSTANCE_ID %d (%s:%d, version %s) is selected: %s",
smf_pool[i].id, smf_info.c_str(), smf_pool[i].port,
smf_pool[i].version.c_str(), selected.c_str());
}
}
......@@ -919,7 +919,7 @@ bool amf_config::resolve_fqdn(
//------------------------------------------------------------------------------
std::string amf_config::get_amf_n1n2_message_subscribe_uri(
const std::string& ue_cxt_id) {
unsigned int sbi_port = 80;
unsigned int sbi_port = DEFAULT_HTTP1_PORT;
if (support_features.use_http2) {
sbi_port = sbi_http2_port;
} else {
......@@ -978,11 +978,9 @@ bool amf_config::get_smf_pdu_session_context_uri(
}
std::string smf_addr = {};
std::string smf_port = {};
std::string smf_ip_addr = {};
smf_addr = psc->smf_info.addr;
smf_port = psc->smf_info.port;
// remove http port from the URI if existed
std::size_t found_port = smf_addr.find(":");
......@@ -995,13 +993,14 @@ bool amf_config::get_smf_pdu_session_context_uri(
if (found != std::string::npos)
smf_uri = psc->smf_info.context_location;
else
smf_uri = smf_addr + ":" + smf_port + psc->smf_info.context_location;
smf_uri = smf_addr + ":" + std::to_string(psc->smf_info.port) +
psc->smf_info.context_location;
return true;
}
//------------------------------------------------------------------------------
std::string amf_config::get_smf_pdu_session_base_uri(
const std::string& smf_addr, const std::string& smf_port,
const std::string& smf_addr, const uint32_t& smf_port,
const std::string& smf_api_version) {
// Remove http port from the URI if existed
std::string smf_ip_addr = {};
......@@ -1011,8 +1010,8 @@ std::string amf_config::get_smf_pdu_session_base_uri(
else
smf_ip_addr = smf_addr;
return smf_ip_addr + ":" + smf_port + "/nsmf-pdusession/" + smf_api_version +
NSMF_PDU_SESSION_CREATE;
return smf_ip_addr + ":" + std::to_string(smf_port) + "/nsmf-pdusession/" +
smf_api_version + NSMF_PDU_SESSION_CREATE;
}
//------------------------------------------------------------------------------
......
......@@ -332,7 +332,7 @@ typedef struct {
typedef struct {
int id;
std::string ipv4;
std::string port;
uint32_t port;
uint32_t http2_port;
std::string version;
bool selected;
......@@ -351,10 +351,9 @@ typedef struct {
}
void from_json(nlohmann::json& json_data) {
this->id = json_data["id"].get<int>();
this->ipv4 = json_data["ipv4"].get<std::string>();
this->port = json_data["port"]
.get<std::string>(); // TODO: use int instead of string
this->id = json_data["id"].get<int>();
this->ipv4 = json_data["ipv4"].get<std::string>();
this->port = json_data["port"].get<int>();
this->http2_port = json_data["http2_port"].get<int>();
this->version = json_data["version"].get<std::string>();
this->selected = json_data["selected"].get<bool>();
......@@ -468,13 +467,13 @@ class amf_config {
/*
* Get the URI of SMF Services
* @param [const std::string&] smf_addr: SMF's Addr in String representation
* @param [const std::string&] smf_port: SMF's port in String representation
* @param [const uint32_t&] smf_port: SMF's port in String representation
* @param [const std::string&] smf_api_version: SMF's API version in String
* representation
* @return URI in string format
*/
std::string get_smf_pdu_session_base_uri(
const std::string& smf_addr, const std::string& smf_port,
const std::string& smf_addr, const uint32_t& smf_port,
const std::string& smf_api_version);
/*
......
This diff is collapsed.
......@@ -671,7 +671,7 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
}
// Store InitialUEMessage for Rereoute NAS later
if (unc->initialUEMsg.buf) {
if (unc->initial_ue_msg.buf) {
Logger::amf_n2().debug(
"Store InitialUEMessage for Reroute NAS (if necessary)");
uint8_t* initial_ue_msg_buf = (uint8_t*) calloc(1, BUFFER_SIZE_1024);
......@@ -681,11 +681,11 @@ void amf_n2::handle_itti_message(itti_initial_ue_message& init_ue_msg) {
if (encoded_size > 0) {
Logger::amf_n2().debug("Encoded InitialUEMessage size %d", encoded_size);
memcpy(
(void*) unc->initialUEMsg.buf, (void*) initial_ue_msg_buf,
(void*) unc->initial_ue_msg.buf, (void*) initial_ue_msg_buf,
encoded_size);
output_wrapper::print_buffer(
"ngap", "InitialUEMessage", unc->initialUEMsg.buf, encoded_size);
unc->initialUEMsg.size = encoded_size;
"ngap", "InitialUEMessage", unc->initial_ue_msg.buf, encoded_size);
unc->initial_ue_msg.size = encoded_size;
}
}
......@@ -2134,9 +2134,9 @@ void amf_n2::handle_itti_message(itti_rereoute_nas& itti_msg) {
reroute_nas_request.setRanUeNgapId(itti_msg.ran_ue_ngap_id);
reroute_nas_request.setAmfUeNgapId(itti_msg.amf_ue_ngap_id);
if (!reroute_nas_request.setAMFSetID(itti_msg.amf_set_id)) return;
if (unc->initialUEMsg.size > 0)
if (unc->initial_ue_msg.size > 0)
reroute_nas_request.setNgapMessage(
unc->initialUEMsg); // Include InitialUEMessage
unc->initial_ue_msg); // Include InitialUEMessage
// TODO: AllowedNSSAI (Optional)
......
......@@ -338,7 +338,7 @@ void amf_sbi::handle_itti_message(itti_nsmf_pdusession_create_sm_context& smf) {
std::string smf_addr = {};
std::string smf_api_version = {};
std::string smf_port = "80"; // Set to default port number
uint32_t smf_port = DEFAULT_HTTP1_PORT;
if (!psc->smf_info.info_available) {
if (amf_cfg.support_features.enable_smf_selection) {
// Get NRF URI
......@@ -369,9 +369,9 @@ void amf_sbi::handle_itti_message(itti_nsmf_pdusession_create_sm_context& smf) {
psc->smf_info.port = smf_port;
psc->smf_info.api_version = smf_api_version;
} else {
smf_addr = psc->smf_info.addr;
smf_api_version = psc->smf_info.api_version;
std::string smf_port = psc->smf_info.port;
smf_addr = psc->smf_info.addr;
smf_api_version = psc->smf_info.api_version;
smf_port = psc->smf_info.port;
}
switch (smf.req_type & 0x07) {
......@@ -438,7 +438,7 @@ void amf_sbi::send_pdu_session_update_sm_context_request(
void amf_sbi::handle_pdu_session_initial_request(
const std::string& supi, std::shared_ptr<pdu_session_context>& psc,
const std::string& smf_addr, const std::string& smf_api_version,
const std::string& smf_port, bstring sm_msg, const std::string& dnn) {
const uint32_t& smf_port, bstring sm_msg, const std::string& dnn) {
Logger::amf_sbi().debug(
"Handle PDU Session Establishment Request (SUPI %s, PDU Session ID %d)",
supi.c_str(), psc->pdu_session_id);
......@@ -749,8 +749,7 @@ void amf_sbi::handle_itti_message(itti_sbi_nf_instance_discovery& itti_msg) {
//------------------------------------------------------------------------------
bool amf_sbi::smf_selection_from_configuration(
std::string& smf_addr, std::string& smf_port,
std::string& smf_api_version) {
std::string& smf_addr, uint32_t& smf_port, std::string& smf_api_version) {
for (int i = 0; i < amf_cfg.smf_pool.size(); i++) {
if (amf_cfg.smf_pool[i].selected) {
if (!amf_cfg.support_features.use_fqdn_dns) {
......@@ -759,7 +758,7 @@ bool amf_sbi::smf_selection_from_configuration(
smf_port = amf_cfg.smf_pool[i].port;
} else {
smf_addr = amf_cfg.smf_pool[i].ipv4;
smf_port = std::to_string(amf_cfg.smf_pool[i].http2_port);
smf_port = amf_cfg.smf_pool[i].http2_port;
}
smf_api_version = amf_cfg.smf_pool[i].version;
......@@ -767,18 +766,19 @@ bool amf_sbi::smf_selection_from_configuration(
} else {
// resolve IP addr from a FQDN/DNS name
uint8_t addr_type = 0;
uint32_t smf_port_resolved = 0;
uint32_t smf_port_resolved = DEFAULT_HTTP1_PORT;
fqdn::resolve(
amf_cfg.smf_pool[i].fqdn, amf_cfg.smf_pool[i].ipv4,
smf_port_resolved, addr_type);
// TODO for HTTP2
if (amf_cfg.support_features.use_http2) smf_port_resolved = 8080;
if (amf_cfg.support_features.use_http2)
smf_port_resolved = DEFAULT_HTTP2_PORT;
if (addr_type != 0) { // IPv6: TODO
Logger::amf_sbi().warn("Do not support IPv6 Addr for SMF");
return false;
} else { // IPv4
smf_addr = amf_cfg.smf_pool[i].ipv4;
smf_port = std::to_string(smf_port_resolved);
smf_port = smf_port_resolved;
smf_api_version = "v1"; // TODO: get API version
return true;
}
......@@ -814,7 +814,7 @@ void amf_sbi::handle_post_sm_context_response_error(
//-----------------------------------------------------------------------------------------------------
bool amf_sbi::discover_smf(
std::string& smf_addr, std::string& smf_port, std::string& smf_api_version,
std::string& smf_addr, uint32_t& smf_port, std::string& smf_api_version,
const snssai_t& snssai, const plmn_t& plmn, const std::string& dnn,
const std::string& nrf_uri) {
Logger::amf_sbi().debug(
......@@ -899,7 +899,7 @@ bool amf_sbi::discover_smf(
if (nf_service.find("ipEndPoints") != nf_service.end()) {
nlohmann::json nf_ip_endpoint = nf_service["ipEndPoints"].at(0);
if (nf_ip_endpoint.find("port") != nf_ip_endpoint.end()) {
smf_port = std::to_string(nf_ip_endpoint["port"].get<int>());
smf_port = nf_ip_endpoint["port"].get<int>();
}
}
......@@ -919,8 +919,8 @@ bool amf_sbi::discover_smf(
}
Logger::amf_sbi().debug(
"NFDiscovery, SMF Addr %s, SMF port %s, SMF Api Version %s",
smf_addr.c_str(), smf_port.c_str(), smf_api_version.c_str());
"NFDiscovery, SMF Info: Addr %s, Port %d, API Version %s",
smf_addr.c_str(), smf_port, smf_api_version.c_str());
}
return result;
......
......@@ -117,7 +117,7 @@ class amf_sbi {
* Session Context
* @param [const std::string&] smf_addr: SMF's Address
* @param [const std::string&] smf_api_version: SMF's API version
* @param [const std::string&] smf_port: SMF's HTTP port
* @param [const uint32_t&] smf_port: SMF's HTTP port
* @param [bstring] sm_msg: SM message
* @param [const std::string&] dnn: DNN
* @return void
......@@ -125,7 +125,7 @@ class amf_sbi {
void handle_pdu_session_initial_request(
const std::string& supi, std::shared_ptr<pdu_session_context>& psc,
const std::string& smf_addr, const std::string& smf_api_version,
const std::string& smf_port, bstring sm_msg, const std::string& dnn);
const uint32_t& smf_port, bstring sm_msg, const std::string& dnn);
/*
* Send SM Context response error to AMF
......@@ -163,19 +163,18 @@ class amf_sbi {
/*
* Select SMF from the configuration file
* @param [const std::string&] smf_addr: SMF's Address
* @param [const std::string&] smf_port: SMF's HTTP port
* @param [const std::string&] smf_api_version: SMF's API version
* @param [std::string&] smf_addr: SMF's Address
* @param [uint32_t&] smf_port: SMF's HTTP port
* @param [std::string&] smf_api_version: SMF's API version
* @return true if successful, otherwise return false
*/
bool smf_selection_from_configuration(
std::string& smf_addr, std::string& smf_port,
std::string& smf_api_version);
std::string& smf_addr, uint32_t& smf_port, std::string& smf_api_version);
/*
* Find suitable SMF from NRF (based on snssai, plmn and dnn)
* @param [std::string&] smf_addr: SMF's Address
* @param [std::string&] smf_port: SMF's HTTP port
* @param [uint32_t&] smf_port: SMF's HTTP port
* @param [std::string&] smf_api_version: SMF's API version
* @param [const snssai_t&] snssai: SNSSAI
* @param [const plmn_t&] plmn: PLMN
......@@ -184,9 +183,9 @@ class amf_sbi {
* @return true if successful, otherwise return false
*/
bool discover_smf(
std::string& smf_addr, std::string& smf_port,
std::string& smf_api_version, const snssai_t& snssai, const plmn_t& plmn,
const std::string& dnn, const std::string& nrf_uri = {});
std::string& smf_addr, uint32_t& smf_port, std::string& smf_api_version,
const snssai_t& snssai, const plmn_t& plmn, const std::string& dnn,
const std::string& nrf_uri = {});
/*
* Send UE Authentication Request to AUSF
......
......@@ -22,25 +22,21 @@
#include "nas_context.hpp"
//------------------------------------------------------------------------------
nas_context::nas_context() : _vector(), _5g_he_av(), _5g_av(), kamf() {
security_ctx = nullptr;
is_imsi_present = false;
is_stacs_available = false;
is_auth_vectors_present = false;
auts = nullptr;
ctx_avaliability_ind = false;
amf_ue_ngap_id = 0;
ran_ue_ngap_id = 0;
_5gmm_state = {};
registration_type = 0;
follow_on_req_pending_ind = false;
ngKsi = 0;
mmCapability = 0;
ueSecurityCapEnc = 0;
ueSecurityCapInt = 0;
ueSecurityCapEEA = 0;
ueSecurityCapEIA = 0;
// requestedNssai = {};
nas_context::nas_context()
: _vector(), _5g_he_av(), _5g_av(), kamf(), _5gmm_capability() {
security_ctx = nullptr;
is_imsi_present = false;
is_stacs_available = false;
is_auth_vectors_present = false;
auts = nullptr;
ctx_avaliability_ind = false;
amf_ue_ngap_id = 0;
ran_ue_ngap_id = 0;
_5gmm_state = {};
registration_type = 0;
follow_on_req_pending_ind = false;
ngksi = 0;
ue_security_capability = {};
is_specific_procedure_for_registration_running = false;
is_specific_procedure_for_deregistration_running = false;
is_specific_procedure_for_eCell_inactivity_running = false;
......@@ -48,7 +44,6 @@ nas_context::nas_context() : _vector(), _5g_he_av(), _5g_av(), kamf() {
is_common_procedure_for_identification_running = false;
is_common_procedure_for_security_mode_control_running = false;
is_common_procedure_for_nas_transport_running = false;
_security = {};
security_ctx = nullptr;
is_current_security_available = false;
registration_attempt_counter = 0;
......@@ -56,12 +51,13 @@ nas_context::nas_context() : _vector(), _5g_he_av(), _5g_av(), kamf() {
is_5g_guti_present = false;
is_auth_vectors_present = false;
to_be_register_by_new_suci = false;
ueSecurityCaplen = 0;
registration_request_is_set = false;
registration_request = nullptr;
nas_status = CM_IDLE;
is_mobile_reachable_timer_timeout = false;
mobile_reachable_timer = ITTI_INVALID_TIMER_ID;
implicit_deregistration_timer = ITTI_INVALID_TIMER_ID;
href = {};
}
//------------------------------------------------------------------------------
......
......@@ -26,6 +26,7 @@
#include <string>
#include "UESecurityCapability.hpp"
#include "authentication_algorithms_with_5gaka.hpp"
#include "itti.hpp"
#include "nas_security_context.hpp"
......@@ -78,22 +79,16 @@ class nas_context {
timer_id_t mobile_reachable_timer;
timer_id_t implicit_deregistration_timer;
// parameters from Registration request
uint8_t registration_type : 3;
// Parameters from Registration request
uint8_t registration_type; // 3 bits
bool follow_on_req_pending_ind;
uint8_t ngKsi : 4;
// mobility identity: imsi, supi, 5g-guti, etc
std::string imsi;
uint8_t mmCapability; // TODO: multiple octets
uint8_t ueSecurityCaplen;
uint8_t ueSecurityCapEnc;
uint8_t ueSecurityCapInt;
uint8_t ueSecurityCapEEA;
uint8_t ueSecurityCapEIA;
std::vector<nas::SNSSAI_t>
requestedNssai; // TODO: update with naming convention
uint8_t ngksi; // 4 bits
std::string imsi; // TODO: use SUPI instead
std::uint8_t _5gmm_capability[13];
nas::UESecurityCapability ue_security_capability;
std::vector<nas::SNSSAI_t> requested_nssai;
std::vector<nas::SNSSAI_t> allowed_nssai; // in Registration Accept
// Set to true if marked as default
std::vector<std::pair<bool, nas::SNSSAI_t>> subscribed_snssai;
......@@ -106,7 +101,7 @@ class nas_context {
bool registration_request_is_set;
std::string serving_network;
bstring auts;
// NAS EP(s)
// NAS procedure
bool is_specific_procedure_for_registration_running;
bool is_specific_procedure_for_deregistration_running;
bool is_specific_procedure_for_eCell_inactivity_running;
......@@ -117,17 +112,13 @@ class nas_context {
// security related
#define MAX_5GS_AUTH_VECTORS 1
auc_vector_t _vector[MAX_5GS_AUTH_VECTORS]; /* 5GS authentication vector */
auc_vector_t _vector[MAX_5GS_AUTH_VECTORS]; // 5GS Authentication vector
_5G_HE_AV_t _5g_he_av[MAX_5GS_AUTH_VECTORS]; // generated by UDM
_5G_AV_t _5g_av[MAX_5GS_AUTH_VECTORS]; // generated by ausf
std::string Href;
_5G_AV_t _5g_av[MAX_5GS_AUTH_VECTORS]; // generated by AUSF
std::string href;
uint8_t kamf[MAX_5GS_AUTH_VECTORS][32];
security_context_t _security;
nas_secu_ctx* security_ctx; // TODO: avoid using naked ptr
bool is_current_security_available;
int registration_attempt_counter; // used to limit the subsequently reject
// registration
// attempts(clause 5.5.1.2.7/5.5.1.3.7,
......
......@@ -26,7 +26,6 @@
#define AUTH_KNAS_INT_SIZE 16 /* NAS integrity key */
#define AUTH_KNAS_ENC_SIZE 16 /* NAS cyphering key */
#define NGKSI_MAX_VALUE 6
/* Type of security context */
......@@ -40,36 +39,6 @@ typedef enum {
/*
Internal data used for security mode control procedure
*/
typedef struct {
unsigned int ue_id; /* UE identifier */
#define SECURITY_COUNTER_MAX 5
unsigned int retransmission_count; /* Retransmission counter */
int ksi; /* NAS key set identifier */
int nea; /* Replayed EPS encryption algorithms */
int eea; /* Replayed EPS encryption algorithms */
int nia; /* Replayed EPS integrity algorithms */
int eia; /* Replayed EPS integrity algorithms */
int ucs2; /* Replayed Alphabet */
int uea; /* Replayed UMTS encryption algorithms */
int uia; /* Replayed UMTS integrity algorithms */
int gea; /* Replayed G encryption algorithms */
bool umts_present;
bool gprs_present;
int selected_eea; /* Selected EPS encryption algorithms */
int selected_eia; /* Selected EPS integrity algorithms */
int saved_selected_eea; /* Previous selected EPS encryption algorithms */
int saved_selected_nea; /* Previous selected EPS encryption algorithms */
int saved_selected_eia; /* Previous selected EPS integrity algorithms */
int saved_selected_nia; /* Previous selected EPS integrity algorithms */
int saved_ngksi; /* Previous ksi */
uint16_t saved_overflow; /* Previous dl_count overflow */
uint8_t saved_seq_num; /* Previous dl_count seq_num */
nas_sc_type_t saved_sc_type;
bool notify_failure; /* Indicates whether the identification
* procedure failure shall be notified
* to the ongoing EMM procedure */
} security_data_t;
typedef uint8_t ngksi_t;
typedef struct {
......
......@@ -34,7 +34,7 @@ pdu_session_context::pdu_session_context() {
smf_info.info_available = false;
smf_info.addr = {};
smf_info.api_version = "v1";
smf_info.port = "80";
smf_info.port = DEFAULT_HTTP1_PORT;
snssai = {};
plmn = {};
is_ho_accepted = false;
......
......@@ -22,15 +22,13 @@
#ifndef _PDU_SESSION_CONTEXT_H_
#define _PDU_SESSION_CONTEXT_H_
#include <string>
#include "amf.hpp"
#include "bstrlib.h"
typedef struct smf_context_info_s {
bool info_available;
std::string addr;
std::string port; // TODO: define as uint32_t
uint32_t port;
std::string api_version;
std::string context_location;
} smf_context_info_t;
......@@ -52,7 +50,6 @@ class pdu_session_context {
smf_context_info_t smf_info;
snssai_t snssai;
plmn_t plmn;
bool is_ho_accepted;
};
......
......@@ -51,57 +51,4 @@
/* "Separation bit" of AMF field */
#define AUTH_AMF_SEPARATION_BIT(a) ((a) &0x80)
/*
* 5GS authentication vector
*/
typedef struct {
/* ASME security key */
uint8_t kasme[AUTH_KASME_SIZE];
/* Random challenge parameter */
uint8_t rand[AUTH_RAND_SIZE];
/* Authentication token parameter */
uint8_t autn[AUTH_AUTN_SIZE];
/* Expected Authentication response parameter */
#define AUTH_XRES_SIZE AUTH_RES_SIZE
uint8_t xres_size;
uint8_t xres[AUTH_XRES_SIZE];
} auth_vector_t;
typedef struct security_context_s {
// emm_sc_type_t sc_type; /* Type of security context */
/* state of security context is implicit due to its storage location
* (current/non-current)*/
#define EKSI_MAX_VALUE 6
// ksi_t eksi; /* NAS key set identifier for E-UTRAN */
#define EMM_SECURITY_VECTOR_INDEX_INVALID (-1)
int vector_index; /* Pointer on vector */
uint8_t knas_enc[AUTH_KNAS_ENC_SIZE]; /* NAS cyphering key */
uint8_t knas_int[AUTH_KNAS_INT_SIZE]; /* NAS integrity key */
struct count_s {
uint32_t spare : 8;
uint32_t overflow : 16;
uint32_t seq_num : 8;
} dl_count, ul_count; /* Downlink and uplink count parameters */
struct {
uint8_t eps_encryption; /* algorithm used for ciphering */
uint8_t eps_integrity; /* algorithm used for integrity protection */
uint8_t umts_encryption; /* algorithm used for ciphering */
uint8_t umts_integrity; /* algorithm used for integrity protection */
uint8_t gprs_encryption; /* algorithm used for ciphering */
bool umts_present : 1;
bool gprs_present : 1;
} capability; /* UE network capability */
struct {
uint8_t encryption : 4; /* algorithm used for ciphering */
uint8_t integrity : 4; /* algorithm used for integrity protection */
} selected_algorithms; /* MME selected algorithms */
// Requirement MME24.301R10_4.4.4.3_2 (DETACH REQUEST (if sent before security
// has been activated);)
uint8_t activated;
} security_context_t;
#endif
......@@ -21,48 +21,52 @@
#include "ue_context.hpp"
#include "amf.hpp"
//------------------------------------------------------------------------------
ue_context::ue_context() {
ran_ue_ngap_id = 0;
amf_ue_ngap_id = -1;
gnb_id = 0;
rrc_estb_cause = {};
isUeContextRequest = false;
cgi = {};
tai = {};
pdu_sessions = {};
tmsi = 0;
ran_ue_ngap_id = 0;
amf_ue_ngap_id = INVALID_AMF_UE_NGAP_ID;
gnb_id = 0;
supi = {};
tmsi = 0;
rrc_estb_cause = {};
is_ue_context_request = false;
cgi = {};
tai = {};
pdu_sessions = {};
}
//------------------------------------------------------------------------------
bool ue_context::find_pdu_session_context(
const std::uint8_t& session_id,
std::uint8_t session_id,
std::shared_ptr<pdu_session_context>& context) const {
std::shared_lock lock(m_pdu_session);
if (pdu_sessions.count(session_id) > 0) {
context = pdu_sessions.at(session_id);
return true;
} else {
return false;
if (pdu_sessions.at(session_id) != nullptr) {
context = pdu_sessions.at(session_id);
return true;
}
}
return false;
}
//------------------------------------------------------------------------------
void ue_context::add_pdu_session_context(
const std::uint8_t& session_id,
std::uint8_t session_id,
const std::shared_ptr<pdu_session_context>& context) {
std::unique_lock lock(m_pdu_session);
pdu_sessions[session_id] = context;
}
//------------------------------------------------------------------------------
void ue_context::copy_pdu_sessions(std::shared_ptr<ue_context>& ue_ctx) {
void ue_context::copy_pdu_sessions(const std::shared_ptr<ue_context>& ue_ctx) {
pdu_sessions = ue_ctx->pdu_sessions;
}
//------------------------------------------------------------------------------
bool ue_context::get_pdu_sessions_context(
std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx) {
std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx) const {
std::shared_lock lock(m_pdu_session);
for (auto s : pdu_sessions) {
sessions_ctx.push_back(s.second);
......@@ -71,7 +75,7 @@ bool ue_context::get_pdu_sessions_context(
}
//------------------------------------------------------------------------------
bool ue_context::remove_pdu_sessions_context(const uint8_t& pdu_session_id) {
bool ue_context::remove_pdu_sessions_context(uint8_t pdu_session_id) {
std::shared_lock lock(m_pdu_session);
pdu_sessions.erase(pdu_session_id);
return true;
......
......@@ -25,8 +25,6 @@
#include <stdint.h>
#include <map>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include "NgapIEsStruct.hpp"
......@@ -43,28 +41,28 @@ class ue_context {
ue_context();
virtual ~ue_context(){};
bool find_pdu_session_context(
const std::uint8_t& session_id,
std::uint8_t session_id,
std::shared_ptr<pdu_session_context>& context) const;
void add_pdu_session_context(
const std::uint8_t& session_id,
std::uint8_t session_id,
const std::shared_ptr<pdu_session_context>& context);
void copy_pdu_sessions(std::shared_ptr<ue_context>& ue_ctx);
void copy_pdu_sessions(const std::shared_ptr<ue_context>& ue_ctx);
bool get_pdu_sessions_context(
std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx);
std::vector<std::shared_ptr<pdu_session_context>>& sessions_ctx) const;
bool remove_pdu_sessions_context(const uint8_t& pdu_session_id);
bool remove_pdu_sessions_context(uint8_t pdu_session_id);
public:
uint32_t ran_ue_ngap_id; // 32bits
long amf_ue_ngap_id : 40; // 40bits
uint32_t ran_ue_ngap_id; // 32bits
long amf_ue_ngap_id; // 40bits
uint32_t gnb_id;
std::string supi;
uint32_t tmsi;
e_Ngap_RRCEstablishmentCause rrc_estb_cause;
bool isUeContextRequest;
bool is_ue_context_request;
NrCgi_t cgi;
Tai_t tai;
std::string supi;
uint32_t tmsi;
// pdu session id <-> pdu_session_contex
std::map<std::uint8_t, std::shared_ptr<pdu_session_context>> pdu_sessions;
mutable std::shared_mutex m_pdu_session;
......
......@@ -22,12 +22,7 @@
#ifndef _UE_NGAP_CONTEXT_H_
#define _UE_NGAP_CONTEXT_H_
#include <stdint.h>
#include <map>
#include "amf.hpp"
#include "gNB_context.hpp"
using namespace sctp;
typedef enum {
......@@ -44,40 +39,39 @@ class ue_ngap_context {
ran_ue_ngap_id = 0;
amf_ue_ngap_id = 0;
target_ran_ue_ngap_id = 0;
sctp_stream_recv = {};
sctp_stream_send = {};
gnb_assoc_id = {};
target_gnb_assoc_id = {};
ueContextRequest = false;
s_tmsi_5g = {};
s_setid = {};
s_pointer = {};
s_tmsi = {};
tai = {};
ng_ue_state = NGAP_UE_INVALID_STATE;
ncc = 0;
initialUEMsg.buf = new uint8_t[BUFFER_SIZE_1024];
initialUEMsg.size = 0;
sctp_stream_recv = {};
sctp_stream_send = {};
gnb_assoc_id = {};
target_gnb_assoc_id = {};
ue_context_request = false;
s_tmsi_5g = {};
s_setid = {};
s_pointer = {};
s_tmsi = {};
tai = {};
ng_ue_state = NGAP_UE_INVALID_STATE;
ncc = 0;
initial_ue_msg.buf = new uint8_t[BUFFER_SIZE_1024];
initial_ue_msg.size = 0;
}
virtual ~ue_ngap_context() {
delete[] initialUEMsg.buf;
initialUEMsg.buf = nullptr;
initialUEMsg.size = 0;
delete[] initial_ue_msg.buf;
initial_ue_msg.buf = nullptr;
initial_ue_msg.size = 0;
}
uint32_t ran_ue_ngap_id; // 32bits
long amf_ue_ngap_id : 40; // 40bits
long amf_ue_ngap_id; // 40bits
uint32_t target_ran_ue_ngap_id; // 32bits, for HO
sctp_stream_id_t sctp_stream_recv; // used to decide which ue in gNB
sctp_stream_id_t sctp_stream_send; // used to decide which ue in gNB
sctp_stream_id_t sctp_stream_recv; // used to decide which ue in gNB
sctp_stream_id_t sctp_stream_send; // used to decide which ue in gNB
sctp_assoc_id_t gnb_assoc_id; // to find which gnb this UE belongs to
sctp_assoc_id_t target_gnb_assoc_id; // for HO
bool ueContextRequest;
bool ue_context_request;
uint32_t s_tmsi_5g;
std ::string s_setid;
......@@ -86,11 +80,11 @@ class ue_ngap_context {
Tai_t tai;
// state management, ue status over the air
// State management, ue status over the air
ng_ue_state_t ng_ue_state;
uint8_t ncc; // Next Hop Chaining Counter
OCTET_STRING_t initialUEMsg;
OCTET_STRING_t initial_ue_msg; // for AMF re-allocation
};
#endif
......@@ -87,6 +87,23 @@ UESecurityCapability::UESecurityCapability(
//------------------------------------------------------------------------------
UESecurityCapability::~UESecurityCapability() {}
void UESecurityCapability::operator=(
const UESecurityCapability& ue_security_capability) {
UESecurityCapability m_ue_security_capability;
_5g_ea_ = ue_security_capability.GetEa();
_5g_ia_ = ue_security_capability.GetIa();
uint8_t eea = 0;
uint8_t eia = 0;
if (ue_security_capability.GetEea(eea)) {
eea_ = std::make_optional<uint8_t>(eea);
}
if (ue_security_capability.GetEia(eia)) {
eia_ = std::make_optional<uint8_t>(eia);
}
}
//------------------------------------------------------------------------------
void UESecurityCapability::SetEa(uint8_t value) {
_5g_ea_ = value;
......
......@@ -41,6 +41,7 @@ class UESecurityCapability : public Type4NasIe {
UESecurityCapability(
uint8_t _5g_ea, uint8_t _5g_ia, uint8_t eea, uint8_t eia);
~UESecurityCapability();
void operator=(const UESecurityCapability& ue_security_capability);
static std::string GetIeName() { return kUeSecurityCapabilityIeName; }
......
......@@ -251,6 +251,12 @@ bool RegistrationRequest::GetUeSecurityCapability(
return true;
}
//------------------------------------------------------------------------------
std::optional<UESecurityCapability>
RegistrationRequest::GetUeSecurityCapability() const {
return ie_ue_security_capability;
}
//------------------------------------------------------------------------------
void RegistrationRequest::SetRequestedNssai(
const std::vector<struct SNSSAI_s>& nssai) {
......
......@@ -74,6 +74,7 @@ class RegistrationRequest : public NasMmPlainHeader {
void SetNonCurrentNativeNasKSI(uint8_t tsc, uint8_t key_set_id);
bool GetNonCurrentNativeNasKSI(uint8_t& value) const;
// TODO: 5GMM Capability as an array[]
void Set5gmmCapability(uint8_t value);
bool Get5gmmCapability(uint8_t& value) const;
......@@ -84,6 +85,7 @@ class RegistrationRequest : public NasMmPlainHeader {
// TODO: use std::optional for optional fields eea,eia
bool GetUeSecurityCapability(
uint8_t& ea, uint8_t& ia, uint8_t& eea, uint8_t& eia) const;
std::optional<UESecurityCapability> GetUeSecurityCapability() const;
void SetRequestedNssai(const std::vector<struct SNSSAI_s>& nssai);
bool GetRequestedNssai(std::vector<struct SNSSAI_s>& nssai) const;
......
......@@ -65,6 +65,22 @@ void SecurityModeCommand::SetUeSecurityCapability(
ie_ue_security_capability.Set(ea, ia, eea, eia);
}
//------------------------------------------------------------------------------
void SecurityModeCommand::SetUeSecurityCapability(
const UESecurityCapability& ue_security_capability) {
uint8_t eea = 0;
uint8_t eia = 0;
if (ue_security_capability.GetEea(eea) &&
ue_security_capability.GetEia(eia)) {
ie_ue_security_capability.Set(
ue_security_capability.GetEa(), ue_security_capability.GetIa(), eea,
eia);
} else {
ie_ue_security_capability.Set(
ue_security_capability.GetEa(), ue_security_capability.GetIa());
}
}
//------------------------------------------------------------------------------
void SecurityModeCommand::SetImeisvRequest(uint8_t value) {
ie_imeisv_request = std::make_optional<ImeisvRequest>(value);
......
......@@ -47,6 +47,8 @@ class SecurityModeCommand : public NasMmPlainHeader {
void SetUeSecurityCapability(
uint8_t ea, uint8_t ia, uint8_t eea, uint8_t eia);
// TODO: Get
void SetUeSecurityCapability(
const UESecurityCapability& ue_security_capability);
void SetImeisvRequest(uint8_t value);
// TODO: Get
......
......@@ -99,17 +99,13 @@ void ngap_app::handle_sctp_new_association(
"Received a new association request on an association that is being "
"%s, ignoring",
ng_gnb_state_str[gc->ng_state]);
return;
} else {
Logger::ngap().debug("Update gNB context with assoc id (%d)", assoc_id);
}
}
if (gc == nullptr) {
Logger::ngap().error(
"Failed to create gNB context for assoc_id (%d)", assoc_id);
return;
};
// Update gNB Context
gc->sctp_assoc_id = assoc_id;
gc->instreams = instreams;
gc->outstreams = outstreams;
......
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