acouzens
/
open5gs
1
0
Fork 1
Code Issues Pull Requests 1 Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/acetcom/cellwire 

Conflicts:
	src/mme/mme_context.c
	src/mme/mme_context.h
	src/mme/s1ap_handler.c
This commit is contained in:
James Park 2017-04-28 14:43:04 +09:00
parent 65b5378c91 7fe75bd6af
commit 2939cf1349
17 changed files with 347 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/mme/emm_handler.c
View File

@ -39,13 +39,13 @@ void emm_handle_esm_message_container(
pti = h->procedure_transaction_identity;
ebi = h->eps_bearer_identity;
if (pti == NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED && ebi)
bearer = mme_bearer_find_by_ebi(ue, ebi);
bearer = mme_bearer_find_by_ue_ebi(ue, ebi);
else if (ebi == NAS_EPS_BEARER_IDENTITY_UNASSIGNED && pti)
bearer = mme_bearer_find_by_pti(ue, pti);
bearer = mme_bearer_find_by_ue_pti(ue, pti);
if (!bearer)
bearer = mme_bearer_add(ue, pti);
d_assert(bearer, return, "Null param");
bearer = mme_sess_add(ue, pti);
d_assert(bearer, return, "No Bearer Context");
/* 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. */

38
src/mme/emm_sm.c
View File

@ -81,26 +81,30 @@ void emm_state_operational(fsm_t *s, event_t *e)
}
case S6A_CMD_UPDATE_LOCATION:
{
mme_bearer_t *bearer = mme_bearer_first(ue);
while(bearer)
mme_sess_t *sess = mme_sess_first(ue);
while(sess)
{
event_t e;
event_set(&e, MME_EVT_ESM_BEARER_FROM_S6A);
event_set_param1(&e, (c_uintptr_t)bearer->index);
event_set_param2(&e,
(c_uintptr_t)S6A_CMD_UPDATE_LOCATION);
mme_event_send(&e);
mme_bearer_t *bearer = mme_bearer_first(sess);
while(bearer)
{
event_t e;
event_set(&e, MME_EVT_ESM_BEARER_FROM_S6A);
event_set_param1(&e, (c_uintptr_t)bearer->index);
event_set_param2(&e,
(c_uintptr_t)S6A_CMD_UPDATE_LOCATION);
mme_event_send(&e);
bearer = mme_bearer_next(bearer);
bearer = mme_bearer_next(bearer);
}
sess = mme_sess_next(sess);
}
break;
}
case GTP_MODIFY_BEARER_RESPONSE_TYPE:
{
d_info("[GTP] Modify Bearer Response : "
"MME[%d] <-- SGW[%d]",
ue->mme_s11_teid, ue->sgw_s11_teid);
"MME <-- SGW");
break;
}
}
@ -174,6 +178,16 @@ void emm_state_operational(fsm_t *s, event_t *e)
}
break;
}
case MME_EVT_EMM_UE_T3:
{
index_t index = event_get_param1(e);
mme_ue_t *ue = NULL;
d_assert(index, return, "Null param");
ue = mme_ue_find(index);
d_assert(ue, return, "Null param");
break;
}
default:
{

8
src/mme/esm_handler.c
View File

@ -57,18 +57,18 @@ void esm_handle_s6a_update_location(mme_bearer_t *bearer)
void esm_handle_modify_bearer_request(mme_bearer_t *bearer)
{
status_t rv;
mme_ue_t *ue = NULL;
mme_sess_t *sess = NULL;
pkbuf_t *pkbuf = NULL;
d_assert(bearer, return, "Null param");
ue = bearer->ue;
d_assert(ue, return, "Null param");
sess = bearer->sess;
d_assert(sess, return, "Null param");
rv = mme_s11_build_modify_bearer_request(&pkbuf, bearer);
d_assert(rv == CORE_OK, return, "S11 build error");
rv = mme_s11_send_to_sgw(bearer->sgw,
GTP_MODIFY_BEARER_REQUEST_TYPE, ue->sgw_s11_teid, pkbuf);
GTP_MODIFY_BEARER_REQUEST_TYPE, sess->sgw_s11_teid, pkbuf);
d_assert(rv == CORE_OK, return, "S11 send error");
}

253
src/mme/mme_context.c
View File

@ -7,6 +7,7 @@
#include "s1ap_message.h"
#include "mme_context.h"
#include "mme_event.h"
#define MAX_CELL_PER_ENB 8
@ -24,6 +25,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(enb_ue_pool, enb_ue_t, MAX_NUM_OF_UE);
index_declare(mme_sess_pool, mme_sess_t, MAX_NUM_OF_UE);
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);
@ -55,6 +57,7 @@ status_t mme_context_init()
index_init(&mme_ue_pool, MAX_NUM_OF_UE);
index_init(&enb_ue_pool, MAX_NUM_OF_UE);
index_init(&mme_sess_pool, MAX_NUM_OF_UE);
index_init(&mme_bearer_pool, MAX_NUM_OF_UE_BEARER);
pool_init(&mme_pdn_pool, MAX_NUM_OF_UE_PDN);
@ -119,6 +122,7 @@ status_t mme_context_final()
pool_final(&mme_pdn_pool);
index_final(&mme_bearer_pool);
index_final(&mme_sess_pool);
index_final(&mme_ue_pool);
index_final(&enb_ue_pool);
@ -325,24 +329,10 @@ enb_ue_t* enb_ue_add(mme_enb_t *enb)
ue->mme_ue_s1ap_id = NEXT_ID(self.mme_ue_s1ap_id, 1, 0xffffffff);
hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id,
sizeof(ue->mme_ue_s1ap_id), ue);
#if 0
ue->mme_s11_teid = ue->index;
ue->mme_s11_addr = mme_self()->s11_addr;
ue->ebi = MIN_EPS_BEARER_ID - 1; /* Setup EBI Generator */
list_init(&ue->pdn_list);
list_init(&ue->bearer_list);
#endif
list_append(&enb->ue_list, ue);
ue->enb = enb;
#if 0
fsm_create(&ue->sm, enbue_state_initial, enbue_state_final);
fsm_init(&ue->sm, 0);
#endif
return ue;
}
@ -359,14 +349,6 @@ status_t enb_ue_remove(enb_ue_t *ue)
d_assert(ue, return CORE_ERROR, "Null param");
d_assert(ue->enb, return CORE_ERROR, "Null param");
#if 0
fsm_final(&ue->sm, 0);
fsm_clear(&ue->sm);
mme_bearer_remove_all(ue);
mme_pdn_remove_all(ue);
#endif
list_remove(&ue->enb->ue_list, ue);
hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id,
sizeof(ue->mme_ue_s1ap_id), NULL);
@ -437,30 +419,25 @@ mme_ue_t* mme_ue_add(enb_ue_t *enb_ue)
{
mme_ue_t *ue = NULL;
#if 0
d_assert(self.mme_ue_s1ap_id_hash, return NULL, "Null param");
#endif
d_assert(enb_ue, return NULL, "Null param");
index_alloc(&mme_ue_pool, &ue);
d_assert(ue, return NULL, "Null param");
#if 0
ue->mme_ue_s1ap_id = NEXT_ID(self.mme_ue_s1ap_id, 1, 0xffffffff);
hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id,
sizeof(ue->mme_ue_s1ap_id), ue);
#endif
ue->mme_s11_teid = ue->index;
ue->mme_s11_addr = mme_self()->s11_addr;
ue->ebi = MIN_EPS_BEARER_ID - 1; /* Setup EBI Generator */
list_init(&ue->pdn_list);
list_init(&ue->bearer_list);
//list_append(&enb->ue_list, ue);
list_init(&ue->sess_list);
ue->enb_ue = enb_ue;
enb_ue->mme_ue = ue;
#define MME_UE_T3_DURATION 3000 /* 3 seconds */
ue->tm_t3 = event_timer(&self.tm_service, MME_EVT_EMM_UE_T3,
MME_UE_T3_DURATION, ue->index);
#if 1 /* example code : please remove if you know the usage */
tm_start(ue->tm_t3);
tm_stop(ue->tm_t3);
#endif
fsm_create(&ue->sm, emm_state_initial, emm_state_final);
fsm_init(&ue->sm, 0);
@ -470,22 +447,16 @@ mme_ue_t* mme_ue_add(enb_ue_t *enb_ue)
status_t mme_ue_remove(mme_ue_t *ue)
{
//d_assert(self.mme_ue_s1ap_id_hash, return CORE_ERROR, "Null param");
d_assert(ue, return CORE_ERROR, "Null param");
//d_assert(ue->enb, return CORE_ERROR, "Null param");
tm_delete(ue->tm_t3);
fsm_final(&ue->sm, 0);
fsm_clear(&ue->sm);
mme_bearer_remove_all(ue);
mme_sess_remove_all(ue);
mme_pdn_remove_all(ue);
#if 0
list_remove(&ue->enb->ue_list, ue);
hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id,
sizeof(ue->mme_ue_s1ap_id), NULL);
#endif
index_free(&mme_ue_pool, ue);
return CORE_OK;
@ -520,11 +491,6 @@ mme_ue_t* mme_ue_find_by_mme_ue_s1ap_id(c_uint32_t mme_ue_s1ap_id)
}
#endif
mme_ue_t* mme_ue_find_by_teid(c_uint32_t teid)
{
return mme_ue_find(teid);
}
mme_ue_t* mme_ue_find_by_imsi(c_uint8_t *imsi, int imsi_len)
{
mme_ue_t *iter = NULL;
@ -628,10 +594,110 @@ mme_ue_t* mme_ue_next_in_enb(mme_ue_t *ue)
}
#endif
mme_bearer_t* mme_bearer_add(mme_ue_t *ue, c_uint8_t pti)
mme_bearer_t *mme_sess_add(mme_ue_t *ue, c_uint8_t pti)
{
mme_sess_t *sess = NULL;
mme_bearer_t *bearer = NULL;
index_alloc(&mme_sess_pool, &sess);
d_assert(sess, return NULL, "Null param");
sess->mme_s11_teid = sess->index;
sess->mme_s11_addr = mme_self()->s11_addr;
list_init(&sess->bearer_list);
list_append(&ue->sess_list, sess);
sess->ue = ue;
bearer = mme_bearer_add(sess, pti);
d_assert(bearer, mme_sess_remove(sess); return NULL,
"Can't add default bearer context");
return bearer;
}
status_t mme_sess_remove(mme_sess_t *sess)
{
d_assert(sess, return CORE_ERROR, "Null param");
d_assert(sess->ue, return CORE_ERROR, "Null param");
mme_bearer_remove_all(sess);
list_remove(&sess->ue->sess_list, sess);
index_free(&mme_sess_pool, sess);
return CORE_OK;
}
status_t mme_sess_remove_all(mme_ue_t *ue)
{
mme_sess_t *sess = NULL, *next_sess = NULL;
sess = mme_sess_first(ue);
while (sess)
{
next_sess = mme_sess_next(sess);
mme_sess_remove(sess);
sess = next_sess;
}
return CORE_OK;
}
mme_sess_t* mme_sess_find(index_t index)
{
d_assert(index, return NULL, "Invalid Index");
return index_find(&mme_sess_pool, index);
}
mme_sess_t* mme_sess_find_by_teid(c_uint32_t teid)
{
return mme_sess_find(teid);
}
mme_sess_t* mme_sess_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi)
{
mme_sess_t *sess = NULL;
mme_bearer_t *bearer = NULL;
sess = mme_sess_first(ue);
while (sess)
{
bearer = mme_bearer_first(sess);
while (bearer)
{
if (ebi == bearer->ebi)
return sess;
bearer = mme_bearer_next(bearer);
}
sess = mme_sess_next(sess);
}
return NULL;
}
mme_sess_t* mme_sess_first(mme_ue_t *ue)
{
return list_first(&ue->sess_list);
}
mme_sess_t* mme_sess_next(mme_sess_t *sess)
{
return list_next(sess);
}
mme_bearer_t* mme_bearer_add(mme_sess_t *sess, c_uint8_t pti)
{
mme_bearer_t *bearer = NULL;
mme_ue_t *ue = NULL;
d_assert(sess, return NULL, "Null param");
ue = sess->ue;
d_assert(ue, return NULL, "Null param");
index_alloc(&mme_bearer_pool, &bearer);
@ -640,9 +706,11 @@ mme_bearer_t* mme_bearer_add(mme_ue_t *ue, c_uint8_t pti)
bearer->pti = pti;
bearer->ebi = NEXT_ID(ue->ebi, MIN_EPS_BEARER_ID, MAX_EPS_BEARER_ID);
bearer->ue = ue;
list_append(&ue->bearer_list, bearer);
list_append(&sess->bearer_list, bearer);
bearer->ue = ue;
bearer->sess = sess;
fsm_create(&bearer->sm, esm_state_initial, esm_state_final);
fsm_init(&bearer->sm, 0);
@ -652,24 +720,24 @@ mme_bearer_t* mme_bearer_add(mme_ue_t *ue, c_uint8_t pti)
status_t mme_bearer_remove(mme_bearer_t *bearer)
{
d_assert(bearer, return CORE_ERROR, "Null param");
d_assert(bearer->ue, return CORE_ERROR, "Null param");
d_assert(bearer->sess, return CORE_ERROR, "Null param");
fsm_final(&bearer->sm, 0);
fsm_clear(&bearer->sm);
list_remove(&bearer->ue->bearer_list, bearer);
list_remove(&bearer->sess->bearer_list, bearer);
index_free(&mme_bearer_pool, bearer);
return CORE_OK;
}
status_t mme_bearer_remove_all(mme_ue_t *ue)
status_t mme_bearer_remove_all(mme_sess_t *sess)
{
mme_bearer_t *bearer = NULL, *next_bearer = NULL;
d_assert(ue, return CORE_ERROR, "Null param");
d_assert(sess, return CORE_ERROR, "Null param");
bearer = mme_bearer_first(ue);
bearer = mme_bearer_first(sess);
while (bearer)
{
next_bearer = mme_bearer_next(bearer);
@ -688,47 +756,84 @@ mme_bearer_t* mme_bearer_find(index_t index)
return index_find(&mme_bearer_pool, index);
}
mme_bearer_t* mme_bearer_find_by_pti(mme_ue_t *ue, c_uint8_t pti)
mme_bearer_t* mme_bearer_find_by_ue_pti(mme_ue_t *ue, c_uint8_t pti)
{
mme_sess_t *sess = NULL;
mme_bearer_t *bearer = NULL;
d_assert(ue, return NULL, "Null param");
bearer = mme_bearer_first(ue);
while (bearer)
{
if (pti == bearer->pti)
break;
bearer = mme_bearer_next(bearer);
sess = mme_sess_first(ue);
while (sess)
{
bearer = mme_bearer_first(sess);
while (bearer)
{
if (pti == bearer->pti)
return bearer;
bearer = mme_bearer_next(bearer);
}
sess = mme_sess_next(sess);
}
return bearer;
return NULL;
}
mme_bearer_t* mme_bearer_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi)
mme_bearer_t* mme_bearer_find_by_ue_ebi(mme_ue_t *ue, c_uint8_t ebi)
{
mme_sess_t *sess = NULL;
mme_bearer_t *bearer = NULL;
d_assert(ue, return NULL, "Null param");
bearer = mme_bearer_first(ue);
sess = mme_sess_first(ue);
while (sess)
{
bearer = mme_bearer_first(sess);
while (bearer)
{
if (ebi == bearer->ebi)
return bearer;
bearer = mme_bearer_next(bearer);
}
sess = mme_sess_next(sess);
}
return NULL;
}
mme_bearer_t* mme_bearer_find_by_sess_ebi(mme_sess_t *sess, c_uint8_t ebi)
{
mme_bearer_t *bearer = NULL;
d_assert(sess, return NULL, "Null param");
bearer = mme_bearer_first(sess);
while (bearer)
{
if (ebi == bearer->ebi)
break;
return bearer;
bearer = mme_bearer_next(bearer);
}
return bearer;
return NULL;
}
mme_bearer_t* mme_bearer_first(mme_ue_t *ue)
mme_bearer_t* mme_default_bearer_in_sess(mme_sess_t *sess)
{
d_assert(ue, return NULL, "Null param");
return mme_bearer_first(sess);
}
return list_first(&ue->bearer_list);
mme_bearer_t* mme_bearer_first(mme_sess_t *sess)
{
d_assert(sess, return NULL, "Null param");
return list_first(&sess->bearer_list);
}
mme_bearer_t* mme_bearer_next(mme_bearer_t *bearer)

58
src/mme/mme_context.h
View File

@ -178,21 +178,36 @@ struct _mme_ue_t {
list_t pdn_list;
c_uint32_t subscribed_rau_tau_timer; /* seconds */
/* IMPORTANT!
* MME-S11-TEID is same with an index */
c_uint32_t mme_s11_teid;
c_uint32_t mme_s11_addr;
c_uint32_t sgw_s11_teid;
c_uint32_t sgw_s11_addr;
/* ESM Info */
c_uint8_t ebi; /* EPS Bearer ID generator */
list_t bearer_list;
list_t sess_list;
/* Timer Info */
tm_block_id tm_t3; /**< T3 Timer */
/* enb ue context */
enb_ue_t *enb_ue;
};
typedef struct _mme_sess_t {
lnode_t node; /**< A node of list_t */
index_t index; /**< An index of this node */
/* IMPORTANT!
* MME-S11-TEID is same with an index */
c_uint32_t mme_s11_teid;
c_uint32_t mme_s11_addr;
c_uint32_t sgw_s11_teid;
c_uint32_t sgw_s11_addr;
/* mme_bearer_first(sess) : Default Bearer Context */
list_t bearer_list;
/* Related Context */
mme_ue_t *ue;
} mme_sess_t;
typedef struct _mme_bearer_t {
lnode_t node; /**< A node of list_t */
index_t index; /**< An index of this node */
@ -212,10 +227,12 @@ typedef struct _mme_bearer_t {
c_uint8_t pgw_pco[MAX_PCO_LEN];
int pgw_pco_len;
/* Related Context */
mme_sgw_t *sgw;
pdn_t *pdn;
mme_ue_t *ue;
mme_sess_t *sess;
} mme_bearer_t;
CORE_DECLARE(status_t) mme_context_init(void);
@ -244,7 +261,6 @@ CORE_DECLARE(status_t) mme_ue_remove_all();
CORE_DECLARE(mme_ue_t*) mme_ue_find(index_t index);
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_mme_ue_s1ap_id(
c_uint32_t mme_ue_s1ap_id);
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_teid(c_uint32_t teid);
CORE_DECLARE(hash_index_t *) mme_ue_first();
CORE_DECLARE(hash_index_t *) mme_ue_next(hash_index_t *hi);
CORE_DECLARE(mme_ue_t *) mme_ue_this(hash_index_t *hi);
@ -257,13 +273,27 @@ CORE_DECLARE(mme_ue_t*) mme_ue_next_in_enb(mme_ue_t *ue);
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_imsi(c_uint8_t *imsi, int imsi_len);
CORE_DECLARE(mme_ue_t*) mme_ue_find_by_guti(guti_t *guti);
CORE_DECLARE(mme_bearer_t*) mme_bearer_add(mme_ue_t *ue, c_uint8_t pti);
CORE_DECLARE(mme_bearer_t*) mme_sess_add(mme_ue_t *ue, c_uint8_t pti);
CORE_DECLARE(status_t ) mme_sess_remove(mme_sess_t *sess);
CORE_DECLARE(status_t ) mme_sess_remove_all(mme_ue_t *ue);
CORE_DECLARE(mme_sess_t*) mme_sess_find(index_t index);
CORE_DECLARE(mme_sess_t*) mme_sess_find_by_teid(c_uint32_t teid);
CORE_DECLARE(mme_sess_t*) mme_sess_find_by_ebi(mme_ue_t *ue, c_uint8_t ebi);
CORE_DECLARE(mme_sess_t*) mme_sess_first(mme_ue_t *ue);
CORE_DECLARE(mme_sess_t*) mme_sess_next(mme_sess_t *sess);
CORE_DECLARE(mme_bearer_t*) mme_bearer_add(mme_sess_t *sess, 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(status_t) mme_bearer_remove_all(mme_sess_t *sess);
CORE_DECLARE(mme_bearer_t*) mme_bearer_find(index_t index);
CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_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_find_by_ue_pti(
mme_ue_t *ue, c_uint8_t pti);
CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_ue_ebi(
mme_ue_t *ue, c_uint8_t ebi);
CORE_DECLARE(mme_bearer_t*) mme_bearer_find_by_sess_ebi(
mme_sess_t *sess, c_uint8_t ebi);
CORE_DECLARE(mme_bearer_t*) mme_default_bearer_in_sess(mme_sess_t *sess);
CORE_DECLARE(mme_bearer_t*) mme_bearer_first(mme_sess_t *sess);
CORE_DECLARE(mme_bearer_t*) mme_bearer_next(mme_bearer_t *bearer);
CORE_DECLARE(pdn_t*) mme_pdn_add(mme_ue_t *ue, c_int8_t *apn);

1
src/mme/mme_event.h
View File

@ -23,6 +23,7 @@ typedef enum {
MME_EVT_EMM_UE_FROM_S6A,
MME_EVT_EMM_UE_FROM_S11,
MME_EVT_EMM_BEARER_FROM_S11,
MME_EVT_EMM_UE_T3,
MME_EVT_ESM_BEARER_MSG,
MME_EVT_ESM_BEARER_FROM_S6A,

12
src/mme/mme_s11_build.c
View File

@ -8,12 +8,14 @@
#include "3gpp_common.h"
#include "mme_context.h"
status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_bearer_t *bearer)
status_t mme_s11_build_create_session_request(
pkbuf_t **pkbuf, mme_bearer_t *bearer)
{
status_t rv;
pdn_t *pdn = NULL;
mme_sgw_t *sgw = NULL;
mme_ue_t *ue = NULL;
mme_sess_t *sess = NULL;
gtp_message_t gtp_message;
gtp_create_session_request_t *req = &gtp_message.create_session_request;
@ -30,7 +32,9 @@ status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_bearer_t *bea
d_assert(pdn, return CORE_ERROR, "Null param");
sgw = bearer->sgw;
d_assert(sgw, return CORE_ERROR, "Null param");
ue = bearer->ue;
sess = bearer->sess;
d_assert(sess, return CORE_ERROR, "Null param");
ue = sess->ue;
d_assert(ue, return CORE_ERROR, "Null param");
d_assert(ue->enb_ue, return CORE_ERROR, "Null param");
@ -67,8 +71,8 @@ status_t mme_s11_build_create_session_request(pkbuf_t **pkbuf, mme_bearer_t *bea
memset(&mme_s11_teid, 0, sizeof(gtp_f_teid_t));
mme_s11_teid.ipv4 = 1;
mme_s11_teid.interface_type = GTP_F_TEID_S11_MME_GTP_C;
mme_s11_teid.teid = htonl(ue->mme_s11_teid);
mme_s11_teid.ipv4_addr = ue->mme_s11_addr;
mme_s11_teid.teid = htonl(sess->mme_s11_teid);
mme_s11_teid.ipv4_addr = sess->mme_s11_addr;
req->sender_f_teid_for_control_plane.presence = 1;
req->sender_f_teid_for_control_plane.data = &mme_s11_teid;
req->sender_f_teid_for_control_plane.len = GTP_F_TEID_IPV4_LEN;

20
src/mme/mme_s11_handler.c
View File

@ -9,7 +9,7 @@
#include "mme_s11_handler.h"
void mme_s11_handle_create_session_response(
mme_ue_t *ue, gtp_create_session_response_t *rsp)
mme_sess_t *sess, gtp_create_session_response_t *rsp)
{
event_t e;
@ -19,7 +19,7 @@ void mme_s11_handle_create_session_response(
mme_bearer_t *bearer = NULL;
pdn_t *pdn = NULL;
d_assert(ue, return, "Null param");
d_assert(sess, return, "Null param");
d_assert(rsp, return, "Null param");
if (rsp->sender_f_teid_for_control_plane.presence == 0)
@ -48,16 +48,16 @@ void mme_s11_handle_create_session_response(
return;
}
bearer = mme_bearer_find_by_ebi(
ue, rsp->bearer_contexts_created.eps_bearer_id.u8);
bearer = mme_bearer_find_by_sess_ebi(
sess, rsp->bearer_contexts_created.eps_bearer_id.u8);
d_assert(bearer, return, "No ESM Context");
pdn = bearer->pdn;
d_assert(pdn, return, "No PDN Context");
/* Receive Control Plane(UL) : SGW-S11 */
sgw_s11_teid = rsp->sender_f_teid_for_control_plane.data;
ue->sgw_s11_teid = ntohl(sgw_s11_teid->teid);
ue->sgw_s11_addr = sgw_s11_teid->ipv4_addr;
sess->sgw_s11_teid = ntohl(sgw_s11_teid->teid);
sess->sgw_s11_addr = sgw_s11_teid->ipv4_addr;
memcpy(&pdn->paa, rsp->pdn_address_allocation.data,
rsp->pdn_address_allocation.len);
@ -75,7 +75,7 @@ void mme_s11_handle_create_session_response(
bearer->sgw_s1u_addr = sgw_s1u_teid->ipv4_addr;
d_info("[GTP] Create Session Response : "
"MME[%d] <-- SGW[%d]", ue->mme_s11_teid, ue->sgw_s11_teid);
"MME[%d] <-- SGW[%d]", sess->mme_s11_teid, sess->sgw_s11_teid);
event_set(&e, MME_EVT_EMM_BEARER_FROM_S11);
event_set_param1(&e, (c_uintptr_t)bearer->index);
@ -84,10 +84,14 @@ void mme_s11_handle_create_session_response(
}
void mme_s11_handle_modify_bearer_response(
mme_ue_t *ue, gtp_modify_bearer_response_t *rsp)
mme_sess_t *sess, gtp_modify_bearer_response_t *rsp)
{
mme_ue_t *ue = NULL;
event_t e;
d_assert(sess, return, "Null param");
ue = sess->ue;
event_set(&e, MME_EVT_EMM_UE_FROM_S11);
event_set_param1(&e, (c_uintptr_t)ue->index);
event_set_param2(&e, (c_uintptr_t)GTP_MODIFY_BEARER_RESPONSE_TYPE);

4
src/mme/mme_s11_handler.h
View File

@ -10,9 +10,9 @@ extern "C" {
#endif /* __cplusplus */
CORE_DECLARE(void) mme_s11_handle_create_session_response(
mme_ue_t *ue, gtp_create_session_response_t *rsp);
mme_sess_t *sess, gtp_create_session_response_t *rsp);
CORE_DECLARE(void) mme_s11_handle_modify_bearer_response(
mme_ue_t *ue, gtp_modify_bearer_response_t *rsp);
mme_sess_t *sess, gtp_modify_bearer_response_t *rsp);
#ifdef __cplusplus
}

11
src/mme/mme_sm.c
View File

@ -185,6 +185,7 @@ void mme_state_operational(fsm_t *s, event_t *e)
case MME_EVT_EMM_UE_FROM_S6A:
case MME_EVT_EMM_UE_FROM_S11:
case MME_EVT_EMM_BEARER_FROM_S11:
case MME_EVT_EMM_UE_T3:
{
nas_message_t message;
index_t index = event_get_param1(e);
@ -269,7 +270,7 @@ void mme_state_operational(fsm_t *s, event_t *e)
c_uint8_t type;
c_uint32_t teid;
gtp_message_t gtp_message;
mme_ue_t *ue = NULL;
mme_sess_t *sess = NULL;
d_assert(pkbuf, break, "Null param");
d_assert(sock, pkbuf_free(pkbuf); break, "Null param");
@ -281,18 +282,18 @@ void mme_state_operational(fsm_t *s, event_t *e)
if (rv != CORE_OK)
break;
ue = mme_ue_find_by_teid(teid);
d_assert(ue, pkbuf_free(pkbuf); break,
sess = mme_sess_find_by_teid(teid);
d_assert(sess, pkbuf_free(pkbuf); break,
"No Session Context(TEID:%d)", teid);
switch(type)
{
case GTP_CREATE_SESSION_RESPONSE_TYPE:
mme_s11_handle_create_session_response(
ue, &gtp_message.create_session_response);
sess, &gtp_message.create_session_response);
break;
case GTP_MODIFY_BEARER_RESPONSE_TYPE:
mme_s11_handle_modify_bearer_response(
ue, &gtp_message.modify_bearer_response);
sess, &gtp_message.modify_bearer_response);
break;
default:
d_warn("Not implmeneted(type:%d)", type);

4
src/mme/s1ap_handler.c
View File

@ -79,7 +79,7 @@ static void event_s1ap_to_nas(enb_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
return;
}
bearer = mme_bearer_find_by_pti(mme_ue,
bearer = mme_bearer_find_by_ue_pti(mme_ue,
h->procedure_transaction_identity);
if (bearer)
{
@ -285,7 +285,7 @@ void s1ap_handle_initial_context_setup_response(
ies->e_RABSetupListCtxtSURes.s1ap_E_RABSetupItemCtxtSURes.array[i];
d_assert(e_rab, return, "Null param");
bearer = mme_bearer_find_by_ebi(mme_ue, e_rab->e_RAB_ID);
bearer = mme_bearer_find_by_ue_ebi(mme_ue, e_rab->e_RAB_ID);
d_assert(bearer, return, "Null param");
memcpy(&bearer->enb_s1u_teid, e_rab->gTP_TEID.buf,
sizeof(bearer->enb_s1u_teid));

30
src/pgw/pgw_context.c
View File

@ -93,9 +93,10 @@ pgw_context_t* pgw_self()
return &self;
}
pgw_sess_t *pgw_sess_add()
pgw_bearer_t *pgw_sess_add(c_uint8_t id)
{
pgw_sess_t *sess = NULL;
pgw_bearer_t *bearer = NULL;
index_alloc(&pgw_sess_pool, &sess);
d_assert(sess, return NULL, "Null param");
@ -107,7 +108,11 @@ pgw_sess_t *pgw_sess_add()
list_init(&sess->bearer_list);
list_append(&self.sess_list, sess);
return sess;
bearer = pgw_bearer_add(sess, id);
d_assert(bearer, pgw_sess_remove(sess); return NULL,
"Can't add default bearer context");
return bearer;
}
status_t pgw_sess_remove(pgw_sess_t *sess)
@ -125,16 +130,16 @@ status_t pgw_sess_remove(pgw_sess_t *sess)
status_t pgw_sess_remove_all()
{
pgw_sess_t *enb = NULL, *next_enb = NULL;
pgw_sess_t *sess = NULL, *next_sess = NULL;
enb = pgw_sess_first();
while (enb)
sess = pgw_sess_first();
while (sess)
{
next_enb = pgw_sess_next(enb);
next_sess = pgw_sess_next(sess);
pgw_sess_remove(enb);
pgw_sess_remove(sess);
enb = next_enb;
sess = next_sess;
}
return CORE_OK;
@ -156,9 +161,9 @@ pgw_sess_t* pgw_sess_first()
return list_first(&self.sess_list);
}
pgw_sess_t* pgw_sess_next(pgw_sess_t *enb)
pgw_sess_t* pgw_sess_next(pgw_sess_t *sess)
{
return list_next(enb);
return list_next(sess);
}
pdn_t* pgw_pdn_add(pgw_sess_t *sess, c_int8_t *apn)
@ -320,6 +325,11 @@ pgw_bearer_t* pgw_bearer_find_by_id(pgw_sess_t *sess, c_uint8_t id)
return bearer;
}
pgw_bearer_t* pgw_default_bearer_in_sess(pgw_sess_t *sess)
{
return pgw_bearer_first(sess);
}
pgw_bearer_t* pgw_bearer_first(pgw_sess_t *sess)
{
d_assert(sess, return NULL, "Null param");

3
src/pgw/pgw_context.h
View File

@ -77,7 +77,7 @@ CORE_DECLARE(status_t) pgw_context_final(void);
CORE_DECLARE(pgw_context_t*) pgw_self(void);
CORE_DECLARE(pgw_sess_t*) pgw_sess_add();
CORE_DECLARE(pgw_bearer_t*) pgw_sess_add(c_uint8_t id);
CORE_DECLARE(status_t ) pgw_sess_remove(pgw_sess_t *sess);
CORE_DECLARE(status_t ) pgw_sess_remove_all();
CORE_DECLARE(pgw_sess_t*) pgw_sess_find(index_t index);
@ -97,6 +97,7 @@ CORE_DECLARE(status_t) pgw_bearer_remove(pgw_bearer_t *bearer);
CORE_DECLARE(status_t) pgw_bearer_remove_all(pgw_sess_t *sess);
CORE_DECLARE(pgw_bearer_t*) pgw_bearer_find_by_id(
pgw_sess_t *sess, c_uint8_t id);
CORE_DECLARE(pgw_bearer_t*) pgw_default_bearer_in_sess(pgw_sess_t *sess);
CORE_DECLARE(pgw_bearer_t*) pgw_bearer_first(pgw_sess_t *sess);
CORE_DECLARE(pgw_bearer_t*) pgw_bearer_next(pgw_bearer_t *bearer);

16
src/pgw/pgw_handler.c
View File

@ -146,8 +146,10 @@ void pgw_handle_create_session_request(
}
/* Generate Control Plane(UL) : PGW-S5C */
sess = pgw_sess_add();
d_assert(sess, return, "No Session Context");
bearer = pgw_sess_add(req->bearer_contexts_to_be_created.eps_bearer_id.u8);
d_assert(bearer, return, "No Bearer Context");
sess = bearer->sess;
d_assert(sess, return, "Null param");
memcpy(apn, req->access_point_name.data, req->access_point_name.len);
apn[req->access_point_name.len] = 0;
@ -158,16 +160,6 @@ void pgw_handle_create_session_request(
}
d_assert(pdn, pgw_sess_remove(sess); return, "No PDN Context");
bearer = pgw_bearer_find_by_id(sess,
req->bearer_contexts_to_be_created.eps_bearer_id.u8);
if (!bearer)
{
/* Generate Data Plane(UL) : PGW-S5U */
bearer = pgw_bearer_add(sess,
req->bearer_contexts_to_be_created.eps_bearer_id.u8);
}
d_assert(bearer, pgw_sess_remove(sess); return, "No Bearer Context");
memset(&gtp_message, 0, sizeof(gtp_message_t));
memset(&cause, 0, sizeof(cause));

30
src/sgw/sgw_context.c
View File

@ -108,9 +108,10 @@ sgw_context_t* sgw_self()
return &self;
}
sgw_sess_t *sgw_sess_add()
sgw_bearer_t *sgw_sess_add(c_uint8_t id)
{
sgw_sess_t *sess = NULL;
sgw_bearer_t *bearer = NULL;
index_alloc(&sgw_sess_pool, &sess);
d_assert(sess, return NULL, "Null param");
@ -124,7 +125,11 @@ sgw_sess_t *sgw_sess_add()
list_init(&sess->bearer_list);
list_append(&self.sess_list, sess);
return sess;
bearer = sgw_bearer_add(sess, id);
d_assert(bearer, sgw_sess_remove(sess); return NULL,
"Can't add default bearer context");
return bearer;
}
status_t sgw_sess_remove(sgw_sess_t *sess)
@ -141,16 +146,16 @@ status_t sgw_sess_remove(sgw_sess_t *sess)
status_t sgw_sess_remove_all()
{
sgw_sess_t *enb = NULL, *next_enb = NULL;
sgw_sess_t *sess = NULL, *next_sess = NULL;
enb = sgw_sess_first();
while (enb)
sess = sgw_sess_first();
while (sess)
{
next_enb = sgw_sess_next(enb);
next_sess = sgw_sess_next(sess);
sgw_sess_remove(enb);
sgw_sess_remove(sess);
enb = next_enb;
sess = next_sess;
}
return CORE_OK;
@ -172,9 +177,9 @@ sgw_sess_t* sgw_sess_first()
return list_first(&self.sess_list);
}
sgw_sess_t* sgw_sess_next(sgw_sess_t *enb)
sgw_sess_t* sgw_sess_next(sgw_sess_t *sess)
{
return list_next(enb);
return list_next(sess);
}
sgw_bearer_t* sgw_bearer_add(sgw_sess_t *sess, c_uint8_t id)
@ -264,6 +269,11 @@ sgw_bearer_t* sgw_bearer_find_by_id(sgw_sess_t *sess, c_uint8_t id)
return bearer;
}
sgw_bearer_t* sgw_default_bearer_in_sess(sgw_sess_t *sess)
{
return sgw_bearer_first(sess);
}
sgw_bearer_t* sgw_bearer_first(sgw_sess_t *sess)
{
d_assert(sess, return NULL, "Null param");

9
src/sgw/sgw_context.h
View File

@ -94,7 +94,7 @@ CORE_DECLARE(status_t) sgw_context_final(void);
CORE_DECLARE(sgw_context_t*) sgw_self(void);
CORE_DECLARE(sgw_sess_t*) sgw_sess_add();
CORE_DECLARE(sgw_bearer_t*) sgw_sess_add(c_uint8_t id);
CORE_DECLARE(status_t ) sgw_sess_remove(sgw_sess_t *sess);
CORE_DECLARE(status_t ) sgw_sess_remove_all();
CORE_DECLARE(sgw_sess_t*) sgw_sess_find(index_t index);
@ -105,13 +105,16 @@ CORE_DECLARE(sgw_sess_t *) sgw_sess_next(sgw_sess_t *sess);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_add(sgw_sess_t *sess, c_uint8_t id);
CORE_DECLARE(status_t) sgw_bearer_remove(sgw_bearer_t *bearer);
CORE_DECLARE(status_t) sgw_bearer_remove_all(sgw_sess_t *sess);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_find_by_sgw_s5u_teid(
c_uint32_t sgw_s5u_teid);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_find_by_sgw_s1u_teid(
c_uint32_t sgw_s1u_teid);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_find_by_id(
sgw_sess_t *sess, c_uint8_t id);
CORE_DECLARE(sgw_bearer_t*) sgw_default_bearer_in_sess(sgw_sess_t *sess);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_first(sgw_sess_t *sess);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_next(sgw_bearer_t *bearer);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_find_by_sgw_s5u_teid(c_uint32_t sgw_s5u_teid);
CORE_DECLARE(sgw_bearer_t*) sgw_bearer_find_by_sgw_s1u_teid(c_uint32_t sgw_s1u_teid);
#ifdef __cplusplus
}

20
src/sgw/sgw_handler.c
View File

@ -44,19 +44,13 @@ void sgw_handle_create_session_request(
/* Generate Control Plane(UL) : SGW-S11 */
/* Generate Control Plane(DL) : SGW-S5C */
sess = sgw_sess_add();
d_assert(sess, return, "sess_add failed");
bearer = sgw_bearer_find_by_id(sess,
req->bearer_contexts_to_be_created.eps_bearer_id.u8);
if (!bearer)
{
/* Generate Data Plane(UL) : SGW-S1U */
/* Generate Data Plane(DL) : SGW-S5U */
bearer = sgw_bearer_add(sess,
req->bearer_contexts_to_be_created.eps_bearer_id.u8);
}
d_assert(bearer, sgw_sess_remove(sess); return, "No Bearer Context");
/* Generate Data Plane(UL) : SGW-S1U */
/* Generate Data Plane(DL) : SGW-S5U */
bearer = sgw_sess_add(
req->bearer_contexts_to_be_created.eps_bearer_id.u8);
d_assert(bearer, return, "No Bearer Context");
sess = bearer->sess;
d_assert(sess, return, "Null param");
/* Receive Control Plane(DL) : MME-S11 */
mme_s11_teid = req->sender_f_teid_for_control_plane.data;