paulmataruso/open5gs
1
0
Fork 0
mirror of https://github.com/open5gs/open5gs.git synced 2025-11-02 04:53:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

update it

Browse Source
This commit is contained in:
Sukchan Lee
2017-11-27 23:53:47 +09:00
parent 0b78387d7f
commit 1528568bb8
4 changed files with 334 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

121
src/app/context.c
View File

@@ -135,8 +135,7 @@ status_t context_parse_config()
status_t rv;
config_t *config = &self.config;
yaml_document_t *document = NULL;
yaml_node_pair_t *root_pair;
yaml_node_t *root_node = NULL;
yaml_iter_t root_iter;
d_assert(config, return CORE_ERROR,);
document = config->document;
@@ -145,123 +144,87 @@ status_t context_parse_config()
rv = context_prepare();
if (rv != CORE_OK) return rv;
root_node = yaml_document_get_root_node(document);
if (root_node == NULL || root_node->type != YAML_MAPPING_NODE)
yaml_iter_init(&root_iter, document);
while(yaml_iter_next(&root_iter))
{
d_warn("No content in configuration file '%s'", config->path);
return CORE_OK;
}
for (root_pair = root_node->data.mapping.pairs.start;
root_pair < root_node->data.mapping.pairs.top; root_pair++)
{
const char *root_key =
YAML_MAPPING_KEY(document, root_pair);
const char *root_key = yaml_iter_key(&root_iter);
d_assert(root_key, return CORE_ERROR,);
if (!strcmp(root_key, "db_uri"))
{
self.db_uri = YAML_MAPPING_VALUE(document, root_pair);
self.db_uri = yaml_iter_value(&root_iter);
}
else if (!strcmp(root_key, "logger"))
{
yaml_node_pair_t *logger_pair = NULL;
yaml_node_t *logger_node =
yaml_document_get_node(document, root_pair->value);
if (logger_node == NULL || logger_node->type != YAML_MAPPING_NODE)
continue;
for (logger_pair = logger_node->data.mapping.pairs.start;
logger_pair < logger_node->data.mapping.pairs.top;
logger_pair++)
yaml_iter_t logger_iter;
yaml_iter_recurse(&root_iter, &logger_iter);
while(yaml_iter_next(&logger_iter))
{
const char *logger_key =
YAML_MAPPING_KEY(document, logger_pair);
const char *logger_key = yaml_iter_key(&logger_iter);
d_assert(logger_key, return CORE_ERROR,);
if (!strcmp(logger_key, "file"))
{
self.logger.file = YAML_MAPPING_VALUE(document, logger_pair);
self.logger.file = yaml_iter_value(&logger_iter);
}
else if (!strcmp(logger_key, "console"))
{
const char *v = YAML_MAPPING_VALUE(document, logger_pair);
const char *v = yaml_iter_value(&logger_iter);
if (v) self.logger.console = atoi(v);
}
else if (!strcmp(logger_key, "syslog"))
{
self.logger.syslog = YAML_MAPPING_VALUE(document, logger_pair);
self.logger.syslog = yaml_iter_value(&logger_iter);
}
else if (!strcmp(logger_key, "network"))
{
yaml_node_pair_t *network_pair = NULL;
yaml_node_t *network_node =
yaml_document_get_node(document, logger_pair->value);
if (network_node == NULL ||
network_node->type != YAML_MAPPING_NODE)
continue;
for (network_pair = network_node->data.mapping.pairs.start;
network_pair < network_node->data.mapping.pairs.top;
network_pair++)
yaml_iter_t network_iter;
yaml_iter_recurse(&logger_iter, &network_iter);
while(yaml_iter_next(&network_iter))
{
const char *network_key =
YAML_MAPPING_KEY(document, network_pair);
const char *network_key = yaml_iter_key(&network_iter);
d_assert(network_key, return CORE_ERROR,);
if (!strcmp(network_key, "file"))
{
self.logger.network.file =
YAML_MAPPING_VALUE(document, network_pair);
yaml_iter_value(&network_iter);
}
else if (!strcmp(network_key, "unixDomain"))
{
self.logger.network.unix_domain =
YAML_MAPPING_VALUE(document, network_pair);
yaml_iter_value(&network_iter);
}
}
}
else if (!strcmp(logger_key, "trace"))
{
yaml_node_pair_t *trace_pair = NULL;
yaml_node_t *trace_node =
yaml_document_get_node(document, logger_pair->value);
if (trace_node == NULL ||
trace_node->type != YAML_MAPPING_NODE)
continue;
for (trace_pair = trace_node->data.mapping.pairs.start;
trace_pair < trace_node->data.mapping.pairs.top;
trace_pair++)
yaml_iter_t trace_iter;
yaml_iter_recurse(&logger_iter, &trace_iter);
while(yaml_iter_next(&trace_iter))
{
const char *trace_key =
YAML_MAPPING_KEY(document, trace_pair);
const char *trace_key = yaml_iter_key(&trace_iter);
d_assert(trace_key, return CORE_ERROR,);
if (!strcmp(trace_key, "s1ap"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
const char *v = yaml_iter_value(&trace_iter);
if (v) self.logger.trace.s1ap = atoi(v);
}
else if (!strcmp(trace_key, "nas"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
const char *v = yaml_iter_value(&trace_iter);
if (v) self.logger.trace.nas = atoi(v);
}
else if (!strcmp(trace_key, "diameter"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
const char *v = yaml_iter_value(&trace_iter);
if (v) self.logger.trace.fd = atoi(v);
}
else if (!strcmp(trace_key, "gtp"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
const char *v = yaml_iter_value(&trace_iter);
if (v) self.logger.trace.gtp = atoi(v);
}
else if (!strcmp(trace_key, "others"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
const char *v = yaml_iter_value(&trace_iter);
if (v) self.logger.trace.others = atoi(v);
}
}
@@ -270,54 +233,46 @@ status_t context_parse_config()
}
else if (!strcmp(root_key, "parameter"))
{
yaml_node_pair_t *parameter_pair = NULL;
yaml_node_t *parameter_node =
yaml_document_get_node(document, root_pair->value);
if (parameter_node == NULL ||
parameter_node->type != YAML_MAPPING_NODE)
continue;
for (parameter_pair = parameter_node->data.mapping.pairs.start;
parameter_pair < parameter_node->data.mapping.pairs.top;
parameter_pair++)
yaml_iter_t parameter_iter;
yaml_iter_recurse(&root_iter, &parameter_iter);
while(yaml_iter_next(&parameter_iter))
{
const char *parameter_key =
YAML_MAPPING_KEY(document, parameter_pair);
const char *parameter_key = yaml_iter_key(&parameter_iter);
d_assert(parameter_key, return CORE_ERROR,);
if (!strcmp(parameter_key, "no_hss"))
{
self.parameter.no_hss =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
else if (!strcmp(parameter_key, "no_sgw"))
{
self.parameter.no_sgw =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
else if (!strcmp(parameter_key, "no_pgw"))
{
self.parameter.no_pgw =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
else if (!strcmp(parameter_key, "no_pcrf"))
{
self.parameter.no_pcrf =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
else if (!strcmp(parameter_key, "no_ipv4"))
{
self.parameter.no_ipv4 =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
else if (!strcmp(parameter_key, "no_ipv6"))
{
self.parameter.no_ipv6 =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
else if (!strcmp(parameter_key, "prefer_ipv4"))
{
self.parameter.prefer_ipv4 =
YAML_MAPPING_BOOL(document, parameter_pair);
yaml_iter_bool(&parameter_iter);
}
}
}

172
src/app/yaml_helper.c
View File

@@ -2,44 +2,156 @@
#include "yaml_helper.h"
const char *YAML_MAPPING_KEY(
yaml_document_t *document, yaml_node_pair_t *node_pair)
void yaml_iter_init(yaml_iter_t *iter, yaml_document_t *document)
{
yaml_node_t *node = NULL;
d_assert(iter, return,);
d_assert(document, return,);
node = yaml_document_get_node(document, node_pair->key);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
memset(iter, 0, sizeof(yaml_iter_t));
return (const char *)node->data.scalar.value;
iter->document = document;
iter->node = yaml_document_get_root_node(document);
d_assert(iter->node, return,);
if (iter->node->type == YAML_MAPPING_NODE)
iter->pair = iter->node->data.mapping.pairs.start - 1;
else if (iter->node->type == YAML_SEQUENCE_NODE)
iter->item = iter->node->data.sequence.items.start - 1;
}
const char *YAML_MAPPING_VALUE(
yaml_document_t *document, yaml_node_pair_t *node_pair)
int yaml_iter_next(yaml_iter_t *iter)
{
yaml_node_t *node = NULL;
d_assert(iter, return 0,);
d_assert(iter->document, return 0,);
d_assert(iter->node, return 0,);
node = yaml_document_get_node(document, node_pair->value);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
if (iter->node->type == YAML_MAPPING_NODE)
{
if (iter->pair)
{
iter->pair++;
if (iter->pair < iter->node->data.mapping.pairs.top)
return 1;
}
return (const char *)node->data.scalar.value;
}
int YAML_MAPPING_BOOL(
yaml_document_t *document, yaml_node_pair_t *node_pair)
{
yaml_node_t *node = NULL;
const char *v = NULL;
node = yaml_document_get_node(document, node_pair->value);
d_assert(node, return 0,);
d_assert(node->type == YAML_SCALAR_NODE, return 0,);
v = (const char *)node->data.scalar.value;
d_assert(v, return 0,);
if (!strcasecmp(v, "true") || !strcasecmp(v, "yes")) return 1;
if (atoi(v)) return 1;
}
else if (iter->node->type == YAML_SEQUENCE_NODE)
{
if (iter->item)
{
iter->item++;
if (iter->item < iter->node->data.sequence.items.top)
return 1;
}
}
return 0;
}
void yaml_iter_recurse(yaml_iter_t *parent, yaml_iter_t *iter)
{
d_assert(parent, return,);
d_assert(parent->document, return,);
d_assert(parent->node, return,);
d_assert(iter, return,);
memset(iter, 0, sizeof(yaml_iter_t));
iter->document = parent->document;
if (parent->node->type == YAML_MAPPING_NODE)
{
d_assert(parent->pair, return,);
iter->node = yaml_document_get_node(
parent->document, parent->pair->value);
d_assert(iter->node, return,);
if (iter->node->type == YAML_MAPPING_NODE)
iter->pair = iter->node->data.mapping.pairs.start - 1;
else if (iter->node->type == YAML_SEQUENCE_NODE)
iter->item = iter->node->data.sequence.items.start - 1;
}
else if (parent->node->type == YAML_SEQUENCE_NODE)
{
d_assert(parent->item, return,);
iter->node = yaml_document_get_node(parent->document, *parent->item);
d_assert(iter->node, return,);
if (iter->node->type == YAML_MAPPING_NODE)
iter->pair = iter->node->data.mapping.pairs.start - 1;
else if (iter->node->type == YAML_SEQUENCE_NODE)
iter->item = iter->node->data.sequence.items.start - 1;
}
else
d_assert(0, return,);
}
int yaml_iter_type(yaml_iter_t *iter)
{
d_assert(iter, return 0,);
d_assert(iter->node, return 0,);
return iter->node->type;
}
const char *yaml_iter_key(yaml_iter_t *iter)
{
yaml_node_t *node = NULL;
d_assert(iter, return NULL,);
d_assert(iter->document, return NULL,);
d_assert(iter->node, return NULL,);
if (iter->node->type == YAML_MAPPING_NODE)
{
d_assert(iter->pair, return NULL,);
node = yaml_document_get_node(iter->document, iter->pair->key);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
return (const char *)node->data.scalar.value;
}
else if (iter->node->type == YAML_SEQUENCE_NODE)
{
d_assert(iter->item, return NULL,);
node = yaml_document_get_node(iter->document, *iter->item);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
return (const char *)node->data.scalar.value;
}
else
d_assert(0, return 0,);
}
const char *yaml_iter_value(yaml_iter_t *iter)
{
d_assert(iter, return NULL,);
d_assert(iter->document, return NULL,);
d_assert(iter->node, return NULL,);
if (iter->node->type == YAML_MAPPING_NODE)
{
yaml_node_t *node = NULL;
d_assert(iter->pair, return NULL,);
node = yaml_document_get_node(iter->document, iter->pair->value);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
return (const char *)node->data.scalar.value;
}
else
d_assert(0, return NULL,"type = %d\n", iter->node->type);
}
int yaml_iter_bool(yaml_iter_t *iter)
{
const char *v = yaml_iter_value(iter);
if (v)
{
if (!strcasecmp(v, "true") || !strcasecmp(v, "yes")) return 1;
if (atoi(v)) return 1;
}
return 0;
}

22
src/app/yaml_helper.h
View File

@@ -5,13 +5,21 @@
#include <yaml.h>
/* YAML helper functions */
CORE_DECLARE(const char *) YAML_MAPPING_KEY(
yaml_document_t *document, yaml_node_pair_t *node_pair);
CORE_DECLARE(const char *) YAML_MAPPING_VALUE(
yaml_document_t *document, yaml_node_pair_t *node_pair);
CORE_DECLARE(int) YAML_MAPPING_BOOL(
yaml_document_t *document, yaml_node_pair_t *node_pair);
typedef struct {
yaml_document_t *document;
yaml_node_t *node;
yaml_node_pair_t *pair;
yaml_node_item_t *item;
} yaml_iter_t;
CORE_DECLARE(void) yaml_iter_init(yaml_iter_t *iter, yaml_document_t *document);
CORE_DECLARE(int) yaml_iter_next(yaml_iter_t *iter);
CORE_DECLARE(void) yaml_iter_recurse(yaml_iter_t *parent, yaml_iter_t *iter);
CORE_DECLARE(int) yaml_iter_type(yaml_iter_t *iter);
CORE_DECLARE(const char *) yaml_iter_key(yaml_iter_t *iter);
CORE_DECLARE(const char *) yaml_iter_value(yaml_iter_t *iter);
CORE_DECLARE(int) yaml_iter_bool(yaml_iter_t *iter);
#ifdef __cplusplus
}

143
src/mme/mme_context.c
View File

@@ -282,7 +282,7 @@ status_t mme_context_parse_old_config()
int family = AF_UNSPEC;
const char *hostname = NULL;
c_uint16_t port = S1AP_SCTP_PORT;
#if 0
#if 1
mme_s1ap_t *s1ap = NULL;
#endif
@@ -334,7 +334,7 @@ status_t mme_context_parse_old_config()
}
}
#if 0
#if 1
s1ap = mme_s1ap_add(family, hostname, port);
d_assert(s1ap, return CORE_ERROR,);
#endif
@@ -380,7 +380,7 @@ status_t mme_context_parse_old_config()
}
else if (!strcmp(mme_key, "GUMMEI"))
{
#if 0
#if 1
int gummei_index = 0;
bson_iter_t gummei_array;
@@ -934,8 +934,11 @@ status_t mme_context_parse_config()
status_t rv;
config_t *config = &context_self()->config;
yaml_document_t *document = NULL;
yaml_iter_t root_iter;
#if 0
yaml_node_pair_t *root_pair;
yaml_node_t *root_node = NULL;
#endif
d_assert(config, return CORE_ERROR,);
document = config->document;
@@ -945,7 +948,138 @@ status_t mme_context_parse_config()
rv = context_prepare();
if (rv != CORE_OK) return rv;
#endif
yaml_iter_init(&root_iter, document);
while(yaml_iter_next(&root_iter))
{
const char *root_key = yaml_iter_key(&root_iter);
d_assert(root_key, return CORE_ERROR,);
printf("root_key = %s\n", root_key);
if (!strcmp(root_key, "mme"))
{
yaml_iter_t mme_iter;
yaml_iter_recurse(&root_iter, &mme_iter);
while(yaml_iter_next(&mme_iter))
{
const char *mme_key = yaml_iter_key(&mme_iter);
d_assert(mme_key, return CORE_ERROR,);
printf("mme_key = %s\n", mme_key);
if (!strcmp(mme_key, "freeDiameterConfigPath"))
{
self.fd_conf_path = yaml_iter_value(&mme_iter);
}
else if (!strcmp(mme_key, "relative_capacity"))
{
const char *v = yaml_iter_value(&mme_iter);
if (v) self.relative_capacity = atoi(v);
}
else if (!strcmp(mme_key, "s1ap"))
{
yaml_iter_t s1ap_array, s1ap_iter;
yaml_iter_recurse(&mme_iter, &s1ap_array);
while(yaml_iter_next(&s1ap_array))
{
if (yaml_iter_type(&s1ap_array) == YAML_MAPPING_NODE)
memcpy(&s1ap_iter, &s1ap_array,
sizeof(yaml_iter_t));
else if (yaml_iter_type(&s1ap_array) ==
YAML_SEQUENCE_NODE)
{
yaml_iter_recurse(&s1ap_array, &s1ap_iter);
d_assert(yaml_iter_next(&s1ap_iter),
return CORE_ERROR,);
}
else
d_assert(0, return CORE_ERROR,);
do
{
const char *s1ap_key = yaml_iter_key(&s1ap_iter);
d_assert(s1ap_key, return CORE_ERROR,);
printf("s1ap_ley = %s\n", s1ap_key);
} while(
yaml_iter_type(&s1ap_array) ==
YAML_SEQUENCE_NODE &&
yaml_iter_next(&s1ap_iter));
}
}
else if (!strcmp(mme_key, "gummei"))
{
yaml_iter_t gummei_array, gummei_iter;
yaml_iter_recurse(&mme_iter, &gummei_array);
while(yaml_iter_next(&gummei_array))
{
if (yaml_iter_type(&gummei_array) ==
YAML_MAPPING_NODE)
memcpy(&gummei_iter, &gummei_array,
sizeof(yaml_iter_t));
else if (yaml_iter_type(&gummei_array) ==
YAML_SEQUENCE_NODE)
{
yaml_iter_recurse(&gummei_array, &gummei_iter);
d_assert(yaml_iter_next(&gummei_iter),
return CORE_ERROR,);
}
else
d_assert(0, return CORE_ERROR,);
do
{
const char *gummei_key =
yaml_iter_key(&gummei_iter);
d_assert(gummei_key, return CORE_ERROR,);
if (!strcmp(gummei_key, "plmn_id"))
{
}
else if (!strcmp(gummei_key, "mme_gid"))
{
#if 0
yaml_iter_t mme_gid_array, mme_gid_iter;
yaml_iter_recurse(&gummei_iter, &mme_gid_array);
if (yaml_iter_type(&mme_gid_array) ==
YAML_SCALAR_NODE)
memcpy(&mme_gid_iter, &mme_gid_array,
sizeof(yaml_iter_t));
else if (yaml_iter_type(&mme_gid_array) ==
YAML_SEQUENCE_NODE)
{
yaml_iter_recurse(&mme_gid_array,
&mme_gid_iter);
d_assert(yaml_iter_next(&mme_gid_iter),
return CORE_ERROR,);
}
else
d_assert(0, return CORE_ERROR,);
do
{
const char *v =
yaml_iter_value(&mme_gid_iter);
printf("v = %s\n", v);
} while(
yaml_iter_type(&mme_gid_array) ==
YAML_SEQUENCE_NODE &&
yaml_iter_next(&mme_gid_iter));
#endif
}
} while(
yaml_iter_type(&gummei_array) ==
YAML_SEQUENCE_NODE &&
yaml_iter_next(&gummei_iter));
}
}
}
}
else if (!strcmp(root_key, "sgw"))
{
}
else if (!strcmp(root_key, "pgw"))
{
}
}
#if 0
root_node = yaml_document_get_root_node(document);
if (root_node == NULL || root_node->type != YAML_MAPPING_NODE)
{
@@ -1010,7 +1144,7 @@ status_t mme_context_parse_config()
}
else
d_assert(0, return CORE_ERROR,);
do
{
int family = AF_UNSPEC;
@@ -1445,6 +1579,7 @@ status_t mme_context_parse_config()
{
}
}
#endif
rv = mme_context_validation();
if (rv != CORE_OK) return rv;