Index: modules/carrierroute/cr_config.c |
diff --git a/modules/carrierroute/cr_config.c b/modules/carrierroute/cr_config.c |
index 92f96a9f4a2090baae636f7ccf52d2e047a350ea..42ce972c2e6f4d91d800f5f0e4b772c9ce1f3283 100644 |
--- a/modules/carrierroute/cr_config.c |
+++ b/modules/carrierroute/cr_config.c |
@@ -20,14 +20,13 @@ |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
*/ |
-/** |
+/*! |
* \file cr_config.c |
* \brief Functions for load and save routing data from a config file. |
* \ingroup carrierroute |
* - Module; \ref carrierroute |
*/ |
-#include <confuse.h> |
#include <sys/types.h> |
#include <sys/stat.h> |
#include <unistd.h> |
@@ -42,86 +41,78 @@ |
#include "cr_rule.h" |
#include "cr_domain.h" |
#include "cr_carrier.h" |
+#include "parser_carrierroute.h" |
mariuszbi
2013/11/23 20:05:24
The reset and initialization steps should be in th
|
+#define DEFAULT_DOMAIN_NUM 16 |
mariuszbi
2013/11/23 20:05:24
If you increase this to 256, I would consider it s
|
+#define MAX_DOMAIN_NUM 64 // must be a power of 2 |
-/** |
- * reports errors during config file parsing using LOG macro |
- * |
- * @param cfg points to the current config data structure |
- * @param fmt a format string |
- * @param ap format arguments |
- */ |
-static void conf_error(cfg_t *cfg, const char * fmt, va_list ap) { |
- int ret; |
- static char buf[1024]; |
- |
- ret = vsnprintf(buf, sizeof(buf), fmt, ap); |
- if (ret < 0 || ret >= sizeof(buf)) { |
- LM_ERR("could not print error message\n"); |
- } else { |
- // FIXME this don't seems to work reliable in all cases, charset |
- // problems |
- LM_GEN1(L_ERR, "%s", buf); |
- } |
-} |
+enum target_opt_ids { TO_ID_COMMENT = 0, TO_ID_STRIP, TO_ID_REWR_PREFIX, TO_ID_PROB, TO_ID_HASH_INDEX, |
+ TO_ID_REWR_SUFFIX, TO_ID_STATUS, TO_ID_BACKED_UP, TO_ID_BACKUP, TO_MAX_IDS }; |
+enum prefix_opt_ids { PO_MAX_TARGETS = 0, PO_MAX_IDS }; |
+option_description target_options[TO_MAX_IDS]; |
+option_description prefix_options[PO_MAX_IDS]; |
-/** |
- * Parses the config file |
- * |
- * @return a pointer to the configuration data structure, NULL on failure |
- */ |
-static cfg_t * parse_config(void) { |
- cfg_t * cfg = NULL; |
- |
- cfg_opt_t target_opts[] = { |
- CFG_STR("comment", 0, CFGF_NONE), |
- CFG_INT("strip", 0, CFGF_NONE), |
- CFG_STR("rewrite_prefix", 0, CFGF_NONE), |
- CFG_FLOAT("prob", 0, CFGF_NONE), |
- CFG_INT("hash_index", 0, CFGF_NONE), |
- CFG_STR("rewrite_suffix", 0, CFGF_NONE), |
- CFG_INT("status", 1, CFGF_NONE), |
- CFG_INT_LIST("backed_up", NULL, CFGF_NONE), |
- CFG_INT("backup", -1, CFGF_NONE), |
- CFG_END() |
- }; |
- |
- cfg_opt_t prefix_opts[] = { |
- CFG_SEC("target", target_opts, CFGF_MULTI | CFGF_TITLE), |
- CFG_INT("max_targets", -1, CFGF_NONE), |
- CFG_END() |
- }; |
- |
- cfg_opt_t domain_opts[] = { |
- CFG_SEC("prefix", prefix_opts, CFGF_MULTI | CFGF_TITLE), |
- CFG_END() |
- }; |
- |
- cfg_opt_t opts[] = { |
- CFG_SEC("domain", domain_opts, CFGF_MULTI | CFGF_TITLE), |
- CFG_END() |
- }; |
- |
- cfg = cfg_init(opts, CFGF_NONE); |
- if (cfg == NULL) { |
- LM_ERR("could not initialize configuration\n"); |
- return NULL; |
+static void reset_opts(option_description * opts, int size){ |
+ int i; |
+ if ( NULL == opts){ |
+ LM_ERR("Trying to init a NULL pointer location \n"); |
+ return; |
} |
+ for (i=0; i < size; i++){ |
+ memset(&(opts[i].value),'\0', sizeof(union opt_data)); |
+ opts[i].visited = 0; |
+ opts[i].no_elems = 0; |
+ if ( CFG_STR == opts[i].type ){ |
+ opts[i].value.string_data.s = opts[i].str_buf; |
+ strcpy(opts[i].str_buf,""); |
+ opts[i].value.string_data.len = 0; |
+ } |
+ } |
+ return; |
+} |
- cfg_set_error_function(cfg, conf_error); |
- |
- switch (cfg_parse(cfg, config_file)) { |
- case CFG_FILE_ERROR: LM_ERR("file not found: %s\n", config_file); |
- return NULL; |
- case CFG_PARSE_ERROR: LM_ERR("error while parsing %s in line %i, section %s\n", |
- cfg->filename, cfg->line, cfg->name); |
- return NULL; |
- case CFG_SUCCESS: break; |
+static int init_target_opts(option_description * opts){ |
+ if ( NULL == opts){ |
+ LM_DBG("Trying to init a NULL pointer location \n"); |
+ return -1; |
} |
- return cfg; |
+ memset(opts, '\0', sizeof(option_description) * TO_MAX_IDS); |
+ |
+ strcpy((char*)(opts[TO_ID_COMMENT].name), "comment"); |
+ strcpy((char*)(opts[TO_ID_STRIP].name), "strip"); |
+ strcpy((char*)(opts[TO_ID_REWR_PREFIX].name),"rewrite_prefix"); |
+ strcpy((char*)(opts[TO_ID_PROB].name), "prob"); |
+ strcpy((char*)(opts[TO_ID_HASH_INDEX].name), "hash_index"); |
+ strcpy((char*)(opts[TO_ID_REWR_SUFFIX].name),"rewrite_suffix"); |
+ strcpy((char*)(opts[TO_ID_STATUS].name), "status"); |
+ strcpy((char*)(opts[TO_ID_BACKED_UP].name), "backed_up"); |
+ strcpy((char*)(opts[TO_ID_BACKUP].name), "backup"); |
+ |
+ opts[TO_ID_COMMENT ].type=CFG_STR; |
+ opts[TO_ID_STRIP ].type=CFG_INT; |
+ opts[TO_ID_REWR_PREFIX].type=CFG_STR; |
+ opts[TO_ID_PROB ].type=CFG_FLOAT; |
+ opts[TO_ID_HASH_INDEX ].type=CFG_INT; |
+ opts[TO_ID_REWR_SUFFIX].type=CFG_STR; |
+ opts[TO_ID_STATUS ].type=CFG_INT; |
+ opts[TO_ID_BACKED_UP ].type=CFG_INT_LIST; |
+ opts[TO_ID_BACKUP ].type=CFG_INT; |
+ |
+ reset_opts(opts, TO_MAX_IDS); |
+ return 0; |
} |
+static int init_prefix_opts(option_description * opts){ |
+ if ( NULL == opts){ |
+ LM_DBG("Trying to init a NULL pointer location \n"); |
+ return -1; |
+ } |
+ memset(opts, '\0', sizeof(option_description) * PO_MAX_IDS); |
+ strcpy((char*)(opts[PO_MAX_TARGETS].name), "max_targets"); |
+ opts[PO_MAX_TARGETS].type=CFG_INT; |
+ return 0; |
+} |
static int backup_config(void) { |
FILE * from, * to; |
@@ -188,10 +179,11 @@ errout: |
return -1; |
} |
- |
/** |
* Loads the routing data from the config file given in global |
* variable config_data and stores it in routing tree rd. |
+ * The function mixes code parsing calls with rd structure |
+ * completion. |
* |
* @param rd Pointer to the route data tree where the routing data |
* shall be loaded into |
@@ -200,173 +192,279 @@ errout: |
* |
*/ |
int load_config(struct route_data_t * rd) { |
- cfg_t * cfg = NULL; |
- int m, o, i, j, k,l, status, hash_index, max_targets, strip; |
- cfg_t * d, * p, * t; |
+ FILE * file; |
+ |
+ int ret_domain, ret_prefix, ret_target, ret_prefix_opts, ret_target_opts; |
+ int domain_id, allocated_domain_num = DEFAULT_DOMAIN_NUM; |
+ str domain_name, prefix_name, rewrite_host; |
+ char domain_buf[CR_MAX_LINE_SIZE], prefix_buf[CR_MAX_LINE_SIZE], rewrite_buf[CR_MAX_LINE_SIZE]; |
+ |
+ str rewrite_prefix, rewrite_suffix, comment; |
+ struct domain_data_t *domain_data = NULL; |
struct carrier_data_t * tmp_carrier_data; |
- int domain_id; |
- str domain, prefix, rewrite_prefix, rewrite_suffix, rewrite_host, comment; |
+ int hash_index, max_targets = 0, strip; |
double prob; |
int * backed_up = NULL; |
- int backed_up_size, backup; |
- backed_up_size = backup = 0; |
+ int backed_up_size = 0, backup = 0, status; |
+ void* p_realloc; |
+ int i=0, l, k; |
+ |
+ domain_name.s = domain_buf; domain_name.len = CR_MAX_LINE_SIZE; |
+ prefix_name.s = prefix_buf; prefix_name.len = CR_MAX_LINE_SIZE; |
+ rewrite_host.s = rewrite_buf; rewrite_host.len = CR_MAX_LINE_SIZE; |
+ |
+ //sleep(15); |
mariuszbi
2013/11/23 20:05:24
Please remove this dead code (wrong comment)
|
- if ((cfg = parse_config()) == NULL) { |
+ /* open source file */ |
mariuszbi
2013/11/23 20:05:24
Open configuration file would be clearer. Same bel
|
+ if ((file = fopen(config_file, "rb"))==NULL) { |
+ LM_ERR("Cannot open source file.\n"); |
return -1; |
} |
rd->carrier_num = 1; |
rd->first_empty_carrier = 0; |
- rd->domain_num = cfg_size(cfg, "domain"); |
+ rd->domain_num = 0; |
if ((rd->carriers = shm_malloc(sizeof(struct carrier_data_t *))) == NULL) { |
SHM_MEM_ERROR; |
- return -1; |
+ goto errclose; |
} |
memset(rd->carriers, 0, sizeof(struct carrier_data_t *)); |
/* Create carrier map */ |
if ((rd->carrier_map = shm_malloc(sizeof(struct name_map_t))) == NULL) { |
SHM_MEM_ERROR; |
- return -1; |
+ goto errclose; |
} |
+ |
memset(rd->carrier_map, 0, sizeof(struct name_map_t)); |
rd->carrier_map[0].id = 1; |
rd->carrier_map[0].name.len = default_tree.len; |
rd->carrier_map[0].name.s = shm_malloc(rd->carrier_map[0].name.len); |
+ |
if (rd->carrier_map[0].name.s == NULL) { |
SHM_MEM_ERROR; |
- return -1; |
+ goto errclose; |
} |
memcpy(rd->carrier_map[0].name.s, default_tree.s, rd->carrier_map[0].name.len); |
/* Create domain map */ |
- if ((rd->domain_map = shm_malloc(sizeof(struct name_map_t) * rd->domain_num)) == NULL) { |
+ if ((rd->domain_map = shm_malloc(sizeof(struct name_map_t) * allocated_domain_num)) == NULL) { |
SHM_MEM_ERROR; |
- return -1; |
+ goto errclose; |
} |
- memset(rd->domain_map, 0, sizeof(struct name_map_t) * rd->domain_num); |
- for (i=0; i<rd->domain_num; i++) { |
- d = cfg_getnsec(cfg, "domain", i); |
- domain.s = (char *)cfg_title(d); |
- if (domain.s==NULL) domain.s=""; |
- domain.len = strlen(domain.s); |
- rd->domain_map[i].id = i+1; |
- rd->domain_map[i].name.len = domain.len; |
- rd->domain_map[i].name.s = shm_malloc(rd->domain_map[i].name.len); |
- if (rd->domain_map[i].name.s == NULL) { |
- SHM_MEM_ERROR; |
- return -1; |
- } |
- memcpy(rd->domain_map[i].name.s, domain.s, rd->domain_map[i].name.len); |
- } |
- /* sort domain map by id for faster access */ |
- qsort(rd->domain_map, rd->domain_num, sizeof(rd->domain_map[0]), compare_name_map); |
+ memset(rd->domain_map, 0, sizeof(struct name_map_t) * allocated_domain_num); |
/* Create and insert carrier data structure */ |
- tmp_carrier_data = create_carrier_data(1, &rd->carrier_map[0].name, rd->domain_num); |
+ tmp_carrier_data = create_carrier_data(1, &rd->carrier_map[0].name, allocated_domain_num); |
+ tmp_carrier_data->domain_num = 0; |
+ tmp_carrier_data->id = 1; |
+ tmp_carrier_data->name = &(rd->carrier_map[0].name); |
+ |
if (tmp_carrier_data == NULL) { |
LM_ERR("can't create new carrier\n"); |
- return -1; |
+ goto errclose; |
} |
if (add_carrier_data(rd, tmp_carrier_data) < 0) { |
LM_ERR("couldn't add carrier data\n"); |
destroy_carrier_data(tmp_carrier_data); |
- return -1; |
+ goto errclose; |
} |
- /* add all routes */ |
- for (i = 0; i < rd->domain_num; i++) { |
- d = cfg_getnsec(cfg, "domain", i); |
- domain.s = (char *)cfg_title(d); |
- if (domain.s==NULL) domain.s=""; |
- domain.len = strlen(domain.s); |
- m = cfg_size(d, "prefix"); |
- |
- LM_INFO("loading domain %.*s\n", domain.len, domain.s); |
- for (j = 0; j < m; j++) { |
- p = cfg_getnsec(d, "prefix", j); |
- prefix.s = (char *)cfg_title(p); |
- if (prefix.s==NULL) prefix.s=""; |
- prefix.len = strlen(prefix.s); |
- if (str_strcasecmp(&prefix, &CR_EMPTY_PREFIX) == 0) { |
- prefix.s = ""; |
- prefix.len = 0; |
+ init_prefix_opts(prefix_options); |
+ init_target_opts(target_options); |
+ |
+ /* add all routes by parsing the route conf file */ |
+ /* while there are domain structures, get name and parse the structure*/ |
+ while ((ret_domain = parse_struct_header(file, "domain", &domain_name)) |
+ == SUCCESSFUL_PARSING) { |
+ |
+ domain_id = ++rd->domain_num; |
+ tmp_carrier_data->domain_num++; |
+ |
+ /* (re)allocate memory for a maximum of MAX_DOMAIN_NUM domains |
+ rd is not fully allocated from the start as this would require the preparsing |
+ of the entire route file */ |
+ if ( rd->domain_num > allocated_domain_num){ |
mariuszbi
2013/11/23 20:05:24
If this would be increased to 256 as a default val
|
+ |
+ if (MAX_DOMAIN_NUM <= allocated_domain_num){ |
+ LM_ERR("Maximum number of domains reached"); |
+ break; |
} |
- LM_INFO("loading prefix %.*s\n", prefix.len, prefix.s); |
- max_targets = cfg_getint(p, "max_targets"); |
- o = cfg_size(p, "target"); |
- for (k = 0; k < o; k++) { |
- t = cfg_getnsec(p, "target", k); |
- rewrite_host.s = (char *)cfg_title(t); |
- if (rewrite_host.s==NULL) rewrite_host.s=""; |
- rewrite_host.len = strlen(rewrite_host.s); |
+ LM_INFO("crt_alloc_size=%d must be increased \n", allocated_domain_num); |
+ allocated_domain_num = allocated_domain_num * 2; |
mariuszbi
2013/11/23 20:05:24
allocated_domain_num *= 2
|
+ |
+ if ( ( p_realloc = shm_realloc(rd->domain_map, |
+ sizeof(struct name_map_t) * allocated_domain_num) ) == NULL) |
+ { |
+ SHM_MEM_ERROR; |
+ goto errclose; |
+ } |
+ |
+ rd->domain_map = (struct name_map_t *)p_realloc; |
+ |
+ if (( p_realloc = shm_realloc( rd->carriers[0]->domains, |
+ sizeof(struct domain_data_t *) * allocated_domain_num)) == NULL) { |
+ SHM_MEM_ERROR; |
+ goto errclose; |
+ } |
+ rd->carriers[0]->domains = (struct domain_data_t **)p_realloc; |
+ |
+ for (i=0; i<rd->domain_num-1; i++){ |
+ rd->carriers[0]->domains[i]->name = &(rd->domain_map[i].name); |
+ } |
+ }// end of mem (re)allocation for domains |
+ |
+ /*insert domain in domain map*/ |
+ rd->domain_map[domain_id-1].id = domain_id; |
+ rd->domain_map[domain_id-1].name.len = domain_name.len; |
+ rd->domain_map[domain_id-1].name.s = shm_malloc(rd->domain_map[domain_id-1].name.len); |
+ if (rd->domain_map[domain_id-1].name.s == NULL) { |
+ SHM_MEM_ERROR; |
+ goto errclose; |
+ } |
+ memcpy(rd->domain_map[domain_id-1].name.s, domain_name.s, rd->domain_map[domain_id-1].name.len); |
+ |
+ /* create new domain data */ |
+ if ((domain_data = create_domain_data(domain_id,&(rd->domain_map[domain_id-1].name))) == NULL) { |
+ LM_ERR("could not create new domain data\n"); |
+ goto errclose; |
+ } |
+ |
+ if (add_domain_data(tmp_carrier_data, domain_data, domain_id-1) < 0) { |
+ LM_ERR("could not add domain data\n"); |
+ destroy_domain_data(domain_data); |
+ goto errclose; |
+ } |
+ LM_DBG("added domain %d '%.*s' to carrier %d '%.*s'\n", |
+ domain_id, domain_name.len, domain_name.s, |
+ tmp_carrier_data->id, tmp_carrier_data->name->len, tmp_carrier_data->name->s); |
+ |
+ /* while there are prefix structures, get name and parse the structure */ |
+ while ((ret_prefix = parse_struct_header(file, "prefix", &prefix_name)) |
+ == SUCCESSFUL_PARSING) { |
+ |
+ reset_opts(prefix_options, PO_MAX_IDS); |
+ if (str_strcasecmp(&prefix_name, &CR_EMPTY_PREFIX) == 0) { |
+ prefix_name.s[0] = '\0'; |
+ prefix_name.len = 0; |
+ } |
+ |
+ /* look for max_targets = value which is described in prefix_options */ |
+ if ((ret_prefix_opts = parse_options(file, prefix_options, |
+ PO_MAX_IDS, "target")) != SUCCESSFUL_PARSING) { |
+ LM_ERR("Error in parsing \n"); |
+ goto errclose; |
+ } |
+ |
+ max_targets = prefix_options[PO_MAX_TARGETS].value.int_data; |
+ /* look for max_targets target structures */ |
+ for ( k = 0; k < max_targets; k++) { |
+ /* parse the target header, get name and continue*/ |
+ ret_target = parse_struct_header(file, "target", &rewrite_host); |
+ if (ret_target != SUCCESSFUL_PARSING) { |
+ LM_ERR("Error in parsing \n"); |
+ goto errclose; |
+ } |
+ |
+ reset_opts(target_options, TO_MAX_IDS); |
+ /* look for the target options: prob, hash index, status, etc*/ |
+ ret_target_opts = parse_options(file, target_options, TO_MAX_IDS, "}"); |
+ if ( SUCCESSFUL_PARSING == ret_target_opts ){ |
+ /* parsing target structure closing bracket*/ |
+ parse_struct_stop(file); |
+ }else{ |
+ LM_ERR("Error in parsing in target options \n"); |
+ goto errclose; |
+ } |
+ /* intermediary variables for more lisibility */ |
if (str_strcasecmp(&rewrite_host, &CR_EMPTY_PREFIX) == 0) { |
- rewrite_host.s = ""; |
+ rewrite_host.s[0] = '\0'; |
rewrite_host.len = 0; |
} |
- |
- LM_INFO("loading target %.*s\n", rewrite_host.len, rewrite_host.s); |
- prob = cfg_getfloat(t, "prob"); |
- strip = cfg_getint(t, "strip"); |
- rewrite_prefix.s = (char *)cfg_getstr(t, "rewrite_prefix"); |
- if (rewrite_prefix.s==NULL) rewrite_prefix.s=""; |
- rewrite_prefix.len = strlen(rewrite_prefix.s); |
- rewrite_suffix.s = (char *)cfg_getstr(t, "rewrite_suffix"); |
- if (rewrite_suffix.s==NULL) rewrite_suffix.s=""; |
- rewrite_suffix.len = strlen(rewrite_suffix.s); |
- hash_index = cfg_getint(t, "hash_index"); |
- comment.s = (char *)cfg_getstr(t, "comment"); |
- if (comment.s==NULL) comment.s=""; |
- comment.len = strlen(comment.s); |
- status = cfg_getint(t, "status"); |
- |
- if ((backed_up_size = cfg_size(t, "backed_up")) > 0) { |
+ LM_DBG("loading target %.*s\n", rewrite_host.len, rewrite_host.s); |
+ prob = target_options[TO_ID_PROB].value.float_data; |
+ strip = target_options[TO_ID_STRIP].value.int_data; |
+ rewrite_prefix.s = target_options[TO_ID_REWR_PREFIX].value.string_data.s; |
+ rewrite_prefix.len = target_options[TO_ID_REWR_PREFIX].value.string_data.len; |
+ rewrite_suffix.s = target_options[TO_ID_REWR_SUFFIX].value.string_data.s; |
+ rewrite_suffix.len = target_options[TO_ID_REWR_SUFFIX].value.string_data.len; |
+ hash_index = target_options[TO_ID_HASH_INDEX].value.int_data; |
+ comment.s = target_options[TO_ID_COMMENT].value.string_data.s; |
+ comment.len = target_options[TO_ID_COMMENT].value.string_data.len; |
+ status = target_options[TO_ID_STATUS].value.int_data; |
+ |
+ if ( (backed_up_size = target_options[TO_ID_BACKED_UP].no_elems) > 0){ |
if ((backed_up = pkg_malloc(sizeof(int) * (backed_up_size + 1))) == NULL) { |
PKG_MEM_ERROR; |
- return -1; |
+ goto errclose; |
} |
for (l = 0; l < backed_up_size; l++) { |
- backed_up[l] = cfg_getnint(t, "backed_up", l); |
+ backed_up[l] = target_options[TO_ID_BACKED_UP].value.int_list[l]; |
} |
backed_up[backed_up_size] = -1; |
} |
- backup = cfg_getint(t, "backup"); |
- |
- domain_id = map_name2id(rd->domain_map, rd->domain_num, &domain); |
- if (domain_id < 0) { |
- LM_ERR("cannot find id for domain '%.*s'", domain.len, domain.s); |
- if (backed_up) { |
- pkg_free(backed_up); |
- } |
- return -1; |
- } |
- |
- LM_INFO("adding route for prefix %.*s, to host %.*s, prob %f, backed up: %i, backup: %i\n", |
- prefix.len, prefix.s, rewrite_host.len, rewrite_host.s, prob, backed_up_size, backup); |
- if (add_route(rd, 1, domain_id, &prefix, 0, 0, max_targets, prob, &rewrite_host, |
- strip, &rewrite_prefix, &rewrite_suffix, status, |
- hash_index, backup, backed_up, &comment) < 0) { |
+ backup = target_options[TO_ID_BACKUP].value.int_data; |
+ |
+ LM_ERR("\n Adding route to tree <'%.*s'>: prefix_name:%s\n," |
+ " max_targets =%d\n, prob=%f\n, rewr_host=%s\n," |
+ " strip=%i\n, rwr_prefix=%s\n, rwr_suff=%s\n," |
+ " status=%i\n, hash_index=%i\n, comment=%s \n", |
+ domain_data->name->len, domain_data->name->s, prefix_name.s, |
+ max_targets, prob, rewrite_host.s, strip, rewrite_prefix.s, |
+ rewrite_suffix.s, status, hash_index, comment.s); |
+ |
+ if (add_route_to_tree(domain_data->tree, &prefix_name, 0, 0, |
+ &prefix_name, max_targets, prob, &rewrite_host, |
+ strip, &rewrite_prefix, &rewrite_suffix, status, |
+ hash_index, backup, backed_up, &comment) < 0) { |
LM_INFO("Error while adding route\n"); |
if (backed_up) { |
pkg_free(backed_up); |
} |
- return -1; |
+ goto errclose; |
} |
+ |
if (backed_up) { |
pkg_free(backed_up); |
} |
backed_up = NULL; |
} |
+ |
+ if (k != prefix_options[0].value.int_data ) { |
+ LM_ERR("Error in parsing: max_targets =%i, actual targets =%i \n", |
+ prefix_options[0].value.int_data, i); |
+ goto errclose; |
+ } |
+ /* parsing prefix structure closing bracket */ |
+ if (parse_struct_stop(file) != SUCCESSFUL_PARSING) { |
+ LM_ERR("Error in parsing targets, expecting } \n"); |
+ goto errclose; |
+ |
+ } |
+ } // END OF PREFIX part |
+ |
+ /* parsing domain structure closing bracket */ |
+ if (parse_struct_stop(file) != SUCCESSFUL_PARSING) { |
+ LM_ERR("Error in parsing targets, expecting } \n"); |
+ goto errclose; |
} |
+ } |
+ if (EOF_REACHED != ret_domain){ |
+ LM_ERR("Error appeared while parsing domain header \n"); |
+ goto errclose; |
} |
- cfg_free(cfg); |
+ |
+ LM_ERR("File parsed successfully \n"); |
+ fclose(file); |
return 0; |
+errclose: |
+ fclose(file); |
+ return -1; |
} |
- |
/** |
* Does the work for save_config, traverses the routing data tree |
* and writes each rule to file. |