#include <dirent.h>
#include <talloc.h>
+#include <tr_cfgwatch.h>
#include <tr_config.h>
#include <tr_debug.h>
-#include <tr.h>
#include <tr_filter.h>
#include <trust_router/tr_constraint.h>
+#include <tr_idp.h>
+#include <tr.h>
void tr_print_config (TR_CFG *cfg) {
tr_notice("tr_print_config: Logging running trust router configuration.");
}
}
+TR_CFG *tr_cfg_new(TALLOC_CTX *mem_ctx)
+{
+ return talloc_zero(mem_ctx, TR_CFG);
+}
+
void tr_cfg_free (TR_CFG *cfg) {
talloc_free(cfg);
- return;
}
-TR_CFG_RC tr_apply_new_config (TR_INSTANCE *tr) {
- if (!tr)
+TR_CFG_MGR *tr_cfg_mgr_new(TALLOC_CTX *mem_ctx)
+{
+ return talloc_zero(mem_ctx, TR_CFG_MGR);
+}
+
+void tr_cfg_mgr_free (TR_CFG_MGR *cfg_mgr) {
+ talloc_free(cfg_mgr);
+}
+
+TR_CFG_RC tr_apply_new_config (TR_CFG_MGR *cfg_mgr)
+{
+ /* cfg_mgr->active is allowed to be null, but new cannot be */
+ if ((cfg_mgr==NULL) || (cfg_mgr->new==NULL))
return TR_CFG_BAD_PARAMS;
- if (tr->active_cfg)
- tr_cfg_free(tr->active_cfg);
+ if (cfg_mgr->active != NULL)
+ tr_cfg_free(cfg_mgr->active);
- tr->active_cfg = tr->new_cfg;
+ cfg_mgr->active = cfg_mgr->new;
+ cfg_mgr->new=NULL; /* only keep a single handle on the new configuration */
- tr_log_threshold(tr->active_cfg->internal->log_threshold);
- tr_console_threshold(tr->active_cfg->internal->console_threshold);
+ tr_log_threshold(cfg_mgr->active->internal->log_threshold);
+ tr_console_threshold(cfg_mgr->active->internal->console_threshold);
return TR_CFG_SUCCESS;
}
static TR_CFG_RC tr_cfg_parse_internal (TR_CFG *trc, json_t *jcfg) {
json_t *jint = NULL;
json_t *jmtd = NULL;
- json_t *jtp = NULL;
+ json_t *jtidsp = NULL;
+ json_t *jtrpsp = NULL;
json_t *jhname = NULL;
json_t *jlog = NULL;
json_t *jconthres = NULL;
json_t *jlogthres = NULL;
+ json_t *jcfgpoll = NULL;
+ json_t *jcfgsettle = NULL;
+ json_t *jroutesweep = NULL;
+ json_t *jrouteupdate = NULL;
+ json_t *jrouteconnect = NULL;
if ((!trc) || (!jcfg))
return TR_CFG_BAD_PARAMS;
if (NULL == trc->internal) {
- if (NULL == (trc->internal = talloc(trc, TR_CFG_INTERNAL)))
+ if (NULL == (trc->internal = talloc_zero(trc, TR_CFG_INTERNAL)))
return TR_CFG_NOMEM;
-
- memset(trc->internal, 0, sizeof(TR_CFG_INTERNAL));
}
if (NULL != (jint = json_object_get(jcfg, "tr_internal"))) {
/* If not configured, use the default */
trc->internal->max_tree_depth = TR_DEFAULT_MAX_TREE_DEPTH;
}
- if (NULL != (jtp = json_object_get(jint, "tids_port"))) {
- if (json_is_number(jtp)) {
- trc->internal->tids_port = json_integer_value(jtp);
+ if (NULL != (jtidsp = json_object_get(jint, "tids_port"))) {
+ if (json_is_number(jtidsp)) {
+ trc->internal->tids_port = json_integer_value(jtidsp);
} else {
- tr_debug("tr_cfg_parse_internal: Parsing error, port is not a number.");
+ tr_debug("tr_cfg_parse_internal: Parsing error, tids_port is not a number.");
return TR_CFG_NOPARSE;
}
} else {
/* If not configured, use the default */
trc->internal->tids_port = TR_DEFAULT_TIDS_PORT;
}
+ if (NULL != (jtrpsp = json_object_get(jint, "trps_port"))) {
+ if (json_is_number(jtrpsp)) {
+ trc->internal->trps_port = json_integer_value(jtrpsp);
+ } else {
+ tr_debug("tr_cfg_parse_internal: Parsing error, trps_port is not a number.");
+ return TR_CFG_NOPARSE;
+ }
+ } else {
+ /* If not configured, use the default */
+ trc->internal->trps_port = TR_DEFAULT_TRPS_PORT;
+ }
if (NULL != (jhname = json_object_get(jint, "hostname"))) {
if (json_is_string(jhname)) {
trc->internal->hostname = json_string_value(jhname);
return TR_CFG_NOPARSE;
}
}
+ if (NULL != (jcfgpoll = json_object_get(jint, "cfg_poll_interval"))) {
+ if (json_is_number(jcfgpoll)) {
+ trc->internal->cfg_poll_interval = json_integer_value(jcfgpoll);
+ } else {
+ tr_debug("tr_cfg_parse_internal: Parsing error, cfg_poll_interval is not a number.");
+ return TR_CFG_NOPARSE;
+ }
+ } else {
+ trc->internal->cfg_poll_interval = TR_CFGWATCH_DEFAULT_POLL;
+ }
+
+ if (NULL != (jcfgsettle = json_object_get(jint, "cfg_settling_time"))) {
+ if (json_is_number(jcfgsettle)) {
+ trc->internal->cfg_settling_time = json_integer_value(jcfgsettle);
+ } else {
+ tr_debug("tr_cfg_parse_internal: Parsing error, cfg_settling_time is not a number.");
+ return TR_CFG_NOPARSE;
+ }
+ } else {
+ trc->internal->cfg_settling_time = TR_CFGWATCH_DEFAULT_SETTLE;
+ }
+
+ if (NULL != (jrouteconnect = json_object_get(jint, "trp_connect_interval"))) {
+ if (json_is_number(jrouteconnect)) {
+ trc->internal->trp_connect_interval = json_integer_value(jrouteconnect);
+ } else {
+ tr_debug("tr_cfg_parse_internal: Parsing error, trp_connect_interval is not a number.");
+ return TR_CFG_NOPARSE;
+ }
+ } else {
+ /* if not configured, use the default */
+ trc->internal->trp_connect_interval=TR_DEFAULT_TRP_CONNECT_INTERVAL;
+ }
+
+ if (NULL != (jroutesweep = json_object_get(jint, "trp_sweep_interval"))) {
+ if (json_is_number(jroutesweep)) {
+ trc->internal->trp_sweep_interval = json_integer_value(jroutesweep);
+ } else {
+ tr_debug("tr_cfg_parse_internal: Parsing error, trp_sweep_interval is not a number.");
+ return TR_CFG_NOPARSE;
+ }
+ } else {
+ /* if not configured, use the default */
+ trc->internal->trp_sweep_interval=TR_DEFAULT_TRP_SWEEP_INTERVAL;
+ }
+
+ if (NULL != (jrouteupdate = json_object_get(jint, "trp_update_interval"))) {
+ if (json_is_number(jrouteupdate)) {
+ trc->internal->trp_update_interval = json_integer_value(jrouteupdate);
+ } else {
+ tr_debug("tr_cfg_parse_internal: Parsing error, trp_update_interval is not a number.");
+ return TR_CFG_NOPARSE;
+ }
+ } else {
+ /* if not configured, use the default */
+ trc->internal->trp_update_interval=TR_DEFAULT_TRP_UPDATE_INTERVAL;
+ }
if (NULL != (jlog = json_object_get(jint, "logging"))) {
if (NULL != (jlogthres = json_object_get(jlog, "log_threshold"))) {
return NULL;
}
- if (NULL == (cons = talloc(trc, TR_CONSTRAINT))) {
+ if (NULL == (cons = talloc_zero(trc, TR_CONSTRAINT))) {
tr_debug("tr_cfg_parse_one_constraint: Out of memory (cons).");
*rc = TR_CFG_NOMEM;
return NULL;
}
- memset(cons, 0, sizeof(TR_CONSTRAINT));
-
if (NULL == (cons->type = tr_new_name(ctype))) {
tr_debug("tr_cfg_parse_one_constraint: Out of memory (type).");
*rc = TR_CFG_NOMEM;
return NULL;
}
- if (NULL == (filt = talloc(trc, TR_FILTER))) {
+ if (NULL == (filt = talloc_zero(trc, TR_FILTER))) {
tr_debug("tr_cfg_parse_one_filter: Out of memory.");
*rc = TR_CFG_NOMEM;
return NULL;
}
- memset(filt, 0, sizeof(TR_FILTER));
-
if (!strcmp(json_string_value(jftype), "rp_permitted")) {
filt->type = TR_FILTER_TYPE_RP_PERMITTED;
}
return NULL;
}
- if (NULL == (filt->lines[i] = talloc(trc, TR_FLINE))) {
+ if (NULL == (filt->lines[i] = talloc_zero(trc, TR_FLINE))) {
tr_debug("tr_cfg_parse_one_filter: Out of memory (fline).");
*rc = TR_CFG_NOMEM;
tr_filter_free(filt);
return NULL;
}
- memset(filt->lines[i], 0, sizeof(TR_FLINE));
-
if (!strcmp(json_string_value(jfaction), "accept")) {
filt->lines[i]->action = TR_FILTER_ACTION_ACCEPT;
}
return NULL;
}
- if (NULL == (filt->lines[i]->specs[j] = talloc(trc, TR_FSPEC))) {
+ if (NULL == (filt->lines[i]->specs[j] = talloc_zero(trc, TR_FSPEC))) {
tr_debug("tr_cfg_parse_one_filter: Out of memory.");
*rc = TR_CFG_NOMEM;
tr_filter_free(filt);
return NULL;
}
- memset(filt->lines[i]->specs[j], 0, sizeof(TR_FSPEC));
-
if ((NULL == (filt->lines[i]->specs[j]->field = tr_new_name((char *)json_string_value(jffield)))) ||
(NULL == (filt->lines[i]->specs[j]->match = tr_new_name((char *)json_string_value(jfmatch))))) {
tr_debug("tr_cfg_parse_one_filter: Out of memory.");
return NULL;
}
- if (NULL == (rp = talloc(trc, TR_RP_CLIENT))) {
+ if (NULL == (rp = talloc_zero(trc, TR_RP_CLIENT))) {
tr_debug("tr_cfg_parse_one_rp_realm: Out of memory.");
*rc = TR_CFG_NOMEM;
return NULL;
}
-
- memset(rp, 0, sizeof(TR_RP_CLIENT));
/* TBD -- support more than one filter entry per RP Client? */
if (NULL == (rp->filter = tr_cfg_parse_one_filter(trc, jfilt, rc))) {
trc->rp_clients = rp;
}
}
+ tr_debug("tr_cfg_parse_rp_clients: Finished (rc=%d)", rc);
return rc;
}
-static TR_AAA_SERVER *tr_cfg_parse_one_aaa_server (TR_CFG *trc, json_t *jaddr, TR_CFG_RC *rc) {
+static TR_AAA_SERVER *tr_cfg_parse_one_aaa_server (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t *jaddr, TR_CFG_RC *rc) {
TR_AAA_SERVER *aaa = NULL;
+ TR_NAME *name=NULL;
if ((!trc) || (!jaddr) || (!json_is_string(jaddr))) {
tr_debug("tr_cfg_parse_one_aaa_server: Bad parameters.");
return NULL;
}
- if (NULL == (aaa = talloc(trc, TR_AAA_SERVER))) {
- tr_debug("tr_cfg_parse_one_aaa_server: Out of memory.");
+ name=tr_new_name((char *)(json_string_value(jaddr)));
+ if (name==NULL) {
+ tr_debug("tr_cfg_parse_one_aaa_server: Out of memory allocating hostname.");
*rc = TR_CFG_NOMEM;
return NULL;
}
- memset(aaa, 0, sizeof(TR_AAA_SERVER));
-
- aaa->hostname = tr_new_name((char *)(json_string_value(jaddr)));
+ aaa=tr_aaa_server_new(mem_ctx, name);
+ if (aaa==NULL) {
+ tr_free_name(name);
+ tr_debug("tr_cfg_parse_one_aaa_server: Out of memory allocating AAA server.");
+ *rc = TR_CFG_NOMEM;
+ return NULL;
+ }
return aaa;
}
-static TR_AAA_SERVER *tr_cfg_parse_aaa_servers (TR_CFG *trc, json_t *jaaas, TR_CFG_RC *rc)
+static TR_AAA_SERVER *tr_cfg_parse_aaa_servers (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t *jaaas, TR_CFG_RC *rc)
{
+ TALLOC_CTX *tmp_ctx=NULL;
TR_AAA_SERVER *aaa = NULL;
TR_AAA_SERVER *temp_aaa = NULL;
int i = 0;
for (i = 0; i < json_array_size(jaaas); i++) {
- if (NULL == (temp_aaa = tr_cfg_parse_one_aaa_server(trc, json_array_get(jaaas, i), rc))) {
+ if (NULL == (temp_aaa = tr_cfg_parse_one_aaa_server(mem_ctx, trc, json_array_get(jaaas, i), rc))) {
+ talloc_free(tmp_ctx);
return NULL;
}
/* TBD -- IPv6 addresses */
temp_aaa->next = aaa;
aaa = temp_aaa;
}
+ tr_debug("tr_cfg_parse_aaa_servers: Finished (rc=%d)", *rc);
+
+ for (temp_aaa=aaa; temp_aaa!=NULL; temp_aaa=temp_aaa->next)
+ talloc_steal(mem_ctx, temp_aaa);
+ talloc_free(tmp_ctx);
return aaa;
}
-static TR_APC *tr_cfg_parse_apcs (TR_CFG *trc, json_t *japcs, TR_CFG_RC *rc)
+static TR_APC *tr_cfg_parse_apcs (TALLOC_CTX *mem_ctx, TR_CFG *trc, json_t *japcs, TR_CFG_RC *rc)
{
TR_APC *apc;
return NULL;
}
- if (NULL == (apc = talloc(trc, TR_APC))) {
+ apc=tr_apc_new(mem_ctx);
+ if (apc==NULL) {
tr_debug("tr_cfg_parse_apcs: Out of memory.");
*rc = TR_CFG_NOMEM;
return NULL;
}
- memset(apc, 0, sizeof(TR_APC));
-
/* TBD, deal with more than one APC. In the meantime, though... */
/* Only parse the first APC, because we only know how to deal with one, anyway. */
- if (0 == json_array_size(japcs))
+ if (0 == json_array_size(japcs)) {
+ talloc_free(apc);
return NULL;
+ }
if (NULL == (apc->id = tr_new_name((char *)json_string_value(json_array_get(japcs, 0))))) {
tr_debug("tr_cfg_parse_apcs: No memory for APC name.");
*rc = TR_CFG_NOMEM;
+ talloc_free(apc);
return NULL;
}
+ tr_debug("tr_cfg_parse_apcs: Finished (rc=%d)", *rc);
return apc;
}
static TR_IDP_REALM *tr_cfg_parse_one_idp_realm (TR_CFG *trc, json_t *jidp, TR_CFG_RC *rc) {
+ TALLOC_CTX *tmp_ctx=talloc_new(NULL);
TR_IDP_REALM *idp = NULL;
+ json_t *jremote = NULL;
json_t *jrid = NULL;
json_t *jscfg = NULL;
json_t *jsrvrs = NULL;
return NULL;
}
- if (NULL == (idp = talloc(trc, TR_IDP_REALM))) {
+ if (NULL == (idp = tr_idp_realm_new(tmp_ctx))) {
tr_debug("tr_cfg_parse_one_idp_realm: Out of memory.");
*rc = TR_CFG_NOMEM;
+ talloc_free(tmp_ctx);
return NULL;
}
- memset(idp, 0, sizeof(TR_IDP_REALM));
-
- if ((NULL == (jrid = json_object_get(jidp, "realm_id"))) ||
- (!json_is_string(jrid)) ||
- (NULL == (jscfg = json_object_get(jidp, "shared_config"))) ||
- (!json_is_string(jscfg)) ||
- (NULL == (jsrvrs = json_object_get(jidp, "aaa_servers"))) ||
- (!json_is_array(jsrvrs))) {
- tr_debug("tr_cfg_parse_one_idp_realm: Error parsing IDP realm configuration.");
- *rc = TR_CFG_NOPARSE;
+ /* Assume local route unless specified as remote. */
+ jremote = json_object_get(jidp, "remote");
+ if ((jremote!=NULL) && (!json_is_number(jremote))) {
+ tr_debug("tr_cfg_parse_one_idp_realm: Error parsing IDP realm configuration (remote is not a number).");
+ *rc=TR_CFG_NOPARSE;
+ talloc_free(tmp_ctx);
return NULL;
}
- if (0 == strcmp(json_string_value(jscfg), "no")) {
- idp->shared_config = 0;
- } else {
- idp->shared_config = 1;
+ if ((NULL == (jrid = json_object_get(jidp, "realm_id"))) ||
+ (!json_is_string(jrid))) {
+ tr_debug("tr_cfg_parse_one_idp_realm: Error parsing IDP realm configuration (realm_id missing or invalid).");
+ *rc = TR_CFG_NOPARSE;
+ talloc_free(tmp_ctx);
+ return NULL;
}
+
+ if ((jremote==NULL) || (0==json_integer_value(jremote))) {
+ idp->origin=TR_REALM_LOCAL;
+
+ if ((NULL == (jscfg = json_object_get(jidp, "shared_config"))) ||
+ (!json_is_string(jscfg)) ||
+ (NULL == (jsrvrs = json_object_get(jidp, "aaa_servers"))) ||
+ (!json_is_array(jsrvrs))) {
+ tr_debug("tr_cfg_parse_one_idp_realm: Error parsing IDP realm configuration.");
+ *rc = TR_CFG_NOPARSE;
+ talloc_free(tmp_ctx);
+ return NULL;
+ }
+
+ if (0 == strcmp(json_string_value(jscfg), "no")) {
+ idp->shared_config = 0;
+ } else {
+ idp->shared_config = 1;
+ }
+ } else
+ idp->origin=TR_REALM_REMOTE_INCOMPLETE;
if (NULL == (idp->realm_id = tr_new_name((char *)json_string_value(jrid)))) {
tr_debug("tr_cfg_parse_one_idp_realm: No memory for realm id.");
*rc = TR_CFG_NOMEM;
- return NULL;
- }
-
- if (NULL == (idp->aaa_servers = tr_cfg_parse_aaa_servers(trc, jsrvrs, rc))) {
- tr_debug("tr_cfg_parse_one_idp_realm: Can't parse AAA servers for realm %s.", idp->realm_id->buf);
- tr_free_name(idp->realm_id);
+ talloc_free(tmp_ctx);
return NULL;
}
if ((NULL != (japcs = json_object_get(jidp, "apcs"))) &&
(json_is_array(japcs))) {
- if (NULL == (idp->apcs = tr_cfg_parse_apcs(trc, japcs, rc))) {
+ if (NULL == (idp->apcs = tr_cfg_parse_apcs(idp, trc, japcs, rc))) {
tr_debug("tr_cfg_parse_one_idp_realm: Can't parse APCs for realm %s .", idp->realm_id->buf);
- tr_free_name(idp->realm_id);
- /* TBD -- free aaa_servers */;
+ talloc_free(tmp_ctx);
return NULL;
}
}
+
+ if ((idp->origin==TR_REALM_LOCAL) &&
+ (NULL == (idp->aaa_servers = tr_cfg_parse_aaa_servers(idp, trc, jsrvrs, rc)))) {
+ tr_debug("tr_cfg_parse_one_idp_realm: Can't parse AAA servers for realm %s.", idp->realm_id->buf);
+ talloc_free(tmp_ctx);
+ return NULL;
+ }
+
+ talloc_steal(trc, idp);
+ talloc_free(tmp_ctx);
return idp;
}
(0 < json_array_size(jdss))) {
for (i = 0; i < json_array_size(jdss); i++) {
- if (NULL == (ds = tr_cfg_parse_one_aaa_server(trc,
+ if (NULL == (ds = tr_cfg_parse_one_aaa_server(trc, trc,
json_array_get(jdss, i),
&rc))) {
return rc;
}
}
+ tr_debug("tr_cfg_parse_default_servers: Finished (rc=%d)", rc);
return rc;
}
}
}
+ tr_debug("tr_cfg_parse_idp_realms: Finished (rc=%d)", rc);
return rc;
}
}
for (i = (json_array_size(jrps)-1); i >= 0; i--) {
- if (NULL == (temp_rp = talloc(trc, TR_RP_REALM))) {
+ if (NULL == (temp_rp = talloc_zero(trc, TR_RP_REALM))) {
tr_debug("tr_cfg_parse_comm_rps: Can't allocate memory for RP Realm.");
if (rc)
*rc = TR_CFG_NOMEM;
return NULL;
}
- memset (temp_rp, 0, sizeof(TR_RP_REALM));
if (NULL == (temp_rp->realm_name = tr_new_name((char *)json_string_value(json_array_get(jrps, i))))) {
tr_debug("tr_cfg_parse_comm_rps: No memory for RP Realm Name.");
comm->type = TR_COMM_APC;
} else if (0 == strcmp(json_string_value(jtype), "coi")) {
comm->type = TR_COMM_COI;
- if (NULL == (comm->apcs = tr_cfg_parse_apcs(trc, japcs, rc))) {
+ if (NULL == (comm->apcs = tr_cfg_parse_apcs(trc, trc, japcs, rc))) {
tr_debug("tr_cfg_parse_one_comm: Can't parse APCs for COI %s.", comm->id->buf);
tr_free_name(comm->id);
return NULL;
trc->comms = comm;
}
}
+ tr_debug("tr_cfg_parse_comms: Finished (rc=%d)", rc);
return rc;
}
/* Join two paths and return a pointer to the result. This should be freed
* via talloc_free. Returns NULL on failure. */
-static char *join_paths(const char *p1, const char *p2) {
- return talloc_asprintf(NULL, "%s/%s", p1, p2); /* returns NULL on a failure */
+static char *join_paths(TALLOC_CTX *mem_ctx, const char *p1, const char *p2) {
+ return talloc_asprintf(mem_ctx, "%s/%s", p1, p2); /* returns NULL on a failure */
}
-/* Reads configuration files in config_dir ("" or "./" will use the current directory) */
-TR_CFG_RC tr_parse_config (TR_INSTANCE *tr, const char *config_dir, int n, struct dirent **cfg_files) {
+/* Reads configuration files in config_dir ("" or "./" will use the current directory). */
+TR_CFG_RC tr_parse_config (TR_CFG_MGR *cfg_mgr, const char *config_dir, int n, struct dirent **cfg_files)
+{
+ TALLOC_CTX *tmp_ctx=talloc_new(NULL);
json_t *jcfg;
json_t *jser;
json_error_t rc;
char *file_with_path;
+ int ii;
+ TR_CFG_RC cfg_rc=TR_CFG_ERROR;
- if ((!tr) || (!cfg_files) || (n<=0))
- return TR_CFG_BAD_PARAMS;
-
- /* If there is a partial/abandoned config lying around, free it */
- if (tr->new_cfg)
- tr_cfg_free(tr->new_cfg);
-
- if (NULL == (tr->new_cfg = talloc(NULL, TR_CFG)))
- return TR_CFG_NOMEM;
+ if ((!cfg_mgr) || (!cfg_files) || (n<=0)) {
+ cfg_rc=TR_CFG_BAD_PARAMS;
+ goto cleanup;
+ }
- memset(tr->new_cfg, 0, sizeof(TR_CFG));
+ if (cfg_mgr->new != NULL)
+ tr_cfg_free(cfg_mgr->new);
+ cfg_mgr->new=tr_cfg_new(tmp_ctx); /* belongs to the temporary context for now */
+ if (cfg_mgr->new == NULL) {
+ cfg_rc=TR_CFG_NOMEM;
+ goto cleanup;
+ }
/* Parse configuration information from each config file */
- while (n--) {
- file_with_path=join_paths(config_dir, cfg_files[n]->d_name); /* must free result with talloc_free */
+ for (ii=0; ii<n; ii++) {
+ file_with_path=join_paths(tmp_ctx, config_dir, cfg_files[ii]->d_name); /* must free result with talloc_free */
if(file_with_path == NULL) {
tr_crit("tr_parse_config: error joining path.");
- return TR_CFG_NOMEM;
+ cfg_rc=TR_CFG_NOMEM;
+ goto cleanup;
}
- tr_debug("tr_parse_config: Parsing %s.", cfg_files[n]->d_name); /* print the filename without the path */
+ tr_debug("tr_parse_config: Parsing %s.", cfg_files[ii]->d_name); /* print the filename without the path */
if (NULL == (jcfg = json_load_file(file_with_path,
JSON_DISABLE_EOF_CHECK, &rc))) {
tr_debug("tr_parse_config: Error parsing config file %s.",
- cfg_files[n]->d_name);
- talloc_free(file_with_path);
- return TR_CFG_NOPARSE;
+ cfg_files[ii]->d_name);
+ cfg_rc=TR_CFG_NOPARSE;
+ goto cleanup;
}
talloc_free(file_with_path); /* done with filename */
}
}
- if ((TR_CFG_SUCCESS != tr_cfg_parse_internal(tr->new_cfg, jcfg)) ||
- (TR_CFG_SUCCESS != tr_cfg_parse_rp_clients(tr->new_cfg, jcfg)) ||
- (TR_CFG_SUCCESS != tr_cfg_parse_idp_realms(tr->new_cfg, jcfg)) ||
- (TR_CFG_SUCCESS != tr_cfg_parse_default_servers(tr->new_cfg, jcfg)) ||
- (TR_CFG_SUCCESS != tr_cfg_parse_comms(tr->new_cfg, jcfg))) {
- tr_cfg_free(tr->new_cfg);
- return TR_CFG_ERROR;
+ if ((TR_CFG_SUCCESS != tr_cfg_parse_internal(cfg_mgr->new, jcfg)) ||
+ (TR_CFG_SUCCESS != tr_cfg_parse_rp_clients(cfg_mgr->new, jcfg)) ||
+ (TR_CFG_SUCCESS != tr_cfg_parse_idp_realms(cfg_mgr->new, jcfg)) ||
+ (TR_CFG_SUCCESS != tr_cfg_parse_default_servers(cfg_mgr->new, jcfg)) ||
+ (TR_CFG_SUCCESS != tr_cfg_parse_comms(cfg_mgr->new, jcfg))) {
+ cfg_rc=TR_CFG_ERROR;
+ goto cleanup;
}
}
/* make sure we got a complete, consistent configuration */
- if (TR_CFG_SUCCESS != tr_cfg_validate(tr->new_cfg)) {
- tr_debug("tr_parse_config: Error: INVALID CONFIGURATION, EXITING");
- return TR_CFG_ERROR;
+ if (TR_CFG_SUCCESS != tr_cfg_validate(cfg_mgr->new)) {
+ tr_err("tr_parse_config: Error: INVALID CONFIGURATION");
+ cfg_rc=TR_CFG_ERROR;
+ goto cleanup;
}
- return TR_CFG_SUCCESS;
+ /* success! */
+ talloc_steal(cfg_mgr, cfg_mgr->new); /* hand this over to the cfg_mgr context */
+ cfg_rc=TR_CFG_SUCCESS;
+
+cleanup:
+ talloc_free(tmp_ctx);
+ return cfg_rc;
}
TR_IDP_REALM *tr_cfg_find_idp (TR_CFG *tr_cfg, TR_NAME *idp_id, TR_CFG_RC *rc)
* by scandir(). These can be freed with tr_free_config_file_list().
*/
int tr_find_config_files (const char *config_dir, struct dirent ***cfg_files) {
- int n = 0, i = 0;
+ int n = 0;
- n = scandir(config_dir, cfg_files, &is_cfg_file, 0);
+ n = scandir(config_dir, cfg_files, is_cfg_file, alphasort);
if (n < 0) {
perror("scandir");
tr_debug("tr_find_config: scandir error trying to scan %s.", config_dir);
- } else if (n == 0) {
- tr_debug("tr_find_config: No config files found.");
- } else {
- i = n;
- while(i--) {
- tr_debug("tr_find_config: Config file found (%s).", (*cfg_files)[i]->d_name);
- }
- }
+ }
return n;
}
projects / trust_router.git / blobdiff