sysmocom
/
open5gs
forked from acouzens/open5gs
11
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

S1AP MAC is done

This commit is contained in:
Sukchan Lee 2017-12-08 14:29:35 +09:00
parent 793b06ce33
commit a0599f7c2d
8 changed files with 187 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
lib/core/include/core_network.h
View File

@ -170,11 +170,10 @@ CORE_DECLARE(status_t) tcp_client(sock_id *new, c_sockaddr_t *sa_list);
*/
CORE_DECLARE(status_t) sctp_socket(sock_id *new, int family, int type);
CORE_DECLARE(status_t) sctp_server(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port);
CORE_DECLARE(status_t) sctp_client(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port);
CORE_DECLARE(status_t) sctp_connect(sock_id id,
const char *hostname, c_uint16_t port);
int type, c_sockaddr_t *sa_list);
CORE_DECLARE(status_t) sctp_client(sock_id *new,
int type, c_sockaddr_t *sa_list);
CORE_DECLARE(status_t) sctp_connect(sock_id id, c_sockaddr_t *sa_list);
CORE_DECLARE(int) core_sctp_sendmsg(sock_id id, const void *msg, size_t len,
c_sockaddr_t *to, c_uint32_t ppid, c_uint16_t stream_no);
#define CORE_SCTP_REMOTE_CLOSED -2

95
lib/core/src/unix/sctp.c
View File

@ -50,128 +50,114 @@ status_t sctp_socket(sock_id *new, int family, int type)
return CORE_OK;
}
status_t sctp_server(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port)
status_t sctp_server(sock_id *new, int type, c_sockaddr_t *sa_list)
{
status_t rv;
c_sockaddr_t *sa;
c_sockaddr_t *addr;
char buf[CORE_ADDRSTRLEN];
rv = core_getaddrinfo(&sa, family, hostname, port, AI_PASSIVE);
d_assert(rv == CORE_OK && sa, return CORE_ERROR,);
while(sa)
addr = sa_list;
while(addr)
{
rv = sctp_socket(new, sa->c_sa_family, type);
rv = sctp_socket(new, addr->c_sa_family, type);
if (rv != CORE_OK) continue;
d_assert(sock_setsockopt(*new, SOCK_O_REUSEADDR, 1) == CORE_OK,
return CORE_ERROR,
"setsockopt(%s:%d) failed(%d:%s)",
CORE_ADDR(sa, buf), port, errno, strerror(errno));
"setsockopt [%s]:%d failed(%d:%s)",
CORE_ADDR(addr, buf), CORE_PORT(addr), errno, strerror(errno));
if (sock_bind(*new, sa) == CORE_OK)
if (sock_bind(*new, addr) == CORE_OK)
{
d_trace(1, "sctp bind %d:%s:%d\n",
sa->c_sa_family, CORE_ADDR(sa, buf), port);
d_trace(1, "sctp_server() [%s]:%d\n",
CORE_ADDR(addr, buf), CORE_PORT(addr));
break;
}
rv = sock_delete(*new);
d_assert(rv == CORE_OK, return CORE_ERROR,);
sa = sa->next;
addr = addr->next;
}
if (sa == NULL)
if (addr == NULL)
{
d_error("sctp bind(%d:%s:%d) failed(%d:%s)",
family, hostname, port, errno, strerror(errno));
d_error("sctp_server() [%s]:%d failed(%d:%s)",
CORE_ADDR(sa_list, buf), CORE_PORT(sa_list),
errno, strerror(errno));
return CORE_ERROR;
}
rv = core_freeaddrinfo(sa);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = sock_listen(*new);
d_assert(rv == CORE_OK, return CORE_ERROR,);
return CORE_OK;
}
status_t sctp_client(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port)
status_t sctp_client(sock_id *new, int type, c_sockaddr_t *sa_list)
{
status_t rv;
c_sockaddr_t *sa;
c_sockaddr_t *addr;
char buf[CORE_ADDRSTRLEN];
rv = core_getaddrinfo(&sa, family, hostname, port, 0);
d_assert(rv == CORE_OK && sa, return CORE_ERROR,);
while(sa)
addr = sa_list;
while(addr)
{
rv = sctp_socket(new, sa->c_sa_family, type);
rv = sctp_socket(new, addr->c_sa_family, type);
if (rv != CORE_OK) continue;
if (sock_connect(*new, sa) == CORE_OK)
if (sock_connect(*new, addr) == CORE_OK)
{
d_trace(1, "sctp connect %s:%d\n", CORE_ADDR(sa, buf), port);
d_trace(1, "sctp_client() [%s]:%d\n",
CORE_ADDR(addr, buf), CORE_PORT(addr));
break;
}
rv = sock_delete(*new);
d_assert(rv == CORE_OK, return CORE_ERROR,);
sa = sa->next;
addr = addr->next;
}
if (sa == NULL)
if (addr == NULL)
{
d_error("sctp connect(%d:%s:%d) failed(%d:%s)",
family, hostname, port, errno, strerror(errno));
d_error("sctp_client() [%s]:%d failed(%d:%s)",
CORE_ADDR(sa_list, buf), CORE_PORT(sa_list),
errno, strerror(errno));
return CORE_ERROR;
}
rv = core_freeaddrinfo(sa);
d_assert(rv == CORE_OK, return CORE_ERROR,);
return CORE_OK;
}
status_t sctp_connect(sock_id id, const char *hostname, c_uint16_t port)
status_t sctp_connect(sock_id id, c_sockaddr_t *sa_list)
{
status_t rv;
c_sockaddr_t *sa;
sock_t *sock = (sock_t *)id;
c_sockaddr_t *addr;
char buf[CORE_ADDRSTRLEN];
d_assert(id, return CORE_ERROR,);
rv = core_getaddrinfo(&sa, sock->family, hostname, port, 0);
d_assert(rv == CORE_OK && sa, return CORE_ERROR,);
while(sa)
addr = sa_list;
while(addr)
{
if (sock_connect(id, sa) == CORE_OK)
if (sock_connect(id, addr) == CORE_OK)
{
d_trace(1, "sctp connect %s:%d\n", CORE_ADDR(sa, buf), port);
d_trace(1, "sctp_connect() [%s]:%d\n",
CORE_ADDR(addr, buf), CORE_PORT(addr));
break;
}
sa = sa->next;
addr = addr->next;
}
if (sa == NULL)
if (addr == NULL)
{
d_error("sctp connect(%d:%s:%d) failed(%d:%s)",
sock->family, hostname, port, errno, strerror(errno));
d_error("sctp_connect() [%s]:%d failed(%d:%s)",
CORE_ADDR(sa_list, buf), CORE_PORT(sa_list),
errno, strerror(errno));
return CORE_ERROR;
}
rv = core_freeaddrinfo(sa);
d_assert(rv == CORE_OK, return CORE_ERROR,);
return CORE_OK;
}
@ -257,7 +243,6 @@ int core_sctp_recvmsg(sock_id id, void *msg, size_t len,
if (not->sn_assoc_change.sac_state == SCTP_COMM_UP)
d_trace(3, "SCTP_COMM_UP\n");
break;
case SCTP_SEND_FAILED :
d_error("SCTP_SEND_FAILED"

103
lib/core/test/testsctp.c
View File

@ -13,6 +13,7 @@
static void sctp_test1(abts_case *tc, void *data)
{
sock_id sctp;
c_sockaddr_t *addr;
status_t rv;
rv = sctp_socket(&sctp, AF_INET6, SOCK_SEQPACKET);
@ -21,13 +22,21 @@ static void sctp_test1(abts_case *tc, void *data)
rv = sock_delete(sctp);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, AF_INET, SOCK_STREAM, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_INET, NULL, PORT, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_STREAM, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sock_delete(sctp);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, AF_UNSPEC, SOCK_SEQPACKET, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_UNSPEC, NULL, PORT, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_SEQPACKET, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sock_delete(sctp);
@ -43,12 +52,17 @@ static void *THREAD_FUNC test2_main(thread_id id, void *data)
char str[STRLEN];
ssize_t size;
c_uint32_t ppid;
c_sockaddr_t sa;
c_sockaddr_t *addr;
c_sockaddr_t from;
rv = sctp_client(&sctp, AF_UNSPEC, SOCK_SEQPACKET, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_UNSPEC, NULL, PORT, 0);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_client(&sctp, SOCK_SEQPACKET, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
size = core_sctp_recvmsg(sctp, str, STRLEN, &sa, &ppid, NULL);
size = core_sctp_recvmsg(sctp, str, STRLEN, &from, &ppid, NULL);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
ABTS_INT_EQUAL(tc, PPID, ppid);
@ -64,8 +78,13 @@ static void sctp_test2(abts_case *tc, void *data)
status_t rv;
sock_id sctp, sctp2;
ssize_t size;
c_sockaddr_t *addr;
rv = sctp_server(&sctp, AF_INET6, SOCK_STREAM, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_INET6, NULL, PORT, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_STREAM, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = thread_create(&test2_thread, NULL, test2_main, tc);
@ -93,7 +112,8 @@ static void *THREAD_FUNC test3_main(thread_id id, void *data)
abts_case *tc = data;
status_t rv;
sock_id sctp;
c_sockaddr_t *sa;
c_sockaddr_t *addr;
c_sockaddr_t *to;
char str[STRLEN];
ssize_t size;
int rc;
@ -101,13 +121,13 @@ static void *THREAD_FUNC test3_main(thread_id id, void *data)
rv = sctp_socket(&sctp, AF_INET, SOCK_SEQPACKET);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_getaddrinfo(&sa, AF_INET, NULL, PORT, 0);
rv = core_getaddrinfo(&to, AF_INET, NULL, PORT, 0);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), sa, PPID, 0);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), to, PPID, 0);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
rv = core_freeaddrinfo(sa);
rv = core_freeaddrinfo(to);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sock_delete(sctp);
@ -122,18 +142,22 @@ static void sctp_test3(abts_case *tc, void *data)
sock_id sctp;
status_t rv;
ssize_t size;
c_sockaddr_t sa;
c_sockaddr_t from, *addr;
char str[STRLEN];
char buf[CORE_ADDRSTRLEN];
c_uint32_t ppid;
rv = sctp_server(&sctp, AF_INET, SOCK_SEQPACKET, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_INET, NULL, PORT, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_SEQPACKET, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = thread_create(&test3_thread, NULL, test3_main, tc);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
size = core_sctp_recvmsg(sctp, str, STRLEN, &sa, &ppid, NULL);
size = core_sctp_recvmsg(sctp, str, STRLEN, &from, &ppid, NULL);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
ABTS_INT_EQUAL(tc, PPID, ppid);
@ -150,11 +174,16 @@ static void *THREAD_FUNC test4_main(thread_id id, void *data)
abts_case *tc = data;
status_t rv;
sock_id sctp;
c_sockaddr_t *addr;
char str[STRLEN];
ssize_t size;
c_uint32_t ppid;
rv = sctp_client(&sctp, AF_UNSPEC, SOCK_STREAM, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_UNSPEC, NULL, PORT, 0);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_client(&sctp, SOCK_STREAM, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), NULL, PPID, 0);
@ -176,23 +205,27 @@ static void sctp_test4(abts_case *tc, void *data)
sock_id sctp;
status_t rv;
ssize_t size;
c_sockaddr_t sa;
c_sockaddr_t from, *addr;
char str[STRLEN];
c_uint32_t ppid;
char buf[CORE_ADDRSTRLEN];
rv = sctp_server(&sctp, AF_INET6, SOCK_SEQPACKET, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_INET6, NULL, PORT, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_SEQPACKET, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = thread_create(&test4_thread, NULL, test4_main, tc);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
size = core_sctp_recvmsg(sctp, str, STRLEN, &sa, &ppid, NULL);
size = core_sctp_recvmsg(sctp, str, STRLEN, &from, &ppid, NULL);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(&sa, buf));
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(&from, buf));
ABTS_INT_EQUAL(tc, PPID, ppid);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), &sa, PPID, 0);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), &from, PPID, 0);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
thread_join(&rv, test4_thread);
@ -209,15 +242,23 @@ static void *THREAD_FUNC test5_main(thread_id id, void *data)
status_t rv;
sock_id sctp;
char str[STRLEN];
c_sockaddr_t sa, *remote_addr;
c_sockaddr_t from, *remote_addr, *addr;
c_uint32_t ppid;
ssize_t size;
char buf[CORE_ADDRSTRLEN];
rv = sctp_server(&sctp, AF_INET6, SOCK_SEQPACKET, NULL, PORT2);
rv = core_getaddrinfo(&addr, AF_INET6, NULL, PORT2, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_SEQPACKET, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_connect(sctp, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_INET6, NULL, PORT, 0);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_connect(sctp, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
remote_addr = sock_remote_addr(sctp);
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(remote_addr, buf));
@ -226,9 +267,9 @@ static void *THREAD_FUNC test5_main(thread_id id, void *data)
remote_addr, PPID, 0);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
size = core_sctp_recvmsg(sctp, str, STRLEN, &sa, &ppid, NULL);
size = core_sctp_recvmsg(sctp, str, STRLEN, &from, &ppid, NULL);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(&sa, buf));
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(&from, buf));
ABTS_INT_EQUAL(tc, PPID, ppid);
rv = sock_delete(sctp);
@ -243,24 +284,28 @@ static void sctp_test5(abts_case *tc, void *data)
sock_id sctp;
status_t rv;
ssize_t size;
c_sockaddr_t sa;
c_sockaddr_t from, *addr;
socklen_t addrlen;
char str[STRLEN];
c_uint32_t ppid;
char buf[CORE_ADDRSTRLEN];
rv = sctp_server(&sctp, AF_INET6, SOCK_SEQPACKET, NULL, PORT);
rv = core_getaddrinfo(&addr, AF_INET6, NULL, PORT, AI_PASSIVE);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sctp_server(&sctp, SOCK_SEQPACKET, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = core_freeaddrinfo(addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = thread_create(&test5_thread, NULL, test5_main, tc);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
size = core_sctp_recvmsg(sctp, str, STRLEN, &sa, &ppid, NULL);
size = core_sctp_recvmsg(sctp, str, STRLEN, &from, &ppid, NULL);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(&sa, buf));
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(&from, buf));
ABTS_INT_EQUAL(tc, PPID, ppid);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), &sa, ppid, 0);
size = core_sctp_sendmsg(sctp, DATASTR, strlen(DATASTR), &from, ppid, 0);
ABTS_INT_EQUAL(tc, strlen(DATASTR), size);
thread_join(&rv, test5_thread);

49
src/mme/s1ap_path.c
View File

@ -12,6 +12,9 @@
#include "s1ap_build.h"
#include "s1ap_path.h"
static status_t s1ap_server_list(list_t *list, int type);
static status_t s1ap_delete_list(list_t *list);
status_t s1ap_open(void)
{
status_t rv;
@ -20,36 +23,44 @@ status_t s1ap_open(void)
#else
int type = SOCK_SEQPACKET;
#endif
sock_node_t *snode = NULL;
for (snode = list_first(&mme_self()->s1ap_list);
snode; snode = list_next(snode))
{
rv = s1ap_server(&snode->sock, type, snode->list);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
for (snode = list_first(&mme_self()->s1ap_list6);
snode; snode = list_next(snode))
{
rv = s1ap_server(&snode->sock, type, snode->list);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
rv = s1ap_server_list(&mme_self()->s1ap_list, type);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = s1ap_server_list(&mme_self()->s1ap_list6, type);
d_assert(rv == CORE_OK, return CORE_ERROR,);
return CORE_OK;
}
status_t s1ap_close()
{
s1ap_delete_list(&mme_self()->s1ap_list);
s1ap_delete_list(&mme_self()->s1ap_list6);
return CORE_OK;
}
static status_t s1ap_server_list(list_t *list, int type)
{
status_t rv;
sock_node_t *snode = NULL;
for (snode = list_first(&mme_self()->s1ap_list);
snode; snode = list_next(snode))
d_assert(list, return CORE_ERROR,);
for (snode = list_first(list); snode; snode = list_next(snode))
{
s1ap_delete(snode->sock);
rv = s1ap_server(snode, type);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
for (snode = list_first(&mme_self()->s1ap_list6);
snode; snode = list_next(snode))
return CORE_OK;
}
static status_t s1ap_delete_list(list_t *list)
{
sock_node_t *snode = NULL;
for (snode = list_first(list); snode; snode = list_next(snode))
{
s1ap_delete(snode->sock);
}

5
src/mme/s1ap_path.h
View File

@ -16,10 +16,7 @@ CORE_DECLARE(status_t) s1ap_final();
CORE_DECLARE(status_t) s1ap_open();
CORE_DECLARE(status_t) s1ap_close();
CORE_DECLARE(status_t) s1ap_server(sock_id *new,
int type, c_sockaddr_t *sa_list);
CORE_DECLARE(status_t) s1ap_client(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port);
CORE_DECLARE(status_t) s1ap_server(sock_node_t *snode, int type);
CORE_DECLARE(status_t) s1ap_delete(sock_id sock);
CORE_DECLARE(int) s1ap_recv_handler(sock_id sock, void *data);

35
src/mme/s1ap_sctp.c
View File

@ -19,33 +19,25 @@ status_t s1ap_final()
return CORE_OK;
}
status_t s1ap_server(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port)
status_t s1ap_server(sock_node_t *snode, int type)
{
status_t rv;
c_sockaddr_t *addr = NULL;
char buf[CORE_ADDRSTRLEN];
rv = sctp_server(new, family, type, hostname, port);
d_assert(snode, return CORE_ERROR,);
rv = sctp_server(&snode->sock, type, snode->list);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = sock_register(*new, s1ap_accept_handler, NULL);
rv = sock_register(snode->sock, s1ap_accept_handler, NULL);
d_assert(rv == CORE_OK, return CORE_ERROR,);
addr = sock_local_addr(*new);
d_assert(addr, return CORE_ERROR,);
d_trace(1, "s1ap_server [%s]:%d\n", CORE_ADDR(addr, buf), CORE_PORT(addr));
d_trace(1, "s1ap_server() [%s]:%d\n",
CORE_ADDR(snode->list, buf), CORE_PORT(snode->list));
return CORE_OK;
}
status_t s1ap_client(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port)
{
return sctp_client(new, family, type, hostname, port);
}
status_t s1ap_delete(sock_id sock)
{
d_assert(sock, return CORE_ERROR,);
@ -155,9 +147,6 @@ int s1ap_recv_handler(sock_id sock, void *data)
{
pkbuf_free(pkbuf);
if (errno == 0 || errno == EAGAIN)
return 0;
if (size == CORE_SCTP_REMOTE_CLOSED)
{
addr = core_calloc(1, sizeof(c_sockaddr_t));
@ -169,16 +158,18 @@ int s1ap_recv_handler(sock_id sock, void *data)
event_set_param2(&e, (c_uintptr_t)addr);
if (mme_event_send(&e) != CORE_OK)
{
pkbuf_free(pkbuf);
core_free(addr);
}
return 0;
}
d_error("core_sctp_recvmsg(%d) failed(%d:%s)",
size, errno, strerror(errno));
return -1;
if (errno != EAGAIN)
{
d_error("core_sctp_recvmsg(%d) failed(%d:%s)",
size, errno, strerror(errno));
}
return 0;
}
pkbuf->len = size;

28
src/mme/s1ap_usrsctp.c
View File

@ -66,7 +66,23 @@ status_t s1ap_delete(sock_id sock)
return CORE_OK;
}
status_t s1ap_server(sock_id *new, int type, c_sockaddr_t *sa_list)
status_t s1ap_server(sock_node_t *snode, int type)
{
status_t rv;
char buf[CORE_ADDRSTRLEN];
d_assert(snode, return CORE_ERROR,);
rv = sctp_server(&snode->sock, type, snode->list);
d_assert(rv == CORE_OK, return CORE_ERROR,);
d_trace(1, "s1ap_server() [%s]:%d\n",
CORE_ADDR(snode->list, buf), CORE_PORT(snode->list));
return CORE_OK;
}
status_t sctp_server(sock_id *new, int type, c_sockaddr_t *sa_list)
{
status_t rv;
c_sockaddr_t *addr;
@ -105,16 +121,13 @@ status_t s1ap_server(sock_id *new, int type, c_sockaddr_t *sa_list)
return CORE_OK;
}
status_t s1ap_client(sock_id *new,
int family, int type, const char *hostname, c_uint16_t port)
status_t sctp_client(sock_id *new, int type, c_sockaddr_t *sa_list)
{
status_t rv;
c_sockaddr_t *addr;
char buf[CORE_ADDRSTRLEN];
rv = core_getaddrinfo(&addr, family, hostname, port, 0);
d_assert(rv == CORE_OK && addr, return CORE_ERROR,);
addr = sa_list;
while(addr)
{
rv = s1ap_usrsctp_socket(new, addr->c_sa_family, type, NULL);
@ -140,9 +153,6 @@ status_t s1ap_client(sock_id *new,
return CORE_ERROR;
}
rv = core_freeaddrinfo(addr);
d_assert(rv == CORE_OK, return CORE_ERROR,);
return CORE_OK;
}

7
test/testpacket.c
View File

@ -19,8 +19,13 @@ extern int test_only_control_plane;
status_t tests1ap_enb_connect(sock_id *new)
{
status_t rv;
sock_node_t *snode = NULL;
rv = s1ap_client(new, AF_UNSPEC, SOCK_STREAM, NULL, S1AP_SCTP_PORT);
snode = list_first(&mme_self()->s1ap_list);
if (!snode) snode = list_first(&mme_self()->s1ap_list6);
d_assert(snode, return CORE_ERROR,);
rv = sctp_client(new, SOCK_STREAM, snode->list);
d_assert(rv == CORE_OK, return CORE_ERROR,);
return CORE_OK;