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

context uses YAML config.

This commit is contained in:
Sukchan Lee 2017-11-27 14:58:53 +09:00
parent 8e40a0eb64
commit 8b5ae91547
8 changed files with 230 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/app/Makefile.am
View File

@ -3,8 +3,8 @@
noinst_LTLIBRARIES = libapp.la
libapp_la_SOURCES = \
context.h app.h \
context.c init.c \
context.h app.h yaml_helper.h \
context.c init.c yaml_helper.c \
$(NULL)
libapp_la_DEPENDENCIES = \

255
src/app/context.c
View File

@ -8,6 +8,7 @@
#include <yaml.h>
#include <mongoc.h>
#include "yaml_helper.h"
#include "context.h"
static context_t self;
@ -131,174 +132,196 @@ static status_t context_prepare()
status_t context_parse_config()
{
status_t rv;
config_t *config = &self.config;
yaml_document_t *document = NULL;
yaml_node_t *node = NULL;
yaml_node_pair_t *root_pair;
yaml_node_t *root_node = NULL;
d_assert(config, return CORE_ERROR,);
document = config->document;
d_assert(document, return CORE_ERROR,);
for (node = document->nodes.start; node < document->nodes.top; node++)
{
#if 0
switch (node->type)
{
case YAML_SCALAR_NODE:
printf("SCALAR: %s\n", node->data.scalar.value);
break;
case YAML_SEQUENCE_NODE:
printf("SEQUENCE\n");
break;
case YAML_MAPPING_NODE:
printf("MAPPIGNG\n");
break;
default:
d_assert(0, return CORE_ERROR,);
break;
}
#endif
}
return CORE_OK;
}
status_t context_parse_old_config()
{
status_t rv;
config_t *config = &self.config;
bson_iter_t iter;
c_uint32_t length = 0;
d_assert(config, return CORE_ERROR, );
rv = context_prepare();
if (rv != CORE_OK) return rv;
if (!bson_iter_init(&iter, config->bson))
root_node = yaml_document_get_root_node(document);
if (root_node == NULL || root_node->type != YAML_MAPPING_NODE)
{
d_error("bson_iter_init failed in this document");
return CORE_ERROR;
d_warn("No content in configuration file '%s'", config->path);
return CORE_OK;
}
while(bson_iter_next(&iter))
for (root_pair = root_node->data.mapping.pairs.start;
root_pair < root_node->data.mapping.pairs.top; root_pair++)
{
const char *key = bson_iter_key(&iter);
if (!strcmp(key, "DB_URI") && BSON_ITER_HOLDS_UTF8(&iter))
const char *root_key =
YAML_MAPPING_KEY(document, root_pair);
d_assert(root_key, return CORE_ERROR,);
if (!strcmp(root_key, "dbUri"))
{
self.db_uri = bson_iter_utf8(&iter, &length);
self.db_uri = YAML_MAPPING_VALUE(document, root_pair);
}
else if (!strcmp(key, "LOG") && BSON_ITER_HOLDS_DOCUMENT(&iter))
else if (!strcmp(root_key, "logger"))
{
bson_iter_t log_iter;
bson_iter_recurse(&iter, &log_iter);
while(bson_iter_next(&log_iter))
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++)
{
const char *log_key = bson_iter_key(&log_iter);
if (!strcmp(log_key, "CONSOLE") &&
BSON_ITER_HOLDS_INT32(&log_iter))
const char *logger_key =
YAML_MAPPING_KEY(document, logger_pair);
d_assert(logger_key, return CORE_ERROR,);
if (!strcmp(logger_key, "file"))
{
self.log.console = bson_iter_int32(&log_iter);
self.log.file = YAML_MAPPING_VALUE(document, logger_pair);
}
else if (!strcmp(log_key, "SYSLOG") &&
BSON_ITER_HOLDS_UTF8(&log_iter))
else if (!strcmp(logger_key, "console"))
{
self.log.syslog = bson_iter_utf8(&log_iter, &length);
const char *v = YAML_MAPPING_VALUE(document, logger_pair);
if (v) self.log.console = atoi(v);
}
else if (!strcmp(log_key, "SOCKET") &&
BSON_ITER_HOLDS_DOCUMENT(&log_iter))
else if (!strcmp(logger_key, "syslog"))
{
bson_iter_t socket_iter;
bson_iter_recurse(&log_iter, &socket_iter);
while(bson_iter_next(&socket_iter))
self.log.syslog = YAML_MAPPING_VALUE(document, logger_pair);
}
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++)
{
const char *socket_key = bson_iter_key(&socket_iter);
if (!strcmp(socket_key, "FILE") &&
BSON_ITER_HOLDS_UTF8(&socket_iter))
const char *network_key =
YAML_MAPPING_KEY(document, network_pair);
d_assert(network_key, return CORE_ERROR,);
if (!strcmp(network_key, "path"))
{
self.log.socket.file =
bson_iter_utf8(&socket_iter, &length);
self.log.socket.file =
YAML_MAPPING_VALUE(document, network_pair);
}
else if (!strcmp(socket_key, "UNIX_DOMAIN") &&
BSON_ITER_HOLDS_UTF8(&socket_iter))
else if (!strcmp(network_key, "unixDomain"))
{
self.log.socket.unix_domain =
bson_iter_utf8(&socket_iter, &length);
self.log.socket.unix_domain =
YAML_MAPPING_VALUE(document, network_pair);
}
}
}
else if (!strcmp(log_key, "FILE") &&
BSON_ITER_HOLDS_UTF8(&log_iter))
else if (!strcmp(logger_key, "trace"))
{
self.log.file = bson_iter_utf8(&log_iter, &length);
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++)
{
const char *trace_key =
YAML_MAPPING_KEY(document, trace_pair);
d_assert(trace_key, return CORE_ERROR,);
if (!strcmp(trace_key, "s1ap"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
if (v) self.trace_level.s1ap = atoi(v);
}
else if (!strcmp(trace_key, "nas"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
if (v) self.trace_level.nas = atoi(v);
}
else if (!strcmp(trace_key, "diameter"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
if (v) self.trace_level.fd = atoi(v);
}
else if (!strcmp(trace_key, "gtp"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
if (v) self.trace_level.gtp = atoi(v);
}
else if (!strcmp(trace_key, "others"))
{
const char *v =
YAML_MAPPING_VALUE(document, trace_pair);
if (v) self.trace_level.others = atoi(v);
}
}
}
}
}
else if (!strcmp(key, "TRACE") && BSON_ITER_HOLDS_DOCUMENT(&iter))
else if (!strcmp(root_key, "parameter"))
{
bson_iter_t trace_iter;
bson_iter_recurse(&iter, &trace_iter);
while(bson_iter_next(&trace_iter))
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++)
{
const char *trace_key = bson_iter_key(&trace_iter);
if (!strcmp(trace_key, "S1AP") &&
BSON_ITER_HOLDS_INT32(&trace_iter))
const char *parameter_key =
YAML_MAPPING_KEY(document, parameter_pair);
d_assert(parameter_key, return CORE_ERROR,);
if (!strcmp(parameter_key, "no_hss"))
{
self.trace_level.s1ap = bson_iter_int32(&trace_iter);
self.parameter.no_hss =
YAML_MAPPING_BOOL(document, parameter_pair);
}
else if (!strcmp(trace_key, "NAS") &&
BSON_ITER_HOLDS_INT32(&trace_iter))
else if (!strcmp(parameter_key, "no_sgw"))
{
self.trace_level.nas = bson_iter_int32(&trace_iter);
self.parameter.no_sgw =
YAML_MAPPING_BOOL(document, parameter_pair);
}
else if (!strcmp(trace_key, "FD") &&
BSON_ITER_HOLDS_INT32(&trace_iter))
else if (!strcmp(parameter_key, "no_pgw"))
{
self.trace_level.fd = bson_iter_int32(&trace_iter);
self.parameter.no_pgw =
YAML_MAPPING_BOOL(document, parameter_pair);
}
else if (!strcmp(trace_key, "GTP") &&
BSON_ITER_HOLDS_INT32(&trace_iter))
else if (!strcmp(parameter_key, "no_pcrf"))
{
self.trace_level.gtp = bson_iter_int32(&trace_iter);
self.parameter.no_pcrf =
YAML_MAPPING_BOOL(document, parameter_pair);
}
else if (!strcmp(trace_key, "OTHERS") &&
BSON_ITER_HOLDS_INT32(&trace_iter))
else if (!strcmp(parameter_key, "no_ipv4"))
{
self.trace_level.others = bson_iter_int32(&trace_iter);
self.parameter.no_ipv4 =
YAML_MAPPING_BOOL(document, parameter_pair);
}
}
}
else if (!strcmp(key, "NODE") && BSON_ITER_HOLDS_DOCUMENT(&iter))
{
bson_iter_t node_iter;
bson_iter_recurse(&iter, &node_iter);
while(bson_iter_next(&node_iter))
{
const char *node_key = bson_iter_key(&node_iter);
if (!strcmp(node_key, "DISABLE_HSS") &&
BSON_ITER_HOLDS_INT32(&node_iter))
else if (!strcmp(parameter_key, "no_ipv6"))
{
self.node.disable_hss = bson_iter_int32(&node_iter);
self.parameter.no_ipv6 =
YAML_MAPPING_BOOL(document, parameter_pair);
}
else if (!strcmp(node_key, "DISABLE_SGW") &&
BSON_ITER_HOLDS_INT32(&node_iter))
else if (!strcmp(parameter_key, "prefer_ipv4"))
{
self.node.disable_sgw = bson_iter_int32(&node_iter);
}
else if (!strcmp(node_key, "DISABLE_PGW") &&
BSON_ITER_HOLDS_INT32(&node_iter))
{
self.node.disable_pgw = bson_iter_int32(&node_iter);
}
else if (!strcmp(node_key, "DISABLE_PCRF") &&
BSON_ITER_HOLDS_INT32(&node_iter))
{
self.node.disable_pcrf = bson_iter_int32(&node_iter);
self.parameter.prefer_ipv4 =
YAML_MAPPING_BOOL(document, parameter_pair);
}
}
}
}
return CORE_OK;
}

16
src/app/context.h
View File

@ -49,11 +49,17 @@ typedef struct _context_t {
} trace_level;
struct {
int disable_hss;
int disable_sgw;
int disable_pgw;
int disable_pcrf;
} node;
/* Element */
int no_hss;
int no_sgw;
int no_pgw;
int no_pcrf;
/* Network */
int no_ipv4;
int no_ipv6;
int prefer_ipv4;
} parameter;
} context_t;

4
src/app/init.c
View File

@ -9,7 +9,7 @@
#include "app.h"
#define DEFAULT_CONFIG_FILE_PATH_JSON SYSCONF_DIR PACKAGE "/nextepc.json"
#define DEFAULT_CONFIG_FILE_PATH SYSCONF_DIR PACKAGE "/nextepc.json"
#define DEFAULT_CONFIG_FILE_PATH SYSCONF_DIR PACKAGE "/nextepc.conf"
#define DEFAULT_RUNTIME_DIR_PATH LOCALSTATE_DIR "run/"
static status_t app_logger_init();
@ -34,8 +34,10 @@ status_t app_will_initialize(const char *config_path, const char *log_path)
rv = context_read_old_file();
if (rv != CORE_OK) return rv;
#if 0
rv = context_parse_old_config();
if (rv != CORE_OK) return rv;
#endif
rv = context_read_file();
if (rv != CORE_OK) return rv;

46
src/app/yaml_helper.c Normal file
View File

@ -0,0 +1,46 @@
#define TRACE_MODULE _yaml_helper
#include "yaml_helper.h"
const char *YAML_MAPPING_KEY(
yaml_document_t *document, yaml_node_pair_t *node_pair)
{
yaml_node_t *node = NULL;
node = yaml_document_get_node(document, node_pair->key);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
return (const char *)node->data.scalar.value;
}
const char *YAML_MAPPING_VALUE(
yaml_document_t *document, yaml_node_pair_t *node_pair)
{
yaml_node_t *node = NULL;
node = yaml_document_get_node(document, node_pair->value);
d_assert(node, return NULL,);
d_assert(node->type == YAML_SCALAR_NODE, return NULL,);
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;
return 0;
}

20
src/app/yaml_helper.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef __YAML_HELPER_H__
#define __YAML_HELPER_H__
#include "core_debug.h"
#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);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __YAML_HELPER_H__ */

16
src/epc.c
View File

@ -41,7 +41,7 @@ status_t app_initialize(const char *config_path, const char *log_path)
semaphore_create(&pcrf_sem1, 0); /* copied to PCRF/PGW/SGW/HSS process */
semaphore_create(&pcrf_sem2, 0); /* copied to PCRF/PGW/SGW/HSS process */
if (context_self()->node.disable_pcrf == 0)
if (context_self()->parameter.no_pcrf == 0)
{
pid = fork();
d_assert(pid >= 0, _exit(EXIT_FAILURE), "fork() failed");
@ -85,7 +85,7 @@ status_t app_initialize(const char *config_path, const char *log_path)
semaphore_create(&pgw_sem1, 0); /* copied to PGW/SGW/HSS process */
semaphore_create(&pgw_sem2, 0); /* copied to PGW/SGW/HSS process */
if (context_self()->node.disable_pgw == 0)
if (context_self()->parameter.no_pgw == 0)
{
pid = fork();
d_assert(pid >= 0, _exit(EXIT_FAILURE), "fork() failed");
@ -133,7 +133,7 @@ status_t app_initialize(const char *config_path, const char *log_path)
semaphore_create(&sgw_sem1, 0); /* copied to SGW/HSS process */
semaphore_create(&sgw_sem2, 0); /* copied to SGW/HSS process */
if (context_self()->node.disable_sgw == 0)
if (context_self()->parameter.no_sgw == 0)
{
pid = fork();
d_assert(pid >= 0, _exit(EXIT_FAILURE), "fork() failed");
@ -183,7 +183,7 @@ status_t app_initialize(const char *config_path, const char *log_path)
semaphore_create(&hss_sem1, 0); /* copied to HSS process */
semaphore_create(&hss_sem2, 0); /* copied to HSS process */
if (context_self()->node.disable_hss == 0)
if (context_self()->parameter.no_hss == 0)
{
pid = fork();
d_assert(pid >= 0, _exit(EXIT_FAILURE), "fork() failed");
@ -247,7 +247,7 @@ void app_terminate(void)
mme_terminate();
d_trace(1, "MME terminate...done\n");
if (context_self()->node.disable_hss == 0)
if (context_self()->parameter.no_hss == 0)
{
if (hss_sem2) semaphore_post(hss_sem2);
if (hss_sem1) semaphore_wait(hss_sem1);
@ -255,7 +255,7 @@ void app_terminate(void)
if (hss_sem1) semaphore_delete(hss_sem1);
if (hss_sem2) semaphore_delete(hss_sem2);
if (context_self()->node.disable_sgw == 0)
if (context_self()->parameter.no_sgw == 0)
{
if (sgw_sem2) semaphore_post(sgw_sem2);
if (sgw_sem1) semaphore_wait(sgw_sem1);
@ -263,7 +263,7 @@ void app_terminate(void)
if (sgw_sem1) semaphore_delete(sgw_sem1);
if (sgw_sem2) semaphore_delete(sgw_sem2);
if (context_self()->node.disable_pgw == 0)
if (context_self()->parameter.no_pgw == 0)
{
if (pgw_sem2) semaphore_post(pgw_sem2);
if (pgw_sem1) semaphore_wait(pgw_sem1);
@ -271,7 +271,7 @@ void app_terminate(void)
if (pgw_sem1) semaphore_delete(pgw_sem1);
if (pgw_sem2) semaphore_delete(pgw_sem2);
if (context_self()->node.disable_pcrf == 0)
if (context_self()->parameter.no_pcrf == 0)
{
if (pcrf_sem2) semaphore_post(pcrf_sem2);
if (pcrf_sem1) semaphore_wait(pcrf_sem1);

2
support/config/nextepc.conf.in
View File

@ -1,7 +1,7 @@
dbUri: "mongodb://localhost/nextepc"
logger:
path: "@LOCALSTATE_DIR@/log/nextepc/nextepc.log"
file: "@LOCALSTATE_DIR@/log/nextepc/nextepc.log"
trace:
s1ap: 1
nas: 1