update it

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);
+    bearer = mme_bearer_find_by_pti(ue, pti);
-    if (!esm)
+    if (!bearer)
     {
-        esm = mme_esm_add(ue, pti);
+        bearer = mme_bearer_add(ue, pti);
-        d_assert(esm, return, "Null param");
+        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");
+    d_assert(bearer, return, "Null param");
-    ue = esm->ue;
+    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);
+    rv = esm_build_activate_default_bearer_context(&bearerbuf, bearer);
-    d_assert(rv == CORE_OK, return, "esm build error");
+    d_assert(rv == CORE_OK, return, "bearer build error");
 
-    rv = emm_build_attach_accept(&emmbuf, ue, esmbuf);
+    rv = emm_build_attach_accept(&emmbuf, ue, bearerbuf);
-    d_assert(rv == CORE_OK, pkbuf_free(esmbuf); return, "emm build error");
+    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,,);

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
 }

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);
+            bearer = mme_bearer_find(index);
-            d_assert(esm, break, "No ESM context");
+            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:

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");
+    d_assert(bearer, return CORE_ERROR, "Null param");
-    ue = esm->ue;
+    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");
+    d_assert(bearer, return CORE_ERROR, "Null param");
-    ue = esm->ue;
+    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,,);

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
 }

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");
+    d_assert(bearer, return, "Null param");
-    ue = esm->ue;
+    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;
+        bearer->ue_pco_len = protocol_configuration_options->length;
-        d_assert(esm->ue_pco_len <= MAX_PCO_LEN, return, 
+        d_assert(bearer->ue_pco_len <= MAX_PCO_LEN, return, 
-                "length(%d) exceeds MAX:%d", esm->ue_pco_len, MAX_PCO_LEN);
+                "length(%d) exceeds MAX:%d", bearer->ue_pco_len, MAX_PCO_LEN);
-        memcpy(esm->ue_pco, protocol_configuration_options->buffer, 
+        memcpy(bearer->ue_pco, protocol_configuration_options->buffer, 
-                esm->ue_pco_len);
+                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");
 }

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, 
+CORE_DECLARE(void) esm_handle_information_response(mme_bearer_t *bearer, 
-        nas_esm_information_response_t *esm_information_response);
+        nas_esm_information_response_t *bearer_information_response);
 
 #ifdef __cplusplus
 }

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);
+            bearer = mme_bearer_find(index);
-            d_assert(esm, return, "Null param");
+            d_assert(bearer, return, "Null param");
-            ue = esm->ue;
+            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);
+            bearer = mme_bearer_find(index);
-            d_assert(esm, return, "Null param");
+            d_assert(bearer, return, "Null param");
-            ue = esm->ue;
+            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:

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);
+    index_alloc(&mme_bearer_pool, &bearer);
-    d_assert(esm, return NULL, "Null param");
+    d_assert(bearer, return NULL, "Null param");
 
-    esm->pti = pti;
+    bearer->pti = pti;
-    esm->ebi = NEXT_ID(ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID);
+    bearer->ebi = NEXT_ID(ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID);
 
-    esm->ue = ue;
+    bearer->ue = ue;
-    list_append(&ue->esm_list, esm);
+    list_append(&ue->bearer_list, bearer);
     
-    fsm_create(&esm->sm, esm_state_initial, esm_state_final);
+    fsm_create(&bearer->sm, esm_state_initial, esm_state_final);
-    fsm_init(&esm->sm, 0);
+    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(bearer, return CORE_ERROR, "Null param");
-    d_assert(esm->ue, return CORE_ERROR, "Null param");
+    d_assert(bearer->ue, return CORE_ERROR, "Null param");
     
-    fsm_final(&esm->sm, 0);
+    fsm_final(&bearer->sm, 0);
-    fsm_clear(&esm->sm);
+    fsm_clear(&bearer->sm);
 
-    list_remove(&esm->ue->esm_list, esm);
+    list_remove(&bearer->ue->bearer_list, bearer);
-    index_free(&mme_esm_pool, esm);
+    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);
+    bearer = mme_bearer_first(ue);
-    while (esm)
+    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);
+    bearer = mme_bearer_first(ue);
-    while (esm)
+    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);
+    bearer = mme_bearer_first(ue);
-    while (esm)
+    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)

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(mme_bearer_t*) mme_bearer_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_bearer_remove(mme_bearer_t *bearer);
-CORE_DECLARE(status_t)      mme_esm_remove_all(mme_ue_t *ue);
+CORE_DECLARE(status_t)      mme_bearer_remove_all(mme_ue_t *ue);
-CORE_DECLARE(mme_esm_t*)    mme_esm_find(index_t index);
+CORE_DECLARE(mme_bearer_t*) mme_bearer_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_bearer_t*) mme_bearer_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_bearer_t*) mme_bearer_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_bearer_t*) mme_bearer_first(mme_ue_t *ue);
-CORE_DECLARE(mme_esm_t*)    mme_esm_next(mme_esm_t *esm);
+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);

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, 
+void mme_event_emm_to_esm(mme_bearer_t *bearer, 
-                nas_esm_message_container_t *esm_message_container)
+                nas_esm_message_container_t *bearer_message_container)
 {
     pkbuf_t *sendbuf = NULL;
     event_t e;
 
-    d_assert(esm, return, "Null param");
+    d_assert(bearer, return, "Null param");
-    d_assert(esm_message_container, 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);
 }

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, 
+CORE_DECLARE(void) mme_event_emm_to_esm(mme_bearer_t *bearer, 
-                        nas_esm_message_container_t *esm_message_container);
+                        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

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");
+    d_assert(bearer, return CORE_ERROR, "Null param");
-    pdn = esm->pdn;
+    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(&gtp_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.data = bearer->ue_pco;
-    req->protocol_configuration_options.len = esm->ue_pco_len;
+    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;

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
 }

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");
+    d_assert(bearer, return, "No ESM Context");
-    pdn = esm->pdn;
+    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;
+        bearer->pgw_pco_len = rsp->protocol_configuration_options.len;
-        memcpy(esm->pgw_pco, rsp->protocol_configuration_options.data,
+        memcpy(bearer->pgw_pco, rsp->protocol_configuration_options.data,
-                esm->pgw_pco_len);
+                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);
+    bearer->sgw_s1u_teid = ntohl(sgw_s1u_teid->teid);
-    esm->sgw_s1u_addr = sgw_s1u_teid->ipv4_addr;
+    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);
 }

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);
+                bearer = mme_bearer_find(index);
-                d_assert(esm, break, "No ESM context");
+                d_assert(bearer, break, "No ESM context");
-                ue = esm->ue;
+                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);
+            bearer = mme_bearer_find(index);
-            d_assert(esm, break, "No ESM context");
+            d_assert(bearer, break, "No ESM context");
-            d_assert(ue = esm->ue, break, "No UE context");
+            d_assert(ue = bearer->ue, break, "No UE context");
-            d_assert(FSM_STATE(&esm->sm), break, "No ESM State Machine");
+            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)
             {

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");
+    d_assert(bearer, return CORE_ERROR, "Null param");
-    ue = esm->ue;
+    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;

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
 }