Esempio n. 1
0
int mst_config_load(const char *conf_path)
{
    int rv = -1;

    config_init(&g_config);

    rv = config_read_file(&g_config, conf_path);

    if (CONFIG_FALSE == rv) {
        fprintf(stderr, "Failed to load config: %s @ %d\n", config_error_text(&g_config), config_error_line(&g_config));
        return -1;
    }

    if (CONFIG_TRUE != (rv = mst_read_version(&g_config))) {
        fprintf(stderr, "Error: %s @ %d\n", config_error_text(&g_config), config_error_line(&g_config));
        return -1;
    }
    if (CONFIG_TRUE != (rv = mst_read_type(&g_config))) {
        fprintf(stderr, "Error: %s @ %d\n", config_error_text(&g_config), config_error_line(&g_config));
        return -1;
    }
    if (CONFIG_TRUE != (rv = mst_read_globals(&g_config))) {
        fprintf(stderr, "Error: %s @ %d\n", config_error_text(&g_config), config_error_line(&g_config));
        return -1;
    }

    if (CONFIG_TRUE != (rv = mst_read_policy_details(&g_config))) {
        fprintf(stderr, "Error: %s @ %d\n", config_error_text(&g_config), config_error_line(&g_config));
        return -1;
    }

    return 0;
}
Esempio n. 2
0
File: config.c Progetto: nicb/psOSCd
static void
load_configuration_from_file(psOSCdSystem *s)
{
    const char *cfname = get_configuration_filename_path(s);

    if (configuration_file_exists(cfname))
    {
	    config_t config_settings;
	    int i = 0;
      /*
       * NOTE: the order in which configuration variables get evaluated is
       * extremely significant for proper initialization. Do not tamper with
       * it unless you know what you are doing.
       */
	    ConfigVar config_vars[] =
	    {
	        { "verbose", &s->is_verbose, int_handler },
	        { "slave", &s->is_slave, int_handler },
	        { "phasespace_server", &s->phasespace, string_handler },
	        { "osc_server", &s->osc_server_name, string_handler },
	        { "frequency", s, system_frequency_handler },
	        { "num_markers", &s->data.u.markers.num_markers, num_markers_handler },
	        { "rigids", &s->data.u.rigids, rigids_handler },
	    };
	    const int num_elems = sizeof(config_vars)/sizeof(ConfigVar); /* num_elems = number of elements in config vars */
      int res = CONFIG_TRUE;
	
	    config_init(&config_settings);
	
	    if ((res = config_read_file(&config_settings, cfname)) == CONFIG_FALSE)
	        fatal("configuration - line %d: %s (configuration error)", config_error_line(&config_settings),
	                                                                   config_error_text(&config_settings));
	
	    for (i = 0; i < num_elems; ++i)
      {
	        res = (*(config_vars[i].handler))(&config_settings, config_vars[i].path, &config_vars[i]);
          if (res == CONFIG_FALSE)
          {
              if (config_error_text(&config_settings) != (const char *) NULL)
	              fatal("configuration - line %d: %s (configuration error)", config_error_line(&config_settings),
	                                                                         config_error_text(&config_settings));
              else
                psOSCd_debug("configuration: missing variable %s", config_vars[i].path);
          }
      }
	
	    config_destroy(&config_settings);
    }
}
Esempio n. 3
0
static void
read_config_from_file (const char *filename)
{
  FILE *fp;

  fp = fopen (filename, "r");
  if (fp != NULL) {
    config_t conf;

    config_init (&conf);

    /*
    if (verbose)
      fprintf (stderr, "%s: reading configuration from %s\n",
               guestfs_int_program_name, filename);
    */

    if (config_read (&conf, fp) == CONFIG_FALSE) {
      fprintf (stderr,
               _("%s: %s: line %d: error parsing configuration file: %s\n"),
               guestfs_int_program_name, filename, config_error_line (&conf),
               config_error_text (&conf));
      exit (EXIT_FAILURE);
    }

    if (fclose (fp) == -1) {
      perror (filename);
      exit (EXIT_FAILURE);
    }

    config_lookup_bool (&conf, "read_only", &read_only);

    config_destroy (&conf);
  }
}
Esempio n. 4
0
int configure_server(spade_server* server, char* configuration_path,
        unsigned int override_port) {
    config_t configuration_struct, *configuration;
    configuration = &configuration_struct;
    config_init(configuration);

    if (!config_read_file(configuration, configuration_path)) {
        log4c_category_log(log4c_category_get("spade"), LOG4C_PRIORITY_ERROR,
                "Configuration error: %s:%d - %s",
                configuration_path,
                config_error_line(configuration),
                config_error_text(configuration));
        config_destroy(configuration);
        return(EXIT_FAILURE);
    }

    configure_hostname(server, configuration);
    configure_port(server, override_port, configuration);
    configure_reverse_lookups(server, configuration);
    configure_static_file_path(server, configuration);
    configure_dynamic_file_paths(server, configuration);
    configure_dynamic_handlers(server, configuration);

    config_destroy(configuration);
    return 0;
}
Esempio n. 5
0
int readCfg (void)
{
	config_t cfg;
	config_init(&cfg);

	/* Read the file. If there is an error, report it and exit. */
	if (!config_read_file(&cfg, config_file_name))
	{
		printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	if (!config_lookup_int(&cfg, "onTemp", &onTemp))  printf("\nNo 'onTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "offTemp", &offTemp)) printf("\nNo 'offTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "highTemp", &highTemp)) printf("\nNo 'highTemp' setting in configuration file.");
	if (!config_lookup_int(&cfg, "onHum", &onHum)) printf("\nNo 'onHum' setting in configuration file.");
	if (!config_lookup_int(&cfg, "offHum", &offHum)) printf("\nNo 'offHum' setting in configuration file.");
	if (!config_lookup_int(&cfg, "webOR", &webOR)) printf("\nNo 'webOR' setting in configuration file.");
	if (!config_lookup_int(&cfg, "tempState", &tempState)) printf("\nNo 'tempState' setting in configuration file.");
	if (!config_lookup_int(&cfg, "humState", &humState)) printf("\nNo 'humState' setting in configuration file.");

	config_destroy(&cfg);

	return 0;
}
Esempio n. 6
0
int read_scenario_master_file(char scenario_list[30][60],
                              unsigned int scenario_reps[60]) {
  config_t cfg; // Returns all parameters in this structure
  char current_scenario[30];
  const char *tmpS;
  int num_scenarios = 1;
  int tmpI; // Stores the value of Integer Parameters from Config file

  config_init(&cfg);

  // Read the file. If there is an error, report it and exit.
  if (!config_read_file(&cfg, "master_scenario_file.cfg")) {
    printf("Error reading master scenario file on line %i\n",
           config_error_line(&cfg));
    exit(1);
  }

  // Read the parameter group
  if (config_lookup_int(&cfg, "NumberofScenarios", &tmpI))
    num_scenarios = (int)tmpI;

  for (int i = 0; i < num_scenarios; i++) {
    sprintf(current_scenario, "scenario_%d", i + 1);
    if (config_lookup_string(&cfg, current_scenario, &tmpS))
      strcpy(&scenario_list[i][0], tmpS);
  }
  for (int i = 0; i < num_scenarios; i++) {
    sprintf(current_scenario, "reps_scenario_%d", i + 1);
    if (config_lookup_int(&cfg, current_scenario, &tmpI))
      scenario_reps[i] = tmpI;
  }
  config_destroy(&cfg);
  return num_scenarios;
} // End readScMasterFile()
Esempio n. 7
0
/*! \brief log error from config reader */
static void config_log_error(const config_t * config)
{
	message(LOG_EMERG, FACILITY_CONFIG,
			"Failed to read config file at line %d (%s)\n",
			config_error_line(config),
			config_error_text(config));
}
Esempio n. 8
0
	void Init(HINSTANCE i_thisInstanceOfTheApplication, HINSTANCE i_thisIsNothing, char* i_commandLineArguments, int i_initialWindowDisplayState)
	{
		config_t cfg;
		int Screenwidth;
		int Screenheight;
		config_init(&cfg);

		if(! config_read_file(&cfg, "config.cfg"))
		{
			fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
							config_error_line(&cfg), config_error_text(&cfg));
			config_destroy(&cfg);
		}
		config_lookup_int(&cfg, "ScreenWidth", &Screenwidth);
		config_lookup_int(&cfg, "ScreenHeight", &Screenheight);
		  
		config_destroy(&cfg);
		Renderer::width=Screenwidth;
		Renderer::height=Screenheight;

		Singleton<Time>::getInstance().Init();
		Singleton<Physics>::getInstance().Init();
		Singleton<Renderer>::getInstance().Init( i_thisInstanceOfTheApplication, i_thisIsNothing,  i_commandLineArguments,  i_initialWindowDisplayState);
		Singleton<World>::getInstance().Init();
		Singleton<Collision>::getInstance().Init();
		Singleton<EventHandler>::getInstance().Init();
		SoundManager::Manager().Init();
	}
int readCfgState (void) {
	config_t cfg;
	config_init(&cfg);

	/* Read the file. If there is an error, report it and exit. */
	if (!config_read_file(&cfg, config_state_path)) {
		printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	/*  */
	if (!config_lookup_int(&cfg, "tempState", &tempState)) printf("\nNo 'tempState' setting in configuration file.");
	if (!config_lookup_int(&cfg, "humState", &humState)) printf("\nNo 'humState' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay1o", &relay1o)) printf("\nNo 'relay1o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay2o", &relay2o)) printf("\nNo 'relay2o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay3o", &relay3o)) printf("\nNo 'relay3o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay4o", &relay4o)) printf("\nNo 'relay4o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay5o", &relay5o)) printf("\nNo 'relay5o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay6o", &relay6o)) printf("\nNo 'relay6o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay7o", &relay7o)) printf("\nNo 'relay7o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "relay8o", &relay8o)) printf("\nNo 'relay8o' setting in configuration file.");
	if (!config_lookup_int(&cfg, "RHeatTS", &RHeatTS)) printf("\nNo 'RHeatTS' setting in configuration file.");
	if (!config_lookup_int(&cfg, "RHumTS", &RHumTS)) printf("\nNo 'RHumTS' setting in configuration file.");
	if (!config_lookup_int(&cfg, "RHepaTS", &RHepaTS)) printf("\nNo 'RHepaTS' setting in configuration file.");
	if (!config_lookup_int(&cfg, "RFanTS", &RFanTS)) printf("\nNo 'RFanTS' setting in configuration file.");
	if (!config_lookup_float(&cfg, "wfactor", &wfactor)) printf("\nNo 'wfactor' setting in configuration file.");


	config_destroy(&cfg);
	return 0;
}
Esempio n. 10
0
/**
 * Load configuration file.
 * @param[in] path Configuration file location.
 * @param[in,out] zconf Parsed configuration storage.
 * @return True on success.
 */
bool zconfig_load(const char *path, zconfig_t *zconf)
{
    if (NULL == path) {
        ZLOG(LOG_ERR, "config: configuration file not specified");
        return false;
    }

    bool loaded = false;
    config_t config;
    config_init(&config);

    if (!config_read_file(&config, path)) {
        ZLOG(LOG_ERR, "config: failed to parse %s (error: %s at %d line)",
             path, config_error_text(&config), config_error_line(&config));
        goto end;
    }

    const config_setting_t *root = config_root_setting(&config);

    if (!zconfig_load_sections(root, zconf)) {
        zconfig_destroy(zconf);
    } else {
        loaded = true;
    }

    end:
    config_destroy(&config);

    return loaded;
}
Esempio n. 11
0
void db_init_pg_conn(const char *conf_file) {
  if(config_read_file(&config, conf_file) != CONFIG_TRUE) {
    fprintf(stderr, "%s:%d %s\n", config_error_file(&config), config_error_line(&config), config_error_text(&config));
    config_destroy(&config);
    exit(EXIT_FAILURE);
  }

  conn = PQsetdbLogin(
    read_db_setting("db_host"),
    read_db_setting("db_port"),
    NULL, NULL,
    read_db_setting("db_name"),
    read_db_setting("db_login"),
    read_db_setting("db_password"));

  const char *store_dir_tmp = read_db_setting("store_dir");
  store_dir = (char*)malloc(strlen(store_dir_tmp)+1);
  strcpy(store_dir, store_dir_tmp);

  if(PQstatus(conn) != CONNECTION_OK) {
    fprintf(stderr, "Connection to database failed: %s\n", PQerrorMessage(conn));
    config_destroy(&config);
    exit(EXIT_FAILURE);
  } else {
    fprintf(stderr, "database OK\n");
  }

  if(pthread_mutex_init(&db_lock, NULL) < 0) {
    fprintf(stderr, "pthread_mutex_init failed\n");
    exit(EXIT_FAILURE);
  }
}
Esempio n. 12
0
// TODO: audit exit routes to "unset"/"unalloc" values.
int upd8_config_parse(upd8_config_t *config, const char *config_file) {
  // TODO: check that config is not null.
  config_t *cfg = malloc(sizeof(config_t));

  config_init(cfg);

  if (!config_read_file(cfg, config_file)) {
    fprintf(stderr, "%s:%d - %s\n", config_error_file(cfg),
            config_error_line(cfg), config_error_text(cfg));
    config_destroy(cfg);
    return EXIT_FAILURE;
  }

  config->cfg = cfg;

  config_setting_t *settings;
  settings = config_lookup(cfg, settings_path);

  if (settings == NULL) {
    fprintf(stderr, "Unable to find %s in %s\n", settings_path, config_file);
    config_destroy(cfg);
    return EXIT_FAILURE;
  }

  config->num_sources = config_setting_length(settings);
  config->sources = malloc(config->num_sources * sizeof(upd8_source_t));
  for (int i = 0; i < config->num_sources; ++i) {
    config_setting_t *individual_config = config_setting_get_elem(settings, i);
    upd8_source_parse(&(config->sources[i]), individual_config);
  }
  return 0;
}
Esempio n. 13
0
int main(int argc, char **argv) {
	
	char SRVR[1000];
	char *p=SRVR;
	config_t config;
	config_init(&config);
	if ( config_read_file(&config, "/etc/snowflake.conf") == CONFIG_TRUE ) {
		printf("PARt 1\n");
		const config_setting_t *setting = config_lookup(&config, "server");
		
		if( setting != NULL) {
			p = config_setting_get_string(setting);
			printf("opened file\n");	
			printf("SERVER ADDRESS = %s\n",p);
		}
		else {
			printf("ERROR\n");
		}
	}
	else {
		fprintf(stderr, "%s:%d - %s\n", config_error_file(&config),
            config_error_line(&config), config_error_text(&config));
    config_destroy(&config);
    return(1);
	}
	
	
}
Esempio n. 14
0
int
main ()
{
  config_t cfg;
  laser_container_t *lasers = NULL;

  config_init (&cfg);

  if(! config_read_file(&cfg, "test.cfg"))
  {
    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
            config_error_line(&cfg), config_error_text(&cfg));
    config_destroy(&cfg);
    exit(EXIT_FAILURE);
  }

  lasers = laser_container_cfg_parse_ctor(&cfg);

  config_destroy (&cfg);

  if (lasers == NULL)
    {
      fprintf(stderr, "Failed to parse laser configuration.\n");
      exit (EXIT_FAILURE);
    }
	      
  printf ("nlasers: %d\n", lasers->nlasers);
  laser_container_dtor(lasers);

  return 0;
}
Esempio n. 15
0
File: sally.c Progetto: yangke/sally
/**
 * Load the configuration of Sally
 * @param argc number of arguments
 * @param argv arguments
 */
static void sally_load_config(int argc, char **argv)
{
    char* cfg_file = NULL;
    int ch;

    /* Check for config file in command line */
    while ((ch = getopt_long(argc, argv, OPTSTRING, longopts, NULL)) != -1) {
        switch (ch) {
        case 'c':
            cfg_file = optarg;
            break;
        case '?':
            print_usage();
            exit(EXIT_SUCCESS);
            break;
        default:                                                                    
            /* empty */
            break;
        }
    }

    /* Init and load configuration */
    config_init(&cfg);

    if (cfg_file != NULL) {
        if (config_read_file(&cfg, cfg_file) != CONFIG_TRUE)
            fatal("Could not read configuration (%s in line %d)",
                  config_error_text(&cfg), config_error_line(&cfg));
    }

    /* Check configuration */
    if (!config_check(&cfg)) {
        exit(EXIT_FAILURE);
    }
}
Esempio n. 16
0
static void config_print_error(char * file, const config_t * config)
{
	werr(LOGUSER,"libconfig error %s@%d : %s\n",
		 file,
		 config_error_line(config),
		 config_error_text(config));
}
Esempio n. 17
0
struct scenario_parameters read_scenario_parameters(char *scenario_file) {
  // configuration variable
  config_t cfg;
  config_init(&cfg);

  // string pointing to scenario file
  char scenario[100];
  strcpy(scenario, "scenarios/");
  strcat(scenario, scenario_file);

  // Read the file. If there is an error, report it and exit.
  if (!config_read_file(&cfg, scenario)) {
    printf("Error reading %s on line %i\n", scenario, config_error_line(&cfg));
    printf("%s\n", config_error_text(&cfg));
    config_destroy(&cfg);
    exit(1);
  }

  // Read scenario parameters
  struct scenario_parameters sp;
  int tmpI;
  double tmpD;

  config_lookup_int(&cfg, "num_nodes", &tmpI);
  sp.num_nodes = tmpI;
  config_lookup_float(&cfg, "run_time", &tmpD);
  sp.runTime = (time_t)tmpD;
  config_destroy(&cfg);

  return sp;
} // End readScConfigFile()
Esempio n. 18
0
int main(int argc, char **argv)
{
  static const char *output_file = "updated.cfg";
  config_t cfg;
  config_setting_t *root, *setting, *movie;

  config_init(&cfg);

  /* Read the file. If there is an error, report it and exit. */
  if(! config_read_file(&cfg, "example.cfg"))
  {
    fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
            config_error_line(&cfg), config_error_text(&cfg));
    config_destroy(&cfg);
    return(EXIT_FAILURE);
  }

  /* Find the 'movies' setting. Add intermediate settings if they don't yet
  * exist.
  */
  root = config_root_setting(&cfg);

  setting = config_setting_get_member(root, "inventory");
  if(!setting)
    setting = config_setting_add(root, "inventory", CONFIG_TYPE_GROUP);

  setting = config_setting_get_member(setting, "movies");
  if(!setting)
    setting = config_setting_add(setting, "movies", CONFIG_TYPE_LIST);

  /* Create the new movie entry. */
  movie = config_setting_add(setting, NULL, CONFIG_TYPE_GROUP);

  setting = config_setting_add(movie, "title", CONFIG_TYPE_STRING);
  config_setting_set_string(setting, "Buckaroo Banzai");

  setting = config_setting_add(movie, "media", CONFIG_TYPE_STRING);
  config_setting_set_string(setting, "DVD");

  setting = config_setting_add(movie, "price", CONFIG_TYPE_FLOAT);
  config_setting_set_float(setting, 12.99);

  setting = config_setting_add(movie, "qty", CONFIG_TYPE_INT);
  config_setting_set_float(setting, 20);

  /* Write out the updated configuration. */
  if(! config_write_file(&cfg, output_file))
  {
    fprintf(stderr, "Error while writing file.\n");
    config_destroy(&cfg);
    return(EXIT_FAILURE);
  }

  fprintf(stderr, "Updated configuration successfully written to: %s\n",
          output_file);

  config_destroy(&cfg);
  return(EXIT_SUCCESS);
}
Esempio n. 19
0
static int read_settings_file(config_t *cfg, const char *filename)
{
	int ret;

	/* Read the file. If there is an error, report it and exit. */
	ret = config_read_file(cfg, filename);
	if (ret != CONFIG_TRUE) {
		fprintf(stderr, "%s ", config_error_file(cfg));
		fprintf(stderr, "%d ", config_error_line(cfg));
		fprintf(stderr, "%s ", config_error_text(cfg));

		fprintf(stderr, "%s:%d - %s\n", config_error_file(cfg),
			config_error_line(cfg), config_error_text(cfg));
	}

	return ret;
}
Esempio n. 20
0
static void read_config(void) {
	char *filename = NULL;
	FILE *file = open_config_file(&filename);

	if (config_read(config, file) != CONFIG_TRUE)
		die("%s:%d %s", filename, config_error_line(config), config_error_text(config));

	if (fclose(file) == EOF) perror_die("fclose");
}
Esempio n. 21
0
int writeCfgCond(void) {
	config_t cfg;
	config_setting_t *tminTemp = 0;
	config_setting_t *tmaxTemp = 0;
	config_setting_t *tminHum = 0;
	config_setting_t *tmaxHum = 0;
	config_setting_t *twebOR = 0;

	config_init(&cfg);

	if (!config_read_file(&cfg, config_cond_path))
	{
		printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	/* lookup variables in config file */
	tminTemp = config_lookup(&cfg, "minTemp");
	tmaxTemp = config_lookup(&cfg, "maxTemp");
	tminHum = config_lookup(&cfg, "minHum");
	tmaxHum = config_lookup(&cfg, "maxHum");
	twebOR = config_lookup(&cfg, "webOR");

	/* get variables from config file then print the variables that changed */
	if (config_setting_get_int(tminTemp) != minTemp) {
		printf("\nminTemp: %i -> ", config_setting_get_int(tminTemp));
		config_setting_set_int(tminTemp, minTemp);
		printf("%i", config_setting_get_int(tminTemp));
	}
	if (config_setting_get_int(tmaxTemp) != maxTemp) {
		printf("\nmaxTemp: %i -> ", config_setting_get_int(tmaxTemp));
		config_setting_set_int(tmaxTemp, maxTemp);
		printf("%i", config_setting_get_int(tmaxTemp));
	}
	if (config_setting_get_int(tminHum) != minHum) {
		printf("\nminHum: %i -> ", config_setting_get_int(tminHum));
		config_setting_set_int(tminHum, minHum);
		printf("%i", config_setting_get_int(tminHum));
	}
	if (config_setting_get_int(tmaxHum) != maxHum) {
		printf("\nmaxHum: %i -> ", config_setting_get_int(tmaxHum));
		config_setting_set_int(tmaxHum, maxHum);
		printf("%i", config_setting_get_int(tmaxHum));
	}
	if (config_setting_get_int(twebOR) != webOR) {
		printf("\nwebOR: %i -> ", config_setting_get_int(twebOR));
		config_setting_set_int(twebOR, webOR);
		printf("%i", config_setting_get_int(twebOR));
	}

	/* write the modified config file */
	config_write_file(&cfg, config_cond_path);
	config_destroy(&cfg);
	return 0;
}
Esempio n. 22
0
void Conf_init(const char *conffile)
{
	config_init(&configuration);
	if (conffile == NULL)
		conffile = defaultconfig;
	if (config_read_file(&configuration, conffile) != CONFIG_TRUE) {
		Log_fatal("Error in config file %s line %d: %s", conffile,
			config_error_line(&configuration), config_error_text(&configuration));
	}
}
Esempio n. 23
0
int conf_read_file(config_t *config, const char *config_filename) {
	libconfig->init(config);
	if (!libconfig->read_file_src(config, config_filename)) {
		ShowError("%s:%d - %s\n", config_error_file(config),
		          config_error_line(config), config_error_text(config));
		libconfig->destroy(config);
		return 1;
	}
	return 0;
}
Esempio n. 24
0
int settings_init(context_t *context) {
  int rc = config_read_file(&context->config, DEFAULT_CONFIG);

  if (rc == CONFIG_FALSE) {
    daemon_log(LOG_ERR, "config: %s:%d: %s",
                         config_error_file(&context->config) ?: "",
                         config_error_line(&context->config),
                         config_error_text(&context->config));
    return 1;
  }
Esempio n. 25
0
int conf_read_file(config_t *config, const char *config_filename)
{
	config_init(config);
	if (!config_read_file(config, config_filename)) {
		ShowError("%s:%d - %s\n", config_error_file(config),
		          config_error_line(config), config_error_text(config));
		config_destroy(config);
		return 1;
	}
	return 0;
}
Esempio n. 26
0
config_setting_t *_cfg_lookup(cfg_t *cfg, const char *path, u4_t flags)
{
	config_setting_t *setting;
	if ((setting = config_lookup(&cfg->config, path)) == NULL) {
		if (config_error_line(&cfg->config)) cfg_error(&cfg->config, "cfg_string");
		if (!(flags & CFG_REQUIRED)) return NULL;
		lprintf("%s: lookup parameter not found: %s\n", cfg->filename, path);
		panic("cfg_string");
	}
	return setting;
}
Esempio n. 27
0
/**
 * Re-reads configuration from the given file
 */
int read_config() {
	config_t cfg;
	config_init(&cfg);

	if (config_read_file(&cfg, conf.config_file) == CONFIG_FALSE) {
		if (config_error_type(&cfg) == CONFIG_ERR_FILE_IO) {
			log_error("Configuration file not found: %s", conf.config_file);
			config_destroy(&cfg);
			return -1;
		}
		log_error("%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return -1;
	}

	int intVal;
	const char* charVal;
	if (config_lookup_int(&cfg, "num_connections", &intVal) == CONFIG_TRUE) {
		conf.num_connections = intVal;
	}
	if (config_lookup_int(&cfg, "report_freq", &intVal) == CONFIG_TRUE) {
		conf.report_freq = intVal;
	}
	if (config_lookup_int(&cfg, "packet_size", &intVal) == CONFIG_TRUE) {
		if (intVal > MAXPACKET) {
			log_error("packet_size: %d exceeds maximal packet size (%d)", intVal, MAXPACKET);
			config_destroy(&cfg);
			return -1;
		}
		conf.packet_size = intVal;
	}
	if (config_lookup_int(&cfg, "packets_count", &intVal) == CONFIG_TRUE) {
		conf.packets_count = intVal;
	}
	if (config_lookup_string(&cfg, "reports_dir", &charVal) == CONFIG_TRUE) {
		free(conf.reports_dir);
		conf.reports_dir = strdup(charVal);
	}
	if (config_lookup_string(&cfg, "hosts_file", &charVal) == CONFIG_TRUE) {
		free(conf.hosts_file);
		conf.hosts_file = strdup(charVal);
	}
	if (config_lookup_string(&cfg, "log_file", &charVal) == CONFIG_TRUE) {
		free(conf.log_file);
		conf.log_file = strdup(charVal);
	}
	config_destroy(&cfg);

	if (read_hosts() == -1) {
		return -1;
	}

	return 0;
}
Esempio n. 28
0
config_t *cfg_open(const char *path)
{

	FILE *file = NULL;
	config_t *config = (config_t*)malloc(sizeof(config_t));

	if (config == NULL)
	{
		return NULL;
	}

	if (path == NULL || path[0] == 0)
	{
		config_init(config);
		return config;
	}

	file = fopen(path,"r");

	if (file == NULL)
	{
		config_init(config);
		return config;
	}

	// Not initializing produces a crash
	config_init(config);

	if (config_read(config,file) != CONFIG_TRUE)
	{
#ifdef DEBUG
		if (config_error_type(config) == CONFIG_ERR_FILE_IO)
		{
			printf("Error opening configuration file.\n");
		}
		else
		{
			printf("Error parsing configuration file.\n");
			printf("Line: %d\n", config_error_line(config));
			printf("Text: %s\n", config_error_text(config));
		}
#endif
		// Destroy the config and initialize a new one
		config_destroy(config);
		config_init(config);
	}

	fclose(file);

	config_set_tab_width(config,0);

	return config;

}
Esempio n. 29
0
/**
 * Initializes 'config' and loads a configuration file.
 *
 * Shows error and destroys 'config' in case of failure.
 * It is the caller's care to destroy 'config' in case of success.
 *
 * @param config          The config file to initialize.
 * @param config_filename The file to read.
 *
 * @retval CONFIG_TRUE  in case of success.
 * @retval CONFIG_FALSE in case of failure.
 */
int config_load_file(struct config_t *config, const char *config_filename)
{
	libconfig->init(config);
	if (libconfig->read_file_src(config, config_filename) != CONFIG_TRUE) {
		ShowError("%s:%d - %s\n", config_error_file(config),
		          config_error_line(config), config_error_text(config));
		libconfig->destroy(config);
		return CONFIG_FALSE;
	}
	return CONFIG_TRUE;
}
Esempio n. 30
0
static int load_conf_file() {
    int status = -1, fd;
    struct config_t config;
    DEBUG_FUNCTION;

    config_init(&config);

    if ((fd = open(storaged_config_file, O_RDWR)) == -1) {
        fprintf(stderr, "can't load config file %s: %s\n",
                storaged_config_file, strerror(errno));
        fatal("can't load config file %s: %s", storaged_config_file,
                strerror(errno));
        status = -1;
        goto out;
    }
    close(fd);

    if (config_read_file(&config, storaged_config_file) == CONFIG_FALSE) {
        errno = EIO;
        fprintf(stderr, "can't read config file: %s at line: %d\n",
                config_error_text(&config), config_error_line(&config));
        fatal("can't read config file: %s at line: %d",
                config_error_text(&config), config_error_line(&config));
        goto out;
    }

    if (load_layout_conf(&config) != 0) {
        goto out;
    }

    if (load_storages_conf(&config) != 0) {
        goto out;
    }

    status = 0;

out:
    config_destroy(&config);
    return status;
}