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

update it

This commit is contained in:
Sukchan Lee 2017-04-13 19:15:53 +09:00
parent 3ca1fa39d9
commit 07242abd87
18 changed files with 184 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/mme/emm_handler.c
View File

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

2
src/mme/emm_handler.h
View File

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

16
src/mme/emm_sm.c
View File

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

26
src/mme/esm_build.c
View File

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

4
src/mme/esm_build.h
View File

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

26
src/mme/esm_handler.c
View File

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

6
src/mme/esm_handler.h
View File

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

32
src/mme/esm_sm.c
View File

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

104
src/mme/mme_context.c
View File

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

22
src/mme/mme_context.h
View File

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

20
src/mme/mme_event.c
View File

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

6
src/mme/mme_event.h
View File

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

18
src/mme/mme_s11_build.c
View File

@ -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(&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.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;

2
src/mme/mme_s11_build.h
View File

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

20
src/mme/mme_s11_handler.c
View File

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

20
src/mme/mme_sm.c
View File

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

14
src/mme/s1ap_build.c
View File

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

2
src/mme/s1ap_build.h
View File

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