intermediate

src/Makefile.am

@@ -9,7 +9,7 @@ libcellwire_la_SOURCES = \
 
 nodist_libcellwire_la_SOURCES = \
     init.c event.c context.c s1ap_message.c s1ap_conv.c s1_path.c \
-	mme_sm.c
+	mme_sm.c enb_s1_sm.c
 
 AM_CPPFLAGS = \
 	-I$(top_srcdir)/include \

src/mme_sm.c

@@ -54,6 +54,61 @@ void mme_state_operational(mme_sm_t *s, event_t *e)
             }
             break;
         }
+        case EVT_LO_ENB_S1_ACCEPT:
+        {
+            int rc;
+
+            net_sock_t *sock = (net_sock_t *)event_get_param1(e);
+            d_assert(sock, break, "Null param");
+
+            c_uint32_t ip_addr = sock->remote.sin_addr.s_addr;
+
+            d_trace(1, "eNB-S1 accepted[%s] in master_sm module\n", 
+                INET_NTOP(&sock->remote.sin_addr.s_addr, buf));
+                    
+            enb_ctx_t *enb = enb_ctx_find_by_ip(ip_addr);
+            if (!enb)
+            {
+                rc = net_register_sock(sock, _s1_recv_cb, (void*)s->queue_id);
+                d_assert(rc == 0, break, "register _s1_recv_cb failed");
+
+                enb_ctx_t *enb = enb_ctx_add();
+                d_assert(enb, break, "Null param");
+                enb->ip = sock->remote.sin_addr.s_addr;
+                enb->s1_sock = sock;
+
+                fsm_create((fsm_t*)&enb->s1_sm, 
+                        enb_s1_state_initial, enb_s1_state_final);
+                enb->s1_sm.ctx = enb;
+                enb->s1_sm.queue_id = s->queue_id;
+                enb->s1_sm.tm_service = s->tm_service;
+                fsm_init((fsm_t*)&enb->s1_sm, 0);
+            }
+            else
+            {
+                d_warn("eNB context duplicated with IP-address [%s]!!!", 
+                        INET_NTOP(&ip_addr, buf));
+                net_close(sock);
+                d_warn("S1 Socket Closed");
+            }
+            
+            break;
+        }
+        case EVT_S1_ENB_INF:
+        {
+            c_uint32_t ip_addr = event_get_msg_ip_addr(e);
+            enb_ctx_t *enb = enb_ctx_find_by_ip(ip_addr);
+            if (enb)
+            {
+                fsm_dispatch((fsm_t*)&enb->s1_sm, (fsm_event_t*)e);
+            }
+            else
+            {
+                d_error("eNB context is not created[%s]",
+                        INET_NTOP(&ip_addr, buf));
+            }
+            break;
+        }
         case EVT_LO_ENB_S1_CONNREFUSED:
         {
             net_sock_t *sock = (net_sock_t *)event_get_param1(e);

src/s1_path.c

@@ -84,35 +84,32 @@ static int _s1_accept_cb(net_sock_t *net_sock, void *data)
     return r;
 }
 
-static status_t s1_recv(net_sock_t *net_sock, pkbuf_t *pkb, 
-        msgq_id queue_id, event_e event)
+static status_t s1_recv(net_sock_t *net_sock, pkbuf_t *pkb, msgq_id queue_id)
 {
     event_t e;
 
     d_assert(net_sock, return CORE_ERROR, "Null param");
     d_assert(pkb, return CORE_ERROR, "Null param");
-    d_assert(event == EVT_S1_ENB_INF, 
-            return CORE_ERROR, "Invalid event = %d", event);
     d_assert(queue_id, return -1, "Null param");
 
     d_trace(1, "S1AP_PDU is received from eNB-Inf\n");
     d_trace_hex(1, pkb->payload, pkb->len);
 
-    event_set(&e, event, 0);
+    event_set(&e, EVT_S1_ENB_INF, 0);
     event_set_msg(&e, pkb, net_sock->remote.sin_addr.s_addr);
 
     return event_send(queue_id, &e);
 }
 
-int _s1_recv_cb(net_sock_t *net_sock, msgq_id queue_id, event_e event)
+int _s1_recv_cb(net_sock_t *net_sock, void *data)
 {
     status_t rv;
     pkbuf_t *pkb;
     ssize_t r;
     c_uint32_t ip_addr = net_sock->remote.sin_addr.s_addr;
+    msgq_id queue_id = (msgq_id)data;
 
     d_assert(net_sock, return -1, "Null param");
-    d_assert(event, return -1, "Null param");
     d_assert(queue_id, return -1, "Null param");
 
     pkb = pkbuf_alloc(0, MAX_S1_PKBUF_SIZE);
@@ -129,25 +126,23 @@ int _s1_recv_cb(net_sock_t *net_sock, msgq_id queue_id, event_e event)
 
         if (net_sock->sndrcv_errno == EAGAIN)
         {
-            d_warn("net_read(event:%d) failed(%d:%s)", event, 
+            d_warn("net_read failed(%d:%s)",
                     net_sock->sndrcv_errno, strerror(net_sock->sndrcv_errno));
             return 0;
         } 
         else if (net_sock->sndrcv_errno == ECONNREFUSED)
         {
-            d_warn("net_read(event:%d) failed(%d:%s)", event, 
+            d_warn("net_read failed(%d:%s)",
                     net_sock->sndrcv_errno, strerror(net_sock->sndrcv_errno));
         }
         else
         {
-            d_error("net_read(event:%d) failed(%d:%s)", event, 
+            d_error("net_read failed(%d:%s)",
                     net_sock->sndrcv_errno, strerror(net_sock->sndrcv_errno));
         }
 
         event_t e;
 
-        d_assert(event == EVT_S1_ENB_INF, return -1, 
-                "Invalid event = %d", event);
         event_set(&e, EVT_LO_ENB_S1_CONNREFUSED, (c_uintptr_t)net_sock);
         event_set_param2(&e, (c_uintptr_t)ip_addr);
         event_send(queue_id, &e);
@@ -158,7 +153,7 @@ int _s1_recv_cb(net_sock_t *net_sock, msgq_id queue_id, event_e event)
     {
         pkb->len = r;
 
-        rv = s1_recv(net_sock, pkb, queue_id, event);
+        rv = s1_recv(net_sock, pkb, queue_id);
         if (rv == CORE_ERROR)
         {
             pkbuf_free(pkb);

src/s1_path.h

@@ -17,7 +17,7 @@ CORE_DECLARE(status_t) s1_close();
 CORE_DECLARE(status_t) s1_send(net_sock_t *s, pkbuf_t *pkb);
 CORE_DECLARE(status_t) s1_send_to_enb(enb_ctx_t *enb, pkbuf_t *pkb);
 
-int _s1_recv_cb(net_sock_t *net_sock, msgq_id queue_id, event_e event);
+int _s1_recv_cb(net_sock_t *net_sock, void *data);
 
 #ifdef __cplusplus
 }