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; }