sysmocom
/
open5gs
forked from acouzens/open5gs
11
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

change vairable name from 'ue' to 'enb_ue or mme_ue'

This commit is contained in:
Sukchan Lee 2017-04-28 16:11:45 +09:00
parent 129f484394
commit 6a68eaac02
20 changed files with 462 additions and 443 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/mme/emm_build.c
View File

@ -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;

2
src/mme/emm_build.h
View File

@ -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
}

178
src/mme/emm_handler.c
View File

@ -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");

18
src/mme/emm_handler.h
View File

@ -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
}

42
src/mme/emm_sm.c
View File

@ -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;
}

15
src/mme/esm_build.c
View File

@ -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");

16
src/mme/esm_handler.c
View File

@ -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);

24
src/mme/esm_sm.c
View File

@ -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:

228
src/mme/mme_context.c
View File

@ -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)

36
src/mme/mme_context.h
View File

@ -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
}

38
src/mme/mme_s11_build.c
View File

@ -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 = &gtp_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(&gtp_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 = &gtp_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(&gtp_message, 0, sizeof(gtp_message_t));

6
src/mme/mme_s11_handler.c
View File

@ -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);
}

72
src/mme/mme_s6a_handler.c
View File

@ -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;

4
src/mme/mme_s6a_handler.h
View File

@ -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
}

26
src/mme/mme_sm.c
View File

@ -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)

37
src/mme/nas_security.c
View File

@ -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);

4
src/mme/nas_security.h
View File

@ -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,

56
src/mme/s1ap_build.c
View File

@ -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;
}

4
src/mme/s1ap_build.h
View File

@ -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
}

86
src/mme/s1ap_handler.c
View File

@ -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);
}