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

refine ipv6

This commit is contained in:
Sukchan Lee 2017-12-05 10:50:31 +09:00
parent 63fb6625b3
commit fe921e0c2f
6 changed files with 154 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -121,8 +121,7 @@ CORE_DECLARE(c_sockaddr_t *) sock_remote_addr(sock_id id);
/*
* Socket Address
*/
CORE_DECLARE(status_t) sock_add_node(
list_t *list, sock_node_t **node, c_sockaddr_t *sa_list, int family);
CORE_DECLARE(sock_node_t *) sock_add_node(list_t *list, c_sockaddr_t *sa_list);
CORE_DECLARE(status_t) sock_remove_node(list_t *list, sock_node_t *node);
CORE_DECLARE(status_t) sock_remove_all_nodes(list_t *list);
CORE_DECLARE(status_t) sock_probe_node(

36
lib/core/src/unix/socket.c
View File

@ -292,38 +292,22 @@ c_sockaddr_t *sock_remote_addr(sock_id id)
* Socket Address
*/
status_t sock_add_node(
list_t *list, sock_node_t **node, c_sockaddr_t *sa_list, int family)
sock_node_t *sock_add_node(list_t *list, c_sockaddr_t *sa_list)
{
status_t rv;
c_sockaddr_t *new = NULL;
sock_node_t *node = NULL;
d_assert(list, return CORE_ERROR,);
d_assert(node, return CORE_ERROR,);
d_assert(sa_list, return CORE_ERROR,);
d_assert(list, return NULL,);
d_assert(sa_list, return NULL,);
rv = core_copyaddrinfo(&new, sa_list);
d_assert(rv == CORE_OK, return CORE_ERROR,);
d_assert(new, return CORE_ERROR,);
pool_alloc_node(&sock_node_pool, &node);
d_assert(node, return NULL,);
memset(node, 0, sizeof(sock_node_t));
if (family != AF_UNSPEC)
{
rv = core_filteraddrinfo(&new, family);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
node->list = sa_list;
if (new)
{
pool_alloc_node(&sock_node_pool, node);
d_assert(*node, return CORE_ERROR,);
memset(*node, 0, sizeof(sock_node_t));
list_append(list, node);
(*node)->list = new;
list_append(list, *node);
}
return CORE_OK;
return node;
}
status_t sock_remove_node(list_t *list, sock_node_t *node)

6
lib/core/test/testsock.c
View File

@ -399,16 +399,12 @@ static void sock_test7(abts_case *tc, void *data)
rv = core_getaddrinfo(&addr, AF_UNSPEC, "localhost", PORT, 0);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sock_add_node(&list, &node, addr, AF_INET);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
rv = sock_add_node(&list6, &node, addr, AF_INET6);
node = sock_add_node(&list, addr);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
core_freeaddrinfo(addr);
sock_remove_all_nodes(&list);
sock_remove_all_nodes(&list6);
rv = sock_probe_node(&list, &list6, PORT);
ABTS_INT_EQUAL(tc, CORE_OK, rv);

13
lib/gtp/gtp_node.c
View File

@ -27,22 +27,11 @@ status_t gtp_node_final(void)
return CORE_OK;
}
gtp_node_t *gtp_add_node(list_t *list,
int family, const char *hostname, c_uint16_t port)
gtp_node_t *gtp_add_node(list_t *list, c_sockaddr_t *sa_list)
{
status_t rv;
gtp_node_t *node = NULL;
c_sockaddr_t *sa_list = NULL;
d_assert(list, return NULL,);
rv = core_getaddrinfo(&sa_list, family, hostname, port, 0);
if (rv != CORE_OK)
{
d_error("core_getaddrinfo(%d:%s:%d)", family, hostname, port);
return NULL;
}
d_assert(sa_list, return NULL,);
pool_alloc_node(&gtp_node_pool, &node);

3
lib/gtp/gtp_node.h
View File

@ -37,8 +37,7 @@ typedef struct _gtp_node_t {
CORE_DECLARE(status_t) gtp_node_init(void);
CORE_DECLARE(status_t) gtp_node_final(void);
CORE_DECLARE(gtp_node_t *) gtp_add_node(list_t *list,
int family, const char *hostname, c_uint16_t port);
CORE_DECLARE(gtp_node_t *) gtp_add_node(list_t *list, c_sockaddr_t *sa_list);
CORE_DECLARE(status_t) gtp_remove_node(list_t *list, gtp_node_t *node);
CORE_DECLARE(status_t) gtp_remove_all_nodes(list_t *list);
CORE_DECLARE(status_t) gtp_filter_node(list_t *list, int family);

193
src/mme/mme_context.c
View File

@ -333,11 +333,11 @@ status_t mme_context_parse_config()
do
{
int family = AF_UNSPEC;
#define MAX_NUM_OF_HOSTNAME 16
int i, num = 0;
#define MAX_NUM_OF_HOSTNAME 16
const char *hostname[MAX_NUM_OF_HOSTNAME];
c_uint16_t port = self.gtpc_port;
c_sockaddr_t *sa_list = NULL;
c_sockaddr_t *head = NULL, *list = NULL, *list6 = NULL;
sock_node_t *node = NULL;
if (yaml_iter_type(&gtpc_array) == YAML_MAPPING_NODE)
@ -416,27 +416,41 @@ status_t mme_context_parse_config()
d_warn("unknown key `%s`", gtpc_key);
}
head = NULL;
for (i = 0; i < num; i++)
{
rv = core_addaddrinfo(&sa_list,
rv = core_addaddrinfo(&head,
family, hostname[i], port, AI_PASSIVE);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv4 == 0)
{
rv = sock_add_node(&self.gtpc_list, &node,
sa_list, AF_INET);
rv = core_copyaddrinfo(&list, head);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 0)
{
rv = sock_add_node(&self.gtpc_list6, &node,
sa_list, AF_INET6);
rv = core_filteraddrinfo(&list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
if (list)
{
node = sock_add_node(&self.gtpc_list, list);
d_assert(node, return CORE_ERROR,);
}
}
core_freeaddrinfo(sa_list);
if (context_self()->parameter.no_ipv6 == 0)
{
rv = core_copyaddrinfo(&list6, head);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = core_filteraddrinfo(&list6, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
if (list6)
{
node = sock_add_node(&self.gtpc_list, list6);
d_assert(node, return CORE_ERROR,);
}
}
core_freeaddrinfo(head);
} while(yaml_iter_type(&gtpc_array) == YAML_SEQUENCE_NODE);
@ -877,8 +891,11 @@ status_t mme_context_parse_config()
do
{
gtp_node_t *sgw = NULL;
c_sockaddr_t *head = NULL, *list = NULL;
int family = AF_UNSPEC;
const char *hostname = NULL;
int i, num = 0;
#define MAX_NUM_OF_HOSTNAME 16
const char *hostname[MAX_NUM_OF_HOSTNAME];
c_uint16_t port = self.gtpc_port;
if (yaml_iter_type(&gtpc_array) == YAML_MAPPING_NODE)
@ -922,7 +939,27 @@ status_t mme_context_parse_config()
else if (!strcmp(gtpc_key, "addr") ||
!strcmp(gtpc_key, "name"))
{
hostname = yaml_iter_value(&gtpc_iter);
yaml_iter_t hostname_iter;
yaml_iter_recurse(&gtpc_iter, &hostname_iter);
d_assert(yaml_iter_type(&hostname_iter) !=
YAML_MAPPING_NODE, return CORE_ERROR,);
do
{
if (yaml_iter_type(&hostname_iter) ==
YAML_SEQUENCE_NODE)
{
if (!yaml_iter_next(&hostname_iter))
break;
}
d_assert(num <= MAX_NUM_OF_HOSTNAME,
return CORE_ERROR,);
hostname[num++] =
yaml_iter_value(&hostname_iter);
} while(
yaml_iter_type(&hostname_iter) ==
YAML_SEQUENCE_NODE);
}
else if (!strcmp(gtpc_key, "port"))
{
@ -933,32 +970,46 @@ status_t mme_context_parse_config()
d_warn("unknown key `%s`", gtpc_key);
}
sgw = gtp_add_node(&self.sgw_list,
family, hostname, port);
d_assert(sgw, return CORE_ERROR,);
head = NULL;
for (i = 0; i < num; i++)
{
rv = core_addaddrinfo(&head,
family, hostname[i], port, AI_PASSIVE);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
rv = core_copyaddrinfo(&list, head);
d_assert(rv == CORE_OK, return CORE_ERROR,);
if (context_self()->parameter.no_ipv4 == 1)
{
rv = core_filteraddrinfo(&list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 1)
{
rv = core_filteraddrinfo(&list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.prefer_ipv4 == 1)
{
rv = core_sortaddrinfo(&list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
else
{
rv = core_sortaddrinfo(&list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (list)
{
sgw = gtp_add_node(&self.sgw_list, list);
d_assert(sgw, return CORE_ERROR,);
}
core_freeaddrinfo(head);
} while(yaml_iter_type(&gtpc_array) == YAML_SEQUENCE_NODE);
if (context_self()->parameter.no_ipv4 == 1)
{
rv = gtp_filter_node(&self.sgw_list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 1)
{
rv = gtp_filter_node(&self.sgw_list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.prefer_ipv4 == 1)
{
rv = gtp_sort_node(&self.sgw_list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
else
{
rv = gtp_sort_node(&self.sgw_list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
}
}
}
@ -977,8 +1028,11 @@ status_t mme_context_parse_config()
do
{
gtp_node_t *pgw = NULL;
c_sockaddr_t *head = NULL, *list = NULL;
int family = AF_UNSPEC;
const char *hostname = NULL;
int i, num = 0;
#define MAX_NUM_OF_HOSTNAME 16
const char *hostname[MAX_NUM_OF_HOSTNAME];
c_uint16_t port = self.gtpc_port;
if (yaml_iter_type(&gtpc_array) == YAML_MAPPING_NODE)
@ -1022,7 +1076,27 @@ status_t mme_context_parse_config()
else if (!strcmp(gtpc_key, "addr") ||
!strcmp(gtpc_key, "name"))
{
hostname = yaml_iter_value(&gtpc_iter);
yaml_iter_t hostname_iter;
yaml_iter_recurse(&gtpc_iter, &hostname_iter);
d_assert(yaml_iter_type(&hostname_iter) !=
YAML_MAPPING_NODE, return CORE_ERROR,);
do
{
if (yaml_iter_type(&hostname_iter) ==
YAML_SEQUENCE_NODE)
{
if (!yaml_iter_next(&hostname_iter))
break;
}
d_assert(num <= MAX_NUM_OF_HOSTNAME,
return CORE_ERROR,);
hostname[num++] =
yaml_iter_value(&hostname_iter);
} while(
yaml_iter_type(&hostname_iter) ==
YAML_SEQUENCE_NODE);
}
else if (!strcmp(gtpc_key, "port"))
{
@ -1033,22 +1107,35 @@ status_t mme_context_parse_config()
d_warn("unknown key `%s`", gtpc_key);
}
pgw = gtp_add_node(&self.pgw_list,
family, hostname, port);
d_assert(pgw, return CORE_ERROR,);
head = NULL;
for (i = 0; i < num; i++)
{
rv = core_addaddrinfo(&head,
family, hostname[i], port, AI_PASSIVE);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
rv = core_copyaddrinfo(&list, head);
d_assert(rv == CORE_OK, return CORE_ERROR,);
if (context_self()->parameter.no_ipv4 == 1)
{
rv = core_filteraddrinfo(&list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 1)
{
rv = core_filteraddrinfo(&list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (list)
{
pgw = gtp_add_node(&self.pgw_list, list);
d_assert(pgw, return CORE_ERROR,);
}
core_freeaddrinfo(head);
} while(yaml_iter_type(&gtpc_array) == YAML_SEQUENCE_NODE);
if (context_self()->parameter.no_ipv4 == 1)
{
rv = gtp_filter_node(&self.pgw_list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 1)
{
rv = gtp_filter_node(&self.pgw_list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
}
}
}