static int __config_read(config_t *config, FILE *stream, const char *filename,
const char *str)
{
yyscan_t scanner;
struct scan_context scan_ctx;
struct parse_context parse_ctx;
YY_BUFFER_STATE buffer = NULL;
int r;
/* Reinitialize the config */
void (*destructor)(void *) = config->destructor;
unsigned short tab_width = config->tab_width;
unsigned short flags = config->flags;
config_destroy(config);
config_init(config);
config->destructor = destructor;
config->tab_width = tab_width;
config->flags = flags;
parsectx_init(&parse_ctx);
parse_ctx.config = config;
parse_ctx.parent = config->root;
parse_ctx.setting = config->root;
__config_locale_override();
scanctx_init(&scan_ctx, filename);
scan_ctx.config = config;
libconfig_yylex_init_extra(&scan_ctx, &scanner);
if(stream)
libconfig_yyrestart(stream, scanner);
else /* read from string */
buffer = libconfig_yy_scan_string(str, scanner);
r = libconfig_yyparse(scanner, &parse_ctx, &scan_ctx);
if(r != 0)
{
config->error_file = scanctx_current_filename(&scan_ctx);
config->error_type = CONFIG_ERR_PARSE;
}
libconfig_yylex_destroy(scanner);
config->filenames = scanctx_cleanup(&scan_ctx, &(config->num_filenames));
parsectx_cleanup(&parse_ctx);
__config_locale_restore();
return(r == 0 ? CONFIG_TRUE : CONFIG_FALSE);
}
int readCfgCond (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_cond_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, "minTemp", &minTemp)) printf("\nNo 'minTemp' setting in configuration file.");
if (!config_lookup_int(&cfg, "maxTemp", &maxTemp)) printf("\nNo 'maxTemp' setting in configuration file.");
if (!config_lookup_int(&cfg, "minHum", &minHum)) printf("\nNo 'minHum' setting in configuration file.");
if (!config_lookup_int(&cfg, "maxHum", &maxHum)) printf("\nNo 'maxHum' setting in configuration file.");
if (!config_lookup_int(&cfg, "webOR", &webOR)) printf("\nNo 'webOR' setting in configuration file.");
config_destroy(&cfg);
return 0;
}
/**
* Main test function
*/
int main(int argc, char **argv)
{
int err = FALSE;
config_init(&cfg);
config_check(&cfg);
err |= test_compare();
config_destroy(&cfg);
return err;
}
int bot_destroy(struct bot* b)
{
config_write(b->conf, "config.conf");
conn_destroy(b->conn);
config_destroy(b->conf);
free(b->conn);
free(b->conf);
b->conn=NULL;
b->conf=NULL;
if(!b->conn && !b->conf) return 0;
else return -1;
}
static int unload_module(void) {
struct DFITCUserLogoutField req = { 0 };
strncat(req.AccountID, userid, sizeof req.AccountID - 1);
xspeed_l2api_user_logout(l2api, &req);
/* FIXME: ?! */
sleep(1);
xspeed_l2api_destory(l2api);
xspeed_l2spi_destroy(l2spi);
config_destroy(cfg);
return unregister_application(app);
}
void terminarCPUSinPCB() {
t_datosEnviar* info1 = pedirPaquete("a", CPU_PCP_DISCONNECTION, 2);
t_datosEnviar* info = pedirPaquete("a", UMV_CAE_CPU, 2);
common_send(umvSocket, info, NULL );
common_send(pcpSocket, info1, NULL );
destruirPaquete(info1);
destruirPaquete(info);
close(umvSocket);
close(pcpSocket);
config_destroy(configuracion_CPU);
exit(0);
}
int read_local_config_from_file(const char * local_path)
{
int rv;
config_t config;
config_init(&config);
rv = config_read_file(&config, local_path);
if (rv != CONFIG_TRUE)
{
config_log_error(&config);
config_destroy(&config);
return rv;
}
rv = read_local_config(&config);
config_destroy(&config);
return rv;
}
static int read_config_auth(char config_file[BUFSIZE], struct config_auth* s_auth)
{
config_t cfg;
const char* buf;
config_init(&cfg);
if (!config_read_file(&cfg, config_file)) {
pam_http_syslog(LOG_ALERT, "%s:%d - %s\n", config_error_file(&cfg),
config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return 0;
}
if (!config_lookup_string(&cfg, "auth_url", &buf)) {
pam_http_syslog(LOG_ALERT, "No 'auth_url' setting in configuration file.");
config_destroy(&cfg);
return 0;
}
s_auth->c_auth_url = strndup(buf, BUFSIZE);
s_auth->c_method = config_get_string(&cfg, "auth_method", DEFAULT_METHOD);
if (strncmp(s_auth->c_method, HTTP_METHOD_GET, 3) != 0 && strncmp(s_auth->c_method, HTTP_METHOD_POST, 4) != 0) {
pam_http_syslog(LOG_ALERT, "Wrong 'auth_method' setting in configuration file (%s).", s_auth->c_method);
config_destroy(&cfg);
return 0;
}
s_auth->c_username_field = config_get_string(&cfg, "auth_username_field", DEFAULT_USERNAME_FIELD);
s_auth->c_password_field = config_get_string(&cfg, "auth_password_field", DEFAULT_PASSWORD_FIELD);
if (!config_lookup_int64(&cfg, "auth_timeout", &s_auth->timeout)) {
s_auth->timeout = DEFAULT_CURL_TIMEOUT;
}
if (!config_lookup_int64(&cfg, "auth_success_code", &s_auth->success_code)) {
s_auth->success_code = DEFAULT_HTTP_SUCCESS_CODE;
}
config_destroy(&cfg);
return 1;
}
void dhcp_edit_read_cfg(void)
{
config_t cfg, *cf;
int i, r;
char token[MAX_LEN];
const char *file = NULL;
const char *name = NULL;
cf = &cfg;
config_init(cf);
if (!config_read_file(cf, "configuracion.cfg"))
goto error;
/* Buscamos redes de hosts para leer desde configuracion.cfg */
for (i=0;i<MAX_N_REDES;i++) {
sprintf(token,"dhcpdconf%i", i);
r = config_lookup_string(cf, token, &file);
if (r == 0)
break;
sprintf(token,"network%i", i);
r = config_lookup_string(cf, token, &name);
if (r == 0)
goto error;
strcpy(redes[i].file, file);
strcpy(redes[i].name, name);
}
config_destroy(cf);
return;
error:
perror("Error al leer la configuracion\n");
config_destroy(cf);
exit(1);
}
int main (int argc, char **argv) {
int error = 0;
char *config_file = NULL;
struct config_t cfg;
int result;
int i;
int c;
while ((c = getopt_long (argc, argv,
"h" /* help */
"c:", /* config file */
long_options, (int *) 0)) != EOF) {
switch (c) {
case 'h':
usage (0);
case 'c':
config_file = optarg;
break;
}
}
config_init(&cfg);
if (config_file == NULL) {
config_file = CONFIG_FILENAME;
}
if (config_read_file(&cfg, config_file) != CONFIG_TRUE) {
fprintf(stderr, "config parse error in %s:%d - %s\n",
config_file,
config_error_line(&cfg),
config_error_text(&cfg));
config_destroy(&cfg);
exit(EXIT_FAILURE);
}
if (error = eosimias_init(&state, &cfg)) {
fprintf (stderr, "eosimias_init returned: %s", eosimias_error_string(error));
}
// if (error = eocene_init(state)) {
// fprintf (stderr, "eocene_init returned: %s", eosimias_error_string(error));
// }
if (error = eonessa_init(state)) {
fprintf (stderr, "eonessa_init returned: %s", eosimias_error_string(error));
}
state->run();
return(0);
}
void get_conf_string (char *key, char *value) {
config_t *conf = &(config_t) {};
config_init (conf);
config_read_file (conf, "TSECDecoder.conf");
char *tmp;
if (config_lookup (conf, key) == NULL)
return;
config_lookup_string (conf, key, (const char **)&tmp);
if (tmp == NULL)
return;
memcpy (value, tmp, strlen (tmp));
config_destroy (conf);
}
void upd8_config_destroy(upd8_config_t *config) {
if (config == NULL) {
return;
}
for (int i = 0; i > config->num_sources; ++i) {
upd8_source_destroy(&(config->sources[i]));
}
free(config->sources);
config->sources = NULL;
config_destroy(config->cfg);
config->cfg = NULL;
}
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;
}
static void init(void)
{
int i;
double bpm;
double decay;
int samp_rate;
int min_burst;
int burst_increase;
int min_gain;
int gain_increase;
int detune;
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);
exit(EXIT_FAILURE);
}
if(!config_lookup_float(&cfg, "bpm", &bpm))
config_die("bpm");
if(!config_lookup_float(&cfg, "subdiv", &subdiv))
config_die("subdiv");
if(!config_lookup_int(&cfg, "samp_rate", &samp_rate))
config_die("samp_rate");
if(!config_lookup_int(&cfg, "min_burst", &min_burst))
config_die("min_burst");
if(!config_lookup_int(&cfg, "burst_increase", &burst_increase))
config_die("burst_increase");
if(!config_lookup_float(&cfg, "decay", &decay))
config_die("decay");
if(!config_lookup_int(&cfg, "min_gain", &min_gain))
config_die("min_gain");
if(!config_lookup_int(&cfg, "gain_increase", &gain_increase))
config_die("gain_increase");
if(!config_lookup_int(&cfg, "detune", &detune))
config_die("detune");
note_length = (float)samp_rate * 60 * subdiv / bpm;
system_init();
agent_count = system_get_agent_count();
synths = calloc(agent_count, sizeof(Synth *));
for(i = 0; i < agent_count; i ++) {
float pan = ((float)i / 20) * ((i % 2) * 2 - 1) + .5;
synths[i] = synth_create(samp_rate, min_burst + i * burst_increase,
decay, pan, min_gain + gain_increase * i, detune);
}
}
int get_server_config(s_config *c, char *config_path)
{
config_t cfg;
config_setting_t *modules_setting, *module_setting;
unsigned int count, i;
const char *module_name;
config_init(&cfg);
if (!config_read_file(&cfg, config_path)) {
config_destroy(&cfg);
return CONFIG_FILE_READ_ERROR;
}
if (config_lookup_int(&cfg, "port", &(c->port))
&& config_lookup_string(&cfg, "host", &(c->host))
&& config_lookup_string(&cfg, "web_root", &(c->web_root))
&& config_lookup_string(&cfg, "web_prefix", &(c->web_prefix))
&& config_lookup_string(&cfg, "api_prefix", &(c->api_prefix))
&& config_lookup_string(&cfg, "index_file", &(c->index_file))
&& config_lookup_string(&cfg, "api_modules_path", &(c->api_modules_path))
&& config_lookup_int(&cfg, "buffer_size", &(c->buffer_size))
&& config_lookup_int(&cfg, "api_modules_number", &(c->api_modules_number))
) {
c->buffer = (char*) calloc((size_t) c->buffer_size, sizeof(char));
/* Output a list of all movies in the inventory. */
modules_setting = config_lookup(&cfg, "api_modules");
if (modules_setting != NULL) {
count = (unsigned int) config_setting_length(modules_setting);
if (count != (unsigned int) c->api_modules_number)
return CONFIG_INCONSISTENT_DATA;
else if (count == 0)
return CONFIG_FILE_READ_OK;
c->api_modules_names = malloc(count * sizeof(char*));
for (i = 0; i < count; ++i) {
module_setting = config_setting_get_elem(modules_setting, i);
module_name = config_setting_get_string(module_setting);
c->api_modules_names[i] = module_name;
}
map_init(&c->api_modules, c->api_modules_number);
}
return CONFIG_FILE_READ_OK;
}
else
return CONFIG_MISSING_KEY;
}
int main(int argc, char **argv)
{
config_t cfg, *cf;
const config_setting_t *figuras, *figura_actual;
const char *base = NULL;
int count, n, enabled;
int xInit,yInit;
cf = &cfg;
config_init(cf);
if (!config_read_file(cf, "Archivos de Configuracion/test.cfg")) {
fprintf(stderr, "%s:%d - %s\n",
config_error_file(cf),
config_error_line(cf),
config_error_text(cf));
config_destroy(cf);
return(EXIT_FAILURE);
}
figuras = config_lookup(cf, "Figuras");
count = config_setting_length(figuras);
for (n = 0; n < count; n++) {
figura_actual = config_setting_get_elem(figuras,n);
config_setting_lookup_int(figura_actual,"Xinit",&xInit);
printf("x: %d \n",xInit);
//printf("\t#%d. %d\n", n + 1,
// config_setting_get_int_elem(figuras, n));
}
config_destroy(cf);
return 0;
}
/* Handles the termination process and frees if required */
void terminate(int signum) {
/* Check if pthread_t has been initialized from default value and is still alive,
* if so, cancel and join it. */
if(!pthread_equal(watchMixerThread, mainThread) && pthread_kill(watchMixerThread, 0) == 0) {
if(pthread_cancel(watchMixerThread) != 0)
syslog(LOG_WARNING, "Unable request cancelation for mixer thread: %s", strerror(errno));
if((errno = pthread_join(watchMixerThread, NULL)) != 0)
syslog(LOG_WARNING, "Unable to join mixer thread: %s\n", strerror(errno));
}
if(!pthread_equal(interfaceListenThread, mainThread) && pthread_kill(interfaceListenThread, 0) == 0) {
if(pthread_cancel(interfaceListenThread) != 0)
syslog(LOG_WARNING, "Unable request cancelation for serial thread: %s", strerror(errno));
if((errno = pthread_join(interfaceListenThread, NULL)) != 0)
syslog(LOG_WARNING, "Unable to join serial thread: %s\n", strerror(errno));
}
if(!pthread_equal(statusQueryThread, mainThread) && pthread_kill(statusQueryThread, 0) == 0) {
if(pthread_cancel(statusQueryThread) != 0)
syslog(LOG_WARNING, "Unable request cancelation for query thread: %s", strerror(errno));
if((errno = pthread_join(statusQueryThread, NULL)) != 0)
syslog(LOG_WARNING, "Unable to join query thread: %s\n", strerror(errno));
}
if(common_data.interface)
common_data.interface->deinit();
if(common_data.process)
common_data.process->deinit();
deinitMixer();
if(common_data.volume)
common_data.volume->deinit();
statusInfo.deinit();
config_destroy(&config);
pthread_mutex_destroy(&lockConfig);
pthread_mutex_destroy(&lockProcess);
#ifndef DISABLE_MSQ
deinitMsQ();
#endif
if(lock_file > 0) {
lockf(lock_file, F_ULOCK, 0);
close(lock_file);
unlink(LOCKFILE);
}
syslog(LOG_NOTICE, "Program terminated: %s (%i)", strsignal(signum), signum);
closelog();
exit(EXIT_SUCCESS);
} /* end terminate */
//METODO PARA OBTENER LOS PARAMETROS DEL ARCHIVO DE CONFIG
void getInfoConf(char* conf) {
t_config* config; //creamos la variable que va a ser el archivo de config
config = config_create(conf); //creamos el "objeto" archivo de config
//OBTENEMOS LOS VALORES DEL ARCHIVO DE CONFIG
//ip_servidor = config_get_int_value(config,"IP_SERVIDOR");
strcpy(ip_servidor, config_get_string_value(config, "IP_SERVIDOR"));
puerto_servidor = config_get_int_value(config, "PUERTO_SERVIDOR");
printf("Extraccion correcta del archivo de configuracion \n");
config_destroy(config); //destruimos el "objeto" archivo de config
}
static int reload_module(void) {
int res;
msgs_unhook_name(inmsg, vxo_exec);
config_destroy(cfg);
table_clear(spots);
load_config();
if ((res = msgs_hook_name(inmsg, vxo_exec, vxo_msgs)) < 0) {
if (res == -2)
xcb_log(XCB_LOG_WARNING, "Queue '%s' not found", inmsg);
return MODULE_LOAD_FAILURE;
}
return MODULE_LOAD_SUCCESS;
}
test_result_t test_set_get_func(test_data_t data)
{
test_config_data_t *test_data = (test_config_data_t *)data;
test_result_t result = PASS;
unsigned i = 0;
config_t config = {0};
const char *section_name = NULL;
const char *entry_name = NULL;
const char *entry_value = NULL;
const char *val = NULL;
int ret = 0;
printf("%s\n", test_data->desc);
config_create(&config);
for (i = 0; i < test_data->num_set_entries; i++)
{
section_name = test_data->set_entries[i].section_name;
entry_name = test_data->set_entries[i].entry_name;
entry_value = test_data->set_entries[i].entry_value;
ret = config_set(&config, section_name, entry_name, entry_value);
if (ret != 0)
{
result = FAIL;
}
DEBUG_PRINT("set: section: '%s', name: '%s', value: '%s'\n", section_name, entry_name, entry_value);
}
DEBUG_PRINT("\n");
for (i = 0; i < test_data->num_get_entries; i++)
{
section_name = test_data->get_entries[i].section_name;
entry_name = test_data->get_entries[i].entry_name;
entry_value = test_data->get_entries[i].entry_value;
val = config_get(&config, section_name, entry_name);
if ((val == NULL) || (strcmp(val, entry_value) != 0))
{
result = FAIL;
}
DEBUG_PRINT("get: section: '%s', name: '%s', value: '%s'\n", section_name, entry_name, entry_value);
}
config_destroy(&config);
return result;
}
int lamb_read_file(config_t *cfg, const char *file) {
if (!cfg || !file) {
return -1;
}
config_init(cfg);
if (!config_read_file(cfg, file)) {
config_destroy(cfg);
return -1;
}
return 0;
}
bool_t Conf_ok(const char *conffile)
{
bool_t rc = true;
config_init(&configuration);
if (conffile == NULL)
conffile = defaultconfig;
if (config_read_file(&configuration, conffile) != CONFIG_TRUE) {
fprintf(stderr, "Error in config file %s line %d: %s\n", conffile,
config_error_line(&configuration), config_error_text(&configuration));
rc = false;
}
config_destroy(&configuration);
return rc;
}
// {{{ session_get_user()
int session_get_user(const char *sessid, char *user, size_t len)
{
struct config_t cfg;
config_init(&cfg);
config_setting_t *cs;
config_setting_t *vs;
if(!config_read_file(&cfg, OD_SESSION_FILE))
return -1;
int i=0;
for(i=0; ;i++)
{
if( !(cs = config_setting_get_elem(cfg.root, i)) )
break;
if( !(vs = config_setting_get_member(cs, "sessid")) )
continue;
char *session_user = config_setting_name(cs);
if(!session_user)
continue;
const char *res = config_setting_get_string(vs);
if(res)
if(strcmp(res, sessid)==0)
{
sstrncpy(user, session_user, len);
config_destroy(&cfg);
return 0;
}
}
config_destroy(&cfg);
return -1;
}
int parse_data_files(int option)
{
int ret;
cf = (config_t *) gtmalloc(sizeof(config_t));
config_init(cf);
if (!config_read_file(cf, MAIN_DATA_FILE)) {
fprintf(stderr, "%s:%d - %s\n",
config_error_file(cf),
config_error_line(cf),
config_error_text(cf));
config_destroy(cf);
return(1);
}
objid = 1;
printf("Reading %s\n", MAIN_DATA_FILE);
if(option == ONLY_CONFIG) {
ret = parse_configfile();
config_destroy(cf);
return ret;
}
/* TODO: This return value stuff makes rather little sense!!
*/
ret = parse_configfile();
ret = parse_objects();
ret = parse_monsters();
config_destroy(cf);
ret = parse_roomdef_files();
return ret;
}
int load_config(CustomData *d)
{
config_t cfg, *cf;
// CustomData *d=*data;
const config_setting_t *logos,*logo;
int count, n;
cf = &cfg;
config_init(cf);
if (!config_read_file(cf, "kiosk.ini")) {
fprintf(stderr, "%s:%d - %s\n",
config_error_file(cf),
config_error_line(cf),
config_error_text(cf));
config_destroy(cf);
return -1;
}
logos = config_lookup(cf, "logos");
d->logo_count = config_setting_length(logos);
g_print("%d logos configured.\n", d->logo_count);
// d->config= malloc(sizeof(ConfigItem[10]));
ConfigItem *ci;
char *b,*i,*p;
for (n = 0; n < d->logo_count; n++) {
logo=config_setting_get_elem(logos, n);
ci=&d->config[n];
config_setting_lookup_string(logo,"background",
&b);
config_setting_lookup_string(logo,"intro",&i);
config_setting_lookup_string(logo,"prompter",&p);
config_setting_lookup_int(logo,"duration",&d->config[n].duration);
strcpy(d->config[n].background,b);
strcpy(d->config[n].intro,i);
strcpy(d->config[n].prompter,p);
}
config_destroy(cf);
return 0;
}
int main(void) {
int i;
_config = config_create(FILE_CONFIG);
_log = log_create(FILE_LOG, "Nodo", false, LOG_LEVEL_INFO);
_data = data_get(config_get_string_value(_config, CONFIG_ARCHIVO_BIN));
bloques_set();
////////////////////////
pthread_t p_fs;
if (pthread_create(&p_fs, NULL, (void*) fs_conectar, NULL) != 0) {
perror("pthread_create");
exit(1);
}
pthread_join(p_fs, (void**) NULL);
/*
void* saludo = malloc(BLOQUE_SIZE);
strcpy(saludo, "ahora cambio el mensaje!");
setBloque(0, saludo);
void* dataget = getBloque(0);
char* saludoget =(char*) malloc(strlen(saludo)+1);
memcpy(saludoget, dataget, strlen(saludo)+1);
printf("%s\n", saludoget);
free_null(saludo);
free_null(saludoget);
free_null(dataget);
*/
/*
char *d = NULL;
d = getFileContent("hola");
for(i=0;i<10;i++)
printf("%c", d[i]);
file_mmap_free(d, "hola");
*/
data_destroy();
config_destroy(_config);
printf("fin ok");
//while (true);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
pthread_mutex_init(&semNiv, NULL );
if (argc < 4 || string_equals_ignore_case(argv[1], "-h")) {
// Help, I need somebody
// Help, not just anybody
// Help, you know, I need someone
// Help
printf("Necesita minimo 3 argumentos:\n"
"\t1) Archivo de configuracion del \"delay\"\n"
"\t2) Archivo para actualizar Quantums\n"
"\t3) Archivo que se pasara como parametro a Koopa (en el directorio de Koopa)\n"
"[opcionales]\n"
"\t\t> -v: Verboso\n"
"\t\t> -ll [trace/debug/info/warning/error]: Nivel de logeo.\n"
"\t\t> -log [PATH]: Nombre del archivo para logear (Crea y apenda)");
exit(EXIT_SUCCESS);
}
signal(SIGINT, cerrarTodo);
feedKoopa = malloc(sizeof(char) * 30);
string_append_with_format(&feedKoopa, "./koopa %s", argv[3]);
pthread_t tQuantum; //Thread para el quantum
config = config_try_create(argv[1], "delay");
// Obtenemos el delay
delay = config_get_int_value(config, "delay");
// y la sacamos
config_destroy(config);
logger = logInit(argv, "PLATAFORMA");
Quantum = leerDesde(argv[2]); //Hace la primera lectura
//Levnatamos el hilo para iNotify
if (pthread_create(&tQuantum, NULL, (void*)iNotify, (void *) argv[2])) {
log_error(logger, "pthread_create: %s", strerror(errno));
exit(EXIT_FAILURE);
}
orquestador();
return EXIT_FAILURE;
}
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);
}
}
/*
* FUNCION : Carga los datos de configuración de la cpu. Valida parametros obtenidos.
* Recibe : estructura de configuracion para la cpu, path del archivo de configuración
* Devuelve : void
*/
void levantarDatosDeConfiguracion(t_configuracion_cpu* configuracion, char* config_path){
t_config* config = config_create(config_path);
if(validarParametrosDeConfiguracion(config)){
log_info(logger, "El archivo de configuración tiene todos los parametros requeridos.");
configuracion->nucleo_ip = config_get_string_value(config,"NUCLEO_IP");
/*char* nucleo_ip = config_get_string_value(config,"NUCLEO_IP");
configuracion->nucleo_ip = malloc(strlen(nucleo_ip));
memcpy(configuracion->nucleo_ip, nucleo_ip, strlen(nucleo_ip));
configuracion->nucleo_ip[strlen(nucleo_ip)] = '\0';*/
configuracion->nucleo_puerto = config_get_string_value(config, "NUCLEO_PUERTO");
/*char* nucleo_puerto = config_get_string_value(config,"NUCLEO_PUERTO");
configuracion->nucleo_puerto = malloc(strlen(nucleo_puerto)+1);
memcpy(configuracion->nucleo_puerto, nucleo_puerto, strlen(nucleo_puerto));
configuracion->nucleo_puerto[strlen(nucleo_puerto)] = '\0';*/
configuracion->umc_ip = config_get_string_value(config,"UMC_IP");
// char* umc_ip = config_get_string_value(config,"UMC_IP");
// configuracion->umc_ip = malloc(strlen(umc_ip));
// memcpy(configuracion->umc_ip, umc_ip, strlen(umc_ip));
// configuracion->umc_ip[strlen(umc_ip)] = '\0';
configuracion->umc_puerto = config_get_string_value(config,"UMC_PUERTO");
// char* umc_puerto = config_get_string_value(config,"UMC_PUERTO");
// configuracion->umc_puerto = malloc(strlen(umc_puerto)+1);
// memcpy(configuracion->umc_puerto, umc_puerto, strlen(umc_puerto));
// configuracion->umc_puerto[strlen(umc_puerto)] = '\0';
configuracion->cpu_id = config_get_int_value(config, "CPU_ID");
// int cpu_id = config_get_int_value(config,"CPU_ID");
// configuracion->cpu_id = malloc(sizeof configuracion->cpu_id);
// memcpy(configuracion->cpu_id, &cpu_id, sizeof(int));
//config_destroy(config);
}else{
log_error_y_cerrar_logger(logger, "Configuracion invalida.");
config_destroy(config);
exit(EXIT_FAILURE);
}
}
//**********************************Init Config****************************************//
int initConfig(char* configFile) {
t_config* _config;
int failure = 0;
int getConfigInt(char *property) {
if (config_has_property(_config, property)) {
return config_get_int_value(_config, property);
}
failure = 1;
log_error(logger, "Config not found for key %s", property);
return -1;
}
char* getConfigString(char* property) {
if (config_has_property(_config, property)) {
return config_get_string_value(_config, property);
}
failure = 1;
log_error(logger, "Config not found for key %s", property);
return "";
}
_config = config_create(configFile);
cfgJob = malloc(sizeof(t_configJob));
cfgJob->PUERTO_MARTA = getConfigInt("PUERTO_MARTA");
cfgJob->IP_MARTA = strdup(getConfigString("IP_MARTA"));
cfgJob->MAPPER = strdup(getConfigString("MAPPER"));
cfgJob->REDUCER = strdup(getConfigString("REDUCER"));
cfgJob->RESULTADO = strdup(getConfigString("RESULTADO"));
cfgJob->LIST_ARCHIVOS = strdup(getConfigString("LIST_ARCHIVOS"));
cfgJob->COMBINER = strdup(getConfigString("COMBINER"));
if (!failure) {
log_info(logger, "PUERTO MARTA: %d", cfgJob->PUERTO_MARTA);
log_info(logger, "IP MARTA: %s", cfgJob->IP_MARTA);
log_info(logger, "MAPPER: %s", cfgJob->MAPPER);
log_info(logger, "REDUCER: %s", cfgJob->REDUCER);
log_info(logger, "RESULTADO: %s", cfgJob->RESULTADO);
log_info(logger, "ARCHIVOS: %s", cfgJob->LIST_ARCHIVOS);
log_info(logger, "COMBINER: %s", cfgJob->COMBINER);
}
config_destroy(_config);
return !failure;
}
