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

all remove core_net.h

This commit is contained in:
Sukchan Lee 2017-11-24 11:49:37 +09:00
parent 685272fce8
commit 6412231f29
11 changed files with 193 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
src/mme/mme_context.c
View File

@ -48,7 +48,8 @@ status_t mme_context_init()
index_init(&mme_sess_pool, MAX_POOL_OF_SESS);
index_init(&mme_bearer_pool, MAX_POOL_OF_BEARER);
self.s1ap_sock_hash = hash_make();
self.enb_sock_hash = hash_make();
self.enb_addr_hash = hash_make();
self.enb_id_hash = hash_make();
self.mme_ue_s1ap_id_hash = hash_make();
self.imsi_ue_hash = hash_make();
@ -71,8 +72,10 @@ status_t mme_context_final()
mme_enb_remove_all();
mme_ue_remove_all();
d_assert(self.s1ap_sock_hash, , "Null param");
hash_destroy(self.s1ap_sock_hash);
d_assert(self.enb_sock_hash, , "Null param");
hash_destroy(self.enb_sock_hash);
d_assert(self.enb_addr_hash, , "Null param");
hash_destroy(self.enb_addr_hash);
d_assert(self.enb_id_hash, , "Null param");
hash_destroy(self.enb_id_hash);
@ -993,20 +996,26 @@ mme_sgw_t* mme_sgw_next(mme_sgw_t *sgw)
return list_next(sgw);
}
mme_enb_t* mme_enb_add(sock_id sock)
mme_enb_t* mme_enb_add(sock_id sock, c_sockaddr_t *addr)
{
mme_enb_t *enb = NULL;
event_t e;
d_assert(sock, return NULL,);
d_assert(addr, return NULL,);
index_alloc(&mme_enb_pool, &enb);
d_assert(enb, return NULL, "Null param");
enb->sock = sock;
enb->addr = addr;
list_init(&enb->enb_ue_list);
hash_set(self.s1ap_sock_hash, &enb->sock, sizeof(enb->sock), enb);
hash_set(self.enb_sock_hash, &enb->sock, sizeof(enb->sock), enb);
hash_set(self.enb_addr_hash, enb->addr, sizeof(c_sockaddr_t), enb);
event_set_param1(&e, (c_uintptr_t)enb->sock);
event_set_param1(&e, (c_uintptr_t)enb->index);
fsm_create(&enb->sm, s1ap_state_initial, s1ap_state_final);
fsm_init(&enb->sm, &e);
@ -1020,21 +1029,20 @@ status_t mme_enb_remove(mme_enb_t *enb)
d_assert(enb, return CORE_ERROR, "Null param");
d_assert(enb->sock, return CORE_ERROR, "Null param");
event_set_param1(&e, (c_uintptr_t)enb->sock);
event_set_param1(&e, (c_uintptr_t)enb->index);
fsm_final(&enb->sm, &e);
fsm_clear(&enb->sm);
hash_set(self.s1ap_sock_hash,
&enb->sock, sizeof(enb->sock), NULL);
hash_set(self.enb_sock_hash, &enb->sock, sizeof(enb->sock), NULL);
hash_set(self.enb_addr_hash, enb->addr, sizeof(c_sockaddr_t), NULL);
if (enb->enb_id)
hash_set(self.enb_id_hash, &enb->enb_id, sizeof(enb->enb_id), NULL);
enb_ue_remove_in_enb(enb);
sock_delete(enb->sock);
#if USE_USRSCTP == 1
if (mme_enb_sock_is_stream(enb->sock))
s1ap_sctp_delete(enb->sock);
core_free(enb->addr);
#endif
index_free(&mme_enb_pool, enb);
@ -1064,7 +1072,16 @@ mme_enb_t* mme_enb_find(index_t index)
mme_enb_t* mme_enb_find_by_sock(sock_id sock)
{
d_assert(sock, return NULL,"Invalid param");
return (mme_enb_t *)hash_get(self.s1ap_sock_hash, &sock, sizeof(sock));
return (mme_enb_t *)hash_get(self.enb_sock_hash, &sock, sizeof(sock));
return NULL;
}
mme_enb_t* mme_enb_find_by_addr(c_sockaddr_t *addr)
{
d_assert(addr, return NULL,"Invalid param");
return (mme_enb_t *)hash_get(self.enb_addr_hash,
addr, sizeof(c_sockaddr_t));
return NULL;
}
@ -1088,8 +1105,8 @@ status_t mme_enb_set_enb_id(mme_enb_t *enb, c_uint32_t enb_id)
hash_index_t* mme_enb_first()
{
d_assert(self.s1ap_sock_hash, return NULL, "Null param");
return hash_first(self.s1ap_sock_hash);
d_assert(self.enb_sock_hash, return NULL, "Null param");
return hash_first(self.enb_sock_hash);
}
hash_index_t* mme_enb_next(hash_index_t *hi)
@ -1103,6 +1120,13 @@ mme_enb_t *mme_enb_this(hash_index_t *hi)
return hash_this_val(hi);
}
int mme_enb_sock_is_stream(sock_id sock)
{
d_assert(sock, return 0,);
return (mme_self()->s1ap_sock != sock);
}
/** enb_ue_context handling function */
enb_ue_t* enb_ue_add(mme_enb_t *enb)
{

7
src/mme/mme_context.h
View File

@ -99,7 +99,8 @@ typedef struct _mme_context_t {
list_t sgw_list; /* SGW GTP Node List */
hash_t *s1ap_sock_hash; /* hash table for S1AP IP address */
hash_t *enb_sock_hash; /* hash table for ENB Socket */
hash_t *enb_addr_hash; /* hash table for ENB Address */
hash_t *enb_id_hash; /* hash table for ENB-ID */
hash_t *mme_ue_s1ap_id_hash; /* hash table for MME-UE-S1AP-ID */
hash_t *imsi_ue_hash; /* hash table (IMSI : MME_UE) */
@ -441,17 +442,19 @@ CORE_DECLARE(status_t) mme_sgw_remove_all(void);
CORE_DECLARE(mme_sgw_t*) mme_sgw_first(void);
CORE_DECLARE(mme_sgw_t*) mme_sgw_next(mme_sgw_t *sgw);
CORE_DECLARE(mme_enb_t*) mme_enb_add(sock_id sock);
CORE_DECLARE(mme_enb_t*) mme_enb_add(sock_id sock, c_sockaddr_t *addr);
CORE_DECLARE(status_t) mme_enb_remove(mme_enb_t *enb);
CORE_DECLARE(status_t) mme_enb_remove_all(void);
CORE_DECLARE(mme_enb_t*) mme_enb_find(index_t index);
CORE_DECLARE(mme_enb_t*) mme_enb_find_by_sock(sock_id sock);
CORE_DECLARE(mme_enb_t*) mme_enb_find_by_addr(c_sockaddr_t *addr);
CORE_DECLARE(mme_enb_t*) mme_enb_find_by_enb_id(c_uint32_t enb_id);
CORE_DECLARE(status_t) mme_enb_set_enb_id(
mme_enb_t *enb, c_uint32_t enb_id);
CORE_DECLARE(hash_index_t *) mme_enb_first();
CORE_DECLARE(hash_index_t *) mme_enb_next(hash_index_t *hi);
CORE_DECLARE(mme_enb_t *) mme_enb_this(hash_index_t *hi);
CORE_DECLARE(int) mme_enb_sock_is_stream(sock_id sock);
CORE_DECLARE(mme_ue_t*) mme_ue_add(enb_ue_t *enb_ue);
CORE_DECLARE(status_t) mme_ue_remove(mme_ue_t *mme_ue);

38
src/mme/mme_sm.c
View File

@ -84,11 +84,16 @@ void mme_state_operational(fsm_t *s, event_t *e)
d_assert(sock, break,);
c_sockaddr_t *addr = (c_sockaddr_t *)event_get_param2(e);
d_assert(addr, break,);
mme_enb_t *enb = NULL;
d_trace(1, "eNB-S1 accepted[%s] in master_sm module\n",
CORE_NTOP(addr, buf));
mme_enb_t *enb = mme_enb_find_by_sock(sock);
if (mme_enb_sock_is_stream(sock))
enb = mme_enb_find_by_sock(sock);
else
enb = mme_enb_find_by_addr(addr);
if (!enb)
{
#if USE_USRSCTP != 1
@ -96,9 +101,8 @@ void mme_state_operational(fsm_t *s, event_t *e)
d_assert(rv == CORE_OK, break, "register s1ap_recv_cb failed");
#endif
mme_enb_t *enb = mme_enb_add(sock);
mme_enb_t *enb = mme_enb_add(sock, addr);
d_assert(enb, break, "Null param");
enb->addr = addr;
}
else
{
@ -114,11 +118,19 @@ void mme_state_operational(fsm_t *s, event_t *e)
{
mme_enb_t *enb = NULL;
sock_id sock = 0;
c_sockaddr_t *addr = NULL;
sock = (sock_id)event_get_param1(e);
d_assert(sock, break, "Null param");
enb = mme_enb_find_by_sock(sock);
addr = (c_sockaddr_t *)event_get_param2(e);
d_assert(addr, break, "Null param");
if (mme_enb_sock_is_stream(sock))
enb = mme_enb_find_by_sock(sock);
else
enb = mme_enb_find_by_addr(addr);
core_free(addr);
if (enb)
{
d_trace(1, "eNB-S1[%x] connection refused!!!\n",
@ -137,22 +149,32 @@ void mme_state_operational(fsm_t *s, event_t *e)
s1ap_message_t message;
mme_enb_t *enb = NULL;
sock_id sock = 0;
c_sockaddr_t *addr = NULL;
pkbuf_t *pkbuf = NULL;
sock = (sock_id)event_get_param1(e);
d_assert(sock, break, "Null param");
addr = (c_sockaddr_t *)event_get_param2(e);
d_assert(addr, break, "Null param");
pkbuf = (pkbuf_t *)event_get_param2(e);
pkbuf = (pkbuf_t *)event_get_param3(e);
d_assert(pkbuf, break, "Null param");
enb = mme_enb_find_by_sock(sock);
if (mme_enb_sock_is_stream(sock))
enb = mme_enb_find_by_sock(sock);
else
enb = mme_enb_find_by_addr(addr);
core_free(addr);
d_assert(enb, break, "No eNB context");
d_assert(FSM_STATE(&enb->sm), break, "No S1AP State Machine");
d_assert(s1ap_decode_pdu(&message, pkbuf) == CORE_OK,
pkbuf_free(pkbuf); break, "Can't decode S1AP_PDU");
event_set_param3(e, (c_uintptr_t)&message);
event_set_param1(e, (c_uintptr_t)enb->index);
event_set_param4(e, (c_uintptr_t)&message);
fsm_dispatch(&enb->sm, (fsm_event_t*)e);
s1ap_free_pdu(&message);

2
src/mme/s1ap_path.c
View File

@ -19,7 +19,7 @@ status_t s1ap_send_to_enb(mme_enb_t *enb, pkbuf_t *pkbuf)
d_assert(pkbuf,,);
d_assert(enb->sock,,);
rv = s1ap_send(enb->sock, pkbuf);
rv = s1ap_send(enb->sock, pkbuf, enb->addr);
if (rv != CORE_OK)
{
d_error("s1_send error");

5
src/mme/s1ap_path.h
View File

@ -19,7 +19,10 @@ CORE_DECLARE(status_t) s1ap_final();
CORE_DECLARE(status_t) s1ap_open();
CORE_DECLARE(status_t) s1ap_close();
CORE_DECLARE(status_t) s1ap_send(sock_id sock, pkbuf_t *pkb);
CORE_DECLARE(status_t) s1ap_sctp_delete(sock_id sock);
CORE_DECLARE(status_t) s1ap_send(sock_id sock,
pkbuf_t *pkbuf, c_sockaddr_t *addr);
CORE_DECLARE(status_t) s1ap_send_to_enb(mme_enb_t *enb, pkbuf_t *pkb);
CORE_DECLARE(status_t) s1ap_delayed_send_to_enb(mme_enb_t *enb,
pkbuf_t *pkbuf, c_uint32_t duration);

52
src/mme/s1ap_sctp.c
View File

@ -50,10 +50,13 @@ status_t s1ap_open(void)
status_t s1ap_close()
{
sock_delete(mme_self()->s1ap_sock);
mme_self()->s1ap_sock = 0;
return s1ap_sctp_delete(mme_self()->s1ap_sock);
}
return CORE_OK;
status_t s1ap_sctp_delete(sock_id sock)
{
d_assert(sock, return CORE_ERROR,);
return sock_delete(sock);
}
static int s1ap_accept_cb(sock_id id, void *data)
@ -67,16 +70,23 @@ static int s1ap_accept_cb(sock_id id, void *data)
rv = sock_accept(&new, id);
if (rv == CORE_OK)
{
c_sockaddr_t *addr = sock_remote_addr_get(new);
c_sockaddr_t *addr = NULL;
event_t e;
addr = core_calloc(1, sizeof(c_sockaddr_t));
d_assert(addr, return -1,);
memcpy(addr, sock_remote_addr_get(new), sizeof(c_sockaddr_t));
d_trace(1, "eNB-S1 accepted[%s] in s1_path module\n",
CORE_NTOP(addr, buf));
event_set(&e, MME_EVT_S1AP_LO_ACCEPT);
event_set_param1(&e, (c_uintptr_t)new);
event_set_param2(&e, (c_uintptr_t)addr);
mme_event_send(&e);
if (mme_event_send(&e) != CORE_OK)
{
core_free(addr);
}
return 0;
}
@ -92,6 +102,8 @@ static int s1ap_accept_cb(sock_id id, void *data)
static status_t s1ap_recv(sock_id sock, pkbuf_t *pkbuf)
{
event_t e;
c_sockaddr_t *addr = NULL;
status_t rv;
d_assert(sock, return CORE_ERROR, "Null param");
d_assert(pkbuf, return CORE_ERROR, "Null param");
@ -99,10 +111,22 @@ static status_t s1ap_recv(sock_id sock, pkbuf_t *pkbuf)
d_trace(10, "S1AP_PDU is received from eNB-Inf\n");
d_trace_hex(10, pkbuf->payload, pkbuf->len);
addr = core_calloc(1, sizeof(c_sockaddr_t));
d_assert(addr, return -1,);
memcpy(addr, sock_remote_addr_get(sock), sizeof(c_sockaddr_t));
event_set(&e, MME_EVT_S1AP_MESSAGE);
event_set_param1(&e, (c_uintptr_t)sock);
event_set_param2(&e, (c_uintptr_t)pkbuf);
return mme_event_send(&e);
event_set_param2(&e, (c_uintptr_t)addr);
event_set_param3(&e, (c_uintptr_t)pkbuf);
rv = mme_event_send(&e);
if (rv != CORE_OK)
{
pkbuf_free(pkbuf);
core_free(addr);
}
return rv;
}
int s1ap_recv_cb(sock_id sock, void *data)
@ -138,9 +162,18 @@ int s1ap_recv_cb(sock_id sock, void *data)
if (rc == CORE_SCTP_REMOTE_CLOSED)
{
c_sockaddr_t *addr = core_calloc(1, sizeof(c_sockaddr_t));
d_assert(addr, return -1,);
memcpy(addr, sock_remote_addr_get(sock), sizeof(c_sockaddr_t));
event_set(&e, MME_EVT_S1AP_LO_CONNREFUSED);
event_set_param1(&e, (c_uintptr_t)sock);
mme_event_send(&e);
event_set_param2(&e, (c_uintptr_t)addr);
if (mme_event_send(&e) != CORE_OK)
{
pkbuf_free(pkbuf);
core_free(addr);
}
return 0;
}
@ -155,7 +188,6 @@ int s1ap_recv_cb(sock_id sock, void *data)
rv = s1ap_recv(sock, pkbuf);
if (rv != CORE_OK)
{
pkbuf_free(pkbuf);
d_error("s1_recv() failed");
return -1;
}
@ -163,7 +195,7 @@ int s1ap_recv_cb(sock_id sock, void *data)
return 0;
}
status_t s1ap_send(sock_id sock, pkbuf_t *pkbuf)
status_t s1ap_send(sock_id sock, pkbuf_t *pkbuf, c_sockaddr_t *addr)
{
int sent;

9
src/mme/s1ap_sm.c
View File

@ -29,17 +29,14 @@ void s1ap_state_final(fsm_t *s, event_t *e)
void s1ap_state_operational(fsm_t *s, event_t *e)
{
mme_enb_t *enb = NULL;
sock_id sock = 0;
d_assert(s, return, "Null param");
d_assert(e, return, "Null param");
mme_sm_trace(3, e);
sock = (sock_id)event_get_param1(e);
d_assert(sock, return, "Null param");
enb = mme_enb_find_by_sock(sock);
d_assert(enb, return, "Null param");
enb = mme_enb_find(event_get_param1(e));
d_assert(enb, return,);
switch (event_get(e))
{
@ -53,7 +50,7 @@ void s1ap_state_operational(fsm_t *s, event_t *e)
}
case MME_EVT_S1AP_MESSAGE:
{
s1ap_message_t *message = (s1ap_message_t *)event_get_param3(e);
s1ap_message_t *message = (s1ap_message_t *)event_get_param4(e);
d_assert(message, break, "Null param");
switch(message->direction)

111
src/mme/s1ap_usrsctp.c
View File

@ -23,10 +23,6 @@ static int s1ap_usrsctp_recv_cb(struct socket *sock,
static void debug_printf(const char *format, ...);
int accept_thread_should_stop = 0;
static thread_id accept_thread;
static void *THREAD_FUNC accept_main(thread_id id, void *data);
status_t s1ap_init(c_uint16_t port)
{
usrsctp_init(port, NULL, debug_printf);
@ -171,7 +167,7 @@ status_t s1ap_open(void)
c_sockaddr_t addr;
rv = s1ap_usrsctp_socket((sock_id *)&mme_self()->s1ap_sock,
AF_INET, SOCK_STREAM, s1ap_usrsctp_recv_cb);
AF_INET, SOCK_SEQPACKET, s1ap_usrsctp_recv_cb);
d_assert(rv == CORE_OK, return CORE_ERROR,);
memset(&addr, 0, sizeof(addr));
@ -185,9 +181,6 @@ status_t s1ap_open(void)
rv = s1ap_usrsctp_listen(mme_self()->s1ap_sock);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = thread_create(&accept_thread, NULL, accept_main, NULL);
if (rv != CORE_OK) return rv;
d_trace(1, "s1_enb_listen() %s:%d\n",
CORE_NTOP(&addr, buf), CORE_PORT(&addr));
@ -200,25 +193,17 @@ status_t s1ap_close()
d_assert(mme_self()->s1ap_sock, return CORE_ERROR,
"S1-ENB path already opened");
accept_thread_should_stop = 1;
sock_delete(mme_self()->s1ap_sock);
#if 0
thread_delete(accept_thread);
#else
d_error("[FIXME] should delete accept_thread : "
"how to release usrsctp_accept() blocking?");
#endif
s1ap_sctp_delete(mme_self()->s1ap_sock);
return CORE_OK;
}
status_t sock_delete(sock_id sock)
status_t s1ap_sctp_delete(sock_id sock)
{
usrsctp_close((struct socket *)sock);
return CORE_OK;
}
status_t s1ap_send(sock_id id, pkbuf_t *pkbuf)
status_t s1ap_send(sock_id id, pkbuf_t *pkbuf, c_sockaddr_t *addr)
{
ssize_t sent;
struct socket *sock = (struct socket *)id;
@ -230,7 +215,7 @@ status_t s1ap_send(sock_id id, pkbuf_t *pkbuf)
memset((void *)&sndinfo, 0, sizeof(struct sctp_sndinfo));
sndinfo.snd_ppid = htonl(SCTP_S1AP_PPID);
sent = usrsctp_sendv(sock, pkbuf->payload, pkbuf->len,
NULL, 0,
addr ? &addr->sa : NULL, addr ? 1 : 0,
(void *)&sndinfo, (socklen_t)sizeof(struct sctp_sndinfo),
SCTP_SENDV_SNDINFO, 0);
@ -246,32 +231,29 @@ status_t s1ap_send(sock_id id, pkbuf_t *pkbuf)
return CORE_OK;
}
static void *THREAD_FUNC accept_main(thread_id id, void *data)
c_sockaddr_t *usrsctp_remote_addr_get(union sctp_sockstore *store)
{
event_t e;
struct socket *sock = NULL;
c_sockaddr_t *addr = NULL;
socklen_t addrlen = sizeof(struct sockaddr_storage);
while (!accept_thread_should_stop)
d_assert(store, return NULL,);
addr = core_calloc(1, sizeof(c_sockaddr_t));
d_assert(addr, return NULL,);
addr->c_sa_family = store->sin.sin_family;
switch(addr->c_sa_family)
{
addr = core_calloc(1, sizeof(c_sockaddr_t));
if ((sock = usrsctp_accept((struct socket *)mme_self()->s1ap_sock,
&addr->sa, &addrlen)) == NULL)
{
d_error("usrsctp_accept failed");
core_free(addr);
continue;
}
event_set(&e, MME_EVT_S1AP_LO_ACCEPT);
event_set_param1(&e, (c_uintptr_t)sock);
event_set_param2(&e, (c_uintptr_t)addr);
mme_event_send(&e);
case AF_INET:
memcpy(&addr->sin, &store->sin, sizeof(struct sockaddr_in));
break;
case AF_INET6:
memcpy(&addr->sin6, &store->sin6, sizeof(struct sockaddr_in6));
break;
default:
d_assert(0, return NULL,);
}
return NULL;
return addr;
}
static int s1ap_usrsctp_recv_cb(struct socket *sock,
@ -303,14 +285,32 @@ static int s1ap_usrsctp_recv_cb(struct socket *sock,
not->sn_assoc_change.sac_state ==
SCTP_COMM_LOST)
{
c_sockaddr_t *c_addr =
usrsctp_remote_addr_get(&addr);
d_assert(c_addr, return 1,);
event_set(&e, MME_EVT_S1AP_LO_CONNREFUSED);
event_set_param1(&e, (c_uintptr_t)sock);
mme_event_send(&e);
break;
event_set_param2(&e, (c_uintptr_t)c_addr);
if (mme_event_send(&e) != CORE_OK)
{
core_free(c_addr);
}
}
else if (not->sn_assoc_change.sac_state == SCTP_COMM_UP)
{
c_sockaddr_t *c_addr =
usrsctp_remote_addr_get(&addr);
d_assert(c_addr, return 1,);
if (not->sn_assoc_change.sac_state == SCTP_COMM_UP)
d_trace(3, "SCTP_COMM_UP\n");
event_set(&e, MME_EVT_S1AP_LO_ACCEPT);
event_set_param1(&e, (c_uintptr_t)sock);
event_set_param2(&e, (c_uintptr_t)c_addr);
if (mme_event_send(&e) != CORE_OK)
{
core_free(c_addr);
}
}
break;
case SCTP_PEER_ADDR_CHANGE:
@ -323,10 +323,19 @@ static int s1ap_usrsctp_recv_cb(struct socket *sock,
not->sn_send_failed_event.ssfe_error);
break;
case SCTP_SHUTDOWN_EVENT :
{
c_sockaddr_t *c_addr = usrsctp_remote_addr_get(&addr);
d_assert(c_addr, return 1,);
event_set(&e, MME_EVT_S1AP_LO_CONNREFUSED);
event_set_param1(&e, (c_uintptr_t)sock);
mme_event_send(&e);
event_set_param2(&e, (c_uintptr_t)c_addr);
if (mme_event_send(&e) != CORE_OK)
{
core_free(c_addr);
}
break;
}
default :
d_error("Discarding event with unknown "
"flags = 0x%x, type 0x%x",
@ -338,17 +347,25 @@ static int s1ap_usrsctp_recv_cb(struct socket *sock,
else if (flags & MSG_EOR)
{
pkbuf_t *pkbuf;
c_sockaddr_t *c_addr = NULL;
pkbuf = pkbuf_alloc(0, MAX_SDU_LEN);
d_assert(pkbuf, return 1, );
c_addr = usrsctp_remote_addr_get(&addr);
d_assert(c_addr, return 1,);
pkbuf->len = datalen;
memcpy(pkbuf->payload, data, pkbuf->len);
event_set(&e, MME_EVT_S1AP_MESSAGE);
event_set_param1(&e, (c_uintptr_t)sock);
event_set_param2(&e, (c_uintptr_t)pkbuf);
mme_event_send(&e);
event_set_param2(&e, (c_uintptr_t)c_addr);
event_set_param3(&e, (c_uintptr_t)pkbuf);
if (mme_event_send(&e) != CORE_OK)
{
pkbuf_free(pkbuf);
core_free(c_addr);
}
}
else
{

4
test/gtp_message_test.c
View File

@ -1,7 +1,6 @@
#include "core_pkbuf.h"
#include "core_lib.h"
#include "core_debug.h"
#include "core_net.h"
#include "types.h"
#include "gtp_types.h"
@ -9,6 +8,9 @@
#include "testutil.h"
/* ADDR */
#include <arpa/inet.h>
static void gtp_message_test1(abts_case *tc, void *data)
{
status_t rv;

1
test/testpacket.h
View File

@ -1,7 +1,6 @@
#ifndef __TESTS1AP_H__
#define __TESTS1AP_H__
#include "core_net.h"
#include "core_network.h"
#ifdef __cplusplus

4
test/testusrsctp.c
View File

@ -51,13 +51,13 @@ status_t tests1ap_enb_connect(sock_id *new)
status_t tests1ap_enb_close(sock_id id)
{
sock_delete(id);
s1ap_sctp_delete(id);
return CORE_OK;
}
status_t tests1ap_enb_send(sock_id id, pkbuf_t *sendbuf)
{
return s1ap_send(id, sendbuf);
return s1ap_send(id, sendbuf, NULL);
}
int tests1ap_enb_read(sock_id id, pkbuf_t *recvbuf)