diff --git a/src/mme/emm_build.c b/src/mme/emm_build.c index 86f87915a..530f63c6d 100644 --- a/src/mme/emm_build.c +++ b/src/mme/emm_build.c @@ -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; diff --git a/src/mme/emm_build.h b/src/mme/emm_build.h index 106d590fc..418a8f43a 100644 --- a/src/mme/emm_build.h +++ b/src/mme/emm_build.h @@ -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 } diff --git a/src/mme/emm_handler.c b/src/mme/emm_handler.c index 3c0b7b9f8..73c4acb4d 100644 --- a/src/mme/emm_handler.c +++ b/src/mme/emm_handler.c @@ -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"); diff --git a/src/mme/emm_handler.h b/src/mme/emm_handler.h index 0105b1cc1..e5b917f0b 100644 --- a/src/mme/emm_handler.h +++ b/src/mme/emm_handler.h @@ -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 } diff --git a/src/mme/emm_sm.c b/src/mme/emm_sm.c index b41f7bdc1..422279de8 100644 --- a/src/mme/emm_sm.c +++ b/src/mme/emm_sm.c @@ -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; } diff --git a/src/mme/esm_build.c b/src/mme/esm_build.c index 2e198144c..7e5e20342 100644 --- a/src/mme/esm_build.c +++ b/src/mme/esm_build.c @@ -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"); diff --git a/src/mme/esm_handler.c b/src/mme/esm_handler.c index 99fc3b36d..c01e92982 100644 --- a/src/mme/esm_handler.c +++ b/src/mme/esm_handler.c @@ -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); diff --git a/src/mme/esm_sm.c b/src/mme/esm_sm.c index c4a4f52b4..71d9f6f47 100644 --- a/src/mme/esm_sm.c +++ b/src/mme/esm_sm.c @@ -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: diff --git a/src/mme/mme_context.c b/src/mme/mme_context.c index c513a248e..e091a205f 100644 --- a/src/mme/mme_context.c +++ b/src/mme/mme_context.c @@ -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) diff --git a/src/mme/mme_context.h b/src/mme/mme_context.h index 23c7cf384..9169fb434 100644 --- a/src/mme/mme_context.h +++ b/src/mme/mme_context.h @@ -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 } diff --git a/src/mme/mme_s11_build.c b/src/mme/mme_s11_build.c index 779290b8e..fdd508d7e 100644 --- a/src/mme/mme_s11_build.c +++ b/src/mme/mme_s11_build.c @@ -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)); diff --git a/src/mme/mme_s11_handler.c b/src/mme/mme_s11_handler.c index 406ae83cc..ffe7907da 100644 --- a/src/mme/mme_s11_handler.c +++ b/src/mme/mme_s11_handler.c @@ -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); } diff --git a/src/mme/mme_s6a_handler.c b/src/mme/mme_s6a_handler.c index 91d35880a..b6c77edfe 100644 --- a/src/mme/mme_s6a_handler.c +++ b/src/mme/mme_s6a_handler.c @@ -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; diff --git a/src/mme/mme_s6a_handler.h b/src/mme/mme_s6a_handler.h index ef37d6e6c..635e45e17 100644 --- a/src/mme/mme_s6a_handler.h +++ b/src/mme/mme_s6a_handler.h @@ -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 } diff --git a/src/mme/mme_sm.c b/src/mme/mme_sm.c index 75036fe26..0534bffd5 100644 --- a/src/mme/mme_sm.c +++ b/src/mme/mme_sm.c @@ -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) diff --git a/src/mme/nas_security.c b/src/mme/nas_security.c index bbc0113e8..145290ff4 100644 --- a/src/mme/nas_security.c +++ b/src/mme/nas_security.c @@ -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); diff --git a/src/mme/nas_security.h b/src/mme/nas_security.h index b34e72ba8..99628566f 100644 --- a/src/mme/nas_security.h +++ b/src/mme/nas_security.h @@ -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, diff --git a/src/mme/s1ap_build.c b/src/mme/s1ap_build.c index 702836a04..448c61d8b 100644 --- a/src/mme/s1ap_build.c +++ b/src/mme/s1ap_build.c @@ -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; } diff --git a/src/mme/s1ap_build.h b/src/mme/s1ap_build.h index dccc18ea3..ed987df60 100644 --- a/src/mme/s1ap_build.h +++ b/src/mme/s1ap_build.h @@ -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 } diff --git a/src/mme/s1ap_handler.c b/src/mme/s1ap_handler.c index 2a5cc33f5..939aebb8c 100644 --- a/src/mme/s1ap_handler.c +++ b/src/mme/s1ap_handler.c @@ -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); }