update it

lib/nas/nas_message.h

@@ -61,7 +61,7 @@ ED2(c_uint8_t security_header_type:4;,
 } __attribute__ ((packed)) nas_emm_header_t;
 
 #define NAS_EPS_BEARER_IDENTITY_UNASSIGNED 0
-#define NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED 0;
+#define NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED 0
 typedef struct _nas_esm_header_t {
 ED2(c_uint8_t eps_bearer_identity:4;,
     c_uint8_t protocol_discriminator:4;)

src/mme/emm_handler.c

@@ -11,11 +11,52 @@
 #include "nas_conv.h"
 #include "mme_s6a_handler.h"
 
+void emm_handle_esm_message_container(
+        mme_ue_t *ue, nas_esm_message_container_t *esm_message_container)
+{
+
+    nas_esm_header_t *h = NULL;
+    c_uint8_t pti = 0;
+    mme_esm_t *esm = NULL;
+
+    d_assert(ue, return, "Null param");
+    d_assert(esm_message_container, return, "Null param");
+    d_assert(esm_message_container->length, return, "Null param");
+
+    h = (nas_esm_header_t *)esm_message_container->buffer;
+    d_assert(h, return, "Null param");
+
+    pti = h->procedure_transaction_identity;
+    if (pti == NAS_PROCEDURE_TRANSACTION_IDENTITY_UNASSIGNED)
+    {
+        d_error("Procedure Trasaction is NOT triggered by UE");
+        return;
+    }
+
+    esm = mme_esm_find_by_pti(ue, pti);
+    if (!esm)
+    {
+        esm = mme_esm_add(ue, pti);
+        d_assert(esm, 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);
+    }
+
+    mme_event_emm_to_esm(esm, esm_message_container);
+}
+
 void emm_handle_attach_request(
         mme_ue_t *ue, nas_attach_request_t *attach_request)
 {
     nas_eps_mobile_identity_t *eps_mobile_identity =
-        &attach_request->eps_mobile_identity;
+                    &attach_request->eps_mobile_identity;
+
+    emm_handle_esm_message_container(
+            ue, &attach_request->esm_message_container);
 
     switch(eps_mobile_identity->imsi.type_of_identity)
     {

src/mme/esm_handler.c

@@ -6,7 +6,18 @@
 
 #include "mme_event.h"
 
-#include "mme_kdf.h"
 #include "nas_security.h"
 #include "nas_conv.h"
-#include "mme_s6a_handler.h"
+
+void esm_handle_pdn_connectivity_request(mme_esm_t *esm, 
+        nas_pdn_connectivity_request_t *pdn_connectivity_request)
+{
+#if 0 /* TODO */
+    printf("request type = 0x%x, %d\n", 
+            pdn_connectivity_request->request_type.request_type,
+            pdn_connectivity_request->request_type.pdn_type);
+    printf("precesce = 0x%x\n", pdn_connectivity_request->presencemask);
+    printf("flag = 0x%x\n", 
+            pdn_connectivity_request->esm_information_transfer_flag.security_protected_required);
+#endif
+}

src/mme/esm_handler.h

@@ -3,12 +3,15 @@
 
 #include "nas_message.h"
 
-#include "context.h"
+#include "mme_context.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
+void esm_handle_pdn_connectivity_request(mme_esm_t *esm, 
+        nas_pdn_connectivity_request_t *pdn_connectivity_request);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

src/mme/esm_sm.c

@@ -6,7 +6,7 @@
 
 #include "mme_event.h"
 #include "nas_security.h"
-#include "emm_handler.h"
+#include "esm_handler.h"
 
 void esm_state_initial(esm_sm_t *s, event_t *e)
 {
@@ -62,10 +62,12 @@ void esm_state_operational(esm_sm_t *s, event_t *e)
                 break;
             }
 
-            switch(message.emm.h.message_type)
+            switch(message.esm.h.message_type)
             {
                 case NAS_PDN_CONNECTIVITY_REQUEST:
                 {
+                    esm_handle_pdn_connectivity_request(
+                            esm, &message.esm.pdn_connectivity_request);
                     break;
                 }
                 default:

src/mme/mme_context.c

@@ -184,15 +184,13 @@ mme_enb_t* mme_enb_add(net_sock_t *s1ap_sock)
     memset(enb, 0, sizeof(mme_enb_t));
 
     enb->s1ap_sock = s1ap_sock;
+    list_init(&enb->ue_list);
+    list_append(&self.enb_list, enb);
 
     fsm_create((fsm_t*)&enb->s1ap_sm, 
             s1ap_state_initial, s1ap_state_final);
     enb->s1ap_sm.ctx = enb;
     fsm_init((fsm_t*)&enb->s1ap_sm, 0);
-
-    list_init(&enb->ue_list);
-
-    list_append(&self.enb_list, enb);
     
     return enb;
 }
@@ -201,11 +199,11 @@ status_t mme_enb_remove(mme_enb_t *enb)
 {
     d_assert(enb, return CORE_ERROR, "Null param");
 
-    mme_ue_remove_in_enb(enb);
-
     fsm_final((fsm_t*)&enb->s1ap_sm, 0);
     fsm_clear((fsm_t*)&enb->s1ap_sm);
 
+    mme_ue_remove_in_enb(enb);
+
     net_unregister_sock(enb->s1ap_sock);
     net_close(enb->s1ap_sock);
 
@@ -286,20 +284,18 @@ mme_ue_t* mme_ue_add(mme_enb_t *enb)
 
     memset(ue, 0, sizeof(mme_ue_t));
 
-    fsm_create((fsm_t*)&ue->emm_sm, 
-            emm_state_initial, emm_state_final);
-    ue->emm_sm.ctx = ue;
-    fsm_init((fsm_t*)&ue->emm_sm, 0);
-
     ue->mme_ue_s1ap_id = NEXT_ID(self.mme_ue_s1ap_id, 0xffffffff);
     hash_set(self.mme_ue_s1ap_id_hash, &ue->mme_ue_s1ap_id, 
             sizeof(ue->mme_ue_s1ap_id), ue);
 
     ue->enb = enb;
-
     list_init(&ue->esm_list);
-
     list_append(&enb->ue_list, ue);
+
+    fsm_create((fsm_t*)&ue->emm_sm, 
+            emm_state_initial, emm_state_final);
+    ue->emm_sm.ctx = ue;
+    fsm_init((fsm_t*)&ue->emm_sm, 0);
     
     return ue;
 }
@@ -310,11 +306,11 @@ status_t mme_ue_remove(mme_ue_t *ue)
     d_assert(ue, return CORE_ERROR, "Null param");
     d_assert(ue->enb, return CORE_ERROR, "Null param");
 
-    mme_esm_remove_all(ue);
-
     fsm_final((fsm_t*)&ue->emm_sm, 0);
     fsm_clear((fsm_t*)&ue->emm_sm);
 
+    mme_esm_remove_all(ue);
+
     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);
@@ -424,11 +420,15 @@ mme_esm_t* mme_esm_add(mme_ue_t *ue, c_uint8_t pti)
     memset(esm, 0, sizeof(mme_esm_t));
 
     esm->pti = pti;
-
     esm->ue = ue;
 
     list_append(&ue->esm_list, esm);
     
+    fsm_create((fsm_t*)&esm->sm, 
+            esm_state_initial, esm_state_final);
+    esm->sm.ctx = esm;
+    fsm_init((fsm_t*)&esm->sm, 0);
+
     return esm;
 }
 

src/mme/mme_event.c

@@ -53,11 +53,12 @@ char* mme_event_get_name(event_t *e)
     return EVT_NAME_UNKNOWN;
 }
 
-void mme_event_s1ap_to_nas(mme_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
+void mme_event_s1ap_to_emm(mme_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
 {
     pkbuf_t *sendbuf = NULL;
     event_t e;
 
+    d_assert(ue, return, "Null param");
     d_assert(nasPdu, return, "Null param");
 
     /* The Packet Buffer(pkbuf_t) for NAS message MUST make a HEADROOM. 
@@ -72,6 +73,28 @@ void mme_event_s1ap_to_nas(mme_ue_t *ue, S1ap_NAS_PDU_t *nasPdu)
     mme_event_send(&e);
 }
 
+void mme_event_emm_to_esm(mme_esm_t *esm, 
+                nas_esm_message_container_t *esm_message_container)
+{
+    pkbuf_t *sendbuf = NULL;
+    event_t e;
+
+    d_assert(esm, return, "Null param");
+    d_assert(esm_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->length);
+    d_assert(sendbuf, return, "Null param");
+    memcpy(sendbuf->payload, 
+            esm_message_container->buffer, esm_message_container->length);
+
+    event_set(&e, EVT_MSG_MME_ESM);
+    event_set_param1(&e, (c_uintptr_t)esm);
+    event_set_param2(&e, (c_uintptr_t)sendbuf);
+    mme_event_send(&e);
+}
+
 void mme_event_nas_to_s1ap(mme_ue_t *ue, pkbuf_t *pkbuf)
 {
     char buf[INET_ADDRSTRLEN];

src/mme/mme_event.h

@@ -10,6 +10,8 @@ extern "C" {
 
 /* forward declaration */
 typedef struct _mme_ue_t mme_ue_t;
+typedef struct _mme_esm_t mme_esm_t;
+typedef struct _nas_esm_message_container_t nas_esm_message_container_t;
 typedef struct OCTET_STRING S1ap_NAS_PDU_t;
 
 typedef enum {
@@ -33,7 +35,9 @@ 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_s1ap_to_emm(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_nas_to_s1ap(mme_ue_t *ue, pkbuf_t *pkbuf);
 
 #ifdef __cplusplus

src/mme/s1ap_handler.c

@@ -89,7 +89,7 @@ void s1ap_handle_initial_ue_message(mme_enb_t *enb, s1ap_message_t *message)
         INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
         enb->enb_id);
 
-    mme_event_s1ap_to_nas(ue, &ies->nas_pdu);
+    mme_event_s1ap_to_emm(ue, &ies->nas_pdu);
 }
 
 void s1ap_handle_uplink_nas_transport(
@@ -111,6 +111,6 @@ void s1ap_handle_uplink_nas_transport(
         INET_NTOP(&enb->s1ap_sock->remote.sin_addr.s_addr, buf),
         enb->enb_id);
 
-    mme_event_s1ap_to_nas(ue, &ies->nas_pdu);
+    mme_event_s1ap_to_emm(ue, &ies->nas_pdu);
 }