change vairable name from 'ue' to 'enb_ue or mme_ue'
This commit is contained in:
parent
129f484394
commit
6a68eaac02
|
@ -8,7 +8,7 @@
|
|||
#include "emm_build.h"
|
||||
|
||||
status_t emm_build_attach_accept(
|
||||
pkbuf_t **emmbuf, mme_ue_t *ue, pkbuf_t *esmbuf)
|
||||
pkbuf_t **emmbuf, mme_ue_t *mme_ue, pkbuf_t *esmbuf)
|
||||
{
|
||||
nas_message_t message;
|
||||
nas_attach_accept_t *attach_accept = &message.emm.attach_accept;
|
||||
|
@ -24,8 +24,8 @@ status_t emm_build_attach_accept(
|
|||
nas_eps_network_feature_support_t *eps_network_feature_support =
|
||||
&attach_accept->eps_network_feature_support;
|
||||
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(ue->enb_ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue->enb_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(message));
|
||||
message.h.security_header_type =
|
||||
|
@ -42,7 +42,7 @@ status_t emm_build_attach_accept(
|
|||
tai_list->length = 6;
|
||||
tai_list->type = 2;
|
||||
tai_list->num = 0; /* +1 = 1 elements */
|
||||
memcpy(&tai_list->type2.tai[0], &ue->enb_ue->tai, sizeof(tai_t));
|
||||
memcpy(&tai_list->type2.tai[0], &mme_ue->enb_ue->tai, sizeof(tai_t));
|
||||
|
||||
attach_accept->esm_message_container.data = esmbuf->payload;
|
||||
attach_accept->esm_message_container.len = esmbuf->len;
|
||||
|
@ -52,7 +52,7 @@ status_t emm_build_attach_accept(
|
|||
guti->length = 11;
|
||||
guti->guti.odd_even = NAS_EPS_MOBILE_IDENTITY_EVEN;
|
||||
guti->guti.type = NAS_EPS_MOBILE_IDENTITY_GUTI;
|
||||
memcpy(&guti->guti.plmn_id, &ue->visited_plmn_id, PLMN_ID_LEN);
|
||||
memcpy(&guti->guti.plmn_id, &mme_ue->visited_plmn_id, PLMN_ID_LEN);
|
||||
guti->guti.mme_gid = 2;
|
||||
guti->guti.mme_code = 1;
|
||||
guti->guti.m_tmsi = 0x040001fb;
|
||||
|
@ -73,7 +73,8 @@ status_t emm_build_attach_accept(
|
|||
eps_network_feature_support->epc_lcs = 1;
|
||||
eps_network_feature_support->ims_vops = 1;
|
||||
|
||||
d_assert(nas_security_encode(emmbuf, ue, &message) == CORE_OK && *emmbuf,,);
|
||||
d_assert(nas_security_encode(emmbuf, mme_ue, &message) == CORE_OK &&
|
||||
*emmbuf,,);
|
||||
pkbuf_free(esmbuf);
|
||||
|
||||
return CORE_OK;
|
||||
|
|
|
@ -8,7 +8,7 @@ extern "C" {
|
|||
#endif /* __cplusplus */
|
||||
|
||||
CORE_DECLARE(status_t) emm_build_attach_accept(
|
||||
pkbuf_t **emmbuf, mme_ue_t *ue, pkbuf_t *esmbuf);
|
||||
pkbuf_t **emmbuf, mme_ue_t *mme_ue, pkbuf_t *esmbuf);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -19,10 +19,10 @@
|
|||
#include "mme_s11_build.h"
|
||||
#include "mme_s11_path.h"
|
||||
|
||||
void emm_handle_identity_request(mme_ue_t *ue);
|
||||
void emm_handle_identity_request(mme_ue_t *mme_ue);
|
||||
|
||||
void emm_handle_esm_message_container(
|
||||
mme_ue_t *ue, nas_esm_message_container_t *esm_message_container)
|
||||
mme_ue_t *mme_ue, nas_esm_message_container_t *esm_message_container)
|
||||
{
|
||||
pkbuf_t *esmbuf = NULL;
|
||||
event_t e;
|
||||
|
@ -32,7 +32,7 @@ void emm_handle_esm_message_container(
|
|||
c_uint8_t ebi = NAS_EPS_BEARER_IDENTITY_UNASSIGNED;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
|
||||
d_assert(ue, return, "Null param");
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
d_assert(esm_message_container, return, "Null param");
|
||||
d_assert(esm_message_container->len, return, "Null param");
|
||||
|
||||
|
@ -42,12 +42,12 @@ void emm_handle_esm_message_container(
|
|||
pti = h->procedure_transaction_identity;
|
||||
ebi = h->eps_bearer_identity;
|
||||
if (pti == NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED && ebi)
|
||||
bearer = mme_bearer_find_by_ue_ebi(ue, ebi);
|
||||
bearer = mme_bearer_find_by_ue_ebi(mme_ue, ebi);
|
||||
else if (ebi == NAS_EPS_BEARER_IDENTITY_UNASSIGNED && pti)
|
||||
bearer = mme_bearer_find_by_ue_pti(ue, pti);
|
||||
bearer = mme_bearer_find_by_ue_pti(mme_ue, pti);
|
||||
|
||||
if (!bearer)
|
||||
bearer = mme_sess_add(ue, pti);
|
||||
bearer = mme_sess_add(mme_ue, pti);
|
||||
d_assert(bearer, return, "No Bearer Context");
|
||||
|
||||
/* The Packet Buffer(pkbuf_t) for NAS message MUST make a HEADROOM.
|
||||
|
@ -64,31 +64,31 @@ void emm_handle_esm_message_container(
|
|||
}
|
||||
|
||||
void emm_handle_attach_request(
|
||||
mme_ue_t *ue, nas_attach_request_t *attach_request)
|
||||
mme_ue_t *mme_ue, nas_attach_request_t *attach_request)
|
||||
{
|
||||
nas_eps_mobile_identity_t *eps_mobile_identity =
|
||||
&attach_request->eps_mobile_identity;
|
||||
|
||||
emm_handle_esm_message_container(
|
||||
ue, &attach_request->esm_message_container);
|
||||
mme_ue, &attach_request->esm_message_container);
|
||||
|
||||
/* Store UE specific information */
|
||||
memcpy(&ue->visited_plmn_id, &mme_self()->plmn_id, PLMN_ID_LEN);
|
||||
memcpy(&mme_ue->visited_plmn_id, &mme_self()->plmn_id, PLMN_ID_LEN);
|
||||
if (attach_request->presencemask &
|
||||
NAS_ATTACH_REQUEST_LAST_VISITED_REGISTERED_TAI_PRESENT)
|
||||
{
|
||||
nas_tracking_area_identity_t *last_visited_registered_tai =
|
||||
&attach_request->last_visited_registered_tai;
|
||||
|
||||
memcpy(&ue->visited_plmn_id,
|
||||
memcpy(&mme_ue->visited_plmn_id,
|
||||
&last_visited_registered_tai->plmn_id,
|
||||
PLMN_ID_LEN);
|
||||
}
|
||||
|
||||
memcpy(&ue->ue_network_capability,
|
||||
memcpy(&mme_ue->ue_network_capability,
|
||||
&attach_request->ue_network_capability,
|
||||
sizeof(attach_request->ue_network_capability));
|
||||
memcpy(&ue->ms_network_capability,
|
||||
memcpy(&mme_ue->ms_network_capability,
|
||||
&attach_request->ms_network_capability,
|
||||
sizeof(attach_request->ms_network_capability));
|
||||
|
||||
|
@ -98,15 +98,16 @@ void emm_handle_attach_request(
|
|||
{
|
||||
nas_imsi_to_bcd(
|
||||
&eps_mobile_identity->imsi, eps_mobile_identity->length,
|
||||
ue->imsi_bcd);
|
||||
core_bcd_to_buffer(ue->imsi_bcd, ue->imsi, &ue->imsi_len);
|
||||
d_assert(ue->imsi_len, return,
|
||||
"Can't get IMSI(len:%d\n", ue->imsi_len);
|
||||
mme_ue->imsi_bcd);
|
||||
core_bcd_to_buffer(mme_ue->imsi_bcd, mme_ue->imsi,
|
||||
&mme_ue->imsi_len);
|
||||
d_assert(mme_ue->imsi_len, return,
|
||||
"Can't get IMSI(len:%d\n", mme_ue->imsi_len);
|
||||
|
||||
d_info("[NAS] Attach request : UE_IMSI[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
mme_s6a_send_air(ue);
|
||||
mme_s6a_send_air(mme_ue);
|
||||
break;
|
||||
}
|
||||
case NAS_EPS_MOBILE_IDENTITY_GUTI:
|
||||
|
@ -131,7 +132,7 @@ void emm_handle_attach_request(
|
|||
|
||||
/* If not found,
|
||||
Initiate NAS Identity procedure to get UE IMSI */
|
||||
emm_handle_identity_request(ue);
|
||||
emm_handle_identity_request(mme_ue);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
@ -148,7 +149,7 @@ void emm_handle_identity_request(mme_ue_t *mme_ue)
|
|||
{
|
||||
status_t rv;
|
||||
mme_enb_t *enb = NULL;
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
pkbuf_t *emmbuf = NULL, *s1apbuf = NULL;
|
||||
|
||||
nas_message_t message;
|
||||
|
@ -156,9 +157,9 @@ void emm_handle_identity_request(mme_ue_t *mme_ue)
|
|||
&message.emm.identity_request;
|
||||
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
ue = mme_ue->enb_ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
enb = ue->enb;
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(message));
|
||||
|
@ -170,7 +171,7 @@ void emm_handle_identity_request(mme_ue_t *mme_ue)
|
|||
|
||||
d_assert(nas_plain_encode(&emmbuf, &message) == CORE_OK && emmbuf,,);
|
||||
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, ue, emmbuf);
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, enb_ue, emmbuf);
|
||||
d_assert(rv == CORE_OK && s1apbuf,
|
||||
pkbuf_free(emmbuf); return, "s1ap build error");
|
||||
|
||||
|
@ -178,11 +179,11 @@ void emm_handle_identity_request(mme_ue_t *mme_ue)
|
|||
}
|
||||
|
||||
void emm_handle_identity_response(
|
||||
mme_ue_t *ue, nas_identity_response_t *identity_response)
|
||||
mme_ue_t *mme_ue, nas_identity_response_t *identity_response)
|
||||
{
|
||||
nas_mobile_identity_t *mobile_identity = NULL;
|
||||
|
||||
d_assert(ue, return, "Null param");
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
d_assert(identity_response, return, "Null param");
|
||||
|
||||
mobile_identity = &identity_response->mobile_identity;
|
||||
|
@ -191,20 +192,20 @@ void emm_handle_identity_response(
|
|||
{
|
||||
nas_imsi_to_bcd(
|
||||
&mobile_identity->imsi, mobile_identity->length,
|
||||
ue->imsi_bcd);
|
||||
core_bcd_to_buffer(ue->imsi_bcd, ue->imsi, &ue->imsi_len);
|
||||
mme_ue->imsi_bcd);
|
||||
core_bcd_to_buffer(mme_ue->imsi_bcd, mme_ue->imsi, &mme_ue->imsi_len);
|
||||
|
||||
d_assert(ue->imsi_len, return,
|
||||
"Can't get IMSI(len:%d\n", ue->imsi_len);
|
||||
d_assert(mme_ue->imsi_len, return,
|
||||
"Can't get IMSI(len:%d\n", mme_ue->imsi_len);
|
||||
}
|
||||
else
|
||||
{
|
||||
d_warn("Not supported Identity type(%d)",mobile_identity->imsi.type);
|
||||
d_warn("Not supported Identity type(%d)", mobile_identity->imsi.type);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Send Authentication Information Request to HSS */
|
||||
mme_s6a_send_air(ue);
|
||||
mme_s6a_send_air(mme_ue);
|
||||
|
||||
}
|
||||
|
||||
|
@ -212,7 +213,7 @@ void emm_handle_authentication_request(mme_ue_t *mme_ue)
|
|||
{
|
||||
status_t rv;
|
||||
mme_enb_t *enb = NULL;
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
pkbuf_t *emmbuf = NULL, *s1apbuf = NULL;
|
||||
|
||||
nas_message_t message;
|
||||
|
@ -220,9 +221,9 @@ void emm_handle_authentication_request(mme_ue_t *mme_ue)
|
|||
&message.emm.authentication_request;
|
||||
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
ue = mme_ue->enb_ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
enb = ue->enb;
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(message));
|
||||
|
@ -238,15 +239,15 @@ void emm_handle_authentication_request(mme_ue_t *mme_ue)
|
|||
|
||||
d_assert(nas_plain_encode(&emmbuf, &message) == CORE_OK && emmbuf,,);
|
||||
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, ue, emmbuf);
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, enb_ue, emmbuf);
|
||||
d_assert(rv == CORE_OK && s1apbuf,
|
||||
pkbuf_free(emmbuf); return, "s1ap build error");
|
||||
|
||||
d_assert(s1ap_send_to_enb(enb, s1apbuf) == CORE_OK,, "s1ap send error");
|
||||
}
|
||||
|
||||
void emm_handle_authentication_response(
|
||||
mme_ue_t *ue, nas_authentication_response_t *authentication_response)
|
||||
void emm_handle_authentication_response(mme_ue_t *mme_ue,
|
||||
nas_authentication_response_t *authentication_response)
|
||||
{
|
||||
status_t rv;
|
||||
mme_enb_t *enb = NULL;
|
||||
|
@ -266,22 +267,22 @@ void emm_handle_authentication_response(
|
|||
nas_ue_security_capability_t *replayed_ue_security_capabilities =
|
||||
&security_mode_command->replayed_ue_security_capabilities;
|
||||
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = ue->enb_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
||||
if (authentication_response_parameter->length != ue->xres_len ||
|
||||
if (authentication_response_parameter->length != mme_ue->xres_len ||
|
||||
memcmp(authentication_response_parameter->res,
|
||||
ue->xres, ue->xres_len) != 0)
|
||||
mme_ue->xres, mme_ue->xres_len) != 0)
|
||||
{
|
||||
d_error("authentication failed");
|
||||
return;
|
||||
}
|
||||
|
||||
d_info("[NAS] Authentication response : UE[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
memset(&message, 0, sizeof(message));
|
||||
message.h.security_header_type =
|
||||
|
@ -305,24 +306,24 @@ void emm_handle_authentication_response(
|
|||
sizeof(replayed_ue_security_capabilities->uea) +
|
||||
sizeof(replayed_ue_security_capabilities->uia) +
|
||||
sizeof(replayed_ue_security_capabilities->gea);
|
||||
replayed_ue_security_capabilities->eea = ue->ue_network_capability.eea;
|
||||
replayed_ue_security_capabilities->eia = ue->ue_network_capability.eia;
|
||||
replayed_ue_security_capabilities->uea = ue->ue_network_capability.uea;
|
||||
replayed_ue_security_capabilities->uia = ue->ue_network_capability.uia;
|
||||
replayed_ue_security_capabilities->eea = mme_ue->ue_network_capability.eea;
|
||||
replayed_ue_security_capabilities->eia = mme_ue->ue_network_capability.eia;
|
||||
replayed_ue_security_capabilities->uea = mme_ue->ue_network_capability.uea;
|
||||
replayed_ue_security_capabilities->uia = mme_ue->ue_network_capability.uia;
|
||||
replayed_ue_security_capabilities->gea =
|
||||
(ue->ms_network_capability.gea1 << 6) |
|
||||
ue->ms_network_capability.extended_gea;
|
||||
(mme_ue->ms_network_capability.gea1 << 6) |
|
||||
mme_ue->ms_network_capability.extended_gea;
|
||||
|
||||
mme_kdf_nas(MME_KDF_NAS_INT_ALG, mme_self()->selected_int_algorithm,
|
||||
ue->kasme, ue->knas_int);
|
||||
mme_ue->kasme, mme_ue->knas_int);
|
||||
mme_kdf_nas(MME_KDF_NAS_ENC_ALG, mme_self()->selected_enc_algorithm,
|
||||
ue->kasme, ue->knas_enc);
|
||||
mme_kdf_enb(ue->kasme, ue->ul_count.i32, ue->kenb);
|
||||
mme_ue->kasme, mme_ue->knas_enc);
|
||||
mme_kdf_enb(mme_ue->kasme, mme_ue->ul_count.i32, mme_ue->kenb);
|
||||
|
||||
d_info("[NAS] Security mode command : UE[%s] <-- EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
rv = nas_security_encode(&emmbuf, ue, &message);
|
||||
rv = nas_security_encode(&emmbuf, mme_ue, &message);
|
||||
d_assert(rv == CORE_OK && emmbuf, return, "emm build error");
|
||||
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, enb_ue, emmbuf);
|
||||
|
@ -335,15 +336,15 @@ void emm_handle_authentication_response(
|
|||
void emm_handle_create_session_response(mme_bearer_t *bearer)
|
||||
{
|
||||
status_t rv;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
mme_enb_t *enb = NULL;
|
||||
pkbuf_t *esmbuf = NULL, *emmbuf = NULL, *s1apbuf = NULL;
|
||||
|
||||
d_assert(bearer, return, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = ue->enb_ue;
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
@ -355,11 +356,11 @@ void emm_handle_create_session_response(mme_bearer_t *bearer)
|
|||
d_info("[NAS] Activate default bearer context request : EMM <-- ESM[%d]",
|
||||
bearer->ebi);
|
||||
|
||||
rv = emm_build_attach_accept(&emmbuf, ue, esmbuf);
|
||||
rv = emm_build_attach_accept(&emmbuf, mme_ue, esmbuf);
|
||||
d_assert(rv == CORE_OK && emmbuf,
|
||||
pkbuf_free(esmbuf); return, "emm build error");
|
||||
|
||||
d_info("[NAS] Attach accept : UE[%s] <-- EMM", ue->imsi_bcd);
|
||||
d_info("[NAS] Attach accept : UE[%s] <-- EMM", mme_ue->imsi_bcd);
|
||||
|
||||
rv = s1ap_build_initial_context_setup_request(&s1apbuf, bearer, emmbuf);
|
||||
d_assert(rv == CORE_OK && s1apbuf,
|
||||
|
@ -369,7 +370,7 @@ void emm_handle_create_session_response(mme_bearer_t *bearer)
|
|||
}
|
||||
|
||||
void emm_handle_attach_complete(
|
||||
mme_ue_t *ue, nas_attach_complete_t *attach_complete)
|
||||
mme_ue_t *mme_ue, nas_attach_complete_t *attach_complete)
|
||||
{
|
||||
status_t rv;
|
||||
mme_enb_t *enb = NULL;
|
||||
|
@ -386,14 +387,14 @@ void emm_handle_attach_complete(
|
|||
time_exp_t time_exp;
|
||||
time_exp_lt(&time_exp, time_now());
|
||||
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = ue->enb_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
||||
emm_handle_esm_message_container(
|
||||
ue, &attach_complete->esm_message_container);
|
||||
mme_ue, &attach_complete->esm_message_container);
|
||||
|
||||
memset(&message, 0, sizeof(message));
|
||||
message.h.security_header_type =
|
||||
|
@ -427,9 +428,9 @@ void emm_handle_attach_complete(
|
|||
network_daylight_saving_time->length = 1;
|
||||
|
||||
d_info("[NAS] EMM information : UE[%s] <-- EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
rv = nas_security_encode(&emmbuf, ue, &message);
|
||||
rv = nas_security_encode(&emmbuf, mme_ue, &message);
|
||||
d_assert(rv == CORE_OK && emmbuf, return, "emm build error");
|
||||
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, enb_ue, emmbuf);
|
||||
|
@ -439,16 +440,16 @@ void emm_handle_attach_complete(
|
|||
d_assert(s1ap_send_to_enb(enb, s1apbuf) == CORE_OK,, "s1ap send error");
|
||||
}
|
||||
|
||||
void emm_handle_emm_status(mme_ue_t *ue, nas_emm_status_t *emm_status)
|
||||
void emm_handle_emm_status(mme_ue_t *mme_ue, nas_emm_status_t *emm_status)
|
||||
{
|
||||
d_assert(ue, return, "Null param");
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
|
||||
d_warn("[NAS] EMM status(%d) : UE[%s] --> EMM",
|
||||
emm_status->emm_cause, ue->imsi_bcd);
|
||||
emm_status->emm_cause, mme_ue->imsi_bcd);
|
||||
}
|
||||
|
||||
void emm_handle_detach_request(
|
||||
mme_ue_t *ue, nas_detach_request_from_ue_t *detach_request)
|
||||
mme_ue_t *mme_ue, nas_detach_request_from_ue_t *detach_request)
|
||||
{
|
||||
status_t rv;
|
||||
mme_enb_t *enb = NULL;
|
||||
|
@ -464,8 +465,8 @@ void emm_handle_detach_request(
|
|||
* detach_type->nas_key_set_identifier
|
||||
*/
|
||||
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = ue->enb_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
@ -479,27 +480,27 @@ void emm_handle_detach_request(
|
|||
/* 0 0 1 : EPS detach */
|
||||
case NAS_DETACH_TYPE_FROM_UE_EPS_DETACH:
|
||||
d_info("[NAS] (EPS) Detach request : UE_IMSI[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
break;
|
||||
/* 0 1 0 : IMSI detach */
|
||||
case NAS_DETACH_TYPE_FROM_UE_IMSI_DETACH:
|
||||
d_info("[NAS] (IMSI) Detach request : UE_IMSI[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
break;
|
||||
case 6: /* 1 1 0 : reserved */
|
||||
case 7: /* 1 1 1 : reserved */
|
||||
d_info("[NAS] (Unknown) Detach request : UE_IMSI[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
break;
|
||||
/* 0 1 1 : combined EPS/IMSI detach */
|
||||
case NAS_DETACH_TYPE_FROM_UE_COMBINED_EPS_IMSI_DETACH:
|
||||
default: /* all other values */
|
||||
d_info("[NAS] (EPS+IMSI) Detach request : UE_IMSI[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
break;
|
||||
}
|
||||
|
||||
sess = mme_sess_first(ue);
|
||||
sess = mme_sess_first(mme_ue);
|
||||
while (sess != NULL)
|
||||
{
|
||||
mme_bearer_t *bearer = mme_default_bearer_in_sess(sess);
|
||||
|
@ -534,9 +535,9 @@ void emm_handle_detach_request(
|
|||
message.emm.h.message_type = NAS_DETACH_ACCEPT;
|
||||
|
||||
d_info("[NAS] Detach accept : UE[%s] <-- EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
rv = nas_security_encode(&emmbuf, ue, &message);
|
||||
rv = nas_security_encode(&emmbuf, mme_ue, &message);
|
||||
d_assert(rv == CORE_OK && emmbuf, return, "emm build error");
|
||||
|
||||
rv = s1ap_build_downlink_nas_transport(&s1apbuf, enb_ue, emmbuf);
|
||||
|
@ -552,7 +553,7 @@ void emm_handle_detach_request(
|
|||
void emm_handle_delete_session_response(mme_bearer_t *bearer)
|
||||
{
|
||||
status_t rv;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
mme_enb_t *enb = NULL;
|
||||
pkbuf_t *s1apbuf = NULL;
|
||||
mme_sess_t *sess;
|
||||
|
@ -560,19 +561,19 @@ void emm_handle_delete_session_response(mme_bearer_t *bearer)
|
|||
enb_ue_t *enb_ue = NULL;
|
||||
|
||||
d_assert(bearer, return, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = ue->enb_ue;
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
||||
sess = mme_sess_find_by_ebi(ue, bearer->ebi);
|
||||
sess = mme_sess_find_by_ebi(mme_ue, bearer->ebi);
|
||||
mme_sess_remove(sess);
|
||||
|
||||
/* sess and bearer are not valid from here */
|
||||
|
||||
sess = mme_sess_first(ue);
|
||||
sess = mme_sess_first(mme_ue);
|
||||
while (sess != NULL)
|
||||
{
|
||||
mme_bearer_t *temp_bearer = mme_default_bearer_in_sess(sess);
|
||||
|
@ -587,9 +588,10 @@ void emm_handle_delete_session_response(mme_bearer_t *bearer)
|
|||
|
||||
if (!b_wait)
|
||||
{
|
||||
d_info("[NAS] Detach done : UE[%s] <-- EMM", ue->imsi_bcd);
|
||||
d_info("[NAS] Detach done : UE[%s] <-- EMM", mme_ue->imsi_bcd);
|
||||
|
||||
rv = s1ap_build_ue_context_release_commmand(&s1apbuf, enb_ue, enb_ue->s1ap.cause);
|
||||
rv = s1ap_build_ue_context_release_commmand(&
|
||||
s1apbuf, enb_ue, enb_ue->s1ap.cause);
|
||||
d_assert(rv == CORE_OK && s1apbuf, return, "s1ap build error");
|
||||
|
||||
d_assert(s1ap_send_to_enb(enb, s1apbuf) == CORE_OK,, "s1ap send error");
|
||||
|
|
|
@ -10,20 +10,22 @@ extern "C" {
|
|||
#endif /* __cplusplus */
|
||||
|
||||
CORE_DECLARE(void) emm_handle_attach_request(
|
||||
mme_ue_t *ue, nas_attach_request_t *attach_request);
|
||||
CORE_DECLARE(void) emm_handle_authentication_request(mme_ue_t *ue);
|
||||
mme_ue_t *mme_ue, nas_attach_request_t *attach_request);
|
||||
CORE_DECLARE(void) emm_handle_authentication_request(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(void) emm_handle_authentication_response(
|
||||
mme_ue_t *ue, nas_authentication_response_t *authentication_response);
|
||||
mme_ue_t *mme_ue, nas_authentication_response_t *authentication_response);
|
||||
CORE_DECLARE(void) emm_handle_create_session_response(mme_bearer_t *bearer);
|
||||
CORE_DECLARE(void) emm_handle_attach_complete(
|
||||
mme_ue_t *ue, nas_attach_complete_t *attach_complete);
|
||||
CORE_DECLARE(void) emm_handle_emm_status(mme_ue_t *ue, nas_emm_status_t *emm_status);
|
||||
mme_ue_t *mme_ue, nas_attach_complete_t *attach_complete);
|
||||
CORE_DECLARE(void) emm_handle_emm_status(
|
||||
mme_ue_t *mme_ue, nas_emm_status_t *emm_status);
|
||||
CORE_DECLARE(void) emm_handle_identity_response(
|
||||
mme_ue_t *ue, nas_identity_response_t *identity_response);
|
||||
mme_ue_t *mme_ue, nas_identity_response_t *identity_response);
|
||||
CORE_DECLARE(void) emm_handle_detach_request(
|
||||
mme_ue_t *ue, nas_detach_request_from_ue_t *detach_request);
|
||||
mme_ue_t *mme_ue, nas_detach_request_from_ue_t *detach_request);
|
||||
CORE_DECLARE(void) emm_handle_delete_session_response(mme_bearer_t *bearer);
|
||||
CORE_DECLARE(mme_ue_t*) emm_find_ue_by_message(enb_ue_t *enb_ue, nas_message_t *message);
|
||||
CORE_DECLARE(mme_ue_t*) emm_find_ue_by_message(
|
||||
enb_ue_t *enb_ue, nas_message_t *message);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -67,24 +67,24 @@ void emm_state_operational(fsm_t *s, event_t *e)
|
|||
case MME_EVT_EMM_UE_FROM_S11:
|
||||
{
|
||||
index_t index = event_get_param1(e);
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(index, return, "Null param");
|
||||
ue = mme_ue_find(index);
|
||||
d_assert(ue, return, "Null param");
|
||||
mme_ue = mme_ue_find(index);
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
|
||||
switch(event_get_param2(e))
|
||||
{
|
||||
case S6A_CMD_AUTHENTICATION_INFORMATION:
|
||||
{
|
||||
d_info("[NAS] Authentication request : UE[%s] <-- EMM",
|
||||
ue->imsi_bcd);
|
||||
emm_handle_authentication_request(ue);
|
||||
mme_ue->imsi_bcd);
|
||||
emm_handle_authentication_request(mme_ue);
|
||||
break;
|
||||
}
|
||||
case S6A_CMD_UPDATE_LOCATION:
|
||||
{
|
||||
mme_sess_t *sess = mme_sess_first(ue);
|
||||
mme_sess_t *sess = mme_sess_first(mme_ue);
|
||||
while(sess)
|
||||
{
|
||||
mme_bearer_t *bearer = mme_bearer_first(sess);
|
||||
|
@ -116,12 +116,12 @@ void emm_state_operational(fsm_t *s, event_t *e)
|
|||
case MME_EVT_EMM_UE_MSG:
|
||||
{
|
||||
index_t index = event_get_param1(e);
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
nas_message_t *message = NULL;
|
||||
|
||||
d_assert(index, return, "Null param");
|
||||
ue = mme_ue_find(index);
|
||||
d_assert(ue, return, "Null param");
|
||||
mme_ue = mme_ue_find(index);
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
|
||||
message = (nas_message_t *)event_get_param3(e);
|
||||
d_assert(message, break, "Null param");
|
||||
|
@ -131,45 +131,45 @@ void emm_state_operational(fsm_t *s, event_t *e)
|
|||
case NAS_ATTACH_REQUEST:
|
||||
{
|
||||
emm_handle_attach_request(
|
||||
ue, &message->emm.attach_request);
|
||||
mme_ue, &message->emm.attach_request);
|
||||
break;
|
||||
}
|
||||
case NAS_IDENTITY_RESPONSE:
|
||||
{
|
||||
emm_handle_identity_response(ue,
|
||||
emm_handle_identity_response(mme_ue,
|
||||
&message->emm.identity_response);
|
||||
break;
|
||||
}
|
||||
case NAS_AUTHENTICATION_RESPONSE:
|
||||
{
|
||||
emm_handle_authentication_response(
|
||||
ue, &message->emm.authentication_response);
|
||||
mme_ue, &message->emm.authentication_response);
|
||||
break;
|
||||
}
|
||||
case NAS_SECURITY_MODE_COMPLETE:
|
||||
{
|
||||
d_info("[NAS] Security mode complete : UE[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_s6a_send_ulr(ue);
|
||||
mme_ue->imsi_bcd);
|
||||
mme_s6a_send_ulr(mme_ue);
|
||||
break;
|
||||
}
|
||||
case NAS_ATTACH_COMPLETE:
|
||||
{
|
||||
d_info("[NAS] Attach complete : UE[%s] --> EMM",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
emm_handle_attach_complete(
|
||||
ue, &message->emm.attach_complete);
|
||||
mme_ue, &message->emm.attach_complete);
|
||||
break;
|
||||
}
|
||||
case NAS_EMM_STATUS:
|
||||
{
|
||||
emm_handle_emm_status(ue, &message->emm.emm_status);
|
||||
emm_handle_emm_status(mme_ue, &message->emm.emm_status);
|
||||
break;
|
||||
}
|
||||
case NAS_DETACH_REQUEST:
|
||||
{
|
||||
emm_handle_detach_request(
|
||||
ue, &message->emm.detach_request_from_ue);
|
||||
mme_ue, &message->emm.detach_request_from_ue);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
@ -184,11 +184,11 @@ void emm_state_operational(fsm_t *s, event_t *e)
|
|||
case MME_EVT_EMM_UE_T3:
|
||||
{
|
||||
index_t index = event_get_param1(e);
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(index, return, "Null param");
|
||||
ue = mme_ue_find(index);
|
||||
d_assert(ue, return, "Null param");
|
||||
mme_ue = mme_ue_find(index);
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
|
@ -10,11 +10,11 @@
|
|||
status_t esm_build_information_request(pkbuf_t **pkbuf, mme_bearer_t *bearer)
|
||||
{
|
||||
nas_message_t message;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(bearer, return CORE_ERROR, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(message));
|
||||
message.h.security_header_type =
|
||||
|
@ -25,7 +25,8 @@ status_t esm_build_information_request(pkbuf_t **pkbuf, mme_bearer_t *bearer)
|
|||
message.esm.h.procedure_transaction_identity = bearer->pti;
|
||||
message.esm.h.message_type = NAS_ESM_INFORMATION_REQUEST;
|
||||
|
||||
d_assert(nas_security_encode(pkbuf, ue, &message) == CORE_OK && *pkbuf,,);
|
||||
d_assert(nas_security_encode(pkbuf, mme_ue, &message) == CORE_OK &&
|
||||
*pkbuf,,);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
@ -49,12 +50,12 @@ status_t esm_build_activate_default_bearer_context(
|
|||
&activate_default_eps_bearer_context_request
|
||||
->protocol_configuration_options;
|
||||
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
pdn_t *pdn = NULL;
|
||||
|
||||
d_assert(bearer, return CORE_ERROR, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
pdn = bearer->pdn;
|
||||
d_assert(pdn, return CORE_ERROR, "Null param");
|
||||
|
||||
|
|
|
@ -31,15 +31,15 @@ void esm_handle_pdn_connectivity_request(mme_bearer_t *bearer,
|
|||
void esm_handle_s6a_update_location(mme_bearer_t *bearer)
|
||||
{
|
||||
status_t rv;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
mme_enb_t *enb = NULL;
|
||||
pkbuf_t *esmbuf = NULL, *s1apbuf = NULL;
|
||||
|
||||
d_assert(bearer, return, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = ue->enb_ue;
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
enb = enb_ue->enb;
|
||||
d_assert(enb, return, "Null param");
|
||||
|
@ -75,18 +75,18 @@ void esm_handle_modify_bearer_request(mme_bearer_t *bearer)
|
|||
void esm_handle_information_response(mme_bearer_t *bearer,
|
||||
nas_esm_information_response_t *esm_information_response)
|
||||
{
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
pkbuf_t *pkbuf = NULL;
|
||||
status_t rv;
|
||||
|
||||
d_assert(bearer, return, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
|
||||
if (esm_information_response->presencemask &
|
||||
NAS_ESM_INFORMATION_RESPONSE_ACCESS_POINT_NAME_PRESENT)
|
||||
{
|
||||
bearer->pdn = mme_pdn_find_by_apn(ue,
|
||||
bearer->pdn = mme_pdn_find_by_apn(mme_ue,
|
||||
esm_information_response->access_point_name.apn);
|
||||
d_assert(bearer->pdn, return, "No PDN Context[APN:%s])",
|
||||
esm_information_response->access_point_name.apn);
|
||||
|
|
|
@ -46,20 +46,21 @@ void esm_state_operational(fsm_t *s, event_t *e)
|
|||
{
|
||||
index_t index = event_get_param1(e);
|
||||
mme_bearer_t *bearer = NULL;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(index, return, "Null param");
|
||||
bearer = mme_bearer_find(index);
|
||||
d_assert(bearer, return, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
|
||||
switch(event_get_param2(e))
|
||||
{
|
||||
case S6A_CMD_UPDATE_LOCATION:
|
||||
{
|
||||
d_info("[NAS] ESM information request : "
|
||||
"UE[%s] <--- ESM[%d]", ue->imsi_bcd, bearer->pti);
|
||||
"UE[%s] <--- ESM[%d]",
|
||||
mme_ue->imsi_bcd, bearer->pti);
|
||||
esm_handle_s6a_update_location(bearer);
|
||||
break;
|
||||
}
|
||||
|
@ -76,14 +77,14 @@ void esm_state_operational(fsm_t *s, event_t *e)
|
|||
{
|
||||
index_t index = event_get_param1(e);
|
||||
mme_bearer_t *bearer = NULL;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
nas_message_t *message = NULL;
|
||||
|
||||
d_assert(index, return, "Null param");
|
||||
bearer = mme_bearer_find(index);
|
||||
d_assert(bearer, return, "Null param");
|
||||
ue = bearer->ue;
|
||||
d_assert(ue, return, "Null param");
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return, "Null param");
|
||||
message = (nas_message_t *)event_get_param3(e);
|
||||
d_assert(message, break, "Null param");
|
||||
|
||||
|
@ -94,7 +95,8 @@ void esm_state_operational(fsm_t *s, event_t *e)
|
|||
esm_handle_pdn_connectivity_request(
|
||||
bearer, &message->esm.pdn_connectivity_request);
|
||||
d_info("[NAS] PDN connectivity request : "
|
||||
"UE[%s] --> ESM[%d]", ue->imsi_bcd, bearer->pti);
|
||||
"UE[%s] --> ESM[%d]",
|
||||
mme_ue->imsi_bcd, bearer->pti);
|
||||
break;
|
||||
}
|
||||
case NAS_ESM_INFORMATION_RESPONSE:
|
||||
|
@ -103,7 +105,8 @@ void esm_state_operational(fsm_t *s, event_t *e)
|
|||
bearer->sgw = mme_sgw_first();
|
||||
|
||||
d_info("[NAS] ESM information response : "
|
||||
"UE[%s] --> ESM[%d]", ue->imsi_bcd, bearer->pti);
|
||||
"UE[%s] --> ESM[%d]",
|
||||
mme_ue->imsi_bcd, bearer->pti);
|
||||
esm_handle_information_response(
|
||||
bearer, &message->esm.esm_information_response);
|
||||
break;
|
||||
|
@ -111,7 +114,8 @@ void esm_state_operational(fsm_t *s, event_t *e)
|
|||
case NAS_ACTIVATE_DEFAULT_EPS_BEARER_CONTEXT_ACCEPT:
|
||||
{
|
||||
d_info("[NAS] Activate default eps bearer context accept : "
|
||||
"UE[%s] --> ESM[%d]", ue->imsi_bcd, bearer->pti);
|
||||
"UE[%s] --> ESM[%d]",
|
||||
mme_ue->imsi_bcd, bearer->pti);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
|
|
@ -223,7 +223,7 @@ mme_enb_t* mme_enb_add(net_sock_t *s1ap_sock)
|
|||
s1ap_sock->app_index = enb->index;
|
||||
|
||||
enb->s1ap_sock = s1ap_sock;
|
||||
list_init(&enb->ue_list);
|
||||
list_init(&enb->enb_ue_list);
|
||||
list_append(&self.enb_list, enb);
|
||||
|
||||
fsm_create(&enb->sm, s1ap_state_initial, s1ap_state_final);
|
||||
|
@ -318,22 +318,22 @@ mme_enb_t* mme_enb_next(mme_enb_t *enb)
|
|||
/** enb_ue_context handling function */
|
||||
enb_ue_t* enb_ue_add(mme_enb_t *enb)
|
||||
{
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
|
||||
d_assert(self.mme_ue_s1ap_id_hash, return NULL, "Null param");
|
||||
d_assert(enb, return NULL, "Null param");
|
||||
|
||||
index_alloc(&enb_ue_pool, &ue);
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
index_alloc(&enb_ue_pool, &enb_ue);
|
||||
d_assert(enb_ue, return NULL, "Null param");
|
||||
|
||||
ue->mme_ue_s1ap_id = NEXT_ID(self.mme_ue_s1ap_id, 1, 0xffffffff);
|
||||
hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id,
|
||||
sizeof(ue->mme_ue_s1ap_id), ue);
|
||||
list_append(&enb->ue_list, ue);
|
||||
enb_ue->mme_ue_s1ap_id = NEXT_ID(self.mme_ue_s1ap_id, 1, 0xffffffff);
|
||||
hash_set(self.mme_ue_s1ap_id_hash, &enb_ue->mme_ue_s1ap_id,
|
||||
sizeof(enb_ue->mme_ue_s1ap_id), enb_ue);
|
||||
list_append(&enb->enb_ue_list, enb_ue);
|
||||
|
||||
ue->enb = enb;
|
||||
enb_ue->enb = enb;
|
||||
|
||||
return ue;
|
||||
return enb_ue;
|
||||
|
||||
}
|
||||
|
||||
|
@ -343,36 +343,36 @@ unsigned int enb_ue_count()
|
|||
return hash_count(self.mme_ue_s1ap_id_hash);
|
||||
}
|
||||
|
||||
status_t enb_ue_remove(enb_ue_t *ue)
|
||||
status_t enb_ue_remove(enb_ue_t *enb_ue)
|
||||
{
|
||||
d_assert(self.mme_ue_s1ap_id_hash, return CORE_ERROR, "Null param");
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(ue->enb, return CORE_ERROR, "Null param");
|
||||
d_assert(enb_ue, return CORE_ERROR, "Null param");
|
||||
d_assert(enb_ue->enb, return CORE_ERROR, "Null param");
|
||||
|
||||
list_remove(&ue->enb->ue_list, ue);
|
||||
hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id,
|
||||
sizeof(ue->mme_ue_s1ap_id), NULL);
|
||||
list_remove(&enb_ue->enb->enb_ue_list, enb_ue);
|
||||
hash_set(self.mme_ue_s1ap_id_hash, &enb_ue->mme_ue_s1ap_id,
|
||||
sizeof(enb_ue->mme_ue_s1ap_id), NULL);
|
||||
|
||||
index_free(&enb_ue_pool, ue);
|
||||
index_free(&enb_ue_pool, enb_ue);
|
||||
|
||||
if (ue->mme_ue)
|
||||
ue->mme_ue->enb_ue = NULL;
|
||||
if (enb_ue->mme_ue)
|
||||
enb_ue->mme_ue->enb_ue = NULL;
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
||||
status_t enb_ue_remove_in_enb(mme_enb_t *enb)
|
||||
{
|
||||
enb_ue_t *ue = NULL, *next_ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL, *next_enb_ue = NULL;
|
||||
|
||||
ue = enb_ue_first_in_enb(enb);
|
||||
while (ue)
|
||||
enb_ue = enb_ue_first_in_enb(enb);
|
||||
while (enb_ue)
|
||||
{
|
||||
next_ue = enb_ue_next_in_enb(ue);
|
||||
next_enb_ue = enb_ue_next_in_enb(enb_ue);
|
||||
|
||||
enb_ue_remove(ue);
|
||||
enb_ue_remove(enb_ue);
|
||||
|
||||
ue = next_ue;
|
||||
enb_ue = next_enb_ue;
|
||||
}
|
||||
|
||||
return CORE_OK;
|
||||
|
@ -387,18 +387,18 @@ enb_ue_t* enb_ue_find(index_t index)
|
|||
enb_ue_t* enb_ue_find_by_enb_ue_s1ap_id(
|
||||
mme_enb_t *enb, c_uint32_t enb_ue_s1ap_id)
|
||||
{
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
|
||||
ue = enb_ue_first_in_enb(enb);
|
||||
while (ue)
|
||||
enb_ue = enb_ue_first_in_enb(enb);
|
||||
while (enb_ue)
|
||||
{
|
||||
if (enb_ue_s1ap_id == ue->enb_ue_s1ap_id)
|
||||
if (enb_ue_s1ap_id == enb_ue->enb_ue_s1ap_id)
|
||||
break;
|
||||
|
||||
ue = enb_ue_next_in_enb(ue);
|
||||
enb_ue = enb_ue_next_in_enb(enb_ue);
|
||||
}
|
||||
|
||||
return ue;
|
||||
return enb_ue;
|
||||
}
|
||||
|
||||
enb_ue_t* enb_ue_find_by_mme_ue_s1ap_id(c_uint32_t mme_ue_s1ap_id)
|
||||
|
@ -410,57 +410,57 @@ enb_ue_t* enb_ue_find_by_mme_ue_s1ap_id(c_uint32_t mme_ue_s1ap_id)
|
|||
|
||||
enb_ue_t* enb_ue_first_in_enb(mme_enb_t *enb)
|
||||
{
|
||||
return list_first(&enb->ue_list);
|
||||
return list_first(&enb->enb_ue_list);
|
||||
}
|
||||
|
||||
enb_ue_t* enb_ue_next_in_enb(enb_ue_t *ue)
|
||||
enb_ue_t* enb_ue_next_in_enb(enb_ue_t *enb_ue)
|
||||
{
|
||||
return list_next(ue);
|
||||
return list_next(enb_ue);
|
||||
}
|
||||
|
||||
mme_ue_t* mme_ue_add(enb_ue_t *enb_ue)
|
||||
{
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(enb_ue, return NULL, "Null param");
|
||||
|
||||
index_alloc(&mme_ue_pool, &ue);
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
index_alloc(&mme_ue_pool, &mme_ue);
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
|
||||
ue->ebi = MIN_EPS_BEARER_ID - 1; /* Setup EBI Generator */
|
||||
mme_ue->ebi = MIN_EPS_BEARER_ID - 1; /* Setup EBI Generator */
|
||||
|
||||
list_init(&ue->pdn_list);
|
||||
list_init(&ue->sess_list);
|
||||
list_init(&mme_ue->pdn_list);
|
||||
list_init(&mme_ue->sess_list);
|
||||
|
||||
ue->enb_ue = enb_ue;
|
||||
enb_ue->mme_ue = ue;
|
||||
mme_ue->enb_ue = enb_ue;
|
||||
enb_ue->mme_ue = mme_ue;
|
||||
#define MME_UE_T3_DURATION 3000 /* 3 seconds */
|
||||
ue->tm_t3 = event_timer(&self.tm_service, MME_EVT_EMM_UE_T3,
|
||||
MME_UE_T3_DURATION, ue->index);
|
||||
mme_ue->tm_t3 = event_timer(&self.tm_service, MME_EVT_EMM_UE_T3,
|
||||
MME_UE_T3_DURATION, mme_ue->index);
|
||||
#if 1 /* example code : please remove if you know the usage */
|
||||
tm_start(ue->tm_t3);
|
||||
tm_stop(ue->tm_t3);
|
||||
tm_start(mme_ue->tm_t3);
|
||||
tm_stop(mme_ue->tm_t3);
|
||||
#endif
|
||||
|
||||
fsm_create(&ue->sm, emm_state_initial, emm_state_final);
|
||||
fsm_init(&ue->sm, 0);
|
||||
fsm_create(&mme_ue->sm, emm_state_initial, emm_state_final);
|
||||
fsm_init(&mme_ue->sm, 0);
|
||||
|
||||
return ue;
|
||||
return mme_ue;
|
||||
}
|
||||
|
||||
status_t mme_ue_remove(mme_ue_t *ue)
|
||||
status_t mme_ue_remove(mme_ue_t *mme_ue)
|
||||
{
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
tm_delete(ue->tm_t3);
|
||||
tm_delete(mme_ue->tm_t3);
|
||||
|
||||
fsm_final(&ue->sm, 0);
|
||||
fsm_clear(&ue->sm);
|
||||
fsm_final(&mme_ue->sm, 0);
|
||||
fsm_clear(&mme_ue->sm);
|
||||
|
||||
mme_sess_remove_all(ue);
|
||||
mme_pdn_remove_all(ue);
|
||||
mme_sess_remove_all(mme_ue);
|
||||
mme_pdn_remove_all(mme_ue);
|
||||
|
||||
index_free(&mme_ue_pool, ue);
|
||||
index_free(&mme_ue_pool, mme_ue);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
@ -468,12 +468,12 @@ status_t mme_ue_remove(mme_ue_t *ue)
|
|||
status_t mme_ue_remove_all()
|
||||
{
|
||||
hash_index_t *hi = NULL;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
for (hi = mme_ue_first(); hi; hi = mme_ue_next(hi))
|
||||
{
|
||||
ue = mme_ue_this(hi);
|
||||
mme_ue_remove(ue);
|
||||
mme_ue = mme_ue_this(hi);
|
||||
mme_ue_remove(mme_ue);
|
||||
}
|
||||
|
||||
return CORE_OK;
|
||||
|
@ -554,16 +554,16 @@ unsigned int mme_ue_count()
|
|||
|
||||
status_t mme_ue_remove_in_enb(mme_enb_t *enb)
|
||||
{
|
||||
mme_ue_t *ue = NULL, *next_ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL, *next_mme_ue = NULL;
|
||||
|
||||
ue = mme_ue_first_in_enb(enb);
|
||||
while (ue)
|
||||
mme_ue = mme_ue_first_in_enb(enb);
|
||||
while (mme_ue)
|
||||
{
|
||||
next_ue = mme_ue_next_in_enb(ue);
|
||||
next_mme_ue = mme_ue_next_in_enb(mme_ue);
|
||||
|
||||
mme_ue_remove(ue);
|
||||
mme_ue_remove(mme_ue);
|
||||
|
||||
ue = next_ue;
|
||||
mme_ue = next_mme_ue;
|
||||
}
|
||||
|
||||
return CORE_OK;
|
||||
|
@ -572,32 +572,32 @@ status_t mme_ue_remove_in_enb(mme_enb_t *enb)
|
|||
mme_ue_t* mme_ue_find_by_enb_ue_s1ap_id(
|
||||
mme_enb_t *enb, c_uint32_t enb_ue_s1ap_id)
|
||||
{
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
ue = mme_ue_first_in_enb(enb);
|
||||
while (ue)
|
||||
mme_ue = mme_ue_first_in_enb(enb);
|
||||
while (mme_ue)
|
||||
{
|
||||
if (enb_ue_s1ap_id == ue->enb_ue_s1ap_id)
|
||||
if (enb_ue_s1ap_id == mme_ue->enb_ue_s1ap_id)
|
||||
break;
|
||||
|
||||
ue = mme_ue_next_in_enb(ue);
|
||||
mme_ue = mme_ue_next_in_enb(mme_ue);
|
||||
}
|
||||
|
||||
return ue;
|
||||
return mme_ue;
|
||||
}
|
||||
|
||||
mme_ue_t* mme_ue_first_in_enb(mme_enb_t *enb)
|
||||
{
|
||||
return list_first(&enb->ue_list);
|
||||
return list_first(&enb->enb_ue_list);
|
||||
}
|
||||
|
||||
mme_ue_t* mme_ue_next_in_enb(mme_ue_t *ue)
|
||||
mme_ue_t* mme_ue_next_in_enb(mme_ue_t *mme_ue)
|
||||
{
|
||||
return list_next(ue);
|
||||
return list_next(mme_ue);
|
||||
}
|
||||
#endif
|
||||
|
||||
mme_bearer_t *mme_sess_add(mme_ue_t *ue, c_uint8_t pti)
|
||||
mme_bearer_t *mme_sess_add(mme_ue_t *mme_ue, c_uint8_t pti)
|
||||
{
|
||||
mme_sess_t *sess = NULL;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
|
@ -609,9 +609,9 @@ mme_bearer_t *mme_sess_add(mme_ue_t *ue, c_uint8_t pti)
|
|||
sess->mme_s11_addr = mme_self()->s11_addr;
|
||||
|
||||
list_init(&sess->bearer_list);
|
||||
list_append(&ue->sess_list, sess);
|
||||
list_append(&mme_ue->sess_list, sess);
|
||||
|
||||
sess->ue = ue;
|
||||
sess->mme_ue = mme_ue;
|
||||
|
||||
bearer = mme_bearer_add(sess, pti);
|
||||
d_assert(bearer, mme_sess_remove(sess); return NULL,
|
||||
|
@ -623,21 +623,21 @@ mme_bearer_t *mme_sess_add(mme_ue_t *ue, c_uint8_t pti)
|
|||
status_t mme_sess_remove(mme_sess_t *sess)
|
||||
{
|
||||
d_assert(sess, return CORE_ERROR, "Null param");
|
||||
d_assert(sess->ue, return CORE_ERROR, "Null param");
|
||||
d_assert(sess->mme_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
mme_bearer_remove_all(sess);
|
||||
|
||||
list_remove(&sess->ue->sess_list, sess);
|
||||
list_remove(&sess->mme_ue->sess_list, sess);
|
||||
index_free(&mme_sess_pool, sess);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
||||
status_t mme_sess_remove_all(mme_ue_t *ue)
|
||||
status_t mme_sess_remove_all(mme_ue_t *mme_ue)
|
||||
{
|
||||
mme_sess_t *sess = NULL, *next_sess = NULL;
|
||||
|
||||
sess = mme_sess_first(ue);
|
||||
sess = mme_sess_first(mme_ue);
|
||||
while (sess)
|
||||
{
|
||||
next_sess = mme_sess_next(sess);
|
||||
|
@ -661,12 +661,12 @@ mme_sess_t* mme_sess_find_by_teid(c_uint32_t teid)
|
|||
return mme_sess_find(teid);
|
||||
}
|
||||
|
||||
mme_sess_t* mme_sess_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi)
|
||||
mme_sess_t* mme_sess_find_by_ebi(mme_ue_t *mme_ue, c_uint8_t ebi)
|
||||
{
|
||||
mme_sess_t *sess = NULL;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
|
||||
sess = mme_sess_first(ue);
|
||||
sess = mme_sess_first(mme_ue);
|
||||
while (sess)
|
||||
{
|
||||
bearer = mme_bearer_first(sess);
|
||||
|
@ -684,9 +684,9 @@ mme_sess_t* mme_sess_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
mme_sess_t* mme_sess_first(mme_ue_t *ue)
|
||||
mme_sess_t* mme_sess_first(mme_ue_t *mme_ue)
|
||||
{
|
||||
return list_first(&ue->sess_list);
|
||||
return list_first(&mme_ue->sess_list);
|
||||
}
|
||||
|
||||
mme_sess_t* mme_sess_next(mme_sess_t *sess)
|
||||
|
@ -697,21 +697,21 @@ mme_sess_t* mme_sess_next(mme_sess_t *sess)
|
|||
mme_bearer_t* mme_bearer_add(mme_sess_t *sess, c_uint8_t pti)
|
||||
{
|
||||
mme_bearer_t *bearer = NULL;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(sess, return NULL, "Null param");
|
||||
ue = sess->ue;
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
mme_ue = sess->mme_ue;
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
|
||||
index_alloc(&mme_bearer_pool, &bearer);
|
||||
d_assert(bearer, return NULL, "Null param");
|
||||
|
||||
bearer->pti = pti;
|
||||
bearer->ebi = NEXT_ID(ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID);
|
||||
bearer->ebi = NEXT_ID(mme_ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID);
|
||||
|
||||
list_append(&sess->bearer_list, bearer);
|
||||
|
||||
bearer->ue = ue;
|
||||
bearer->mme_ue = mme_ue;
|
||||
bearer->sess = sess;
|
||||
|
||||
fsm_create(&bearer->sm, esm_state_initial, esm_state_final);
|
||||
|
@ -759,14 +759,14 @@ mme_bearer_t* mme_bearer_find(index_t index)
|
|||
return index_find(&mme_bearer_pool, index);
|
||||
}
|
||||
|
||||
mme_bearer_t* mme_bearer_find_by_ue_pti(mme_ue_t *ue, c_uint8_t pti)
|
||||
mme_bearer_t* mme_bearer_find_by_ue_pti(mme_ue_t *mme_ue, c_uint8_t pti)
|
||||
{
|
||||
mme_sess_t *sess = NULL;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
|
||||
sess = mme_sess_first(ue);
|
||||
sess = mme_sess_first(mme_ue);
|
||||
while (sess)
|
||||
{
|
||||
bearer = mme_bearer_first(sess);
|
||||
|
@ -784,14 +784,14 @@ mme_bearer_t* mme_bearer_find_by_ue_pti(mme_ue_t *ue, c_uint8_t pti)
|
|||
return NULL;
|
||||
}
|
||||
|
||||
mme_bearer_t* mme_bearer_find_by_ue_ebi(mme_ue_t *ue, c_uint8_t ebi)
|
||||
mme_bearer_t* mme_bearer_find_by_ue_ebi(mme_ue_t *mme_ue, c_uint8_t ebi)
|
||||
{
|
||||
mme_sess_t *sess = NULL;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
|
||||
sess = mme_sess_first(ue);
|
||||
sess = mme_sess_first(mme_ue);
|
||||
while (sess)
|
||||
{
|
||||
bearer = mme_bearer_first(sess);
|
||||
|
@ -844,11 +844,11 @@ mme_bearer_t* mme_bearer_next(mme_bearer_t *bearer)
|
|||
return list_next(bearer);
|
||||
}
|
||||
|
||||
pdn_t* mme_pdn_add(mme_ue_t *ue, c_int8_t *apn)
|
||||
pdn_t* mme_pdn_add(mme_ue_t *mme_ue, c_int8_t *apn)
|
||||
{
|
||||
pdn_t *pdn = NULL;
|
||||
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
d_assert(apn, return NULL, "Null param");
|
||||
|
||||
pool_alloc_node(&mme_pdn_pool, &pdn);
|
||||
|
@ -857,33 +857,33 @@ pdn_t* mme_pdn_add(mme_ue_t *ue, c_int8_t *apn)
|
|||
memset(pdn, 0, sizeof(pdn_t));
|
||||
strcpy(pdn->apn, apn);
|
||||
|
||||
pdn->context = ue;
|
||||
list_append(&ue->pdn_list, pdn);
|
||||
pdn->context = mme_ue;
|
||||
list_append(&mme_ue->pdn_list, pdn);
|
||||
|
||||
return pdn;
|
||||
}
|
||||
|
||||
status_t mme_pdn_remove(pdn_t *pdn)
|
||||
{
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
d_assert(pdn, return CORE_ERROR, "Null param");
|
||||
ue = pdn->context;
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
mme_ue = pdn->context;
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
list_remove(&ue->pdn_list, pdn);
|
||||
list_remove(&mme_ue->pdn_list, pdn);
|
||||
pool_free_node(&mme_pdn_pool, pdn);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
||||
status_t mme_pdn_remove_all(mme_ue_t *ue)
|
||||
status_t mme_pdn_remove_all(mme_ue_t *mme_ue)
|
||||
{
|
||||
pdn_t *pdn = NULL, *next_pdn = NULL;
|
||||
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
pdn = list_first(&ue->pdn_list);
|
||||
pdn = list_first(&mme_ue->pdn_list);
|
||||
while (pdn)
|
||||
{
|
||||
next_pdn = list_next(pdn);
|
||||
|
@ -896,13 +896,13 @@ status_t mme_pdn_remove_all(mme_ue_t *ue)
|
|||
return CORE_OK;
|
||||
}
|
||||
|
||||
pdn_t* mme_pdn_find_by_apn(mme_ue_t *ue, c_int8_t *apn)
|
||||
pdn_t* mme_pdn_find_by_apn(mme_ue_t *mme_ue, c_int8_t *apn)
|
||||
{
|
||||
pdn_t *pdn = NULL;
|
||||
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
|
||||
pdn = list_first(&ue->pdn_list);
|
||||
pdn = list_first(&mme_ue->pdn_list);
|
||||
while (pdn)
|
||||
{
|
||||
if (strcmp(pdn->apn, apn) == 0)
|
||||
|
@ -914,10 +914,10 @@ pdn_t* mme_pdn_find_by_apn(mme_ue_t *ue, c_int8_t *apn)
|
|||
return pdn;
|
||||
}
|
||||
|
||||
pdn_t* mme_pdn_first(mme_ue_t *ue)
|
||||
pdn_t* mme_pdn_first(mme_ue_t *mme_ue)
|
||||
{
|
||||
d_assert(ue, return NULL, "Null param");
|
||||
return list_first(&ue->pdn_list);
|
||||
d_assert(mme_ue, return NULL, "Null param");
|
||||
return list_first(&mme_ue->pdn_list);
|
||||
}
|
||||
|
||||
pdn_t* mme_pdn_next(pdn_t *pdn)
|
||||
|
|
|
@ -95,7 +95,7 @@ typedef struct _mme_enb_t {
|
|||
c_uint32_t enb_id; /** eNB_ID received from eNB */
|
||||
net_sock_t *s1ap_sock;
|
||||
|
||||
list_t ue_list;
|
||||
list_t enb_ue_list;
|
||||
|
||||
} mme_enb_t;
|
||||
|
||||
|
@ -213,7 +213,7 @@ typedef struct _mme_sess_t {
|
|||
list_t bearer_list;
|
||||
|
||||
/* Related Context */
|
||||
mme_ue_t *ue;
|
||||
mme_ue_t *mme_ue;
|
||||
} mme_sess_t;
|
||||
|
||||
typedef struct _mme_bearer_t {
|
||||
|
@ -239,7 +239,7 @@ typedef struct _mme_bearer_t {
|
|||
mme_sgw_t *sgw;
|
||||
pdn_t *pdn;
|
||||
|
||||
mme_ue_t *ue;
|
||||
mme_ue_t *mme_ue;
|
||||
mme_sess_t *sess;
|
||||
} mme_bearer_t;
|
||||
|
||||
|
@ -264,7 +264,7 @@ CORE_DECLARE(mme_enb_t*) mme_enb_first(void);
|
|||
CORE_DECLARE(mme_enb_t*) mme_enb_next(mme_enb_t *enb);
|
||||
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_add(enb_ue_t *enb_ue);
|
||||
CORE_DECLARE(status_t) mme_ue_remove(mme_ue_t *ue);
|
||||
CORE_DECLARE(status_t) mme_ue_remove(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(status_t) mme_ue_remove_all();
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_find(index_t index);
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_mme_ue_s1ap_id(
|
||||
|
@ -277,17 +277,18 @@ CORE_DECLARE(status_t) mme_ue_remove_in_enb(mme_enb_t *enb);
|
|||
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_enb_ue_s1ap_id(
|
||||
mme_enb_t *enb, c_uint32_t enb_ue_s1ap_id);
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_first_in_enb(mme_enb_t *enb);
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_next_in_enb(mme_ue_t *ue);
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_next_in_enb(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_imsi(c_uint8_t *imsi, int imsi_len);
|
||||
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_guti(guti_t *guti);
|
||||
|
||||
CORE_DECLARE(mme_bearer_t*) mme_sess_add(mme_ue_t *ue, c_uint8_t pti);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_sess_add(mme_ue_t *mme_ue, c_uint8_t pti);
|
||||
CORE_DECLARE(status_t ) mme_sess_remove(mme_sess_t *sess);
|
||||
CORE_DECLARE(status_t ) mme_sess_remove_all(mme_ue_t *ue);
|
||||
CORE_DECLARE(status_t ) mme_sess_remove_all(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_find(index_t index);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_find_by_teid(c_uint32_t teid);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_first(mme_ue_t *ue);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_find_by_ebi(
|
||||
mme_ue_t *mme_ue, c_uint8_t ebi);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_first(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(mme_sess_t*) mme_sess_next(mme_sess_t *sess);
|
||||
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_add(mme_sess_t *sess, c_uint8_t pti);
|
||||
|
@ -295,32 +296,33 @@ CORE_DECLARE(status_t) mme_bearer_remove(mme_bearer_t *bearer);
|
|||
CORE_DECLARE(status_t) mme_bearer_remove_all(mme_sess_t *sess);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_find(index_t index);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_ue_pti(
|
||||
mme_ue_t *ue, c_uint8_t pti);
|
||||
mme_ue_t *mme_ue, c_uint8_t pti);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_ue_ebi(
|
||||
mme_ue_t *ue, c_uint8_t ebi);
|
||||
mme_ue_t *mme_ue, c_uint8_t ebi);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_sess_ebi(
|
||||
mme_sess_t *sess, c_uint8_t ebi);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_default_bearer_in_sess(mme_sess_t *sess);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_first(mme_sess_t *sess);
|
||||
CORE_DECLARE(mme_bearer_t*) mme_bearer_next(mme_bearer_t *bearer);
|
||||
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_add(mme_ue_t *ue, c_int8_t *apn);
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_add(mme_ue_t *mme_ue, c_int8_t *apn);
|
||||
CORE_DECLARE(status_t) mme_pdn_remove(pdn_t *pdn);
|
||||
CORE_DECLARE(status_t) mme_pdn_remove_all(mme_ue_t *ue);
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_find_by_apn(mme_ue_t *ue, c_int8_t *apn);
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_first(mme_ue_t *ue);
|
||||
CORE_DECLARE(status_t) mme_pdn_remove_all(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_find_by_apn(
|
||||
mme_ue_t *mme_ue, c_int8_t *apn);
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_first(mme_ue_t *mme_ue);
|
||||
CORE_DECLARE(pdn_t*) mme_pdn_next(pdn_t *pdn);
|
||||
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_add(mme_enb_t *enb);
|
||||
CORE_DECLARE(unsigned int) enb_ue_count();
|
||||
CORE_DECLARE(status_t) enb_ue_remove(enb_ue_t *ue);
|
||||
CORE_DECLARE(status_t) enb_ue_remove(enb_ue_t *enb_ue);
|
||||
CORE_DECLARE(status_t) enb_ue_remove_in_enb(mme_enb_t *enb);
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_find(index_t index);
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_find_by_enb_ue_s1ap_id(mme_enb_t *enb,
|
||||
c_uint32_t enb_ue_s1ap_id);
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_find_by_mme_ue_s1ap_id(c_uint32_t mme_ue_s1ap_id);
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_first_in_enb(mme_enb_t *enb);
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_next_in_enb(enb_ue_t *ue);
|
||||
CORE_DECLARE(enb_ue_t*) enb_ue_next_in_enb(enb_ue_t *enb_ue);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -14,7 +14,7 @@ status_t mme_s11_build_create_session_request(
|
|||
status_t rv;
|
||||
pdn_t *pdn = NULL;
|
||||
mme_sgw_t *sgw = NULL;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
mme_sess_t *sess = NULL;
|
||||
gtp_message_t gtp_message;
|
||||
gtp_create_session_request_t *req = >p_message.create_session_request;
|
||||
|
@ -34,36 +34,38 @@ status_t mme_s11_build_create_session_request(
|
|||
d_assert(sgw, return CORE_ERROR, "Null param");
|
||||
sess = bearer->sess;
|
||||
d_assert(sess, return CORE_ERROR, "Null param");
|
||||
ue = sess->ue;
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(ue->enb_ue, return CORE_ERROR, "Null param");
|
||||
mme_ue = sess->mme_ue;
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue->enb_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(>p_message, 0, sizeof(gtp_message_t));
|
||||
|
||||
d_assert(ue->imsi_len, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue->imsi_len, return CORE_ERROR, "Null param");
|
||||
req->imsi.presence = 1;
|
||||
req->imsi.data = ue->imsi;
|
||||
req->imsi.len = ue->imsi_len;
|
||||
req->imsi.data = mme_ue->imsi;
|
||||
req->imsi.len = mme_ue->imsi_len;
|
||||
|
||||
/* Not used */
|
||||
req->msisdn.presence = 1;
|
||||
req->msisdn.data = ue->imsi;
|
||||
req->msisdn.len = ue->imsi_len;
|
||||
req->msisdn.data = mme_ue->imsi;
|
||||
req->msisdn.len = mme_ue->imsi_len;
|
||||
|
||||
memset(&uli, 0, sizeof(gtp_uli_t));
|
||||
uli.flags.e_cgi = 1;
|
||||
uli.flags.tai = 1;
|
||||
memcpy(&uli.tai.plmn_id, &ue->enb_ue->tai.plmn_id, sizeof(uli.tai.plmn_id));
|
||||
uli.tai.tac = ue->enb_ue->tai.tac;
|
||||
memcpy(&uli.e_cgi.plmn_id, &ue->enb_ue->e_cgi.plmn_id, sizeof(uli.tai.plmn_id));
|
||||
uli.e_cgi.cell_id = ue->enb_ue->e_cgi.cell_id;
|
||||
memcpy(&uli.tai.plmn_id, &mme_ue->enb_ue->tai.plmn_id,
|
||||
sizeof(uli.tai.plmn_id));
|
||||
uli.tai.tac = mme_ue->enb_ue->tai.tac;
|
||||
memcpy(&uli.e_cgi.plmn_id, &mme_ue->enb_ue->e_cgi.plmn_id,
|
||||
sizeof(uli.tai.plmn_id));
|
||||
uli.e_cgi.cell_id = mme_ue->enb_ue->e_cgi.cell_id;
|
||||
req->user_location_information.presence = 1;
|
||||
gtp_build_uli(&req->user_location_information, &uli,
|
||||
uli_buf, GTP_MAX_ULI_LEN);
|
||||
|
||||
req->serving_network.presence = 1;
|
||||
req->serving_network.data = &ue->visited_plmn_id;
|
||||
req->serving_network.len = sizeof(ue->visited_plmn_id);
|
||||
req->serving_network.data = &mme_ue->visited_plmn_id;
|
||||
req->serving_network.len = sizeof(mme_ue->visited_plmn_id);
|
||||
|
||||
req->rat_type.presence = 1;
|
||||
req->rat_type.u8 = GTP_RAT_TYPE_EUTRAN;
|
||||
|
@ -183,15 +185,15 @@ status_t mme_s11_build_modify_bearer_request(
|
|||
status_t mme_s11_build_delete_session_request(pkbuf_t **pkbuf, mme_sess_t *sess)
|
||||
{
|
||||
status_t rv;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
gtp_message_t gtp_message;
|
||||
gtp_delete_session_request_t *req = >p_message.delete_session_request;
|
||||
|
||||
gtp_f_teid_t mme_s11_teid;
|
||||
|
||||
d_assert(sess, return CORE_ERROR, "Null param");
|
||||
ue = sess->ue;
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
mme_ue = sess->mme_ue;
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(>p_message, 0, sizeof(gtp_message_t));
|
||||
|
||||
|
|
|
@ -86,14 +86,14 @@ void mme_s11_handle_create_session_response(
|
|||
void mme_s11_handle_modify_bearer_response(
|
||||
mme_sess_t *sess, gtp_modify_bearer_response_t *rsp)
|
||||
{
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
event_t e;
|
||||
|
||||
d_assert(sess, return, "Null param");
|
||||
ue = sess->ue;
|
||||
mme_ue = sess->mme_ue;
|
||||
|
||||
event_set(&e, MME_EVT_EMM_UE_FROM_S11);
|
||||
event_set_param1(&e, (c_uintptr_t)ue->index);
|
||||
event_set_param1(&e, (c_uintptr_t)mme_ue->index);
|
||||
event_set_param2(&e, (c_uintptr_t)GTP_MODIFY_BEARER_RESPONSE_TYPE);
|
||||
mme_event_send(&e);
|
||||
}
|
||||
|
|
|
@ -13,7 +13,7 @@
|
|||
static struct session_handler *mme_s6a_reg = NULL;
|
||||
|
||||
struct sess_state {
|
||||
mme_ue_t *ue;
|
||||
mme_ue_t *mme_ue;
|
||||
struct timespec ts; /* Time of sending the message */
|
||||
};
|
||||
|
||||
|
@ -33,7 +33,7 @@ static void mme_s6a_aia_cb(void *data, struct msg **msg)
|
|||
int new;
|
||||
|
||||
event_t e;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
CHECK_SYS_DO(clock_gettime(CLOCK_REALTIME, &ts), return);
|
||||
|
||||
|
@ -44,11 +44,11 @@ static void mme_s6a_aia_cb(void *data, struct msg **msg)
|
|||
d_assert(fd_sess_state_retrieve(mme_s6a_reg, sess, &mi) == 0 &&
|
||||
mi && (void *)mi == data, fd_msg_free(*msg); *msg = NULL; return,);
|
||||
|
||||
ue = mi->ue;
|
||||
d_assert(ue, error++; goto out,);
|
||||
mme_ue = mi->mme_ue;
|
||||
d_assert(mme_ue, error++; goto out,);
|
||||
|
||||
d_info("[S6A] Authentication-Information-Response : UE[%s] <-- HSS",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
/* Value of Result Code */
|
||||
d_assert(fd_msg_search_avp(*msg, s6a_result_code, &avp) == 0 && avp,
|
||||
|
@ -72,27 +72,27 @@ static void mme_s6a_aia_cb(void *data, struct msg **msg)
|
|||
d_assert(fd_avp_search_avp(avp_e_utran_vector, s6a_xres, &avp_xres) == 0 &&
|
||||
avp_xres, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avp_xres, &hdr) == 0 && hdr, error++; goto out,);
|
||||
memcpy(ue->xres, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
ue->xres_len = hdr->avp_value->os.len;
|
||||
memcpy(mme_ue->xres, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
mme_ue->xres_len = hdr->avp_value->os.len;
|
||||
|
||||
d_assert(
|
||||
fd_avp_search_avp(avp_e_utran_vector, s6a_kasme, &avp_kasme) == 0 &&
|
||||
avp_kasme, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avp_kasme, &hdr) == 0 && hdr, error++; goto out,);
|
||||
memcpy(ue->kasme, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
memcpy(mme_ue->kasme, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
|
||||
d_assert(fd_avp_search_avp(avp_e_utran_vector, s6a_rand, &avp_rand) == 0 &&
|
||||
avp_rand, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avp_rand, &hdr) == 0 && hdr, error++; goto out,);
|
||||
memcpy(ue->rand, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
memcpy(mme_ue->rand, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
|
||||
d_assert(fd_avp_search_avp(avp_e_utran_vector, s6a_autn, &avp_autn) == 0 &&
|
||||
avp_autn, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avp_autn, &hdr) == 0 && hdr, error++; goto out,);
|
||||
memcpy(ue->autn, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
memcpy(mme_ue->autn, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
|
||||
event_set(&e, MME_EVT_EMM_UE_FROM_S6A);
|
||||
event_set_param1(&e, (c_uintptr_t)ue->index);
|
||||
event_set_param1(&e, (c_uintptr_t)mme_ue->index);
|
||||
event_set_param2(&e, (c_uintptr_t)S6A_CMD_AUTHENTICATION_INFORMATION);
|
||||
mme_event_send(&e);
|
||||
|
||||
|
@ -140,7 +140,7 @@ out:
|
|||
}
|
||||
|
||||
/* MME Sends Authentication Information Request to HSS */
|
||||
int mme_s6a_send_air(mme_ue_t *ue)
|
||||
int mme_s6a_send_air(mme_ue_t *mme_ue)
|
||||
{
|
||||
struct msg *req = NULL;
|
||||
struct avp *avp;
|
||||
|
@ -149,13 +149,13 @@ int mme_s6a_send_air(mme_ue_t *ue)
|
|||
struct sess_state *mi = NULL, *svg;
|
||||
struct session *sess = NULL;
|
||||
|
||||
d_assert(ue, return -1, "Null Param");
|
||||
d_assert(mme_ue, return -1, "Null Param");
|
||||
|
||||
/* Create the random value to store with the session */
|
||||
pool_alloc_node(&sess_state_pool, &mi);
|
||||
d_assert(mi, return -1, "malloc failed: %s", strerror(errno));
|
||||
|
||||
mi->ue = ue;
|
||||
mi->mme_ue = mme_ue;
|
||||
|
||||
/* Create the request */
|
||||
d_assert(fd_msg_new(s6a_cmd_air, MSGFL_ALLOC_ETEID, &req) == 0,
|
||||
|
@ -186,8 +186,8 @@ int mme_s6a_send_air(mme_ue_t *ue)
|
|||
|
||||
/* Set the User-Name AVP */
|
||||
d_assert(fd_msg_avp_new(s6a_user_name, 0, &avp) == 0, goto out,);
|
||||
val.os.data = (c_uint8_t *)ue->imsi_bcd;
|
||||
val.os.len = strlen(ue->imsi_bcd);
|
||||
val.os.data = (c_uint8_t *)mme_ue->imsi_bcd;
|
||||
val.os.len = strlen(mme_ue->imsi_bcd);
|
||||
d_assert(fd_msg_avp_setvalue(avp, &val) == 0, goto out, );
|
||||
d_assert(fd_msg_avp_add(req, MSG_BRW_LAST_CHILD, avp) == 0, goto out,);
|
||||
|
||||
|
@ -209,7 +209,7 @@ int mme_s6a_send_air(mme_ue_t *ue)
|
|||
|
||||
/* Set the Visited-PLMN-Id AVP */
|
||||
d_assert(fd_msg_avp_new(s6a_visited_plmn_id, 0, &avp) == 0, goto out,);
|
||||
val.os.data = (c_uint8_t *)&ue->visited_plmn_id;
|
||||
val.os.data = (c_uint8_t *)&mme_ue->visited_plmn_id;
|
||||
val.os.len = PLMN_ID_LEN;
|
||||
d_assert(fd_msg_avp_setvalue(avp, &val) == 0, goto out,);
|
||||
d_assert(fd_msg_avp_add(req, MSG_BRW_LAST_CHILD, avp) == 0, goto out,);
|
||||
|
@ -232,7 +232,7 @@ int mme_s6a_send_air(mme_ue_t *ue)
|
|||
d_assert(pthread_mutex_unlock(&s6a_config->stats_lock) == 0,, );
|
||||
|
||||
d_info("[S6A] Authentication-Information-Request : UE[%s] --> HSS",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
return 0;
|
||||
|
||||
|
@ -257,7 +257,7 @@ static void mme_s6a_ula_cb(void *data, struct msg **msg)
|
|||
int new;
|
||||
|
||||
event_t e;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
pdn_t *pdn = NULL;
|
||||
|
||||
CHECK_SYS_DO(clock_gettime(CLOCK_REALTIME, &ts), return);
|
||||
|
@ -269,11 +269,11 @@ static void mme_s6a_ula_cb(void *data, struct msg **msg)
|
|||
d_assert(fd_sess_state_retrieve(mme_s6a_reg, sess, &mi) == 0 &&
|
||||
mi && (void *)mi == data, fd_msg_free(*msg); *msg = NULL; return,);
|
||||
|
||||
ue = mi->ue;
|
||||
d_assert(ue, error++; goto out,);
|
||||
mme_ue = mi->mme_ue;
|
||||
d_assert(mme_ue, error++; goto out,);
|
||||
|
||||
d_info("[S6A] Update-Location-Response : UE[%s] <-- HSS",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
/* Value of Result Code */
|
||||
d_assert(fd_msg_search_avp(*msg, s6a_result_code, &avp) == 0 && avp,
|
||||
|
@ -289,7 +289,7 @@ static void mme_s6a_ula_cb(void *data, struct msg **msg)
|
|||
d_assert(fd_msg_search_avp(*msg, s6a_ula_flags, &avp) == 0
|
||||
&& avp, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avp, &hdr) == 0 && hdr, error++; goto out,);
|
||||
ue->ula_flags = hdr->avp_value->i32;
|
||||
mme_ue->ula_flags = hdr->avp_value->i32;
|
||||
|
||||
d_assert(fd_msg_search_avp(*msg, s6a_subscription_data, &avp) == 0 && avp,
|
||||
error++; goto out,);
|
||||
|
@ -299,11 +299,11 @@ static void mme_s6a_ula_cb(void *data, struct msg **msg)
|
|||
d_assert(fd_avp_search_avp(avpch1, s6a_max_bandwidth_ul, &avpch2) == 0 &&
|
||||
avpch2, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avpch2, &hdr) == 0 && hdr, error++; goto out,);
|
||||
ue->max_bandwidth_ul = hdr->avp_value->i32;
|
||||
mme_ue->max_bandwidth_ul = hdr->avp_value->i32;
|
||||
d_assert(fd_avp_search_avp(avpch1, s6a_max_bandwidth_dl, &avpch2) == 0 &&
|
||||
avpch2, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avpch2, &hdr) == 0 && hdr, error++; goto out,);
|
||||
ue->max_bandwidth_dl = hdr->avp_value->i32;
|
||||
mme_ue->max_bandwidth_dl = hdr->avp_value->i32;
|
||||
|
||||
d_assert(fd_avp_search_avp(avp, s6a_apn_configuration_profile, &avpch1)
|
||||
== 0 && avpch1, error++; goto out,);
|
||||
|
@ -329,9 +329,9 @@ static void mme_s6a_ula_cb(void *data, struct msg **msg)
|
|||
memcpy(apn, hdr->avp_value->os.data, hdr->avp_value->os.len);
|
||||
apn[hdr->avp_value->os.len] = 0;
|
||||
|
||||
pdn = mme_pdn_find_by_apn(ue, apn);
|
||||
pdn = mme_pdn_find_by_apn(mme_ue, apn);
|
||||
if (!pdn)
|
||||
pdn = mme_pdn_add(ue, apn);
|
||||
pdn = mme_pdn_add(mme_ue, apn);
|
||||
else
|
||||
d_warn("Duplicate APN:[%s]", apn);
|
||||
d_assert(pdn, error++; goto out,);
|
||||
|
@ -409,10 +409,10 @@ static void mme_s6a_ula_cb(void *data, struct msg **msg)
|
|||
d_assert(fd_msg_search_avp(*msg, s6a_subscribed_rau_tau_timer, &avp) == 0
|
||||
&& avp, error++; goto out,);
|
||||
d_assert(fd_msg_avp_hdr(avp, &hdr) == 0 && hdr, error++; goto out,);
|
||||
ue->subscribed_rau_tau_timer = hdr->avp_value->i32;
|
||||
mme_ue->subscribed_rau_tau_timer = hdr->avp_value->i32;
|
||||
|
||||
event_set(&e, MME_EVT_EMM_UE_FROM_S6A);
|
||||
event_set_param1(&e, (c_uintptr_t)ue->index);
|
||||
event_set_param1(&e, (c_uintptr_t)mme_ue->index);
|
||||
event_set_param2(&e, (c_uintptr_t)S6A_CMD_UPDATE_LOCATION);
|
||||
mme_event_send(&e);
|
||||
out:
|
||||
|
@ -459,7 +459,7 @@ out:
|
|||
}
|
||||
|
||||
/* MME Sends Update Location Request to HSS */
|
||||
int mme_s6a_send_ulr(mme_ue_t *ue)
|
||||
int mme_s6a_send_ulr(mme_ue_t *mme_ue)
|
||||
{
|
||||
struct msg *req = NULL;
|
||||
struct avp *avp;
|
||||
|
@ -467,13 +467,13 @@ int mme_s6a_send_ulr(mme_ue_t *ue)
|
|||
struct sess_state *mi = NULL, *svg;
|
||||
struct session *sess = NULL;
|
||||
|
||||
d_assert(ue, return -1, "Null Param");
|
||||
d_assert(mme_ue, return -1, "Null Param");
|
||||
|
||||
/* Create the random value to store with the session */
|
||||
pool_alloc_node(&sess_state_pool, &mi);
|
||||
d_assert(mi, return -1, "malloc failed: %s", strerror(errno));
|
||||
|
||||
mi->ue = ue;
|
||||
mi->mme_ue = mme_ue;
|
||||
|
||||
/* Create the request */
|
||||
d_assert(fd_msg_new(s6a_cmd_ulr, MSGFL_ALLOC_ETEID, &req) == 0,
|
||||
|
@ -504,8 +504,8 @@ int mme_s6a_send_ulr(mme_ue_t *ue)
|
|||
|
||||
/* Set the User-Name AVP */
|
||||
d_assert(fd_msg_avp_new(s6a_user_name, 0, &avp) == 0, goto out,);
|
||||
val.os.data = (c_uint8_t *)ue->imsi_bcd;
|
||||
val.os.len = strlen(ue->imsi_bcd);
|
||||
val.os.data = (c_uint8_t *)mme_ue->imsi_bcd;
|
||||
val.os.len = strlen(mme_ue->imsi_bcd);
|
||||
d_assert(fd_msg_avp_setvalue(avp, &val) == 0, goto out, );
|
||||
d_assert(fd_msg_avp_add(req, MSG_BRW_LAST_CHILD, avp) == 0, goto out,);
|
||||
|
||||
|
@ -523,7 +523,7 @@ int mme_s6a_send_ulr(mme_ue_t *ue)
|
|||
|
||||
/* Set the Visited-PLMN-Id */
|
||||
d_assert(fd_msg_avp_new(s6a_visited_plmn_id, 0, &avp) == 0, goto out,);
|
||||
val.os.data = (c_uint8_t *)&ue->visited_plmn_id;
|
||||
val.os.data = (c_uint8_t *)&mme_ue->visited_plmn_id;
|
||||
val.os.len = PLMN_ID_LEN;
|
||||
d_assert(fd_msg_avp_setvalue(avp, &val) == 0, goto out,);
|
||||
d_assert(fd_msg_avp_add(req, MSG_BRW_LAST_CHILD, avp) == 0, goto out,);
|
||||
|
@ -552,7 +552,7 @@ int mme_s6a_send_ulr(mme_ue_t *ue)
|
|||
d_assert(pthread_mutex_unlock(&s6a_config->stats_lock) == 0,, );
|
||||
|
||||
d_info("[S6A] Update-Location-Request : UE[%s] --> HSS",
|
||||
ue->imsi_bcd);
|
||||
mme_ue->imsi_bcd);
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
@ -13,9 +13,9 @@ CORE_DECLARE(status_t) mme_s6a_init(void);
|
|||
CORE_DECLARE(void) mme_s6a_final(void);
|
||||
|
||||
/* MME Sends Authentication Information Request to HSS */
|
||||
CORE_DECLARE(int) mme_s6a_send_air(mme_ue_t *ue);
|
||||
CORE_DECLARE(int) mme_s6a_send_air(mme_ue_t *mme_ue);
|
||||
/* MME Sends Update Location Request to HSS */
|
||||
CORE_DECLARE(int) mme_s6a_send_ulr(mme_ue_t *ue);
|
||||
CORE_DECLARE(int) mme_s6a_send_ulr(mme_ue_t *mme_ue);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -150,21 +150,21 @@ void mme_state_operational(fsm_t *s, event_t *e)
|
|||
nas_message_t message;
|
||||
index_t index = event_get_param1(e);
|
||||
pkbuf_t *pkbuf = (pkbuf_t *)event_get_param2(e);
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
|
||||
ue = enb_ue_find(index);
|
||||
d_assert(ue, break, "No ENB UE context");
|
||||
enb_ue = enb_ue_find(index);
|
||||
d_assert(enb_ue, break, "No ENB UE context");
|
||||
|
||||
d_assert(pkbuf, break, "Null param");
|
||||
d_assert(nas_emm_decode(&message, pkbuf) == CORE_OK,
|
||||
pkbuf_free(pkbuf); break, "Can't decode NAS_EMM");
|
||||
|
||||
mme_ue = ue->mme_ue;
|
||||
mme_ue = enb_ue->mme_ue;
|
||||
if (mme_ue == NULL)
|
||||
{
|
||||
/* Find MME UE by NAS message or create if needed */
|
||||
mme_ue = emm_find_ue_by_message(ue, &message);
|
||||
mme_ue = emm_find_ue_by_message(enb_ue, &message);
|
||||
}
|
||||
|
||||
d_assert(mme_ue, pkbuf_free(pkbuf);break, "No MME UE context");
|
||||
|
@ -188,7 +188,7 @@ void mme_state_operational(fsm_t *s, event_t *e)
|
|||
{
|
||||
nas_message_t message;
|
||||
index_t index = event_get_param1(e);
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
pkbuf_t *pkbuf = NULL;
|
||||
|
||||
|
@ -197,15 +197,15 @@ void mme_state_operational(fsm_t *s, event_t *e)
|
|||
d_assert(index, break, "Null param");
|
||||
bearer = mme_bearer_find(index);
|
||||
d_assert(bearer, break, "No ESM context");
|
||||
ue = bearer->ue;
|
||||
mme_ue = bearer->mme_ue;
|
||||
}
|
||||
else
|
||||
{
|
||||
d_assert(index, break, "Null param");
|
||||
ue = mme_ue_find(index);
|
||||
mme_ue = mme_ue_find(index);
|
||||
}
|
||||
d_assert(ue, break, "No UE context");
|
||||
d_assert(FSM_STATE(&ue->sm), break, "No EMM State Machine");
|
||||
d_assert(mme_ue, break, "No UE context");
|
||||
d_assert(FSM_STATE(&mme_ue->sm), break, "No EMM State Machine");
|
||||
|
||||
if (event_get(e) == MME_EVT_EMM_UE_MSG)
|
||||
{
|
||||
|
@ -216,7 +216,7 @@ void mme_state_operational(fsm_t *s, event_t *e)
|
|||
event_set_param3(e, (c_uintptr_t)&message);
|
||||
}
|
||||
|
||||
fsm_dispatch(&ue->sm, (fsm_event_t*)e);
|
||||
fsm_dispatch(&mme_ue->sm, (fsm_event_t*)e);
|
||||
|
||||
if (event_get(e) == MME_EVT_EMM_UE_MSG)
|
||||
{
|
||||
|
@ -231,13 +231,13 @@ void mme_state_operational(fsm_t *s, event_t *e)
|
|||
nas_message_t message;
|
||||
index_t index = event_get_param1(e);
|
||||
mme_bearer_t *bearer = NULL;
|
||||
mme_ue_t *ue = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
pkbuf_t *pkbuf = NULL;
|
||||
|
||||
d_assert(index, break, "Null param");
|
||||
bearer = mme_bearer_find(index);
|
||||
d_assert(bearer, break, "No ESM context");
|
||||
d_assert(ue = bearer->ue, break, "No UE context");
|
||||
d_assert(mme_ue = bearer->mme_ue, break, "No UE context");
|
||||
d_assert(FSM_STATE(&bearer->sm), break, "No ESM State Machine");
|
||||
|
||||
if (event_get(e) == MME_EVT_ESM_BEARER_MSG)
|
||||
|
|
|
@ -6,13 +6,13 @@
|
|||
#include "nas_security.h"
|
||||
|
||||
status_t nas_security_encode(
|
||||
pkbuf_t **pkbuf, mme_ue_t *ue, nas_message_t *message)
|
||||
pkbuf_t **pkbuf, mme_ue_t *mme_ue, nas_message_t *message)
|
||||
{
|
||||
int integrity_protected = 0;
|
||||
int new_security_context = 0;
|
||||
int ciphered = 0;
|
||||
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
d_assert(message, return CORE_ERROR, "Null param");
|
||||
|
||||
switch(message->h.security_header_type)
|
||||
|
@ -44,8 +44,8 @@ status_t nas_security_encode(
|
|||
|
||||
if (new_security_context)
|
||||
{
|
||||
ue->dl_count = 0;
|
||||
ue->ul_count.i32 = 0;
|
||||
mme_ue->dl_count = 0;
|
||||
mme_ue->ul_count.i32 = 0;
|
||||
}
|
||||
|
||||
if (mme_self()->selected_enc_algorithm == 0)
|
||||
|
@ -61,7 +61,7 @@ status_t nas_security_encode(
|
|||
memset(&h, 0, sizeof(h));
|
||||
h.security_header_type = message->h.security_header_type;
|
||||
h.protocol_discriminator = message->h.protocol_discriminator;
|
||||
h.sequence_number = (ue->dl_count & 0xff);
|
||||
h.sequence_number = (mme_ue->dl_count & 0xff);
|
||||
|
||||
d_assert(nas_plain_encode(&new, message) == CORE_OK,
|
||||
return CORE_ERROR, "NAS encoding error");
|
||||
|
@ -75,7 +75,7 @@ status_t nas_security_encode(
|
|||
{
|
||||
/* encrypt NAS message */
|
||||
nas_encrypt(mme_self()->selected_enc_algorithm,
|
||||
ue->knas_enc, ue->dl_count, NAS_SECURITY_BEARER,
|
||||
mme_ue->knas_enc, mme_ue->dl_count, NAS_SECURITY_BEARER,
|
||||
NAS_SECURITY_DOWNLINK_DIRECTION, new);
|
||||
}
|
||||
|
||||
|
@ -85,7 +85,7 @@ status_t nas_security_encode(
|
|||
|
||||
/* calculate NAS MAC(message authentication code) */
|
||||
nas_mac_calculate(mme_self()->selected_int_algorithm,
|
||||
ue->knas_int, ue->dl_count, NAS_SECURITY_BEARER,
|
||||
mme_ue->knas_int, mme_ue->dl_count, NAS_SECURITY_BEARER,
|
||||
NAS_SECURITY_DOWNLINK_DIRECTION, new, mac);
|
||||
memcpy(&h.message_authentication_code, mac, sizeof(mac));
|
||||
/* h.message_authentication_code =
|
||||
|
@ -93,7 +93,7 @@ status_t nas_security_encode(
|
|||
}
|
||||
|
||||
/* increase dl_count */
|
||||
ue->dl_count = (ue->dl_count + 1) & 0xffffff; /* Use 24bit */
|
||||
mme_ue->dl_count = (mme_ue->dl_count + 1) & 0xffffff; /* Use 24bit */
|
||||
|
||||
/* encode all security header */
|
||||
d_assert(CORE_OK == pkbuf_header(new, 5),
|
||||
|
@ -104,13 +104,14 @@ status_t nas_security_encode(
|
|||
|
||||
*pkbuf = new;
|
||||
|
||||
ue->security_context_available = 1;
|
||||
mme_ue->security_context_available = 1;
|
||||
}
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
||||
status_t nas_security_decode(mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed)
|
||||
status_t nas_security_decode(
|
||||
mme_ue_t *mme_ue, pkbuf_t *pkbuf, int *mac_failed)
|
||||
{
|
||||
c_int32_t hsize = 0;
|
||||
|
||||
|
@ -120,7 +121,7 @@ status_t nas_security_decode(mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed)
|
|||
|
||||
nas_security_header_t *h = NULL;
|
||||
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
d_assert(pkbuf, return CORE_ERROR, "Null param");
|
||||
d_assert(pkbuf->payload, return CORE_ERROR, "Null param");
|
||||
d_assert(mac_failed, return CORE_ERROR, "Null param");
|
||||
|
@ -157,7 +158,7 @@ status_t nas_security_decode(mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed)
|
|||
d_assert(pkbuf_header(pkbuf, -hsize) == CORE_OK,
|
||||
return CORE_ERROR, "pkbuf_header error");
|
||||
|
||||
if (!ue->security_context_available)
|
||||
if (!mme_ue->security_context_available)
|
||||
{
|
||||
integrity_protected = 0;
|
||||
new_security_context = 0;
|
||||
|
@ -166,7 +167,7 @@ status_t nas_security_decode(mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed)
|
|||
|
||||
if (new_security_context)
|
||||
{
|
||||
ue->ul_count.i32 = 0;
|
||||
mme_ue->ul_count.i32 = 0;
|
||||
}
|
||||
|
||||
if (mme_self()->selected_enc_algorithm == 0)
|
||||
|
@ -180,15 +181,15 @@ status_t nas_security_decode(mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed)
|
|||
return CORE_ERROR, "pkbuf_header error");
|
||||
|
||||
/* calculate ul_count */
|
||||
if (ue->ul_count.sqn > h->sequence_number)
|
||||
ue->ul_count.overflow++;
|
||||
ue->ul_count.sqn = h->sequence_number;
|
||||
if (mme_ue->ul_count.sqn > h->sequence_number)
|
||||
mme_ue->ul_count.overflow++;
|
||||
mme_ue->ul_count.sqn = h->sequence_number;
|
||||
|
||||
if (ciphered)
|
||||
{
|
||||
/* decrypt NAS message */
|
||||
nas_encrypt(mme_self()->selected_enc_algorithm,
|
||||
ue->knas_enc, ue->ul_count.i32, NAS_SECURITY_BEARER,
|
||||
mme_ue->knas_enc, mme_ue->ul_count.i32, NAS_SECURITY_BEARER,
|
||||
NAS_SECURITY_UPLINK_DIRECTION, pkbuf);
|
||||
}
|
||||
if(integrity_protected)
|
||||
|
@ -198,7 +199,7 @@ status_t nas_security_decode(mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed)
|
|||
|
||||
/* calculate NAS MAC(message authentication code) */
|
||||
nas_mac_calculate(mme_self()->selected_int_algorithm,
|
||||
ue->knas_int, ue->ul_count.i32, NAS_SECURITY_BEARER,
|
||||
mme_ue->knas_int, mme_ue->ul_count.i32, NAS_SECURITY_BEARER,
|
||||
NAS_SECURITY_UPLINK_DIRECTION, pkbuf, mac);
|
||||
|
||||
memcpy(&mac32, mac, NAS_SECURITY_MAC_SIZE);
|
||||
|
|
|
@ -20,9 +20,9 @@ extern "C" {
|
|||
#endif /* __cplusplus */
|
||||
|
||||
CORE_DECLARE(status_t) nas_security_encode(
|
||||
pkbuf_t **pkbuf, mme_ue_t *ue, nas_message_t *message);
|
||||
pkbuf_t **pkbuf, mme_ue_t *mme_ue, nas_message_t *message);
|
||||
CORE_DECLARE(status_t) nas_security_decode(
|
||||
mme_ue_t *ue, pkbuf_t *pkbuf, int *mac_failed);
|
||||
mme_ue_t *mme_ue, pkbuf_t *pkbuf, int *mac_failed);
|
||||
|
||||
CORE_DECLARE(void) nas_mac_calculate(c_uint8_t algorithm_identity,
|
||||
c_uint8_t *knas_int, c_uint32_t count, c_uint8_t bearer,
|
||||
|
|
|
@ -108,7 +108,7 @@ status_t s1ap_build_setup_failure(pkbuf_t **pkbuf, S1ap_Cause_t cause)
|
|||
}
|
||||
|
||||
status_t s1ap_build_downlink_nas_transport(
|
||||
pkbuf_t **s1apbuf, enb_ue_t *ue, pkbuf_t *emmbuf)
|
||||
pkbuf_t **s1apbuf, enb_ue_t *enb_ue, pkbuf_t *emmbuf)
|
||||
{
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
|
||||
|
@ -119,12 +119,12 @@ status_t s1ap_build_downlink_nas_transport(
|
|||
S1ap_NAS_PDU_t *nasPdu = &ies->nas_pdu;
|
||||
|
||||
d_assert(emmbuf, return CORE_ERROR, "Null param");
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(enb_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(s1ap_message_t));
|
||||
|
||||
ies->mme_ue_s1ap_id = ue->mme_ue_s1ap_id;
|
||||
ies->eNB_UE_S1AP_ID = ue->enb_ue_s1ap_id;
|
||||
ies->mme_ue_s1ap_id = enb_ue->mme_ue_s1ap_id;
|
||||
ies->eNB_UE_S1AP_ID = enb_ue->enb_ue_s1ap_id;
|
||||
|
||||
nasPdu->size = emmbuf->len;
|
||||
nasPdu->buf = core_calloc(nasPdu->size, sizeof(c_uint8_t));
|
||||
|
@ -141,9 +141,9 @@ status_t s1ap_build_downlink_nas_transport(
|
|||
|
||||
d_info("[S1AP] downlinkNASTransport : "
|
||||
"UE[eNB-UE-S1AP-ID(%d)] <-- eNB[%s:%d]",
|
||||
ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&ue->enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
ue->enb->enb_id);
|
||||
enb_ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&enb_ue->enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb_ue->enb->enb_id);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
@ -161,22 +161,22 @@ status_t s1ap_build_initial_context_setup_request(
|
|||
struct S1ap_GBR_QosInformation *gbrQosInformation = NULL; /* OPTIONAL */
|
||||
S1ap_NAS_PDU_t *nasPdu = NULL;
|
||||
mme_ue_t *mme_ue = NULL;
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
pdn_t *pdn = NULL;
|
||||
|
||||
d_assert(emmbuf, return CORE_ERROR, "Null param");
|
||||
d_assert(bearer, return CORE_ERROR, "Null param");
|
||||
mme_ue = bearer->ue;
|
||||
mme_ue = bearer->mme_ue;
|
||||
d_assert(mme_ue, return CORE_ERROR, "Null param");
|
||||
ue = mme_ue->enb_ue;
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
enb_ue = mme_ue->enb_ue;
|
||||
d_assert(enb_ue, return CORE_ERROR, "Null param");
|
||||
pdn = bearer->pdn;
|
||||
d_assert(pdn, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(s1ap_message_t));
|
||||
|
||||
ies->mme_ue_s1ap_id = ue->mme_ue_s1ap_id;
|
||||
ies->eNB_UE_S1AP_ID = ue->enb_ue_s1ap_id;
|
||||
ies->mme_ue_s1ap_id = enb_ue->mme_ue_s1ap_id;
|
||||
ies->eNB_UE_S1AP_ID = enb_ue->enb_ue_s1ap_id;
|
||||
|
||||
asn_uint642INTEGER(
|
||||
&ies->uEaggregateMaximumBitrate.uEaggregateMaximumBitRateUL,
|
||||
|
@ -255,15 +255,15 @@ status_t s1ap_build_initial_context_setup_request(
|
|||
|
||||
d_info("[S1AP] Initial Context Setup Request : "
|
||||
"UE[eNB-UE-S1AP-ID(%d)] <-- eNB[%s:%d]",
|
||||
ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&ue->enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
ue->enb->enb_id);
|
||||
enb_ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&enb_ue->enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb_ue->enb->enb_id);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
||||
status_t s1ap_build_ue_context_release_commmand(
|
||||
pkbuf_t **s1apbuf, enb_ue_t *ue, S1ap_Cause_t cause)
|
||||
pkbuf_t **s1apbuf, enb_ue_t *enb_ue, S1ap_Cause_t cause)
|
||||
{
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
|
||||
|
@ -272,27 +272,29 @@ status_t s1ap_build_ue_context_release_commmand(
|
|||
S1ap_UEContextReleaseCommand_IEs_t *ies =
|
||||
&message.s1ap_UEContextReleaseCommand_IEs;
|
||||
|
||||
d_assert(ue, return CORE_ERROR, "Null param");
|
||||
d_assert(enb_ue, return CORE_ERROR, "Null param");
|
||||
|
||||
memset(&message, 0, sizeof(s1ap_message_t));
|
||||
|
||||
if (ue->mme_ue_s1ap_id == 0)
|
||||
if (enb_ue->mme_ue_s1ap_id == 0)
|
||||
{
|
||||
d_error("invalid mme ue s1ap id (idx: %d)", ue->index);
|
||||
d_error("invalid mme ue s1ap id (idx: %d)", enb_ue->index);
|
||||
return CORE_ERROR;
|
||||
}
|
||||
|
||||
if (ue->enb_ue_s1ap_id)
|
||||
if (enb_ue->enb_ue_s1ap_id)
|
||||
{
|
||||
ies->uE_S1AP_IDs.present = S1ap_UE_S1AP_IDs_PR_uE_S1AP_ID_pair;
|
||||
ies->uE_S1AP_IDs.choice.uE_S1AP_ID_pair.mME_UE_S1AP_ID = ue->mme_ue_s1ap_id;
|
||||
ies->uE_S1AP_IDs.choice.uE_S1AP_ID_pair.eNB_UE_S1AP_ID = ue->enb_ue_s1ap_id;
|
||||
ies->uE_S1AP_IDs.choice.uE_S1AP_ID_pair.mME_UE_S1AP_ID =
|
||||
enb_ue->mme_ue_s1ap_id;
|
||||
ies->uE_S1AP_IDs.choice.uE_S1AP_ID_pair.eNB_UE_S1AP_ID =
|
||||
enb_ue->enb_ue_s1ap_id;
|
||||
ies->uE_S1AP_IDs.choice.uE_S1AP_ID_pair.iE_Extensions = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
ies->uE_S1AP_IDs.present = S1ap_UE_S1AP_IDs_PR_mME_UE_S1AP_ID;
|
||||
ies->uE_S1AP_IDs.choice.mME_UE_S1AP_ID = ue->mme_ue_s1ap_id;
|
||||
ies->uE_S1AP_IDs.choice.mME_UE_S1AP_ID = enb_ue->mme_ue_s1ap_id;
|
||||
}
|
||||
|
||||
ies->cause = cause;
|
||||
|
@ -307,9 +309,9 @@ status_t s1ap_build_ue_context_release_commmand(
|
|||
|
||||
d_info("[S1AP] UE Context Release Command : "
|
||||
"UE[mME-UE-S1AP-ID(%d)] <-- eNB[%s:%d]",
|
||||
ue->mme_ue_s1ap_id,
|
||||
INET_NTOP(&ue->enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
ue->enb->enb_id);
|
||||
enb_ue->mme_ue_s1ap_id,
|
||||
INET_NTOP(&enb_ue->enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb_ue->enb->enb_id);
|
||||
|
||||
return CORE_OK;
|
||||
}
|
||||
|
|
|
@ -12,11 +12,11 @@ CORE_DECLARE(status_t) s1ap_build_setup_rsp(pkbuf_t **pkbuf);
|
|||
CORE_DECLARE(status_t) s1ap_build_setup_failure(
|
||||
pkbuf_t **pkbuf, S1ap_Cause_t cause);
|
||||
CORE_DECLARE(status_t) s1ap_build_downlink_nas_transport(
|
||||
pkbuf_t **s1apbuf, enb_ue_t *ue, pkbuf_t *emmbuf);
|
||||
pkbuf_t **s1apbuf, enb_ue_t *enb_ue, pkbuf_t *emmbuf);
|
||||
CORE_DECLARE(status_t) s1ap_build_initial_context_setup_request(
|
||||
pkbuf_t **s1apbuf, mme_bearer_t *bearer, pkbuf_t *emmbuf);
|
||||
CORE_DECLARE(status_t) s1ap_build_ue_context_release_commmand(
|
||||
pkbuf_t **s1apbuf, enb_ue_t *ue, S1ap_Cause_t cause);
|
||||
pkbuf_t **s1apbuf, enb_ue_t *enb_ue, S1ap_Cause_t cause);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -12,14 +12,14 @@
|
|||
|
||||
#include "s1ap_handler.h"
|
||||
|
||||
static void event_s1ap_to_nas(enb_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
|
||||
static void event_s1ap_to_nas(enb_ue_t *enb_ue, S1ap_NAS_PDU_t *nasPdu)
|
||||
{
|
||||
nas_esm_header_t *h = NULL;
|
||||
pkbuf_t *nasbuf = NULL;
|
||||
event_t e;
|
||||
int mac_failed = 0;
|
||||
|
||||
d_assert(ue, return, "Null param");
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
d_assert(nasPdu, return, "Null param");
|
||||
|
||||
/* The Packet Buffer(pkbuf_t) for NAS message MUST make a HEADROOM.
|
||||
|
@ -28,9 +28,9 @@ static void event_s1ap_to_nas(enb_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
|
|||
d_assert(nasbuf, return, "Null param");
|
||||
memcpy(nasbuf->payload, nasPdu->buf, nasPdu->size);
|
||||
|
||||
if (ue->mme_ue)
|
||||
if (enb_ue->mme_ue)
|
||||
{
|
||||
d_assert(nas_security_decode(ue->mme_ue, nasbuf,
|
||||
d_assert(nas_security_decode(enb_ue->mme_ue, nasbuf,
|
||||
&mac_failed) == CORE_OK,
|
||||
pkbuf_free(nasbuf);return,
|
||||
"nas_security_decode failed");
|
||||
|
@ -55,21 +55,21 @@ static void event_s1ap_to_nas(enb_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
|
|||
pkbuf_header(nasbuf, -hsize);
|
||||
}
|
||||
}
|
||||
ue->mac_failed = mac_failed;
|
||||
enb_ue->mac_failed = mac_failed;
|
||||
|
||||
h = nasbuf->payload;
|
||||
d_assert(h, pkbuf_free(nasbuf); return, "Null param");
|
||||
if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_EMM)
|
||||
{
|
||||
event_set(&e, MME_EVT_EMM_UE_MSG);
|
||||
event_set_param1(&e, (c_uintptr_t)ue->index);
|
||||
event_set_param1(&e, (c_uintptr_t)enb_ue->index);
|
||||
event_set_param2(&e, (c_uintptr_t)nasbuf);
|
||||
mme_event_send(&e);
|
||||
}
|
||||
else if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_ESM)
|
||||
{
|
||||
mme_bearer_t *bearer = NULL;
|
||||
mme_ue_t *mme_ue = ue->mme_ue;
|
||||
mme_ue_t *mme_ue = enb_ue->mme_ue;
|
||||
|
||||
if (!mme_ue)
|
||||
{
|
||||
|
@ -148,7 +148,7 @@ void s1ap_handle_initial_ue_message(mme_enb_t *enb, s1ap_message_t *message)
|
|||
{
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
S1ap_InitialUEMessage_IEs_t *ies = NULL;
|
||||
S1ap_TAI_t *tai = NULL;
|
||||
S1ap_PLMNidentity_t *pLMNidentity = NULL;
|
||||
|
@ -175,35 +175,37 @@ void s1ap_handle_initial_ue_message(mme_enb_t *enb, s1ap_message_t *message)
|
|||
cell_ID = &eutran_cgi->cell_ID;
|
||||
d_assert(cell_ID, return,);
|
||||
|
||||
ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
if (!ue)
|
||||
enb_ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
if (!enb_ue)
|
||||
{
|
||||
ue = enb_ue_add(enb);
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = enb_ue_add(enb);
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
|
||||
ue->enb_ue_s1ap_id = ies->eNB_UE_S1AP_ID;
|
||||
enb_ue->enb_ue_s1ap_id = ies->eNB_UE_S1AP_ID;
|
||||
}
|
||||
else
|
||||
{
|
||||
d_warn("Duplicated: eNB[0x%x] sends "
|
||||
"Initial-UE Message[eNB-UE-S1AP-ID(%d)]",
|
||||
enb->enb_id, ue->enb_ue_s1ap_id);
|
||||
enb->enb_id, enb_ue->enb_ue_s1ap_id);
|
||||
}
|
||||
|
||||
memcpy(&ue->tai.plmn_id, pLMNidentity->buf, sizeof(ue->tai.plmn_id));
|
||||
memcpy(&ue->tai.tac, tAC->buf, sizeof(ue->tai.tac));
|
||||
ue->tai.tac = ntohs(ue->tai.tac);
|
||||
memcpy(&ue->e_cgi.plmn_id, pLMNidentity->buf, sizeof(ue->e_cgi.plmn_id));
|
||||
memcpy(&ue->e_cgi.cell_id, cell_ID->buf, sizeof(ue->e_cgi.cell_id));
|
||||
ue->e_cgi.cell_id = (ntohl(ue->e_cgi.cell_id) >> 4);
|
||||
memcpy(&enb_ue->tai.plmn_id, pLMNidentity->buf,
|
||||
sizeof(enb_ue->tai.plmn_id));
|
||||
memcpy(&enb_ue->tai.tac, tAC->buf, sizeof(enb_ue->tai.tac));
|
||||
enb_ue->tai.tac = ntohs(enb_ue->tai.tac);
|
||||
memcpy(&enb_ue->e_cgi.plmn_id, pLMNidentity->buf,
|
||||
sizeof(enb_ue->e_cgi.plmn_id));
|
||||
memcpy(&enb_ue->e_cgi.cell_id, cell_ID->buf, sizeof(enb_ue->e_cgi.cell_id));
|
||||
enb_ue->e_cgi.cell_id = (ntohl(enb_ue->e_cgi.cell_id) >> 4);
|
||||
|
||||
d_assert(enb->s1ap_sock, enb_ue_remove(ue); return,);
|
||||
d_assert(enb->s1ap_sock, enb_ue_remove(enb_ue); return,);
|
||||
d_info("[S1AP] InitialUEMessage : UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]",
|
||||
ue->enb_ue_s1ap_id,
|
||||
enb_ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb->enb_id);
|
||||
|
||||
event_s1ap_to_nas(ue, &ies->nas_pdu);
|
||||
event_s1ap_to_nas(enb_ue, &ies->nas_pdu);
|
||||
}
|
||||
|
||||
void s1ap_handle_uplink_nas_transport(
|
||||
|
@ -211,21 +213,21 @@ void s1ap_handle_uplink_nas_transport(
|
|||
{
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
S1ap_UplinkNASTransport_IEs_t *ies = NULL;
|
||||
|
||||
ies = &message->s1ap_UplinkNASTransport_IEs;
|
||||
d_assert(ies, return, "Null param");
|
||||
|
||||
ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
d_assert(ue, return, "Null param");
|
||||
enb_ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
d_assert(enb_ue, return, "Null param");
|
||||
|
||||
d_info("[S1AP] uplinkNASTransport : UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]",
|
||||
ue->enb_ue_s1ap_id,
|
||||
enb_ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb->enb_id);
|
||||
|
||||
event_s1ap_to_nas(ue, &ies->nas_pdu);
|
||||
event_s1ap_to_nas(enb_ue, &ies->nas_pdu);
|
||||
}
|
||||
|
||||
void s1ap_handle_ue_capability_info_indication(
|
||||
|
@ -233,18 +235,18 @@ void s1ap_handle_ue_capability_info_indication(
|
|||
{
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
S1ap_UECapabilityInfoIndicationIEs_t *ies = NULL;
|
||||
|
||||
ies = &message->s1ap_UECapabilityInfoIndicationIEs;
|
||||
d_assert(ies, return, "Null param");
|
||||
|
||||
ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
d_assert(ue, return, "No UE Context[%d]", ies->eNB_UE_S1AP_ID);
|
||||
enb_ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
d_assert(enb_ue, return, "No UE Context[%d]", ies->eNB_UE_S1AP_ID);
|
||||
|
||||
d_info("[S1AP] UE Capability Info Indication : "
|
||||
"UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]",
|
||||
ue->enb_ue_s1ap_id,
|
||||
enb_ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb->enb_id);
|
||||
}
|
||||
|
@ -255,18 +257,18 @@ void s1ap_handle_initial_context_setup_response(
|
|||
char buf[INET_ADDRSTRLEN];
|
||||
int i = 0;
|
||||
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
S1ap_InitialContextSetupResponseIEs_t *ies = NULL;
|
||||
|
||||
ies = &message->s1ap_InitialContextSetupResponseIEs;
|
||||
d_assert(ies, return, "Null param");
|
||||
|
||||
ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
d_assert(ue, return, "No UE Context[%d]", ies->eNB_UE_S1AP_ID);
|
||||
enb_ue = enb_ue_find_by_enb_ue_s1ap_id(enb, ies->eNB_UE_S1AP_ID);
|
||||
d_assert(enb_ue, return, "No UE Context[%d]", ies->eNB_UE_S1AP_ID);
|
||||
|
||||
d_info("[S1AP] Initial Context Setup Response : "
|
||||
"UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]",
|
||||
ue->enb_ue_s1ap_id,
|
||||
enb_ue->enb_ue_s1ap_id,
|
||||
INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb->enb_id);
|
||||
|
||||
|
@ -276,7 +278,7 @@ void s1ap_handle_initial_context_setup_response(
|
|||
{
|
||||
event_t e;
|
||||
mme_bearer_t *bearer = NULL;
|
||||
mme_ue_t *mme_ue = ue->mme_ue;
|
||||
mme_ue_t *mme_ue = enb_ue->mme_ue;
|
||||
S1ap_E_RABSetupItemCtxtSURes_t *e_rab = NULL;
|
||||
|
||||
e_rab = (S1ap_E_RABSetupItemCtxtSURes_t *)
|
||||
|
@ -303,22 +305,22 @@ void s1ap_handle_ue_context_release_complete(
|
|||
{
|
||||
char buf[INET_ADDRSTRLEN];
|
||||
|
||||
enb_ue_t *ue = NULL;
|
||||
enb_ue_t *enb_ue = NULL;
|
||||
S1ap_UEContextReleaseComplete_IEs_t *ies = NULL;
|
||||
|
||||
ies = &message->s1ap_UEContextReleaseComplete_IEs;
|
||||
d_assert(ies, return, "Null param");
|
||||
|
||||
ue = enb_ue_find_by_mme_ue_s1ap_id(ies->mme_ue_s1ap_id);
|
||||
d_assert(ue, return, "No UE Context[%d]", ies->mme_ue_s1ap_id);
|
||||
enb_ue = enb_ue_find_by_mme_ue_s1ap_id(ies->mme_ue_s1ap_id);
|
||||
d_assert(enb_ue, return, "No UE Context[%d]", ies->mme_ue_s1ap_id);
|
||||
|
||||
d_info("[S1AP] UE Context Release Complete : "
|
||||
"UE[mME-UE-S1AP-ID(%d)] --> eNB[%s:%d]",
|
||||
ue->mme_ue_s1ap_id,
|
||||
enb_ue->mme_ue_s1ap_id,
|
||||
INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
|
||||
enb->enb_id);
|
||||
|
||||
/* BRANDON -> ACETCOM: "pass event to MME SM" or "process here?" */
|
||||
/* process here */
|
||||
enb_ue_remove(ue);
|
||||
enb_ue_remove(enb_ue);
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue