enb->addr is changes to pointer

src/mme/mme_context.c

@@ -1031,7 +1031,10 @@ status_t mme_enb_remove(mme_enb_t *enb)
 
     enb_ue_remove_in_enb(enb);
 
-    s1ap_sctp_close(enb->sock);
+    sock_delete(enb->sock);
+#if USE_USRSCTP == 1
+    core_free(enb->addr);
+#endif
 
     index_free(&mme_enb_pool, enb);
 

src/mme/mme_context.h

@@ -113,7 +113,7 @@ typedef struct _mme_enb_t {
 
     c_uint32_t      enb_id;     /* eNB_ID received from eNB */
     sock_id         sock;       /* eNB S1AP Socket */
-    c_sockaddr_t    addr;       /* eNB S1AP Address */
+    c_sockaddr_t    *addr;      /* eNB S1AP Address */
 
     c_uint8_t       num_of_tai;
     tai_t           tai[MAX_NUM_OF_TAC * MAX_NUM_OF_BPLMN];

src/mme/mme_sm.c

@@ -98,22 +98,16 @@ void mme_state_operational(fsm_t *s, event_t *e)
 
                 mme_enb_t *enb = mme_enb_add(sock);
                 d_assert(enb, break, "Null param");
-                memcpy(&enb->addr, addr, sizeof(c_sockaddr_t));
+                enb->addr = addr;
             }
             else
             {
                 d_warn("eNB context duplicated with IP-address [%s]!!!", 
                         CORE_NTOP(addr, buf));
-#if USE_USRSCTP != 1
                 sock_delete(sock);
-#endif
                 d_warn("S1 Socket Closed");
             }
 
-#if USE_USRSCTP == 1
-            core_free(addr);
-#endif
-            
             break;
         }
         case MME_EVT_S1AP_LO_CONNREFUSED:

src/mme/s1ap_build.c

@@ -143,7 +143,7 @@ status_t s1ap_build_downlink_nas_transport(
     d_trace(3, "[S1AP] downlinkNASTransport : "
             "UE[eNB-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
+            CORE_NTOP(enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
 
     return CORE_OK;
 }
@@ -302,7 +302,7 @@ status_t s1ap_build_initial_context_setup_request(
     d_trace(3, "[S1AP] Initial Context Setup Request : "
             "UE[eNB-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
+            CORE_NTOP(enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
 
     if (emmbuf && emmbuf->len)
     {
@@ -402,7 +402,7 @@ status_t s1ap_build_e_rab_setup_request(
     d_trace(3, "[S1AP] E-RAB Setup Request : "
             "UE[eNB-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
+            CORE_NTOP(enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
 
     pkbuf_free(esmbuf);
 
@@ -470,7 +470,7 @@ status_t s1ap_build_e_rab_release_command(pkbuf_t **s1apbuf,
     d_trace(3, "[S1AP] E-RAB Release Command : "
             "UE[eNB-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
+            CORE_NTOP(enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
 
     pkbuf_free(esmbuf);
 
@@ -526,7 +526,7 @@ status_t s1ap_build_ue_context_release_commmand(
     d_trace(3, "[S1AP] UE Context Release Command : "
             "UE[mME-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             enb_ue->mme_ue_s1ap_id,
-            CORE_NTOP(&enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
+            CORE_NTOP(enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
 
     return CORE_OK;
 }
@@ -633,7 +633,7 @@ status_t s1ap_build_path_switch_ack(pkbuf_t **s1apbuf, mme_ue_t *mme_ue)
     d_trace(3, "[S1AP] Path Switch Ack : "
             "UE[mME-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             enb_ue->mme_ue_s1ap_id,
-            CORE_NTOP(&enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
+            CORE_NTOP(enb_ue->enb->addr, buf), enb_ue->enb->enb_id);
 
     return CORE_OK;
 }
@@ -946,7 +946,7 @@ status_t s1ap_build_handover_request(
     d_trace(3, "[S1AP] Handover Request : ",
             "UE[mME-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             target_ue->mme_ue_s1ap_id,
-            CORE_NTOP(&target_ue->enb->addr, buf), target_ue->enb->enb_id);
+            CORE_NTOP(target_ue->enb->addr, buf), target_ue->enb->enb_id);
 
     return CORE_OK;
 }
@@ -1030,7 +1030,7 @@ status_t s1ap_build_mme_status_transfer(pkbuf_t **s1apbuf,
     d_trace(3, "[S1AP] MME Status Transfer : ",
             "UE[mME-UE-S1AP-ID(%d)] <-- eNB[%s:%d]\n",
             target_ue->mme_ue_s1ap_id,
-            CORE_NTOP(&target_ue->enb->addr, buf), target_ue->enb->enb_id);
+            CORE_NTOP(target_ue->enb->addr, buf), target_ue->enb->enb_id);
 
     return CORE_OK;
 }

src/mme/s1ap_handler.c

@@ -66,7 +66,7 @@ void s1ap_handle_s1_setup_request(mme_enb_t *enb, s1ap_message_t *message)
 
     d_assert(enb->sock, return,);
     d_trace(3, "[S1AP] S1SetupRequest : eNB[%s:%d] --> MME\n",
-        CORE_NTOP(&enb->addr, buf), enb_id);
+        CORE_NTOP(enb->addr, buf), enb_id);
 
     d_assert(mme_enb_set_enb_id(enb, enb_id) == CORE_OK,
             return, "hash add error");
@@ -77,7 +77,7 @@ void s1ap_handle_s1_setup_request(mme_enb_t *enb, s1ap_message_t *message)
 
     d_assert(enb->sock, return,);
     d_trace(3, "[S1AP] S1SetupResponse: eNB[%s:%d] <-- MME\n",
-        CORE_NTOP(&enb->addr, buf), enb_id);
+        CORE_NTOP(enb->addr, buf), enb_id);
 }
 
 void s1ap_handle_initial_ue_message(mme_enb_t *enb, s1ap_message_t *message)
@@ -166,7 +166,7 @@ void s1ap_handle_initial_ue_message(mme_enb_t *enb, s1ap_message_t *message)
     d_trace(3, "[S1AP] InitialUEMessage : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     d_assert(s1ap_send_to_nas(enb_ue, &ies->nas_pdu) == CORE_OK,,
             "s1ap_send_to_nas failed");
@@ -189,7 +189,7 @@ void s1ap_handle_uplink_nas_transport(
     d_trace(3, "[S1AP] uplinkNASTransport : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     d_assert(s1ap_send_to_nas(enb_ue, &ies->nas_pdu) == CORE_OK,,
             "s1ap_send_to_nas failed");
@@ -242,7 +242,7 @@ void s1ap_handle_ue_capability_info_indication(
     d_trace(3, "[S1AP] UE Capability Info Indication : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 }
 
 void s1ap_handle_initial_context_setup_response(
@@ -267,7 +267,7 @@ void s1ap_handle_initial_context_setup_response(
     d_trace(3, "[S1AP] Initial Context Setup Response : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     for (i = 0; i < ies->e_RABSetupListCtxtSURes.
             s1ap_E_RABSetupItemCtxtSURes.count; i++)
@@ -327,7 +327,7 @@ void s1ap_handle_e_rab_setup_response(
     d_trace(3, "[S1AP] E-RAB Setup Response : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     for (i = 0; i < ies->e_RABSetupListBearerSURes.
             s1ap_E_RABSetupItemBearerSURes.count; i++)
@@ -388,7 +388,7 @@ void s1ap_handle_ue_context_release_request(
     d_trace(3, "[S1AP] UE Context Release Request : "
             "UE[mME-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->mme_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     switch(ies->cause.present)
     {
@@ -466,7 +466,7 @@ void s1ap_handle_ue_context_release_complete(
     d_trace(3, "[S1AP] UE Context Release Complete : "
             "UE[mME-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->mme_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     enb_ue_remove(enb_ue);
 
@@ -593,7 +593,7 @@ void s1ap_handle_path_switch_request(
     {
         d_error("Cannot find UE from sourceMME-UE-S1AP-ID[%d] and eNB[%s:%d]",
                 ies->sourceMME_UE_S1AP_ID,
-                CORE_NTOP(&enb->addr, buf), enb->enb_id);
+                CORE_NTOP(enb->addr, buf), enb->enb_id);
 
         cause.present = S1ap_Cause_PR_radioNetwork;
         cause.choice.radioNetwork = 
@@ -675,7 +675,7 @@ void s1ap_handle_path_switch_request(
     d_trace(3, "[S1AP] PathSwitchRequest : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             enb_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 }
 
 void s1ap_handle_handover_required(mme_enb_t *enb, s1ap_message_t *message)
@@ -697,7 +697,7 @@ void s1ap_handle_handover_required(mme_enb_t *enb, s1ap_message_t *message)
     d_assert(source_ue, return,
             "Cannot find UE for eNB-UE-S1AP-ID[%d] and eNB[%s:%d]",
             ies->eNB_UE_S1AP_ID,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
     d_assert(source_ue->mme_ue_s1ap_id == ies->mme_ue_s1ap_id, return,
             "Conflict MME-UE-S1AP-ID : %d != %d\n",
             source_ue->mme_ue_s1ap_id, ies->mme_ue_s1ap_id);
@@ -726,7 +726,7 @@ void s1ap_handle_handover_required(mme_enb_t *enb, s1ap_message_t *message)
     d_trace(3, "[S1AP] Handover Required : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             source_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 }
 
 void s1ap_handle_handover_request_ack(mme_enb_t *enb, s1ap_message_t *message)
@@ -750,7 +750,7 @@ void s1ap_handle_handover_request_ack(mme_enb_t *enb, s1ap_message_t *message)
     d_assert(target_ue, return,
             "Cannot find UE for MME-UE-S1AP-ID[%d] and eNB[%s:%d]",
             ies->mme_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     target_ue->enb_ue_s1ap_id = ies->eNB_UE_S1AP_ID;
 
@@ -819,7 +819,7 @@ void s1ap_handle_handover_request_ack(mme_enb_t *enb, s1ap_message_t *message)
     d_trace(3, "[S1AP] Handover Request Ack : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             target_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 }
 
 void s1ap_handle_handover_failure(mme_enb_t *enb, s1ap_message_t *message)
@@ -841,7 +841,7 @@ void s1ap_handle_handover_failure(mme_enb_t *enb, s1ap_message_t *message)
     d_assert(target_ue, return,
             "Cannot find UE for MME-UE-S1AP-ID[%d] and eNB[%s:%d]",
             ies->mme_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 
     source_ue = target_ue->source_ue;
     d_assert(source_ue, return,);
@@ -857,7 +857,7 @@ void s1ap_handle_handover_failure(mme_enb_t *enb, s1ap_message_t *message)
     d_trace(3, "[S1AP] Handover Failure : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             target_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 }
 
 void s1ap_handle_handover_cancel(mme_enb_t *enb, s1ap_message_t *message)
@@ -880,7 +880,7 @@ void s1ap_handle_handover_cancel(mme_enb_t *enb, s1ap_message_t *message)
     d_assert(source_ue, return,
             "Cannot find UE for eNB-UE-S1AP-ID[%d] and eNB[%s:%d]",
             ies->eNB_UE_S1AP_ID,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
     d_assert(source_ue->mme_ue_s1ap_id == ies->mme_ue_s1ap_id, return,
             "Conflict MME-UE-S1AP-ID : %d != %d\n",
             source_ue->mme_ue_s1ap_id, ies->mme_ue_s1ap_id);
@@ -900,7 +900,7 @@ void s1ap_handle_handover_cancel(mme_enb_t *enb, s1ap_message_t *message)
     d_trace(3, "[S1AP] Handover Cancel : "
             "UE[eNB-UE-S1AP-ID(%d)] --> eNB[%s:%d]\n",
             source_ue->enb_ue_s1ap_id,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
 }
 
 void s1ap_handle_enb_status_transfer(mme_enb_t *enb, s1ap_message_t *message)
@@ -921,7 +921,7 @@ void s1ap_handle_enb_status_transfer(mme_enb_t *enb, s1ap_message_t *message)
     d_assert(source_ue, return,
             "Cannot find UE for eNB-UE-S1AP-ID[%d] and eNB[%s:%d]",
             ies->eNB_UE_S1AP_ID,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
     d_assert(source_ue->mme_ue_s1ap_id == ies->mme_ue_s1ap_id, return,
             "Conflict MME-UE-S1AP-ID : %d != %d\n",
             source_ue->mme_ue_s1ap_id, ies->mme_ue_s1ap_id);
@@ -974,7 +974,7 @@ void s1ap_handle_handover_notification(mme_enb_t *enb, s1ap_message_t *message)
     d_assert(target_ue, return,
             "Cannot find UE for eNB-UE-S1AP-ID[%d] and eNB[%s:%d]",
             ies->eNB_UE_S1AP_ID,
-            CORE_NTOP(&enb->addr, buf), enb->enb_id);
+            CORE_NTOP(enb->addr, buf), enb->enb_id);
     d_assert(target_ue->mme_ue_s1ap_id == ies->mme_ue_s1ap_id, return,
             "Conflict MME-UE-S1AP-ID : %d != %d\n",
             target_ue->mme_ue_s1ap_id, ies->mme_ue_s1ap_id);

src/mme/s1ap_path.h

@@ -16,8 +16,6 @@ extern "C" {
 CORE_DECLARE(status_t) s1ap_open();
 CORE_DECLARE(status_t) s1ap_close();
 
-CORE_DECLARE(status_t) s1ap_sctp_close(sock_id sock);
-
 CORE_DECLARE(status_t) s1ap_final();
 
 CORE_DECLARE(status_t) s1ap_send(sock_id sock, pkbuf_t *pkb);

src/mme/s1ap_sctp.c

@@ -44,19 +44,12 @@ status_t s1ap_open(void)
 
 status_t s1ap_close()
 {
-    s1ap_sctp_close(mme_self()->s1ap_sock);
+    sock_delete(mme_self()->s1ap_sock);
     mme_self()->s1ap_sock = 0;
 
     return CORE_OK;
 }
 
-status_t s1ap_sctp_close(sock_id sock)
-{
-    sock_delete(sock);
-
-    return CORE_OK;
-}
-
 status_t s1ap_final()
 {
     return CORE_OK;

src/mme/s1ap_usrsctp.c

@@ -20,7 +20,6 @@
 
 #define LOCAL_UDP_PORT  9899
 
-static void handle_notification(union sctp_notification *notif, size_t n);
 static int s1ap_usrsctp_recv_cb(struct socket *sock,
         union sctp_sockstore addr, void *data, size_t datalen,
         struct sctp_rcvinfo rcv, int flags, void *ulp_info);
@@ -148,7 +147,7 @@ status_t s1ap_close()
     return CORE_OK;
 }
 
-status_t s1ap_sctp_close(sock_id sock)
+status_t sock_delete(sock_id sock)
 {
     usrsctp_close((struct socket *)sock);
     return CORE_OK;
@@ -187,26 +186,23 @@ static void *THREAD_FUNC accept_main(thread_id id, void *data)
     event_t e;
 
     struct socket *sock = NULL;
-    c_sockaddr_t addr, *paddr = NULL;
+    c_sockaddr_t *addr = NULL;
     socklen_t addrlen = sizeof(struct sockaddr_storage);
 
     while (!accept_thread_should_stop)
     {
-        memset(&addr, 0, sizeof(c_sockaddr_t));
+        addr = core_calloc(1, sizeof(c_sockaddr_t));
         if ((sock = usrsctp_accept((struct socket *)mme_self()->s1ap_sock,
-                    &addr.sa, &addrlen)) == NULL)
+                    &addr->sa, &addrlen)) == NULL)
         {
             d_error("usrsctp_accept failed");
+            core_free(addr);
             continue;
         }
 
-        paddr = core_calloc(1, sizeof(c_sockaddr_t));
-        d_assert(paddr, return NULL,);
-        memcpy(paddr, &addr, sizeof(c_sockaddr_t));
-
         event_set(&e, MME_EVT_S1AP_LO_ACCEPT);
         event_set_param1(&e, (c_uintptr_t)sock);
-        event_set_param2(&e, (c_uintptr_t)paddr);
+        event_set_param2(&e, (c_uintptr_t)addr);
         mme_event_send(&e);
     }
 
@@ -219,16 +215,63 @@ static int s1ap_usrsctp_recv_cb(struct socket *sock,
 {
     if (data)
     {
+        event_t e;
+
+#undef MSG_NOTIFICATION
+#define MSG_NOTIFICATION 0x2000
         if (flags & MSG_NOTIFICATION)
         {
-            handle_notification((union sctp_notification *)data, datalen);
+            union sctp_notification *not = (union sctp_notification *)data;
+            if (not->sn_header.sn_length == (c_uint32_t)datalen)
+            {
+                switch(not->sn_header.sn_type) 
+                {
+                    case SCTP_ASSOC_CHANGE :
+                        d_trace(3, "SCTP_ASSOC_CHANGE"
+                                "(type:0x%x, flags:0x%x, state:0x%x)\n", 
+                                not->sn_assoc_change.sac_type,
+                                not->sn_assoc_change.sac_flags,
+                                not->sn_assoc_change.sac_state);
+
+                        if (not->sn_assoc_change.sac_state == 
+                                SCTP_SHUTDOWN_COMP ||
+                            not->sn_assoc_change.sac_state == 
+                                SCTP_COMM_LOST)
+                        {
+                            event_set(&e, MME_EVT_S1AP_LO_CONNREFUSED);
+                            event_set_param1(&e, (c_uintptr_t)sock);
+                            mme_event_send(&e);
+                            break;
                         }
-        else
+
+                        if (not->sn_assoc_change.sac_state == SCTP_COMM_UP)
+                            d_trace(3, "SCTP_COMM_UP\n");
+
+                        break;
+                    case SCTP_PEER_ADDR_CHANGE:
+                        break;
+                    case SCTP_SEND_FAILED :
+                        d_error("SCTP_SEND_FAILED"
+                                "(type:0x%x, flags:0x%x, error:0x%x)\n", 
+                                not->sn_send_failed_event.ssfe_type,
+                                not->sn_send_failed_event.ssfe_flags,
+                                not->sn_send_failed_event.ssfe_error);
+                        break;
+                    case SCTP_SHUTDOWN_EVENT :
+                        event_set(&e, MME_EVT_S1AP_LO_CONNREFUSED);
+                        event_set_param1(&e, (c_uintptr_t)sock);
+                        mme_event_send(&e);
+                        break;
+                    default :
+                        d_error("Discarding event with unknown "
+                                "flags = 0x%x, type 0x%x", 
+                                flags, not->sn_header.sn_type);
+                        break;
+                }
+            }
+        }
+        else if (flags & MSG_EOR)
         {
-            c_uint32_t ppid = ntohl(rcv.rcv_ppid);
-            if ((flags & MSG_EOR) && ppid == SCTP_S1AP_PPID)
-            {
-                event_t e;
             pkbuf_t *pkbuf;
 
             pkbuf = pkbuf_alloc(0, MAX_SDU_LEN);
@@ -244,216 +287,13 @@ static int s1ap_usrsctp_recv_cb(struct socket *sock,
         }
         else
         {
-                d_warn("Unknwon PPID(%d) for data length(%ld)\n",
+            d_error("Not engough buffer. Need more recv : 0x%x", flags);
-                        ppid, datalen);
-            }
         }
         free(data);
     }
     return (1);
 }
 
-
-static void
-handle_association_change_event(struct sctp_assoc_change *sac)
-{
-    unsigned int i, n;
-
-    printf("Association change ");
-    switch (sac->sac_state) {
-    case SCTP_COMM_UP:
-        printf("SCTP_COMM_UP");
-        break;
-    case SCTP_COMM_LOST:
-        printf("SCTP_COMM_LOST");
-        break;
-    case SCTP_RESTART:
-        printf("SCTP_RESTART");
-        break;
-    case SCTP_SHUTDOWN_COMP:
-        printf("SCTP_SHUTDOWN_COMP");
-        break;
-    case SCTP_CANT_STR_ASSOC:
-        printf("SCTP_CANT_STR_ASSOC");
-        break;
-    default:
-        printf("UNKNOWN");
-        break;
-    }
-    printf(", streams (in/out) = (%u/%u)",
-           sac->sac_inbound_streams, sac->sac_outbound_streams);
-    n = sac->sac_length - sizeof(struct sctp_assoc_change);
-    if (((sac->sac_state == SCTP_COMM_UP) ||
-         (sac->sac_state == SCTP_RESTART)) && (n > 0)) {
-        printf(", supports");
-        for (i = 0; i < n; i++) {
-            switch (sac->sac_info[i]) {
-            case SCTP_ASSOC_SUPPORTS_PR:
-                printf(" PR");
-                break;
-            case SCTP_ASSOC_SUPPORTS_AUTH:
-                printf(" AUTH");
-                break;
-            case SCTP_ASSOC_SUPPORTS_ASCONF:
-                printf(" ASCONF");
-                break;
-            case SCTP_ASSOC_SUPPORTS_MULTIBUF:
-                printf(" MULTIBUF");
-                break;
-            case SCTP_ASSOC_SUPPORTS_RE_CONFIG:
-                printf(" RE-CONFIG");
-                break;
-            default:
-                printf(" UNKNOWN(0x%02x)", sac->sac_info[i]);
-                break;
-            }
-        }
-    } else if (((sac->sac_state == SCTP_COMM_LOST) ||
-                (sac->sac_state == SCTP_CANT_STR_ASSOC)) && (n > 0)) {
-        printf(", ABORT =");
-        for (i = 0; i < n; i++) {
-            printf(" 0x%02x", sac->sac_info[i]);
-        }
-    }
-    printf(".\n");
-    if ((sac->sac_state == SCTP_CANT_STR_ASSOC) ||
-        (sac->sac_state == SCTP_SHUTDOWN_COMP) ||
-        (sac->sac_state == SCTP_COMM_LOST)) {
-        exit(0);
-    }
-    return;
-}
-
-static void
-handle_peer_address_change_event(struct sctp_paddr_change *spc)
-{
-    char addr_buf[INET6_ADDRSTRLEN];
-    const char *addr;
-    struct sockaddr_in *sin;
-    struct sockaddr_in6 *sin6;
-    struct sockaddr_conn *sconn;
-
-    switch (spc->spc_aaddr.ss_family) {
-    case AF_INET:
-        sin = (struct sockaddr_in *)&spc->spc_aaddr;
-        addr = inet_ntop(AF_INET, &sin->sin_addr, addr_buf, INET_ADDRSTRLEN);
-        break;
-    case AF_INET6:
-        sin6 = (struct sockaddr_in6 *)&spc->spc_aaddr;
-        addr = inet_ntop(AF_INET6, &sin6->sin6_addr, addr_buf, INET6_ADDRSTRLEN);
-        break;
-    case AF_CONN:
-        sconn = (struct sockaddr_conn *)&spc->spc_aaddr;
-#ifdef _WIN32
-        _snprintf(addr_buf, INET6_ADDRSTRLEN, "%p", sconn->sconn_addr);
-#else
-        snprintf(addr_buf, INET6_ADDRSTRLEN, "%p", sconn->sconn_addr);
-#endif
-        addr = addr_buf;
-        break;
-    default:
-#ifdef _WIN32
-        _snprintf(addr_buf, INET6_ADDRSTRLEN, "Unknown family %d", spc->spc_aaddr.ss_family);
-#else
-        snprintf(addr_buf, INET6_ADDRSTRLEN, "Unknown family %d", spc->spc_aaddr.ss_family);
-#endif
-        addr = addr_buf;
-        break;
-    }
-    printf("Peer address %s is now ", addr);
-    switch (spc->spc_state) {
-    case SCTP_ADDR_AVAILABLE:
-        printf("SCTP_ADDR_AVAILABLE");
-        break;
-    case SCTP_ADDR_UNREACHABLE:
-        printf("SCTP_ADDR_UNREACHABLE");
-        break;
-    case SCTP_ADDR_REMOVED:
-        printf("SCTP_ADDR_REMOVED");
-        break;
-    case SCTP_ADDR_ADDED:
-        printf("SCTP_ADDR_ADDED");
-        break;
-    case SCTP_ADDR_MADE_PRIM:
-        printf("SCTP_ADDR_MADE_PRIM");
-        break;
-    case SCTP_ADDR_CONFIRMED:
-        printf("SCTP_ADDR_CONFIRMED");
-        break;
-    default:
-        printf("UNKNOWN");
-        break;
-    }
-    printf(" (error = 0x%08x).\n", spc->spc_error);
-    return;
-}
-
-static void
-handle_send_failed_event(struct sctp_send_failed_event *ssfe)
-{
-    size_t i, n;
-
-    if (ssfe->ssfe_flags & SCTP_DATA_UNSENT) {
-        printf("Unsent ");
-    }
-    if (ssfe->ssfe_flags & SCTP_DATA_SENT) {
-        printf("Sent ");
-    }
-    if (ssfe->ssfe_flags & ~(SCTP_DATA_SENT | SCTP_DATA_UNSENT)) {
-        printf("(flags = %x) ", ssfe->ssfe_flags);
-    }
-    printf("message with PPID = %u, SID = %u, flags: 0x%04x due to error = 0x%08x",
-           ntohl(ssfe->ssfe_info.snd_ppid), ssfe->ssfe_info.snd_sid,
-           ssfe->ssfe_info.snd_flags, ssfe->ssfe_error);
-    n = ssfe->ssfe_length - sizeof(struct sctp_send_failed_event);
-    for (i = 0; i < n; i++) {
-        printf(" 0x%02x", ssfe->ssfe_data[i]);
-    }
-    printf(".\n");
-    return;
-}
-
-static void
-handle_notification(union sctp_notification *notif, size_t n)
-{
-    if (notif->sn_header.sn_length != (uint32_t)n) {
-        return;
-    }
-    switch (notif->sn_header.sn_type) {
-    case SCTP_ASSOC_CHANGE:
-        handle_association_change_event(&(notif->sn_assoc_change));
-        break;
-    case SCTP_PEER_ADDR_CHANGE:
-        handle_peer_address_change_event(&(notif->sn_paddr_change));
-        break;
-    case SCTP_REMOTE_ERROR:
-        break;
-    case SCTP_SHUTDOWN_EVENT:
-        break;
-    case SCTP_ADAPTATION_INDICATION:
-        break;
-    case SCTP_PARTIAL_DELIVERY_EVENT:
-        break;
-    case SCTP_AUTHENTICATION_EVENT:
-        break;
-    case SCTP_SENDER_DRY_EVENT:
-        break;
-    case SCTP_NOTIFICATIONS_STOPPED_EVENT:
-        break;
-    case SCTP_SEND_FAILED_EVENT:
-        handle_send_failed_event(&(notif->sn_send_failed_event));
-        break;
-    case SCTP_STREAM_RESET_EVENT:
-        break;
-    case SCTP_ASSOC_RESET_EVENT:
-        break;
-    case SCTP_STREAM_CHANGE_EVENT:
-        break;
-    default:
-        break;
-    }
-}
-
 static void debug_printf(const char *format, ...)
 {
     va_list ap;

test/testusrsctp.c

@@ -93,25 +93,19 @@ int tests1ap_enb_read(sock_id id, pkbuf_t *recvbuf)
         n = usrsctp_recvv(psock, recvbuf->payload, MAX_SDU_LEN,
                 (struct sockaddr *)&addr, &from_len, (void *)&rcv_info,
                 &infolen, &infotype, &flags);
-        if (n > 0) {
+        if (n > 0)
+        {
             if (flags & MSG_NOTIFICATION)
             {
                 /* Nothing to do */
             }
-            else
+            else if (flags & MSG_EOR)
-            {
-                c_uint32_t ppid = ntohl(rcv_info.rcv_ppid);
-                if ((flags & MSG_EOR) && ppid == SCTP_S1AP_PPID)
-                {
-                    if (n > 0)
             {
                 rc = n;
                 break;
             }
         }
     }
-        }
-    }
 
     return rc;
 }