From 07242abd87997c2d367f43d44d7393c9f9c830c5 Mon Sep 17 00:00:00 2001 From: Sukchan Lee Date: Thu, 13 Apr 2017 19:15:53 +0900 Subject: [PATCH] update it --- src/mme/emm_handler.c | 32 ++++++------ src/mme/emm_handler.h | 2 +- src/mme/emm_sm.c | 16 +++--- src/mme/esm_build.c | 26 +++++----- src/mme/esm_build.h | 4 +- src/mme/esm_handler.c | 26 +++++----- src/mme/esm_handler.h | 6 +-- src/mme/esm_sm.c | 32 ++++++------ src/mme/mme_context.c | 104 ++++++++++++++++++-------------------- src/mme/mme_context.h | 22 ++++---- src/mme/mme_event.c | 20 ++++---- src/mme/mme_event.h | 6 +-- src/mme/mme_s11_build.c | 18 +++---- src/mme/mme_s11_build.h | 2 +- src/mme/mme_s11_handler.c | 20 ++++---- src/mme/mme_sm.c | 20 ++++---- src/mme/s1ap_build.c | 14 ++--- src/mme/s1ap_build.h | 2 +- 18 files changed, 184 insertions(+), 188 deletions(-) diff --git a/src/mme/emm_handler.c b/src/mme/emm_handler.c index 6cc3acdb6..f777825f1 100644 --- a/src/mme/emm_handler.c +++ b/src/mme/emm_handler.c @@ -22,7 +22,7 @@ void emm_handle_esm_message_container( nas_esm_header_t *h = NULL; c_uint8_t pti = 0; - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; d_assert(ue, return, "Null param"); d_assert(esm_message_container, return, "Null param"); @@ -38,20 +38,20 @@ void emm_handle_esm_message_container( return; } - esm = mme_esm_find_by_pti(ue, pti); - if (!esm) + bearer = mme_bearer_find_by_pti(ue, pti); + if (!bearer) { - esm = mme_esm_add(ue, pti); - d_assert(esm, return, "Null param"); + bearer = mme_bearer_add(ue, pti); + d_assert(bearer, return, "Null param"); } else { d_warn("Duplicated: MME-UE-S1AP-ID[%d] sends " "PDN Connectivity Message[PTI(%d)]", - ue->mme_ue_s1ap_id, esm->pti); + ue->mme_ue_s1ap_id, bearer->pti); } - mme_event_emm_to_esm(esm, esm_message_container); + mme_event_emm_to_esm(bearer, esm_message_container); } void emm_handle_attach_request( @@ -201,26 +201,26 @@ void emm_handle_authentication_response( mme_event_nas_to_s1ap(ue, sendbuf); } -void emm_handle_lo_create_session(mme_esm_t *esm) +void emm_handle_lo_create_session(mme_bearer_t *bearer) { - pkbuf_t *esmbuf = NULL, *emmbuf = NULL, *s1apbuf = NULL; + pkbuf_t *bearerbuf = NULL, *emmbuf = NULL, *s1apbuf = NULL; mme_ue_t *ue = NULL; mme_enb_t *enb = NULL; status_t rv; - d_assert(esm, return, "Null param"); - ue = esm->ue; + d_assert(bearer, return, "Null param"); + ue = bearer->ue; d_assert(ue, return, "Null param"); enb = ue->enb; d_assert(ue->enb, return, "Null param"); - rv = esm_build_activate_default_bearer_context(&esmbuf, esm); - d_assert(rv == CORE_OK, return, "esm build error"); + rv = esm_build_activate_default_bearer_context(&bearerbuf, bearer); + d_assert(rv == CORE_OK, return, "bearer build error"); - rv = emm_build_attach_accept(&emmbuf, ue, esmbuf); - d_assert(rv == CORE_OK, pkbuf_free(esmbuf); return, "emm build error"); + rv = emm_build_attach_accept(&emmbuf, ue, bearerbuf); + d_assert(rv == CORE_OK, pkbuf_free(bearerbuf); return, "emm build error"); - rv = s1ap_build_initial_context_setup_request(&s1apbuf, esm, emmbuf); + rv = s1ap_build_initial_context_setup_request(&s1apbuf, bearer, emmbuf); d_assert(rv == CORE_OK, pkbuf_free(emmbuf); return, "emm build error"); d_assert(s1ap_send_to_enb(enb, s1apbuf) == CORE_OK,,); diff --git a/src/mme/emm_handler.h b/src/mme/emm_handler.h index da1930e0f..1e7d765d6 100644 --- a/src/mme/emm_handler.h +++ b/src/mme/emm_handler.h @@ -15,7 +15,7 @@ CORE_DECLARE(void) emm_handle_authentication_request(mme_ue_t *ue); CORE_DECLARE(void) emm_handle_authentication_response( mme_ue_t *ue, nas_authentication_response_t *authentication_response); -CORE_DECLARE(void) emm_handle_lo_create_session(mme_esm_t *esm); +CORE_DECLARE(void) emm_handle_lo_create_session(mme_bearer_t *bearer); #ifdef __cplusplus } diff --git a/src/mme/emm_sm.c b/src/mme/emm_sm.c index 9c3f23aaf..03203ad60 100644 --- a/src/mme/emm_sm.c +++ b/src/mme/emm_sm.c @@ -63,18 +63,18 @@ void emm_state_operational(fsm_t *s, event_t *e) } case EVT_LO_MME_EMM_LOCATION_UPDATE: { - mme_esm_t *esm = mme_esm_first(ue); + mme_bearer_t *bearer = mme_bearer_first(ue); d_info("[NAS] Location update : EMM[%s] <-- HSS", ue->imsi_bcd); - while(esm) + while(bearer) { event_t e; event_set(&e, MME_EVT_ESM_BEARER_LO_INFO_REQ); - event_set_param1(&e, (c_uintptr_t)esm->index); + event_set_param1(&e, (c_uintptr_t)bearer->index); mme_event_send(&e); - esm = mme_esm_next(esm); + bearer = mme_bearer_next(bearer); } break; } @@ -84,13 +84,13 @@ void emm_state_operational(fsm_t *s, event_t *e) case MME_EVT_EMM_BEARER_LO_CREATE_SESSION: { index_t index = event_get_param1(e); - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; d_assert(index, break, "Null param"); - esm = mme_esm_find(index); - d_assert(esm, break, "No ESM context"); + bearer = mme_bearer_find(index); + d_assert(bearer, break, "No Bearer context"); - emm_handle_lo_create_session(esm); + emm_handle_lo_create_session(bearer); break; } case EVT_MSG_MME_EMM: diff --git a/src/mme/esm_build.c b/src/mme/esm_build.c index f8d29c400..2e198144c 100644 --- a/src/mme/esm_build.c +++ b/src/mme/esm_build.c @@ -7,13 +7,13 @@ #include "nas_security.h" #include "esm_build.h" -status_t esm_build_information_request(pkbuf_t **pkbuf, mme_esm_t *esm) +status_t esm_build_information_request(pkbuf_t **pkbuf, mme_bearer_t *bearer) { nas_message_t message; mme_ue_t *ue = NULL; - d_assert(esm, return CORE_ERROR, "Null param"); - ue = esm->ue; + d_assert(bearer, return CORE_ERROR, "Null param"); + ue = bearer->ue; d_assert(ue, return CORE_ERROR, "Null param"); memset(&message, 0, sizeof(message)); @@ -22,7 +22,7 @@ status_t esm_build_information_request(pkbuf_t **pkbuf, mme_esm_t *esm) message.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_EMM; message.esm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_ESM; - message.esm.h.procedure_transaction_identity = esm->pti; + 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,,); @@ -31,7 +31,7 @@ status_t esm_build_information_request(pkbuf_t **pkbuf, mme_esm_t *esm) } status_t esm_build_activate_default_bearer_context( - pkbuf_t **pkbuf, mme_esm_t *esm) + pkbuf_t **pkbuf, mme_bearer_t *bearer) { nas_message_t message; nas_activate_default_eps_bearer_context_request_t @@ -52,16 +52,16 @@ status_t esm_build_activate_default_bearer_context( mme_ue_t *ue = NULL; pdn_t *pdn = NULL; - d_assert(esm, return CORE_ERROR, "Null param"); - ue = esm->ue; + d_assert(bearer, return CORE_ERROR, "Null param"); + ue = bearer->ue; d_assert(ue, return CORE_ERROR, "Null param"); - pdn = esm->pdn; + pdn = bearer->pdn; d_assert(pdn, return CORE_ERROR, "Null param"); memset(&message, 0, sizeof(message)); - message.esm.h.eps_bearer_identity = esm->ebi; + message.esm.h.eps_bearer_identity = bearer->ebi; message.esm.h.protocol_discriminator = NAS_PROTOCOL_DISCRIMINATOR_ESM; - message.esm.h.procedure_transaction_identity = esm->pti; + message.esm.h.procedure_transaction_identity = bearer->pti; message.esm.h.message_type = NAS_ACTIVATE_DEFAULT_EPS_BEARER_CONTEXT_REQUEST; @@ -84,13 +84,13 @@ status_t esm_build_activate_default_bearer_context( apn_ambr->dl_apn_ambr_extended2 = 4; apn_ambr->ul_apn_ambr_extended2 = 4; - if (esm->pgw_pco_len) + if (bearer->pgw_pco_len) { activate_default_eps_bearer_context_request->presencemask |= NAS_ACTIVATE_DEFAULT_EPS_BEARER_CONTEXT_REQUEST_PROTOCOL_CONFIGURATION_OPTIONS_PRESENT; - protocol_configuration_options->length = esm->pgw_pco_len; + protocol_configuration_options->length = bearer->pgw_pco_len; memcpy(protocol_configuration_options->buffer, - esm->pgw_pco, protocol_configuration_options->length); + bearer->pgw_pco, protocol_configuration_options->length); } d_assert(nas_plain_encode(pkbuf, &message) == CORE_OK && *pkbuf,,); diff --git a/src/mme/esm_build.h b/src/mme/esm_build.h index 8a460bd74..58a47371f 100644 --- a/src/mme/esm_build.h +++ b/src/mme/esm_build.h @@ -8,10 +8,10 @@ extern "C" { #endif /* __cplusplus */ CORE_DECLARE(status_t) esm_build_information_request( - pkbuf_t **pkbuf, mme_esm_t *esm); + pkbuf_t **pkbuf, mme_bearer_t *bearer); CORE_DECLARE(status_t) esm_build_activate_default_bearer_context( - pkbuf_t **pkbuf, mme_esm_t *esm); + pkbuf_t **pkbuf, mme_bearer_t *bearer); #ifdef __cplusplus } diff --git a/src/mme/esm_handler.c b/src/mme/esm_handler.c index 626f7384a..ade948337 100644 --- a/src/mme/esm_handler.c +++ b/src/mme/esm_handler.c @@ -9,7 +9,7 @@ #include "mme_s11_build.h" #include "mme_s11_path.h" -void esm_handle_pdn_connectivity_request(mme_esm_t *esm, +void esm_handle_pdn_connectivity_request(mme_bearer_t *bearer, nas_pdn_connectivity_request_t *pdn_connectivity_request) { #if 0 /* TODO */ @@ -22,23 +22,23 @@ void esm_handle_pdn_connectivity_request(mme_esm_t *esm, #endif } -void esm_handle_information_response(mme_esm_t *esm, +void esm_handle_information_response(mme_bearer_t *bearer, nas_esm_information_response_t *esm_information_response) { mme_ue_t *ue = NULL; pkbuf_t *pkbuf = NULL; status_t rv; - d_assert(esm, return, "Null param"); - ue = esm->ue; + d_assert(bearer, return, "Null param"); + ue = bearer->ue; d_assert(ue, return, "Null param"); if (esm_information_response->presencemask & NAS_ESM_INFORMATION_RESPONSE_ACCESS_POINT_NAME_PRESENT) { - esm->pdn = mme_pdn_find_by_apn(ue, + bearer->pdn = mme_pdn_find_by_apn(ue, esm_information_response->access_point_name.apn); - d_assert(esm->pdn, return, "No PDN Context[APN:%s])", + d_assert(bearer->pdn, return, "No PDN Context[APN:%s])", esm_information_response->access_point_name.apn); } @@ -47,17 +47,17 @@ void esm_handle_information_response(mme_esm_t *esm, { nas_protocol_configuration_options_t *protocol_configuration_options = &esm_information_response->protocol_configuration_options; - esm->ue_pco_len = protocol_configuration_options->length; - d_assert(esm->ue_pco_len <= MAX_PCO_LEN, return, - "length(%d) exceeds MAX:%d", esm->ue_pco_len, MAX_PCO_LEN); - memcpy(esm->ue_pco, protocol_configuration_options->buffer, - esm->ue_pco_len); + bearer->ue_pco_len = protocol_configuration_options->length; + d_assert(bearer->ue_pco_len <= MAX_PCO_LEN, return, + "length(%d) exceeds MAX:%d", bearer->ue_pco_len, MAX_PCO_LEN); + memcpy(bearer->ue_pco, protocol_configuration_options->buffer, + bearer->ue_pco_len); } - rv = mme_s11_build_create_session_request(&pkbuf, esm); + rv = mme_s11_build_create_session_request(&pkbuf, bearer); d_assert(rv == CORE_OK, return, "S11 build error"); - rv = mme_s11_send_to_sgw(esm->sgw, + rv = mme_s11_send_to_sgw(bearer->sgw, GTP_CREATE_SESSION_REQUEST_TYPE, 0, pkbuf); d_assert(rv == CORE_OK, return, "S11 send error"); } diff --git a/src/mme/esm_handler.h b/src/mme/esm_handler.h index fe7eb93b1..522195d7b 100644 --- a/src/mme/esm_handler.h +++ b/src/mme/esm_handler.h @@ -9,10 +9,10 @@ extern "C" { #endif /* __cplusplus */ -CORE_DECLARE(void) esm_handle_pdn_connectivity_request(mme_esm_t *esm, +CORE_DECLARE(void) esm_handle_pdn_connectivity_request(mme_bearer_t *bearer, nas_pdn_connectivity_request_t *pdn_connectivity_request); -CORE_DECLARE(void) esm_handle_information_response(mme_esm_t *esm, - nas_esm_information_response_t *esm_information_response); +CORE_DECLARE(void) esm_handle_information_response(mme_bearer_t *bearer, + nas_esm_information_response_t *bearer_information_response); #ifdef __cplusplus } diff --git a/src/mme/esm_sm.c b/src/mme/esm_sm.c index b07240198..5fcc741e5 100644 --- a/src/mme/esm_sm.c +++ b/src/mme/esm_sm.c @@ -1,4 +1,4 @@ -#define TRACE_MODULE _esm_sm +#define TRACE_MODULE _bearer_sm #include "core_debug.h" @@ -44,13 +44,13 @@ void esm_state_operational(fsm_t *s, event_t *e) case MME_EVT_ESM_BEARER_LO_INFO_REQ: { index_t index = event_get_param1(e); - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; mme_ue_t *ue = NULL; d_assert(index, return, "Null param"); - esm = mme_esm_find(index); - d_assert(esm, return, "Null param"); - ue = esm->ue; + bearer = mme_bearer_find(index); + d_assert(bearer, return, "Null param"); + ue = bearer->ue; d_assert(ue, return, "Null param"); switch(event_get(e)) @@ -60,12 +60,12 @@ void esm_state_operational(fsm_t *s, event_t *e) pkbuf_t *pkbuf = NULL; status_t rv; - rv = esm_build_information_request(&pkbuf, esm); + rv = esm_build_information_request(&pkbuf, bearer); d_assert(rv == CORE_OK, break, "esm_build failed"); mme_event_nas_to_s1ap(ue, pkbuf); d_info("[NAS] ESM information request : " - "UE[%s] <--- ESM[%d]", ue->imsi_bcd, esm->pti); + "UE[%s] <--- ESM[%d]", ue->imsi_bcd, bearer->pti); break; } } @@ -75,14 +75,14 @@ void esm_state_operational(fsm_t *s, event_t *e) case EVT_MSG_MME_ESM: { index_t index = event_get_param1(e); - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; mme_ue_t *ue = NULL; nas_message_t *message = NULL; d_assert(index, return, "Null param"); - esm = mme_esm_find(index); - d_assert(esm, return, "Null param"); - ue = esm->ue; + bearer = mme_bearer_find(index); + d_assert(bearer, return, "Null param"); + ue = bearer->ue; d_assert(ue, return, "Null param"); message = (nas_message_t *)event_get_param3(e); d_assert(message, break, "Null param"); @@ -92,20 +92,20 @@ void esm_state_operational(fsm_t *s, event_t *e) case NAS_PDN_CONNECTIVITY_REQUEST: { esm_handle_pdn_connectivity_request( - esm, &message->esm.pdn_connectivity_request); + bearer, &message->esm.pdn_connectivity_request); d_info("[NAS] PDN connectivity request : " - "UE[%s] --> ESM[%d]", ue->imsi_bcd, esm->pti); + "UE[%s] --> ESM[%d]", ue->imsi_bcd, bearer->pti); break; } case NAS_ESM_INFORMATION_RESPONSE: { /* FIXME : SGW Selection */ - esm->sgw = mme_sgw_first(); + bearer->sgw = mme_sgw_first(); esm_handle_information_response( - esm, &message->esm.esm_information_response); + bearer, &message->esm.esm_information_response); d_info("[NAS] ESM information response : " - "UE[%s] --> ESM[%d]", ue->imsi_bcd, esm->pti); + "UE[%s] --> ESM[%d]", ue->imsi_bcd, bearer->pti); break; } default: diff --git a/src/mme/mme_context.c b/src/mme/mme_context.c index d00cb876e..6a352f822 100644 --- a/src/mme/mme_context.c +++ b/src/mme/mme_context.c @@ -9,12 +9,8 @@ #include "mme_context.h" #define MAX_CELL_PER_ENB 8 -#define MAX_ESM_PER_UE 4 #define MAX_NUM_OF_SGW 8 -#define MAX_NUM_OF_ESM (MAX_NUM_OF_UE * MAX_ESM_PER_UE) - -#define MME_NUM_OF_PDN (MAX_NUM_OF_UE * MAX_PDN_PER_UE) #define S1AP_SCTP_PORT 36412 @@ -27,7 +23,7 @@ pool_declare(mme_sgw_pool, mme_sgw_t, MAX_NUM_OF_SGW); index_declare(mme_enb_pool, mme_enb_t, MAX_NUM_OF_ENB); index_declare(mme_ue_pool, mme_ue_t, MAX_NUM_OF_UE); -index_declare(mme_esm_pool, mme_esm_t, MAX_NUM_OF_ESM); +index_declare(mme_bearer_pool, mme_bearer_t, MAX_NUM_OF_UE_BEARER); pool_declare(mme_pdn_pool, pdn_t, MAX_NUM_OF_UE_PDN); static int context_initialized = 0; @@ -47,7 +43,7 @@ status_t mme_context_init() list_init(&self.enb_list); index_init(&mme_ue_pool, MAX_NUM_OF_UE); - index_init(&mme_esm_pool, MAX_NUM_OF_ESM); + index_init(&mme_bearer_pool, MAX_NUM_OF_UE_BEARER); pool_init(&mme_pdn_pool, MAX_NUM_OF_UE_PDN); self.mme_addr = inet_addr("127.0.0.1"); @@ -102,7 +98,7 @@ status_t mme_context_final() hash_destroy(self.mme_ue_s1ap_id_hash); pool_final(&mme_pdn_pool); - index_final(&mme_esm_pool); + index_final(&mme_bearer_pool); index_final(&mme_ue_pool); index_final(&mme_enb_pool); @@ -313,7 +309,7 @@ mme_ue_t* mme_ue_add(mme_enb_t *enb) ue->ebi = MIN_EPS_BEARER_ID - 1; /* Setup EBI Generator */ list_init(&ue->pdn_list); - list_init(&ue->esm_list); + list_init(&ue->bearer_list); list_append(&enb->ue_list, ue); ue->enb = enb; @@ -333,7 +329,7 @@ status_t mme_ue_remove(mme_ue_t *ue) fsm_final(&ue->sm, 0); fsm_clear(&ue->sm); - mme_esm_remove_all(ue); + mme_bearer_remove_all(ue); mme_pdn_remove_all(ue); list_remove(&ue->enb->ue_list, ue); @@ -444,112 +440,112 @@ mme_ue_t* mme_ue_next_in_enb(mme_ue_t *ue) return list_next(ue); } -mme_esm_t* mme_esm_add(mme_ue_t *ue, c_uint8_t pti) +mme_bearer_t* mme_bearer_add(mme_ue_t *ue, c_uint8_t pti) { - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; d_assert(ue, return NULL, "Null param"); - index_alloc(&mme_esm_pool, &esm); - d_assert(esm, return NULL, "Null param"); + index_alloc(&mme_bearer_pool, &bearer); + d_assert(bearer, return NULL, "Null param"); - esm->pti = pti; - esm->ebi = NEXT_ID(ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID); + bearer->pti = pti; + bearer->ebi = NEXT_ID(ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID); - esm->ue = ue; - list_append(&ue->esm_list, esm); + bearer->ue = ue; + list_append(&ue->bearer_list, bearer); - fsm_create(&esm->sm, esm_state_initial, esm_state_final); - fsm_init(&esm->sm, 0); + fsm_create(&bearer->sm, esm_state_initial, esm_state_final); + fsm_init(&bearer->sm, 0); - return esm; + return bearer; } -status_t mme_esm_remove(mme_esm_t *esm) +status_t mme_bearer_remove(mme_bearer_t *bearer) { - d_assert(esm, return CORE_ERROR, "Null param"); - d_assert(esm->ue, return CORE_ERROR, "Null param"); + d_assert(bearer, return CORE_ERROR, "Null param"); + d_assert(bearer->ue, return CORE_ERROR, "Null param"); - fsm_final(&esm->sm, 0); - fsm_clear(&esm->sm); + fsm_final(&bearer->sm, 0); + fsm_clear(&bearer->sm); - list_remove(&esm->ue->esm_list, esm); - index_free(&mme_esm_pool, esm); + list_remove(&bearer->ue->bearer_list, bearer); + index_free(&mme_bearer_pool, bearer); return CORE_OK; } -status_t mme_esm_remove_all(mme_ue_t *ue) +status_t mme_bearer_remove_all(mme_ue_t *ue) { - mme_esm_t *esm = NULL, *next_esm = NULL; + mme_bearer_t *bearer = NULL, *next_bearer = NULL; d_assert(ue, return CORE_ERROR, "Null param"); - esm = mme_esm_first(ue); - while (esm) + bearer = mme_bearer_first(ue); + while (bearer) { - next_esm = mme_esm_next(esm); + next_bearer = mme_bearer_next(bearer); - mme_esm_remove(esm); + mme_bearer_remove(bearer); - esm = next_esm; + bearer = next_bearer; } return CORE_OK; } -mme_esm_t* mme_esm_find(index_t index) +mme_bearer_t* mme_bearer_find(index_t index) { d_assert(index, return NULL, "Invalid Index"); - return index_find(&mme_esm_pool, index); + return index_find(&mme_bearer_pool, index); } -mme_esm_t* mme_esm_find_by_pti(mme_ue_t *ue, c_uint8_t pti) +mme_bearer_t* mme_bearer_find_by_pti(mme_ue_t *ue, c_uint8_t pti) { - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; d_assert(ue, return NULL, "Null param"); - esm = mme_esm_first(ue); - while (esm) + bearer = mme_bearer_first(ue); + while (bearer) { - if (pti == esm->pti) + if (pti == bearer->pti) break; - esm = mme_esm_next(esm); + bearer = mme_bearer_next(bearer); } - return esm; + return bearer; } -mme_esm_t* mme_esm_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi) +mme_bearer_t* mme_bearer_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi) { - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; d_assert(ue, return NULL, "Null param"); - esm = mme_esm_first(ue); - while (esm) + bearer = mme_bearer_first(ue); + while (bearer) { - if (ebi == esm->ebi) + if (ebi == bearer->ebi) break; - esm = mme_esm_next(esm); + bearer = mme_bearer_next(bearer); } - return esm; + return bearer; } -mme_esm_t* mme_esm_first(mme_ue_t *ue) +mme_bearer_t* mme_bearer_first(mme_ue_t *ue) { d_assert(ue, return NULL, "Null param"); - return list_first(&ue->esm_list); + return list_first(&ue->bearer_list); } -mme_esm_t* mme_esm_next(mme_esm_t *esm) +mme_bearer_t* mme_bearer_next(mme_bearer_t *bearer) { - return list_next(esm); + return list_next(bearer); } pdn_t* mme_pdn_add(mme_ue_t *ue, c_int8_t *apn) diff --git a/src/mme/mme_context.h b/src/mme/mme_context.h index 0620175c5..ee7cddc38 100644 --- a/src/mme/mme_context.h +++ b/src/mme/mme_context.h @@ -150,12 +150,12 @@ typedef struct _mme_ue_t { /* ESM Info */ c_uint8_t ebi; /* EPS Bearer ID generator */ - list_t esm_list; + list_t bearer_list; mme_enb_t *enb; } mme_ue_t; -typedef struct _mme_esm_t { +typedef struct _mme_bearer_t { lnode_t node; /**< A node of list_t */ index_t index; /**< An index of this node */ fsm_t sm; @@ -178,7 +178,7 @@ typedef struct _mme_esm_t { pdn_t *pdn; mme_ue_t *ue; -} mme_esm_t; +} mme_bearer_t; CORE_DECLARE(status_t) mme_context_init(void); CORE_DECLARE(status_t) mme_context_final(void); @@ -217,14 +217,14 @@ CORE_DECLARE(mme_ue_t*) mme_ue_find_by_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_esm_t*) mme_esm_add(mme_ue_t *ue, c_uint8_t pti); -CORE_DECLARE(status_t) mme_esm_remove(mme_esm_t *esm); -CORE_DECLARE(status_t) mme_esm_remove_all(mme_ue_t *ue); -CORE_DECLARE(mme_esm_t*) mme_esm_find(index_t index); -CORE_DECLARE(mme_esm_t*) mme_esm_find_by_pti(mme_ue_t *ue, c_uint8_t pti); -CORE_DECLARE(mme_esm_t*) mme_esm_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi); -CORE_DECLARE(mme_esm_t*) mme_esm_first(mme_ue_t *ue); -CORE_DECLARE(mme_esm_t*) mme_esm_next(mme_esm_t *esm); +CORE_DECLARE(mme_bearer_t*) mme_bearer_add(mme_ue_t *ue, c_uint8_t pti); +CORE_DECLARE(status_t) mme_bearer_remove(mme_bearer_t *bearer); +CORE_DECLARE(status_t) mme_bearer_remove_all(mme_ue_t *ue); +CORE_DECLARE(mme_bearer_t*) mme_bearer_find(index_t index); +CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_pti(mme_ue_t *ue, c_uint8_t pti); +CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi); +CORE_DECLARE(mme_bearer_t*) mme_bearer_first(mme_ue_t *ue); +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(status_t) mme_pdn_remove(pdn_t *pdn); diff --git a/src/mme/mme_event.c b/src/mme/mme_event.c index c0de12897..f1a1c95b9 100644 --- a/src/mme/mme_event.c +++ b/src/mme/mme_event.c @@ -113,12 +113,12 @@ void mme_event_s1ap_to_nas(mme_ue_t *ue, S1ap_NAS_PDU_t *nasPdu) } else if (h->protocol_discriminator == NAS_PROTOCOL_DISCRIMINATOR_ESM) { - mme_esm_t *esm = mme_esm_find_by_pti(ue, + mme_bearer_t *bearer = mme_bearer_find_by_pti(ue, h->procedure_transaction_identity); - if (esm) + if (bearer) { event_set(&e, EVT_MSG_MME_ESM); - event_set_param1(&e, (c_uintptr_t)esm->index); + event_set_param1(&e, (c_uintptr_t)bearer->index); event_set_param2(&e, (c_uintptr_t)sendbuf); mme_event_send(&e); } @@ -131,24 +131,24 @@ void mme_event_s1ap_to_nas(mme_ue_t *ue, S1ap_NAS_PDU_t *nasPdu) h->protocol_discriminator); } -void mme_event_emm_to_esm(mme_esm_t *esm, - nas_esm_message_container_t *esm_message_container) +void mme_event_emm_to_esm(mme_bearer_t *bearer, + nas_esm_message_container_t *bearer_message_container) { pkbuf_t *sendbuf = NULL; event_t e; - d_assert(esm, return, "Null param"); - d_assert(esm_message_container, return, "Null param"); + d_assert(bearer, return, "Null param"); + d_assert(bearer_message_container, return, "Null param"); /* The Packet Buffer(pkbuf_t) for NAS message MUST make a HEADROOM. * When calculating AES_CMAC, we need to use the headroom of the packet. */ - sendbuf = pkbuf_alloc(NAS_HEADROOM, esm_message_container->len); + sendbuf = pkbuf_alloc(NAS_HEADROOM, bearer_message_container->len); d_assert(sendbuf, return, "Null param"); memcpy(sendbuf->payload, - esm_message_container->data, esm_message_container->len); + bearer_message_container->data, bearer_message_container->len); event_set(&e, EVT_MSG_MME_ESM); - event_set_param1(&e, (c_uintptr_t)esm->index); + event_set_param1(&e, (c_uintptr_t)bearer->index); event_set_param2(&e, (c_uintptr_t)sendbuf); mme_event_send(&e); } diff --git a/src/mme/mme_event.h b/src/mme/mme_event.h index a4d554c19..1e16eb3cb 100644 --- a/src/mme/mme_event.h +++ b/src/mme/mme_event.h @@ -10,7 +10,7 @@ extern "C" { /* forward declaration */ typedef struct _mme_ue_t mme_ue_t; -typedef struct _mme_esm_t mme_esm_t; +typedef struct _mme_bearer_t mme_bearer_t; typedef struct _nas_esm_message_container_t nas_esm_message_container_t; typedef struct OCTET_STRING S1ap_NAS_PDU_t; @@ -53,8 +53,8 @@ typedef enum { CORE_DECLARE(char*) mme_event_get_name(event_t *e); CORE_DECLARE(void) mme_event_s1ap_to_nas(mme_ue_t *ue, S1ap_NAS_PDU_t *nasPdu); -CORE_DECLARE(void) mme_event_emm_to_esm(mme_esm_t *esm, - nas_esm_message_container_t *esm_message_container); +CORE_DECLARE(void) mme_event_emm_to_esm(mme_bearer_t *bearer, + nas_esm_message_container_t *bearer_message_container); CORE_DECLARE(void) mme_event_nas_to_s1ap(mme_ue_t *ue, pkbuf_t *pkbuf); #ifdef __cplusplus diff --git a/src/mme/mme_s11_build.c b/src/mme/mme_s11_build.c index 53032c002..4a7536deb 100644 --- a/src/mme/mme_s11_build.c +++ b/src/mme/mme_s11_build.c @@ -8,7 +8,7 @@ #include "3gpp_common.h" #include "mme_context.h" -status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_esm_t *esm) +status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_bearer_t *bearer) { status_t rv; pdn_t *pdn = NULL; @@ -25,15 +25,15 @@ status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_esm_t *esm) char bearer_qos_buf[GTP_BEARER_QOS_LEN]; gtp_ue_timezone_t ue_timezone; - d_assert(esm, return CORE_ERROR, "Null param"); - pdn = esm->pdn; + d_assert(bearer, return CORE_ERROR, "Null param"); + pdn = bearer->pdn; d_assert(pdn, return CORE_ERROR, "Null param"); - sgw = esm->sgw; + sgw = bearer->sgw; d_assert(sgw, return CORE_ERROR, "Null param"); - ue = esm->ue; + ue = bearer->ue; d_assert(ue, return CORE_ERROR, "Null param"); - d_assert(esm->ue_pco_len, return CORE_ERROR, "Null param"); + d_assert(bearer->ue_pco_len, return CORE_ERROR, "Null param"); memset(>p_message, 0, sizeof(gtp_message_t)); @@ -113,12 +113,12 @@ status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_esm_t *esm) req->aggregate_maximum_bit_rate.len = sizeof(ambr); req->protocol_configuration_options.presence = 1; - req->protocol_configuration_options.data = esm->ue_pco; - req->protocol_configuration_options.len = esm->ue_pco_len; + req->protocol_configuration_options.data = bearer->ue_pco; + req->protocol_configuration_options.len = bearer->ue_pco_len; req->bearer_contexts_to_be_created.presence = 1; req->bearer_contexts_to_be_created.eps_bearer_id.presence = 1; - req->bearer_contexts_to_be_created.eps_bearer_id.u8 = esm->ebi; + req->bearer_contexts_to_be_created.eps_bearer_id.u8 = bearer->ebi; memset(&bearer_qos, 0, sizeof(bearer_qos)); bearer_qos.pre_emption_vulnerability = pdn->pre_emption_vulnerability; diff --git a/src/mme/mme_s11_build.h b/src/mme/mme_s11_build.h index 8f6e907b5..13ce1a1de 100644 --- a/src/mme/mme_s11_build.h +++ b/src/mme/mme_s11_build.h @@ -8,7 +8,7 @@ extern "C" { #endif /* __cplusplus */ CORE_DECLARE(status_t) mme_s11_build_create_session_request( - pkbuf_t **pkbuf, mme_esm_t *esm); + pkbuf_t **pkbuf, mme_bearer_t *bearer); #ifdef __cplusplus } diff --git a/src/mme/mme_s11_handler.c b/src/mme/mme_s11_handler.c index 5e1a33378..51d971705 100644 --- a/src/mme/mme_s11_handler.c +++ b/src/mme/mme_s11_handler.c @@ -16,7 +16,7 @@ void mme_s11_handle_create_session_response( gtp_f_teid_t *sgw_s11_teid = NULL; gtp_f_teid_t *sgw_s1u_teid = NULL; - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; pdn_t *pdn = NULL; d_assert(ue, return, "Null param"); @@ -48,10 +48,10 @@ void mme_s11_handle_create_session_response( return; } - esm = mme_esm_find_by_ebi( + bearer = mme_bearer_find_by_ebi( ue, rsp->bearer_contexts_created.eps_bearer_id.u8); - d_assert(esm, return, "No ESM Context"); - pdn = esm->pdn; + d_assert(bearer, return, "No ESM Context"); + pdn = bearer->pdn; d_assert(pdn, return, "No PDN Context"); /* Receive Control Plane(UL) : SGW-S11 */ @@ -64,17 +64,17 @@ void mme_s11_handle_create_session_response( if (rsp->protocol_configuration_options.presence) { - esm->pgw_pco_len = rsp->protocol_configuration_options.len; - memcpy(esm->pgw_pco, rsp->protocol_configuration_options.data, - esm->pgw_pco_len); + bearer->pgw_pco_len = rsp->protocol_configuration_options.len; + memcpy(bearer->pgw_pco, rsp->protocol_configuration_options.data, + bearer->pgw_pco_len); } /* Receive Data Plane(UL) : SGW-S1U */ sgw_s1u_teid = rsp->bearer_contexts_created.s1_u_enodeb_f_teid.data; - esm->sgw_s1u_teid = ntohl(sgw_s1u_teid->teid); - esm->sgw_s1u_addr = sgw_s1u_teid->ipv4_addr; + bearer->sgw_s1u_teid = ntohl(sgw_s1u_teid->teid); + bearer->sgw_s1u_addr = sgw_s1u_teid->ipv4_addr; event_set(&e, MME_EVT_EMM_BEARER_LO_CREATE_SESSION); - event_set_param1(&e, (c_uintptr_t)esm->index); + event_set_param1(&e, (c_uintptr_t)bearer->index); mme_event_send(&e); } diff --git a/src/mme/mme_sm.c b/src/mme/mme_sm.c index fa2934609..fb747e595 100644 --- a/src/mme/mme_sm.c +++ b/src/mme/mme_sm.c @@ -152,15 +152,15 @@ 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_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; pkbuf_t *pkbuf = NULL; if (event_get(e) == MME_EVT_EMM_BEARER_LO_CREATE_SESSION) { d_assert(index, break, "Null param"); - esm = mme_esm_find(index); - d_assert(esm, break, "No ESM context"); - ue = esm->ue; + bearer = mme_bearer_find(index); + d_assert(bearer, break, "No ESM context"); + ue = bearer->ue; } else { @@ -192,15 +192,15 @@ void mme_state_operational(fsm_t *s, event_t *e) { nas_message_t message; index_t index = event_get_param1(e); - mme_esm_t *esm = NULL; + mme_bearer_t *bearer = NULL; mme_ue_t *ue = NULL; pkbuf_t *pkbuf = NULL; d_assert(index, break, "Null param"); - esm = mme_esm_find(index); - d_assert(esm, break, "No ESM context"); - d_assert(ue = esm->ue, break, "No UE context"); - d_assert(FSM_STATE(&esm->sm), break, "No ESM State Machine"); + bearer = mme_bearer_find(index); + d_assert(bearer, break, "No ESM context"); + d_assert(ue = bearer->ue, break, "No UE context"); + d_assert(FSM_STATE(&bearer->sm), break, "No ESM State Machine"); if (event_get(e) == EVT_MSG_MME_ESM) { @@ -212,7 +212,7 @@ void mme_state_operational(fsm_t *s, event_t *e) event_set_param3(e, (c_uintptr_t)&message); } - fsm_dispatch(&esm->sm, (fsm_event_t*)e); + fsm_dispatch(&bearer->sm, (fsm_event_t*)e); if (event_get(e) == EVT_MSG_MME_ESM) { diff --git a/src/mme/s1ap_build.c b/src/mme/s1ap_build.c index d9e703011..6e0fc06f7 100644 --- a/src/mme/s1ap_build.c +++ b/src/mme/s1ap_build.c @@ -139,7 +139,7 @@ status_t s1ap_build_downlink_nas_transport( } status_t s1ap_build_initial_context_setup_request( - pkbuf_t **s1apbuf, mme_esm_t *esm, pkbuf_t *emmbuf) + pkbuf_t **s1apbuf, mme_bearer_t *bearer, pkbuf_t *emmbuf) { int encoded; s1ap_message_t message; @@ -151,10 +151,10 @@ status_t s1ap_build_initial_context_setup_request( pdn_t *pdn = NULL; d_assert(emmbuf, return CORE_ERROR, "Null param"); - d_assert(esm, return CORE_ERROR, "Null param"); - ue = esm->ue; + d_assert(bearer, return CORE_ERROR, "Null param"); + ue = bearer->ue; d_assert(ue, return CORE_ERROR, "Null param"); - pdn = esm->pdn; + pdn = bearer->pdn; d_assert(pdn, return CORE_ERROR, "Null param"); memset(&message, 0, sizeof(s1ap_message_t)); @@ -171,7 +171,7 @@ status_t s1ap_build_initial_context_setup_request( e_rab = (S1ap_E_RABToBeSetupItemCtxtSUReq_t *) core_calloc(1, sizeof(S1ap_E_RABToBeSetupItemCtxtSUReq_t)); - e_rab->e_RAB_ID = esm->ebi; + e_rab->e_RAB_ID = bearer->ebi; e_rab->e_RABlevelQoSParameters.qCI = pdn->qci; e_rab->e_RABlevelQoSParameters.allocationRetentionPriority. @@ -185,10 +185,10 @@ status_t s1ap_build_initial_context_setup_request( e_rab->transportLayerAddress.size = 4; e_rab->transportLayerAddress.buf = core_calloc(e_rab->transportLayerAddress.size, sizeof(c_uint8_t)); - memcpy(e_rab->transportLayerAddress.buf, &esm->sgw_s1u_addr, + memcpy(e_rab->transportLayerAddress.buf, &bearer->sgw_s1u_addr, e_rab->transportLayerAddress.size); - s1ap_uint32_to_OCTET_STRING(esm->sgw_s1u_teid, &e_rab->gTP_TEID); + s1ap_uint32_to_OCTET_STRING(bearer->sgw_s1u_teid, &e_rab->gTP_TEID); nasPdu = (S1ap_NAS_PDU_t *)core_calloc(1, sizeof(S1ap_NAS_PDU_t)); nasPdu->size = emmbuf->len; diff --git a/src/mme/s1ap_build.h b/src/mme/s1ap_build.h index 0a150aa8c..60ca4765a 100644 --- a/src/mme/s1ap_build.h +++ b/src/mme/s1ap_build.h @@ -14,7 +14,7 @@ CORE_DECLARE(status_t) s1ap_build_setup_failure( CORE_DECLARE(status_t) s1ap_build_downlink_nas_transport( pkbuf_t **s1apbuf, mme_ue_t *ue, pkbuf_t *emmbuf); CORE_DECLARE(status_t) s1ap_build_initial_context_setup_request( - pkbuf_t **s1apbuf, mme_esm_t *esm, pkbuf_t *emmbuf); + pkbuf_t **s1apbuf, mme_bearer_t *bearer, pkbuf_t *emmbuf); #ifdef __cplusplus }