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

mme gtp config is added

This commit is contained in:
Sukchan Lee 2017-12-01 21:47:15 +09:00
parent b6b39c9dad
commit 7e0ce073fb
8 changed files with 162 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -90,7 +90,9 @@ typedef list_t c_socklist_t;
typedef struct _c_socknode_t {
lnode_t node;
c_sockaddr_t *addr;
sock_id sock;
c_sockaddr_t *sa_list;
} c_socknode_t;
/*

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

@ -292,18 +292,18 @@ c_sockaddr_t *sock_remote_addr(sock_id id)
* Socket Address
*/
static c_socknode_t *socknode_add_internal(
c_socklist_t *list, c_sockaddr_t *addr)
c_socklist_t *list, c_sockaddr_t *sa_list)
{
c_socknode_t *node = NULL;
d_assert(list, return NULL,);
d_assert(addr, return NULL,);
d_assert(sa_list, return NULL,);
pool_alloc_node(&socknode_pool, &node);
d_assert(node, return NULL,);
memset(node, 0, sizeof(c_socknode_t));
node->addr = addr;
node->sa_list = sa_list;
list_append(list, node);
@ -314,9 +314,9 @@ c_socknode_t *socknode_add(c_socklist_t *list,
int family, const char *hostname, c_uint16_t port, int flags)
{
status_t rv;
c_sockaddr_t *addr = NULL;
c_sockaddr_t *sa_list = NULL;
rv = core_getaddrinfo(&addr, family, hostname, port, flags);
rv = core_getaddrinfo(&sa_list, family, hostname, port, flags);
if (rv != CORE_OK)
{
d_error("core_getaddrinfo(%d:%s:%d:0x%x)",
@ -324,7 +324,7 @@ c_socknode_t *socknode_add(c_socklist_t *list,
return NULL;
}
return socknode_add_internal(list, addr);
return socknode_add_internal(list, sa_list);
}
status_t socknode_remove(c_socklist_t *list, c_socknode_t *node)
@ -333,7 +333,7 @@ status_t socknode_remove(c_socklist_t *list, c_socknode_t *node)
list_remove(list, node);
core_freeaddrinfo(node->addr);
core_freeaddrinfo(node->sa_list);
pool_free_node(&socknode_pool, node);
return CORE_OK;
@ -430,17 +430,17 @@ status_t socknode_filter_family(c_socklist_t *list, int family)
next_node = list_next(node);
prev_addr = NULL;
addr = node->addr;
addr = node->sa_list;
while(addr)
{
next_addr = addr->next;
if (addr->c_sa_family == family)
if (addr->c_sa_family != family)
{
if (prev_addr)
prev_addr->next = addr->next;
else
node->addr = addr->next;
node->sa_list = addr->next;
core_free(addr);
}
@ -448,7 +448,7 @@ status_t socknode_filter_family(c_socklist_t *list, int family)
addr = next_addr;
}
if (node->addr == NULL)
if (node->sa_list == NULL)
socknode_remove(list, node);
node = next_node;

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

@ -344,33 +344,33 @@ static void sock_test7(abts_case *tc, void *data)
node = socknode_add(&list, AF_INET6, NULL, PORT, 0);
ABTS_PTR_NOTNULL(tc, node);
rv = socknode_filter_family(&list, AF_INET);
rv = socknode_filter_family(&list, AF_INET6);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
node = list_first(&list);
ABTS_PTR_NOTNULL(tc, node);
rv = socknode_filter_family(&list, AF_INET6);
rv = socknode_filter_family(&list, AF_INET);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
node = list_first(&list);
ABTS_PTR_NULL(tc, node);
node = socknode_add(&list, AF_INET, NULL, PORT, AI_PASSIVE);
ABTS_PTR_NOTNULL(tc, node);
rv = socknode_filter_family(&list, AF_INET6);
rv = socknode_filter_family(&list, AF_INET);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
node = list_first(&list);
ABTS_PTR_NOTNULL(tc, node);
rv = socknode_filter_family(&list, AF_INET);
rv = socknode_filter_family(&list, AF_INET6);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
node = list_first(&list);
ABTS_PTR_NULL(tc, node);
node = socknode_add(&list, AF_UNSPEC, NULL, PORT, 0);
ABTS_PTR_NOTNULL(tc, node);
rv = socknode_filter_family(&list, AF_INET);
rv = socknode_filter_family(&list, AF_INET6);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
node = list_first(&list);
ABTS_PTR_NOTNULL(tc, node);
rv = socknode_filter_family(&list, AF_INET6);
rv = socknode_filter_family(&list, AF_INET);
ABTS_INT_EQUAL(tc, CORE_OK, rv);
node = list_first(&list);
ABTS_PTR_NULL(tc, node);
@ -384,21 +384,21 @@ static void sock_test7(abts_case *tc, void *data)
node = list_first(&list);
ABTS_PTR_NOTNULL(tc, node);
addr = node->addr;
addr = node->sa_list;
ABTS_PTR_NOTNULL(tc, addr);
ABTS_STR_EQUAL(tc, "::1", CORE_ADDR(addr, buf));
ABTS_INT_EQUAL(tc, PORT, CORE_PORT(addr));
node = list_next(node);
ABTS_PTR_NOTNULL(tc, node);
addr = node->addr;
addr = node->sa_list;
ABTS_PTR_NOTNULL(tc, addr);
ABTS_STR_EQUAL(tc, "0.0.0.0", CORE_ADDR(addr, buf));
ABTS_INT_EQUAL(tc, PORT, CORE_PORT(addr));
node = list_next(node);
ABTS_PTR_NOTNULL(tc, node);
addr = node->addr;
addr = node->sa_list;
ABTS_PTR_NOTNULL(tc, addr);
ABTS_INT_EQUAL(tc, PORT, CORE_PORT(addr));

32
lib/gtp/gtp_path.c
View File

@ -14,39 +14,13 @@ status_t gtp_server(sock_id *new, c_sockaddr_t *sa, sock_handler handler)
status_t rv;
char buf[CORE_ADDRSTRLEN];
while(sa)
{
rv = udp_socket(new, sa->c_sa_family);
d_assert(rv == CORE_OK, return CORE_ERROR,);
d_assert(sock_setsockopt(*new, SOCK_O_REUSEADDR, 1) == CORE_OK,
return CORE_ERROR,
"setsockopt(%s:%d) failed(%d:%s)",
CORE_ADDR(sa, buf), CORE_PORT(sa), errno, strerror(errno));
if (sock_bind(*new, sa) == CORE_OK)
{
d_trace(1, "udp bind %s:%d\n", CORE_ADDR(sa, buf), CORE_PORT(sa));
break;
}
rv = sock_delete(*new);
d_assert(rv == CORE_OK, return CORE_ERROR,);
sa = sa->next;
}
if (sa == NULL)
{
d_error("udp bind(%s:%d) failed(%d:%s)",
CORE_ADDR(sa, buf), CORE_PORT(sa), errno, strerror(errno));
return CORE_ERROR;
}
rv = sock_register(*new, handler, NULL);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = sock_register(*new, handler, NULL);
d_assert(rv == CORE_OK, return CORE_ERROR,);
d_trace(1, "gtp_server [%s]:%d\n", CORE_ADDR(sa, buf), CORE_PORT(sa));
d_trace(1, "gtp_server() [%s]:%d\n", CORE_ADDR(sa, buf), CORE_PORT(sa));
return CORE_OK;
}

165
src/mme/mme_context.c
View File

@ -27,7 +27,6 @@
static mme_context_t self;
pool_declare(mme_s1ap_pool, mme_s1ap_t, MAX_NUM_OF_S1AP_SERVER);
pool_declare(mme_gtpc_pool, mme_gtpc_t, MAX_NUM_OF_GTP_SERVER);
pool_declare(mme_sgw_pool, mme_sgw_t, MAX_NUM_OF_GTP_CLIENT);
index_declare(mme_enb_pool, mme_enb_t, MAX_NUM_OF_ENB);
@ -48,8 +47,10 @@ status_t mme_context_init()
pool_init(&mme_s1ap_pool, MAX_NUM_OF_S1AP_SERVER);
list_init(&self.s1ap_list);
pool_init(&mme_gtpc_pool, MAX_NUM_OF_GTP_SERVER);
list_init(&self.gtpc_list);
list_init(&self.gtpc4_list);
list_init(&self.gtpc6_list);
pool_init(&mme_sgw_pool, MAX_NUM_OF_GTP_CLIENT);
list_init(&self.sgw_list);
@ -80,7 +81,6 @@ status_t mme_context_final()
"MME context already has been finalized");
mme_s1ap_remove_all();
mme_gtpc_remove_all();
mme_sgw_remove_all();
mme_enb_remove_all();
@ -109,8 +109,10 @@ status_t mme_context_final()
index_final(&mme_enb_pool);
pool_final(&mme_sgw_pool);
socknode_remove_all(&self.gtpc4_list);
socknode_remove_all(&self.gtpc6_list);
pool_final(&mme_s1ap_pool);
pool_final(&mme_gtpc_pool);
context_initialized = 0;
@ -284,6 +286,13 @@ status_t mme_context_parse_config()
break;
yaml_iter_recurse(&s1ap_array, &s1ap_iter);
}
else if (yaml_iter_type(&s1ap_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&s1ap_iter))
{
@ -327,9 +336,7 @@ status_t mme_context_parse_config()
yaml_iter_recurse(&mme_iter, &gtpc_array);
do
{
#if 0
mme_gtpc_t *gtpc = NULL;
#endif
c_socknode_t *node = NULL;
int family = AF_UNSPEC;
const char *hostname = NULL;
c_uint16_t port = GTPV2_C_UDP_PORT;
@ -346,6 +353,13 @@ status_t mme_context_parse_config()
break;
yaml_iter_recurse(&gtpc_array, &gtpc_iter);
}
else if (yaml_iter_type(&gtpc_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpc_iter))
{
@ -386,12 +400,50 @@ status_t mme_context_parse_config()
d_warn("unknown key `%s`", gtpc_key);
}
#if 0
gtpc = mme_gtpc_add(family, hostname, port);
d_assert(gtpc, return CORE_ERROR,);
#endif
if (context_self()->parameter.no_ipv4 == 0)
{
node = socknode_add(&self.gtpc4_list,
family, hostname, port, AI_PASSIVE);
d_assert(node, return CORE_ERROR,);
rv = socknode_filter_family(
&self.gtpc4_list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 0)
{
node = socknode_add(&self.gtpc6_list,
family, hostname, port, AI_PASSIVE);
d_assert(node, return CORE_ERROR,);
rv = socknode_filter_family(
&self.gtpc6_list, AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
} while(yaml_iter_type(&gtpc_array) == YAML_SEQUENCE_NODE);
if (list_first(&self.gtpc4_list) == NULL &&
list_first(&self.gtpc6_list) == NULL)
{
if (context_self()->parameter.no_ipv4 == 0)
{
rv = socknode_getifaddrs_to_list(
&self.gtpc4_list, self.gtpc_port);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = socknode_filter_family(
&self.gtpc4_list, AF_INET);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
if (context_self()->parameter.no_ipv6 == 0)
{
rv = socknode_getifaddrs_to_list(
&self.gtpc6_list, self.gtpc_port);
d_assert(rv == CORE_OK, return CORE_ERROR,);
rv = socknode_filter_family(&self.gtpc6_list,
AF_INET6);
d_assert(rv == CORE_OK, return CORE_ERROR,);
}
}
}
else if (!strcmp(mme_key, "gummei"))
{
@ -420,6 +472,13 @@ status_t mme_context_parse_config()
yaml_iter_recurse(&gummei_array,
&gummei_iter);
}
else if (yaml_iter_type(&gummei_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gummei_iter))
{
@ -455,6 +514,13 @@ status_t mme_context_parse_config()
yaml_iter_recurse(&plmn_id_array,
&plmn_id_iter);
}
else if (yaml_iter_type(&plmn_id_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&plmn_id_iter))
{
@ -607,6 +673,12 @@ status_t mme_context_parse_config()
yaml_iter_recurse(&tai_array,
&tai_iter);
}
else if (yaml_iter_type(&tai_array) == YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&tai_iter))
{
@ -816,6 +888,13 @@ status_t mme_context_parse_config()
break;
yaml_iter_recurse(&gtpc_array, &gtpc_iter);
}
else if (yaml_iter_type(&gtpc_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpc_iter))
{
@ -895,6 +974,13 @@ status_t mme_context_parse_config()
break;
yaml_iter_recurse(&gtpc_array, &gtpc_iter);
}
else if (yaml_iter_type(&gtpc_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpc_iter))
{
@ -1108,59 +1194,6 @@ mme_s1ap_t* mme_s1ap_next(mme_s1ap_t *s1ap)
return list_next(s1ap);
}
mme_gtpc_t* mme_gtpc_add(c_sockaddr_t *addr)
{
mme_gtpc_t *gtpc = NULL;
pool_alloc_node(&mme_gtpc_pool, &gtpc);
d_assert(gtpc, return NULL, "Null param");
memset(gtpc, 0, sizeof(mme_gtpc_t));
gtpc->addr = addr;
list_append(&self.gtpc_list, gtpc);
return gtpc;
}
status_t mme_gtpc_remove(mme_gtpc_t *gtpc)
{
d_assert(gtpc, return CORE_ERROR, "Null param");
list_remove(&self.gtpc_list, gtpc);
pool_free_node(&mme_gtpc_pool, gtpc);
return CORE_OK;
}
status_t mme_gtpc_remove_all()
{
mme_gtpc_t *gtpc = NULL, *next_gtpc = NULL;
gtpc = mme_gtpc_first();
while (gtpc)
{
next_gtpc = mme_gtpc_next(gtpc);
mme_gtpc_remove(gtpc);
gtpc = next_gtpc;
}
return CORE_OK;
}
mme_gtpc_t* mme_gtpc_first()
{
return list_first(&self.gtpc_list);
}
mme_gtpc_t* mme_gtpc_next(mme_gtpc_t *gtpc)
{
return list_next(gtpc);
}
mme_sgw_t* mme_sgw_add()
{
mme_sgw_t *sgw = NULL;

10
src/mme/mme_context.h
View File

@ -41,7 +41,6 @@ typedef struct _mme_ue_t mme_ue_t;
typedef struct _gtp_node_t gtp_node_t;
typedef struct _gtp_xact_t gtp_xact_t;
typedef gtp_node_t mme_gtpc_t;
typedef gtp_node_t mme_sgw_t;
typedef struct _served_gummei {
@ -58,7 +57,8 @@ typedef struct _mme_context_t {
const char *fd_conf_path; /* MME freeDiameter conf path */
list_t s1ap_list; /* MME S1AP Server List */
list_t gtpc_list; /* MME GTPC Server List */
c_socklist_t gtpc4_list; /* MME GTPC IPv4 Server List */
c_socklist_t gtpc6_list; /* MME GTPC IPv6 Server List */
list_t sgw_list; /* SGW GTPC Client List */
c_uint32_t gtpc_addr; /* MME GTPC local address */
@ -459,12 +459,6 @@ CORE_DECLARE(status_t) mme_s1ap_remove_all(void);
CORE_DECLARE(mme_s1ap_t*) mme_s1ap_first(void);
CORE_DECLARE(mme_s1ap_t*) mme_s1ap_next(mme_s1ap_t *s1ap);
CORE_DECLARE(mme_gtpc_t*) mme_gtpc_add(c_sockaddr_t *addr);
CORE_DECLARE(status_t) mme_gtpc_remove(mme_gtpc_t *gtpc);
CORE_DECLARE(status_t) mme_gtpc_remove_all(void);
CORE_DECLARE(mme_gtpc_t*) mme_gtpc_first(void);
CORE_DECLARE(mme_gtpc_t*) mme_gtpc_next(mme_gtpc_t *gtpc);
CORE_DECLARE(mme_sgw_t*) mme_sgw_add(void);
CORE_DECLARE(status_t) mme_sgw_remove(mme_sgw_t *sgw);
CORE_DECLARE(status_t) mme_sgw_remove_all(void);

21
src/pgw/pgw_context.c
View File

@ -198,6 +198,13 @@ status_t pgw_context_parse_config()
break;
yaml_iter_recurse(&gtpc_array, &gtpc_iter);
}
else if (yaml_iter_type(&gtpc_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpc_iter))
{
@ -270,6 +277,13 @@ status_t pgw_context_parse_config()
break;
yaml_iter_recurse(&gtpu_array, &gtpu_iter);
}
else if (yaml_iter_type(&gtpu_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpu_iter))
{
@ -344,6 +358,13 @@ status_t pgw_context_parse_config()
yaml_iter_recurse(&ue_network_array,
&ue_network_iter);
}
else if (yaml_iter_type(&ue_network_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&ue_network_iter))
{

104
src/sgw/sgw_context.c
View File

@ -108,96 +108,6 @@ static status_t sgw_context_validation()
return CORE_OK;
}
#if 0
status_t sgw_context_parse_config()
{
status_t rv;
config_t *config = &context_self()->config;
bson_iter_t iter;
c_uint32_t length = 0;
d_assert(config, return CORE_ERROR, );
rv = sgw_context_prepare();
if (rv != CORE_OK) return rv;
if (!bson_iter_init(&iter, config->bson))
{
d_error("bson_iter_init failed in this document");
return CORE_ERROR;
}
while(bson_iter_next(&iter))
{
const char *key = bson_iter_key(&iter);
if (!strcmp(key, "SGW") && BSON_ITER_HOLDS_DOCUMENT(&iter))
{
bson_iter_t sgw_iter;
bson_iter_recurse(&iter, &sgw_iter);
while(bson_iter_next(&sgw_iter))
{
const char *sgw_key = bson_iter_key(&sgw_iter);
if (!strcmp(sgw_key, "NETWORK"))
{
bson_iter_t network_iter;
if (BSON_ITER_HOLDS_ARRAY(&sgw_iter))
{
bson_iter_t array_iter;
bson_iter_recurse(&sgw_iter, &array_iter);
if (bson_iter_next(&array_iter))
{
/* We will pick only first item of SGW.NETWORK
* if the type is an array */
bson_iter_recurse(&array_iter, &network_iter);
}
}
else if (BSON_ITER_HOLDS_DOCUMENT(&sgw_iter))
{
bson_iter_recurse(&sgw_iter, &network_iter);
}
else
d_assert(0, return CORE_ERROR,);
while(bson_iter_next(&network_iter))
{
const char *network_key = bson_iter_key(&network_iter);
if (!strcmp(network_key, "GTPC_IPV4") &&
BSON_ITER_HOLDS_UTF8(&network_iter))
{
const char *v =
bson_iter_utf8(&network_iter, &length);
if (v) self.gtpc_addr = inet_addr(v);
}
else if (!strcmp(network_key, "GTPC_PORT") &&
BSON_ITER_HOLDS_INT32(&network_iter))
{
self.gtpc_port = bson_iter_int32(&network_iter);
}
else if (!strcmp(network_key, "GTPU_IPV4") &&
BSON_ITER_HOLDS_UTF8(&network_iter))
{
const char *v =
bson_iter_utf8(&network_iter, &length);
if (v) self.gtpu_addr = inet_addr(v);
}
else if (!strcmp(network_key, "GTPU_PORT") &&
BSON_ITER_HOLDS_UTF8(&network_iter))
{
self.gtpu_port = bson_iter_int32(&network_iter);
}
}
}
}
}
}
rv = sgw_context_validation();
if (rv != CORE_OK) return rv;
return CORE_OK;
}
#endif
status_t sgw_context_parse_config()
{
status_t rv;
@ -250,6 +160,13 @@ status_t sgw_context_parse_config()
break;
yaml_iter_recurse(&gtpc_array, &gtpc_iter);
}
else if (yaml_iter_type(&gtpc_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpc_iter))
{
@ -322,6 +239,13 @@ status_t sgw_context_parse_config()
break;
yaml_iter_recurse(&gtpu_array, &gtpu_iter);
}
else if (yaml_iter_type(&gtpu_array) ==
YAML_SCALAR_NODE)
{
break;
}
else
d_assert(0, return CORE_ERROR,);
while(yaml_iter_next(&gtpu_iter))
{