diff --git a/src/app/context.c b/src/app/context.c index 672e0ff6f..07b69d8ef 100644 --- a/src/app/context.c +++ b/src/app/context.c @@ -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, ¶meter_iter); + while(yaml_iter_next(¶meter_iter)) { - const char *parameter_key = - YAML_MAPPING_KEY(document, parameter_pair); + const char *parameter_key = yaml_iter_key(¶meter_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(¶meter_iter); } else if (!strcmp(parameter_key, "no_sgw")) { self.parameter.no_sgw = - YAML_MAPPING_BOOL(document, parameter_pair); + yaml_iter_bool(¶meter_iter); } else if (!strcmp(parameter_key, "no_pgw")) { self.parameter.no_pgw = - YAML_MAPPING_BOOL(document, parameter_pair); + yaml_iter_bool(¶meter_iter); } else if (!strcmp(parameter_key, "no_pcrf")) { self.parameter.no_pcrf = - YAML_MAPPING_BOOL(document, parameter_pair); + yaml_iter_bool(¶meter_iter); } else if (!strcmp(parameter_key, "no_ipv4")) { self.parameter.no_ipv4 = - YAML_MAPPING_BOOL(document, parameter_pair); + yaml_iter_bool(¶meter_iter); } else if (!strcmp(parameter_key, "no_ipv6")) { self.parameter.no_ipv6 = - YAML_MAPPING_BOOL(document, parameter_pair); + yaml_iter_bool(¶meter_iter); } else if (!strcmp(parameter_key, "prefer_ipv4")) { self.parameter.prefer_ipv4 = - YAML_MAPPING_BOOL(document, parameter_pair); + yaml_iter_bool(¶meter_iter); } } } diff --git a/src/app/yaml_helper.c b/src/app/yaml_helper.c index 552e5b983..cc2d4f959 100644 --- a/src/app/yaml_helper.c +++ b/src/app/yaml_helper.c @@ -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; } diff --git a/src/app/yaml_helper.h b/src/app/yaml_helper.h index f3508b579..a368afd8a 100644 --- a/src/app/yaml_helper.h +++ b/src/app/yaml_helper.h @@ -5,13 +5,21 @@ #include -/* 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 } diff --git a/src/mme/mme_context.c b/src/mme/mme_context.c index 9b837ef3f..e54cd689c 100644 --- a/src/mme/mme_context.c +++ b/src/mme/mme_context.c @@ -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;