/** * Checks if player group can use @/#command * @param group_id ID of the group * @param command Command name without @/# and params * @param type enum AtCommanndType { COMMAND_ATCOMMAND = 1, COMMAND_CHARCOMMAND = 2 } */ bool pc_group_can_use_command(int group_id, const char *command, AtCommandType type) { int result = 0; config_setting_t *commands = NULL; GroupSettings *group = NULL; if (pc_group_has_permission(group_id, PC_PERM_USE_ALL_COMMANDS)) return true; if ((group = id2group(group_id)) == NULL) return false; commands = group->commands; if (commands != NULL) { config_setting_t *cmd = NULL; // <commandname> : <bool> (only atcommand) if (type == COMMAND_ATCOMMAND && config_setting_lookup_bool(commands, command, &result)) return (bool)result; // <commandname> : [ <bool>, <bool> ] ([ atcommand, charcommand ]) if ((cmd = config_setting_get_member(commands, command)) != NULL && config_setting_is_aggregate(cmd) && config_setting_length(cmd) == 2) return (bool)config_setting_get_bool_elem(cmd, AtCommandType2idx(type)); } return false; }
/** * Attempt to create a global channel from the channel config * @param chan: Channel list * @param tmp_chan: Temporary channel data * @param i: Index * @return True on success or false on failure */ bool channel_read_sub(config_setting_t *chan, struct Channel *tmp_chan, uint8 i) { config_setting_t *group_list = NULL; int delay = 1000, autojoin = 0, leave = 1, chat = 1, color_override = 0, self_notif = 1, join_notif = 0, leave_notif = 0; int type = CHAN_TYPE_PUBLIC, group_count = 0; const char *name = NULL, *password = NULL, *alias = NULL, *color_str = "Default", *type_str = NULL; if (tmp_chan == NULL) return false; if (!config_setting_lookup_string(chan, "name", &name)) { ShowError("Please input channel 'name' at '%s' line '%d'! Skipping...\n", chan->file, chan->line); return false; } if (config_setting_lookup_string(chan, "type", &type_str) && !script_get_constant(type_str, &type)) { ShowError("Invalid channel type %s at '%s' line '%d'! Skipping...\n", type_str, chan->file, chan->line); return false; } config_setting_lookup_string(chan, "password", &password); config_setting_lookup_string(chan, "alias", &alias); config_setting_lookup_string(chan, "color", &color_str); config_setting_lookup_int(chan, "delay", &delay); config_setting_lookup_bool(chan, "autojoin", &autojoin); config_setting_lookup_bool(chan, "leave", &leave); config_setting_lookup_bool(chan, "chat", &chat); config_setting_lookup_bool(chan, "color_override", &color_override); config_setting_lookup_bool(chan, "self_notif", &self_notif); config_setting_lookup_bool(chan, "join_notif", &join_notif); config_setting_lookup_bool(chan, "leave_notif", &leave_notif); safestrncpy(tmp_chan->name,name+1,sizeof(tmp_chan->name)); if (password) safestrncpy(tmp_chan->pass,password,sizeof(tmp_chan->pass)); else tmp_chan->pass[0] = '\0'; safestrncpy(tmp_chan->alias,alias?alias:name,sizeof(tmp_chan->alias)); tmp_chan->msg_delay = delay; tmp_chan->type = (enum Channel_Type)type; tmp_chan->color = channel_getColor(color_str); tmp_chan->opt = (autojoin ? CHAN_OPT_AUTOJOIN : 0) | (leave ? CHAN_OPT_CAN_LEAVE : 0) | (chat ? CHAN_OPT_CAN_CHAT : 0) | (color_override ? CHAN_OPT_COLOR_OVERRIDE : 0) | (self_notif ? CHAN_OPT_ANNOUNCE_SELF : 0) | (join_notif ? CHAN_OPT_ANNOUNCE_JOIN : 0) | (leave_notif ? CHAN_OPT_ANNOUNCE_LEAVE : 0); if ((group_list = config_setting_get_member(chan, "groupid")) && (group_count = config_setting_length(group_list)) > 0) { int j; CREATE(tmp_chan->groups, unsigned short, group_count); tmp_chan->group_count = group_count; for (j = 0; j < group_count; j++) { int groupid = config_setting_get_int_elem(group_list, j); tmp_chan->groups[j] = groupid; } }
int cfgGetBool(const config_setting_t *setting, const TCHAR *name) { int value; char uName[CONFIG_UTF8_MAXSTRING]; UTF8_Encode(name, uName, CONFIG_UTF8_MAXSTRING); if(!config_setting_lookup_bool(setting, uName, &value)) { wcscpy_s(ConfigErrorString, CONFIG_ERROR_MAXSTRING, name); ConfigError = TRUE; return 0; } return value; }
int initialize_rig() { RIG *my_rig; /* handle to rig (nstance) */ int retcode; config_setting_t *rig_control_settings; rig_control_settings = config_lookup(&cfg, "repeater.rig_control"); int rig_id, baud_rate, data_bits, stop_bits, enabled; const char *serial_port, *frequency; config_setting_lookup_int(rig_control_settings, "rig_id", &rig_id); config_setting_lookup_int(rig_control_settings, "baud_rate", &baud_rate); config_setting_lookup_int(rig_control_settings, "data_bits", &data_bits); config_setting_lookup_int(rig_control_settings, "stop_bits", &stop_bits); config_setting_lookup_bool(rig_control_settings, "enabled", &enabled); config_setting_lookup_string(rig_control_settings, "frequency", &frequency); config_setting_lookup_string(rig_control_settings, "serial_port", &serial_port); if (!enabled) return -1; printf("frequency: %s\n", frequency); rig_set_debug(RIG_DEBUG_WARN); my_rig = rig_init(rig_id); if (!my_rig) { fprintf(stderr,"Unknown rig num: %d\n", rig_id); fprintf(stderr,"Please check riglist.h\n"); exit(1); /* whoops! something went wrong (mem alloc?) */ } strncpy(my_rig->state.rigport.pathname, "/dev/ttyS0", FILPATHLEN - 1); my_rig->state.rigport.parm.serial.rate = baud_rate; my_rig->state.rigport.parm.serial.data_bits = data_bits; my_rig->state.rigport.parm.serial.stop_bits = stop_bits; retcode = rig_open(my_rig); if (retcode != RIG_OK) { printf("rig_open: error = %s\n", rigerror(retcode)); exit(2); } return rig_set_freq(my_rig, RIG_VFO_CURR, atoi(frequency)); }
int settings_load(struct user_settings *s, const char *patharg) { config_t cfg[1]; config_setting_t *setting; const char *str; /* Load default settings */ ui_defaults(s); tox_defaults(s); key_defaults(s); #ifdef _AUDIO audio_defaults(s); #endif config_init(cfg); char path[MAX_STR_SIZE]; /* use default config file path */ if (patharg == NULL) { char *user_config_dir = get_user_config_dir(); snprintf(path, sizeof(path), "%s%stoxic.conf", user_config_dir, CONFIGDIR); free(user_config_dir); /* make sure path exists or is created on first time running */ FILE *fp = fopen(path, "r"); if (fp == NULL) { if ((fp = fopen(path, "w")) == NULL) return -1; } fclose(fp); } else { snprintf(path, sizeof(path), "%s", patharg); } if (!config_read_file(cfg, path)) { config_destroy(cfg); return -1; } /* ui */ if ((setting = config_lookup(cfg, ui_strings.self)) != NULL) { config_setting_lookup_bool(setting, ui_strings.timestamps, &s->timestamps); config_setting_lookup_bool(setting, ui_strings.alerts, &s->alerts); config_setting_lookup_bool(setting, ui_strings.autolog, &s->autolog); config_setting_lookup_bool(setting, ui_strings.native_colors, &s->colour_theme); config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size); config_setting_lookup_int(setting, ui_strings.time_format, &s->time); s->time = s->time == TIME_24 || s->time == TIME_12 ? s->time : TIME_24; /* Check defaults */ } if ((setting = config_lookup(cfg, tox_strings.self)) != NULL) { if ( config_setting_lookup_string(setting, tox_strings.download_path, &str) ) { strcpy(s->download_path, str); } } /* keys */ if((setting = config_lookup(cfg, key_strings.self)) != NULL) { const char* tmp = NULL; if(config_setting_lookup_string(setting, key_strings.next_tab, &tmp)) s->key_next_tab = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.prev_tab, &tmp)) s->key_prev_tab = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp)) s->key_scroll_line_up = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp)) s->key_scroll_line_down= key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.half_page_up, &tmp)) s->key_half_page_up = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.half_page_down, &tmp)) s->key_half_page_down = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.page_bottom, &tmp)) s->key_page_bottom = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp)) s->key_peer_list_up = key_parse(&tmp); if(config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp)) s->key_peer_list_down = key_parse(&tmp); } #ifdef _AUDIO if ((setting = config_lookup(cfg, audio_strings.self)) != NULL) { config_setting_lookup_int(setting, audio_strings.input_device, &s->audio_in_dev); s->audio_in_dev = s->audio_in_dev < 0 || s->audio_in_dev > MAX_DEVICES ? 0 : s->audio_in_dev; config_setting_lookup_int(setting, audio_strings.output_device, &s->audio_out_dev); s->audio_out_dev = s->audio_out_dev < 0 || s->audio_out_dev > MAX_DEVICES ? 0 : s->audio_out_dev; config_setting_lookup_float(setting, audio_strings.VAD_treshold, &s->VAD_treshold); } #endif #ifdef _SOUND_NOTIFY if ((setting = config_lookup(cfg, sound_strings.self)) != NULL) { if ( (config_setting_lookup_string(setting, sound_strings.error, &str) != CONFIG_TRUE) || !set_sound(error, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(error, PACKAGE_DATADIR "/sounds/Error.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.user_log_in, &str) || !set_sound(user_log_in, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ContactLogsIn.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.self_log_in, &str) || !set_sound(self_log_in, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(self_log_in, PACKAGE_DATADIR "/sounds/LogIn.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.user_log_out, &str) || !set_sound(user_log_out, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ContactLogsOut.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.self_log_out, &str) || !set_sound(self_log_out, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(self_log_out, PACKAGE_DATADIR "/sounds/LogOut.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.call_incoming, &str) || !set_sound(call_incoming, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(call_incoming, PACKAGE_DATADIR "/sounds/IncomingCall.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.call_outgoing, &str) || !set_sound(call_outgoing, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(call_outgoing, PACKAGE_DATADIR "/sounds/OutgoingCall.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.generic_message, &str) || !set_sound(generic_message, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(generic_message, PACKAGE_DATADIR "/sounds/NewMessage.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.transfer_pending, &str) || !set_sound(transfer_pending, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/TransferPending.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.transfer_completed, &str) || !set_sound(transfer_completed, str) ) { if (strcasecmp(str, NO_SOUND) != 0) set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/TransferComplete.wav"); } } else { set_sound(error, PACKAGE_DATADIR "/sounds/Error.wav"); set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ContactLogsIn.wav"); set_sound(self_log_in, PACKAGE_DATADIR "/sounds/LogIn.wav"); set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ContactLogsOut.wav"); set_sound(self_log_out, PACKAGE_DATADIR "/sounds/LogOut.wav"); set_sound(call_incoming, PACKAGE_DATADIR "/sounds/IncomingCall.wav"); set_sound(call_outgoing, PACKAGE_DATADIR "/sounds/OutgoingCall.wav"); set_sound(generic_message, PACKAGE_DATADIR "/sounds/NewMessage.wav"); set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/TransferPending.wav"); set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/TransferComplete.wav"); } #endif config_destroy(cfg); return 0; }
void SetValidationParams() { //init parameters config_t cfg; config_setting_t *setting; char settingName[50]; char configFile[30]; char settingFather[50]; int EXITO; int DEFAULT = false; // Reservar memoria // inicializar parámetros de modelo de fondo y de validación ValBGParams = (BGModelParams *) malloc(sizeof(BGModelParams)); if (!ValBGParams) { error(4); exit(1); } valParams = (ValParams*) malloc(sizeof(ValParams)); if (!valParams) { error(4); exit(1); } fprintf(stderr, "\nCargando parámetros de Validación:"); fprintf(stderr, "\nCargando parámetros de umbralización y limpieza de primer plano..."); config_init(&cfg); sprintf(configFile, "config.cfg"); /* Leer archivo. si hay un error, informar y cargar configuración por defecto */ if (!config_read_file(&cfg, configFile)) { fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg)); fprintf(stderr, "Error al acceder al fichero de configuración %s .\n" " Estableciendo valores por defecto.\n", configFile); DefaultValParams( ); } else { sprintf(settingFather, "Procesado"); setting = config_lookup(&cfg, settingFather); /* Si no se se encuentra la setting o bien existe la variable hijo Auto y ésta es true, se establecen TODOS los valores por defecto.*/ if (!setting) { fprintf(stderr, "Error.No se ha podido leer el campo %s.\n" " Estableciendo valores por defecto.\n", settingFather); DEFAULT = true; } else { sprintf(settingName, "Auto"); /* Obtener el valor */ EXITO = config_setting_lookup_bool(setting, settingName, &DEFAULT); if (!EXITO) DEFAULT = true; else if (EXITO && DEFAULT) { fprintf(stderr, "\n Opción Auto activada para el campo %s.\n" " Estableciendo valores por defecto.\n", settingFather); } else if (EXITO && !DEFAULT) fprintf( stderr, "\n Opción Auto desactivada para el campo %s.\n" " Estableciendo valores del fichero de configuración.\n", settingFather); } if (DEFAULT) { DefaultValParams(); } // si el modo auto del padre no está activado comprobar si lo está el del hijo. else { // hijo 1 sprintf(settingFather, "Procesado.Validacion"); setting = config_lookup(&cfg, settingFather); /* Si no se se encuentra la setting o bien existe la variable hijo Auto y ésta es true, se establecen TODOS los valores por defecto.*/ if (setting != NULL) { sprintf(settingName, "Auto"); /* Obtener el valor */ EXITO = config_setting_lookup_bool(setting, settingName, &DEFAULT); if (!EXITO) DEFAULT = true; else if (EXITO && DEFAULT) fprintf(stderr, "\n Opción Auto activada para el campo %s.\n" " Estableciendo valores por defecto.\n", settingFather); else if (EXITO && !DEFAULT) fprintf( stderr, "\n Opción Auto desactivada para el campo %s.\n" " Estableciendo valores del fichero de configuración.\n", settingFather); } else { DEFAULT = true; fprintf(stderr, "Error.No se ha podido leer el campo %s.\n" " Estableciendo valores por defecto.\n", settingFather); } if (DEFAULT) { DefaultValParams(); } else { double val; sprintf(settingName, "MODEL_TYPE"); if (!config_setting_lookup_int(setting, settingName, &ValBGParams->MODEL_TYPE)) { ValBGParams->MODEL_TYPE = MEDIAN_S_UP; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->MODEL_TYPE); } sprintf(settingName, "MORFOLOGIA"); if (!config_setting_lookup_bool(setting, settingName, &ValBGParams->MORFOLOGIA)) { ValBGParams->MORFOLOGIA = true; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->MORFOLOGIA); } sprintf(settingName, "CVCLOSE_ITR"); if (!config_setting_lookup_int(setting, settingName, &ValBGParams->CVCLOSE_ITR)) { ValBGParams->CVCLOSE_ITR = 1; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->CVCLOSE_ITR); } sprintf(settingName, "MAX_CONTOUR_AREA"); if (!config_setting_lookup_int(setting, settingName, &ValBGParams->MAX_CONTOUR_AREA)) { ValBGParams->MAX_CONTOUR_AREA = 0; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->MAX_CONTOUR_AREA); } sprintf(settingName, "MIN_CONTOUR_AREA"); if (!config_setting_lookup_int(setting, settingName, &ValBGParams->MIN_CONTOUR_AREA)) { ValBGParams->MIN_CONTOUR_AREA = 0; //5 fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->MIN_CONTOUR_AREA); } sprintf(settingName, "HIGHT_THRESHOLD"); if (!config_setting_lookup_int(setting, settingName, &ValBGParams->HIGHT_THRESHOLD)) { ValBGParams->HIGHT_THRESHOLD = 20; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->HIGHT_THRESHOLD); } else { if ((!ValBGParams->HIGHT_THRESHOLD || ValBGParams->HIGHT_THRESHOLD > 255)) { ValBGParams->HIGHT_THRESHOLD = 20; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %d \n", settingName, settingName, ValBGParams->BG_Update); } } sprintf(settingName, "LOW_THRESHOLD"); if (!config_setting_lookup_int(setting, settingName, &ValBGParams->LOW_THRESHOLD)) { ValBGParams->LOW_THRESHOLD = 15; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->LOW_THRESHOLD); } else { if ((!ValBGParams->LOW_THRESHOLD || ValBGParams->LOW_THRESHOLD > 255)) { ValBGParams->LOW_THRESHOLD = 15; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %d \n", settingName, settingName, ValBGParams->BG_Update); if (ValBGParams->LOW_THRESHOLD > 50) fprintf(stderr, "ADVERTENCIA: El valor de %s es muy elevado\n " "Establecer por defecto %s a %d \n", settingName, settingName, ValBGParams->LOW_THRESHOLD); } } fprintf(stderr,"\n Cargando parámetros específicos de validación..."); sprintf(settingName, "UmbralCirc"); if (!config_setting_lookup_int(setting, settingName, &valParams->UmbralCirc)) { valParams->UmbralCirc = 0; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, valParams->UmbralCirc); } sprintf(settingName, "Umbral_H"); if (!config_setting_lookup_float(setting, settingName, &val)) { valParams->Umbral_H = 5; //5 fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->MIN_CONTOUR_AREA); }else { if ((!val || val > 255)) { val = 5; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %0.1f \n", settingName, settingName, val); } valParams->Umbral_H = (float)val; } sprintf(settingName, "Umbral_L"); if (!config_setting_lookup_float(setting, settingName, &val)) { valParams->Umbral_L = 5; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, ValBGParams->HIGHT_THRESHOLD); } else { if ((!val || val > 255)) { val = 5; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %0.1f \n", settingName, settingName, valParams->Umbral_L); } valParams->Umbral_L = (float)val; } sprintf(settingName, "Umbral_MinArea"); if (!config_setting_lookup_int(setting, settingName, &valParams->Umbral_MinArea)) { valParams->Umbral_MinArea = 0; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, valParams->Umbral_MinArea); } sprintf(settingName, "MaxIncLTHIters"); if (!config_setting_lookup_int(setting, settingName, &valParams->MaxIncLTHIters)) { valParams->MaxIncLTHIters = 100; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, valParams->MaxIncLTHIters); } sprintf(settingName, "MaxLowTH"); if (!config_setting_lookup_int(setting, settingName, &valParams->MaxLowTH)) { valParams->MaxLowTH = 1000; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, valParams->MaxLowTH); } sprintf(settingName, "MinLowTH"); if (!config_setting_lookup_int(setting, settingName, &valParams->MinLowTH)) { valParams->MinLowTH = 1; // límite inferior para el umbral bajo ( defecto ) fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, valParams->MinLowTH); } sprintf(settingName, "CleanGhosts"); if (!config_setting_lookup_bool(setting, settingName, &valParams->CleanGhosts)) { valParams->CleanGhosts = false; // límite inferior para el umbral bajo ( defecto ) fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n", settingName, valParams->CleanGhosts); } sprintf(settingName, "umbralCleanGhosts"); if (!config_setting_lookup_int(setting, settingName, &valParams->umbralCleanGhosts)) { valParams->umbralCleanGhosts = 10; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d píxels \n", settingName, valParams->umbralCleanGhosts ); } else if( valParams->umbralCleanGhosts < 0 ){ valParams->umbralCleanGhosts = 10; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %d píxels \n", settingName, settingName, valParams->umbralCleanGhosts ); } } }// fin comprobar auto hijos } // fin lectura correcta fichero valParams->privateParams = NULL; ShowValParams(settingFather); // ShowStatsParams( settingFather ); config_destroy(&cfg); }
void bg_config_read(void) { config_t bg_conf; config_setting_t *data = NULL; const char *config_filename = "conf/battlegrounds.conf"; // FIXME hardcoded name if (conf_read_file(&bg_conf, config_filename)) return; data = config_lookup(&bg_conf, "battlegrounds"); if (data != NULL) { config_setting_t *settings = config_setting_get_elem(data, 0); config_setting_t *arenas; const char *delay_var; int i, arena_count = 0, offline = 0; if( !config_setting_lookup_string(settings, "global_delay_var", &delay_var) ) delay_var = "BG_Delay_Tick"; safestrncpy(bg->gdelay_var, delay_var, BG_DELAY_VAR_LENGTH); config_setting_lookup_int(settings, "maximum_afk_seconds", &bg->mafksec); config_setting_lookup_bool(settings, "feature_off", &offline); if( offline == 0 ) bg->queue_on = true; if( (arenas = config_setting_get_member(settings, "arenas")) != NULL ) { arena_count = config_setting_length(arenas); CREATE( bg->arena, struct bg_arena *, arena_count ); for(i = 0; i < arena_count; i++) { config_setting_t *arena = config_setting_get_elem(arenas, i); config_setting_t *reward; const char *aName, *aEvent, *aDelayVar; int minLevel = 0, maxLevel = 0; int prizeWin, prizeLoss, prizeDraw; int minPlayers, maxPlayers, minTeamPlayers; int maxDuration; int fillup_duration = 0, pregame_duration = 0; bg->arena[i] = NULL; if( !config_setting_lookup_string(arena, "name", &aName) ) { ShowError("bg_config_read: failed to find 'name' for arena #%d\n",i); continue; } if( !config_setting_lookup_string(arena, "event", &aEvent) ) { ShowError("bg_config_read: failed to find 'event' for arena #%d\n",i); continue; } config_setting_lookup_int(arena, "minLevel", &minLevel); config_setting_lookup_int(arena, "maxLevel", &maxLevel); if( minLevel < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' minLevel\n",minLevel,aName); minLevel = 0; } if( maxLevel > MAX_LEVEL ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' maxLevel\n",maxLevel,aName); maxLevel = MAX_LEVEL; } if( !(reward = config_setting_get_member(arena, "reward")) ) { ShowError("bg_config_read: failed to find 'reward' for arena '%s'/#%d\n",aName,i); continue; } config_setting_lookup_int(reward, "win", &prizeWin); config_setting_lookup_int(reward, "loss", &prizeLoss); config_setting_lookup_int(reward, "draw", &prizeDraw); if( prizeWin < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' reward:win\n",prizeWin,aName); prizeWin = 0; } if( prizeLoss < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' reward:loss\n",prizeLoss,aName); prizeLoss = 0; } if( prizeDraw < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' reward:draw\n",prizeDraw,aName); prizeDraw = 0; } config_setting_lookup_int(arena, "minPlayers", &minPlayers); config_setting_lookup_int(arena, "maxPlayers", &maxPlayers); config_setting_lookup_int(arena, "minTeamPlayers", &minTeamPlayers); if( minPlayers < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' minPlayers\n",minPlayers,aName); minPlayers = 0; } if( maxPlayers > MAX_BG_MEMBERS * 2 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' maxPlayers, change #define MAX_BG_MEMBERS\n",maxPlayers,aName); maxPlayers = 0; } if( minTeamPlayers < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' minTeamPlayers\n",minTeamPlayers,aName); minTeamPlayers = 0; } if( !config_setting_lookup_string(arena, "delay_var", &aDelayVar) ) { ShowError("bg_config_read: failed to find 'delay_var' for arena '%s'/#%d\n",aName,i); continue; } config_setting_lookup_int(arena, "maxDuration", &maxDuration); if( maxDuration < 0 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' maxDuration\n",maxDuration,aName); maxDuration = 30; } config_setting_lookup_int(arena, "fillDuration", &fillup_duration); config_setting_lookup_int(arena, "pGameDuration", &pregame_duration); if( fillup_duration < 20 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' fillDuration, minimum has to be 20, defaulting to 20.\n",fillup_duration,aName); fillup_duration = 20; } if( pregame_duration < 20 ) { ShowWarning("bg_config_read: invalid %d value for arena '%s' pGameDuration, minimum has to be 20, defaulting to 20.\n",pregame_duration,aName); pregame_duration = 20; } CREATE( bg->arena[i], struct bg_arena, 1 ); bg->arena[i]->id = i; safestrncpy(bg->arena[i]->name, aName, NAME_LENGTH); safestrncpy(bg->arena[i]->npc_event, aEvent, EVENT_NAME_LENGTH); bg->arena[i]->min_level = minLevel; bg->arena[i]->max_level = maxLevel; bg->arena[i]->prize_win = prizeWin; bg->arena[i]->prize_loss = prizeLoss; bg->arena[i]->prize_draw = prizeDraw; bg->arena[i]->min_players = minPlayers; bg->arena[i]->max_players = maxPlayers; bg->arena[i]->min_team_players = minTeamPlayers; safestrncpy(bg->arena[i]->delay_var, aDelayVar, NAME_LENGTH); bg->arena[i]->maxDuration = maxDuration; bg->arena[i]->queue_id = script->queue_create(); bg->arena[i]->begin_timer = INVALID_TIMER; bg->arena[i]->fillup_timer = INVALID_TIMER; bg->arena[i]->pregame_duration = pregame_duration; bg->arena[i]->fillup_duration = fillup_duration; bg->arena[i]->ongoing = false; } bg->arenas = arena_count; }
static void ya_setup_block(config_setting_t * set) { struct ya_block * blk = calloc(1,sizeof(ya_block_t)); int retcnf, retint; const char *retstr; blk->pid = -1; blk->name = strdup(config_setting_name(set)); retcnf = config_setting_lookup_string(set, "inherit", &retstr); if(retcnf == CONFIG_TRUE) { if (ya_inherit_blk(blk, retstr) == -1) { fprintf(stderr, "Skipping block (%s.%s)\n", blk->bar->name, blk->name); free(blk->name); free(blk); return; } } retcnf = config_setting_lookup_string(set, "exec", &retstr); if(retcnf == CONFIG_FALSE) { if(NOT_INHERIT_BLK(blk)) { fprintf(stderr, "No exec is defined for block: %s.%s. Skipping this block...\n", blk->bar->name, blk->name); free(blk->name); free(blk); return; } } else if(strlen(retstr) < 1) { fprintf(stderr, "exec entry is empty for block: %s.%s. Skipping this block...\n", blk->bar->name, blk->name); free(blk->name); free(blk); return; } else { #ifdef YA_INTERNAL //check if internal found, otherwise set external ya_check_blk_internal(blk, set, retstr); #else //just set it external blk->attr |= BLKA_EXTERNAL; #endif //YA_INTERNAL if (blk->attr & BLKA_EXTERNAL) { blk->cmd = strdup(retstr); } } if (blk->attr & BLKA_INTERNAL) goto skip_type; retcnf = config_setting_lookup_string(set, "type", &retstr); if(retcnf == CONFIG_FALSE) { if(NOT_INHERIT_BLK(blk)) { fprintf(stderr, "No type is defined for block: %s. Skipping this block...\n", config_setting_name(set)); free(blk->name); free(blk); return; } } else { if(strcmp(retstr, "persist")==0) { blk->attr |= BLKA_PERSIST; } else if(strcmp(retstr, "once")==0) { blk->attr |= BLKA_ONCE; } else if(strcmp(retstr, "periodic")==0) { blk->attr |= BLKA_PERIODIC; } else { //TODO handle } } skip_type: retcnf = config_setting_lookup_int(set, "interval", &retint); if(retcnf == CONFIG_FALSE) { if(NOT_INHERIT_BLK(blk)) blk->sleep = 5; } else { blk->sleep = retint; } retcnf = config_setting_lookup_string(set, "command-button1", &retstr); if(retcnf == CONFIG_TRUE) { blk->button_cmd[0] = strdup(retstr); } retcnf = config_setting_lookup_string(set, "command-button2", &retstr); if(retcnf == CONFIG_TRUE) { blk->button_cmd[1] = strdup(retstr); } retcnf = config_setting_lookup_string(set, "command-button3", &retstr); if(retcnf == CONFIG_TRUE) { blk->button_cmd[2] = strdup(retstr); } retcnf = config_setting_lookup_string(set, "command-button4", &retstr); if(retcnf == CONFIG_TRUE) { blk->button_cmd[3] = strdup(retstr); } retcnf = config_setting_lookup_string(set, "command-button5", &retstr); if(retcnf == CONFIG_TRUE) { blk->button_cmd[4] = strdup(retstr); } retcnf = config_setting_lookup_string(set, "align", &retstr); if(retcnf == CONFIG_FALSE) { if(NOT_INHERIT_BLK(blk)) blk->align = A_CENTER; } else { if(strcmp(retstr, "left")==0) { blk->align = A_LEFT; } else if(strcmp(retstr, "center")==0) { blk->align = A_CENTER; } else if(strcmp(retstr, "right")==0) { blk->align = A_RIGHT; } else { blk->align = A_CENTER; } } retcnf = config_setting_lookup_int(set, "fixed-size", &retint); if(retcnf == CONFIG_FALSE) { if(NOT_INHERIT_BLK(blk)) blk->width = 80; } else { blk->width = retint; } retcnf = config_setting_lookup_bool(set, "pango-markup", &retint); if((retcnf == CONFIG_TRUE) && retint) { blk->attr |= BLKA_MARKUP_PANGO; } retcnf = config_setting_lookup_int(set, "background-color-argb", &retint); if(retcnf == CONFIG_TRUE) { blk->bgcolor = (uint32_t) retint; blk->attr |= BLKA_BGCOLOR; } retcnf = config_setting_lookup_int(set, "background-color-rgb", &retint); if(retcnf == CONFIG_TRUE) { blk->bgcolor = retint | 0xff000000; blk->attr |= BLKA_BGCOLOR; } retcnf = config_setting_lookup_int(set, "foreground-color-argb", &retint); if(retcnf == CONFIG_TRUE) { blk->fgcolor = retint; blk->attr |= BLKA_FGCOLOR; } retcnf = config_setting_lookup_int(set, "foreground-color-rgb", &retint); if(retcnf == CONFIG_TRUE) { blk->fgcolor = retint | 0xff000000; blk->attr |= BLKA_FGCOLOR; } else { blk->fgcolor = 0xffffffff; } retcnf = config_setting_lookup_int(set, "underline-color-argb", &retint); if(retcnf == CONFIG_TRUE) { blk->ulcolor = retint; blk->attr |= BLKA_UNDERLINE; } retcnf = config_setting_lookup_int(set, "underline-color-rgb", &retint); if(retcnf == CONFIG_TRUE) { blk->ulcolor = retint | 0xff000000; blk->attr |= BLKA_UNDERLINE; } retcnf = config_setting_lookup_int(set, "overline-color-argb", &retint); if(retcnf == CONFIG_TRUE) { blk->olcolor = retint; blk->attr |= BLKA_OVERLINE; } retcnf = config_setting_lookup_int(set, "overline-color-rgb", &retint); if(retcnf == CONFIG_TRUE) { blk->olcolor = retint | 0xff000000; blk->attr |= BLKA_OVERLINE; } retcnf = config_setting_lookup_string(set, "justify", &retstr); if(retcnf == CONFIG_TRUE) { if(strcmp(retstr, "left")==0) { blk->justify = PANGO_ALIGN_LEFT; } else if(strcmp(retstr, "center")==0) { blk->justify = PANGO_ALIGN_CENTER; } else if(strcmp(retstr, "right")==0) { blk->justify = PANGO_ALIGN_RIGHT; } else { blk->justify = PANGO_ALIGN_CENTER; } } else { if(NOT_INHERIT_BLK(blk)) blk->justify = PANGO_ALIGN_CENTER; } if(blk->attr & BLKA_EXTERNAL) { if(blk->attr & BLKA_MARKUP_PANGO) blk->bufsize = BUFSIZE_EXT_PANGO; else blk->bufsize = BUFSIZE_EXT; } else { blk->bufsize = BUFSIZE_INT; } blk->buf = calloc(1, blk->bufsize); #ifdef YA_DYN_COL blk->bgcolor_old = blk->bgcolor; blk->fgcolor_old = blk->fgcolor; blk->ulcolor_old = blk->ulcolor; blk->olcolor_old = blk->olcolor; blk->strbuf = blk->buf; #endif ya_create_block(blk); }
int config_get_services(config_t *config,service ***final_services){ config_setting_t *cs_services=NULL; if((cs_services=config_lookup(config,"services"))==NULL){ return 1; } int service_count=config_setting_length(cs_services); service **services=NULL; services=malloc((service_count+1)*sizeof(service *)); int services_len=0; for(int n=0;n<service_count;n++){ //printf("service: %d\n",n); config_setting_t *cs_service=NULL; if((cs_service=config_setting_get_elem(cs_services,n))==NULL){ //printf("failed to retrieve service\n"); continue; } int enabled=0; if(config_setting_lookup_bool(cs_service,"enabled",&enabled)){ //printf(" enabled: %s\n",enabled?"true":"false"); if(enabled==0){ continue; } } config_setting_t *cs_host=NULL; if((cs_host=config_setting_get_member(cs_service,"host"))==NULL){ continue; } char *host=NULL; host=strdup(config_setting_get_string(cs_host)); if(host==NULL){ printf("failed to retrieve host\n"); continue; } config_setting_t *cs_port=NULL; if((cs_port=config_setting_get_member(cs_service,"port"))==NULL){ free(host); continue; } char *port=NULL; switch(config_setting_type(cs_port)){ case CONFIG_TYPE_INT: port=calloc(16,sizeof(*port)); sprintf(port,"%lu",config_setting_get_int(cs_port)); break; case CONFIG_TYPE_STRING: port=strdup(config_setting_get_string(cs_port)); break; } if(port==NULL){ printf("failed to retrieve port\n"); free(host); continue; } config_setting_t *cs_names=NULL; if((cs_names=config_setting_get_member(cs_service,"names"))==NULL){ free(host); free(port); continue; } int name_count=config_setting_length(cs_names); char **names=malloc((name_count+1)*sizeof(*names)); int names_len=0; for(int ni=0;ni<name_count;++ni){ const char *name=config_setting_get_string_elem(cs_names,ni); if(name!=NULL && strlen(name)>0){ names[names_len]=strdup(name); //printf(" \"%s\"\n",names[names_len]); names_len++; } } names[names_len]=NULL; services[services_len]=malloc(sizeof(service)); services[services_len]->host=host; services[services_len]->port=port; services[services_len]->names=names; services_len++; } services[services_len]=NULL; *final_services=services; return 0; }
void SetShapeParams( BGModelParams* BGParams ){ //init parameters config_t cfg; config_setting_t *setting; char settingName[30]; char configFile[30]; char settingFather[30]; int EXITO; int DEFAULT = false; // Reservar memoria // Iniciar estructura para parametros del modelo de fondo en primera actualización if(!ShParams){ ShParams = ( ShapeParams * )malloc( sizeof(ShapeParams)); if( !ShParams ) {error(4);exit(1);} } config_init(&cfg); fprintf(stderr, "\nCargando parámetros Modelo de Forma:"); fprintf(stderr, "\nCargando parámetros de umbralización y limpieza de primer plano..."); sprintf( configFile, "config.cfg"); sprintf( settingFather,"Preprocesado" ); /* Leer archivo. si hay un error, informar y cargar configuración por defecto */ if(! config_read_file(&cfg, configFile)) { fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg)); fprintf(stderr, "Error al acceder al fichero de configuración %s .\n" " Estableciendo valores por defecto.\n" ,configFile); DEFAULT = true; } else { setting = config_lookup(&cfg, settingFather); /* Si no se se encuentra la setting o bien existe la variable hijo Auto y ésta es true, se establecen TODOS los valores por defecto.*/ if(setting != NULL) { sprintf(settingName,"Auto"); /* Obtener el valor */ EXITO = config_setting_lookup_bool ( setting, settingName, &DEFAULT); if(!EXITO) DEFAULT = true; else if( EXITO && DEFAULT ) fprintf(stderr, "\n Opción Auto activada para el campo %s.\n" " Estableciendo valores por defecto.\n",settingFather); else if( EXITO && !DEFAULT) fprintf(stderr, "\n Opción Auto desactivada para el campo %s.\n" " Estableciendo valores del fichero de configuración.\n",settingFather); } else { DEFAULT = true; fprintf(stderr, "Error.No se ha podido leer el campo %s.\n" " Estableciendo valores por defecto.\n",settingFather); } sprintf( settingFather,"Preprocesado.ShapeModel" ); setting = config_lookup(&cfg, settingFather); /* Si no se se encuentra la setting o bien existe la variable hijo Auto y ésta es true, se establecen TODOS los valores por defecto.*/ if(setting != NULL) { sprintf(settingName,"Auto"); /* Obtener el valor */ EXITO = config_setting_lookup_bool ( setting, settingName, &DEFAULT); if(!EXITO) DEFAULT = true; else if( EXITO && DEFAULT ) fprintf(stderr, "\n Opción Auto activada para el campo %s.\n" " Estableciendo valores por defecto.\n",settingFather); else if( EXITO && !DEFAULT) fprintf(stderr, "\n Opción Auto desactivada para el campo %s.\n" " Estableciendo valores del fichero de configuración.\n",settingFather); } else { DEFAULT = true; fprintf(stderr, "Error.No se ha podido leer el campo %s.\n" " Estableciendo valores por defecto.\n",settingFather); } } if( DEFAULT ) SetDefaultShapeParams( BGParams ); /* Valores leídos del fichero de configuración. Algunos valores puedes ser establecidos por defecto si se indica * expresamente en el fichero de configuración. Si el valor es erroneo o no se encuentra la variable, se establecerán * a los valores por defecto. */ else{ sprintf(settingName,"MORFOLOGIA"); if(! config_setting_lookup_bool ( setting, settingName, &BGParams->MORFOLOGIA ) ){ BGParams->MORFOLOGIA = true; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,BGParams->MORFOLOGIA); } sprintf(settingName,"CVCLOSE_ITR"); if(! config_setting_lookup_int ( setting, settingName, &BGParams->CVCLOSE_ITR ) ){ BGParams->CVCLOSE_ITR = 1; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,BGParams->CVCLOSE_ITR); } sprintf(settingName,"MAX_CONTOUR_AREA"); if(! config_setting_lookup_int ( setting, settingName, &BGParams->MAX_CONTOUR_AREA ) ){ BGParams->MAX_CONTOUR_AREA = 0 ; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,BGParams->MAX_CONTOUR_AREA); } sprintf(settingName,"MIN_CONTOUR_AREA"); if(! config_setting_lookup_int ( setting, settingName, &BGParams->MIN_CONTOUR_AREA ) ){ BGParams->MIN_CONTOUR_AREA = 0; //5 fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,BGParams->MIN_CONTOUR_AREA); } sprintf(settingName,"HIGHT_THRESHOLD"); if(! config_setting_lookup_int ( setting, settingName, &BGParams->HIGHT_THRESHOLD ) ){ BGParams->HIGHT_THRESHOLD = 20; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,BGParams->HIGHT_THRESHOLD); } else { if( ( !BGParams->HIGHT_THRESHOLD || BGParams->HIGHT_THRESHOLD>255 ) ){ BGParams->HIGHT_THRESHOLD = 20; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %d \n",settingName,settingName,BGParams->BG_Update); } } sprintf(settingName,"LOW_THRESHOLD"); if(! config_setting_lookup_int ( setting, settingName, &BGParams->LOW_THRESHOLD ) ){ BGParams->LOW_THRESHOLD = 15; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,BGParams->LOW_THRESHOLD); } else { if( ( !BGParams->LOW_THRESHOLD || BGParams->LOW_THRESHOLD>255 ) ){ BGParams->LOW_THRESHOLD = 15; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %d \n",settingName,settingName,BGParams->BG_Update); if( BGParams->LOW_THRESHOLD > 50 ) fprintf(stderr, "ADVERTENCIA: El valor de %s es muy elevado\n " "Establecer por defecto %s a %d \n",settingName,settingName,BGParams->LOW_THRESHOLD); } } fprintf(stderr, "\nCargando parámetros específicos del modelo de forma..."); /* Get the store name. */ sprintf(settingName,"FramesTraining"); if(! config_setting_lookup_int ( setting, settingName, &ShParams->FramesTraining ) ){ ShParams->FramesTraining = 200; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,ShParams->FramesTraining); } else{ // tipo de valor correcto pero erróneo if( ( ShParams->FramesTraining <= 0) ){ ShParams->FramesTraining = 200; fprintf(stderr, "Se ha activado la detección del plato pero el número de frames de entrenamiento es nulo\n " "Establecer por defecto %s a %d \n",settingName,ShParams->FramesTraining); } } sprintf(settingName,"Max_Area"); if(! config_setting_lookup_int ( setting, settingName, &ShParams->Max_Area ) ){ ShParams->Max_Area = 100; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,ShParams->Max_Area ); } sprintf(settingName,"SHOW_DATA_AREAS"); if(! config_setting_lookup_bool ( setting, settingName, &ShParams->SHOW_DATA_AREAS ) ){ ShParams->SHOW_DATA_AREAS = false; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,ShParams->SHOW_DATA_AREAS ); } sprintf(settingName,"Max_Perimeter"); if(! config_setting_lookup_int ( setting, settingName, &ShParams->Max_Perimeter ) ){ ShParams->Max_Perimeter = 1000; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,ShParams->Max_Perimeter ); } } ShowShapeParams( settingFather, BGParams ); config_destroy(&cfg); }
int settings_load(struct user_settings *s, const char *patharg) { config_t cfg[1]; config_setting_t *setting; const char *str = NULL; /* Load default settings */ ui_defaults(s); tox_defaults(s); key_defaults(s); #ifdef AUDIO audio_defaults(s); #endif config_init(cfg); char path[MAX_STR_SIZE]; /* use default config file path */ if (patharg == NULL) { char *user_config_dir = get_user_config_dir(); snprintf(path, sizeof(path), "%s%stoxic.conf", user_config_dir, CONFIGDIR); free(user_config_dir); /* make sure path exists or is created on first time running */ if (!file_exists(path)) { FILE *fp = fopen(path, "w"); if (fp == NULL) return -1; fclose(fp); } } else { snprintf(path, sizeof(path), "%s", patharg); } if (!config_read_file(cfg, path)) { config_destroy(cfg); return -1; } /* ui */ if ((setting = config_lookup(cfg, ui_strings.self)) != NULL) { config_setting_lookup_bool(setting, ui_strings.timestamps, &s->timestamps); int time = 24; if ( config_setting_lookup_int(setting, ui_strings.time_format, &time) ) { if (time == 12) { snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", "%I:%M:%S %p"); snprintf(s->log_timestamp_format, sizeof(s->log_timestamp_format), "%s", "%Y/%m/%d [%I:%M:%S %p]"); } } if ( config_setting_lookup_string(setting, ui_strings.timestamp_format, &str) ) { snprintf(s->timestamp_format, sizeof(s->timestamp_format), "%s", str); } if ( config_setting_lookup_string(setting, ui_strings.log_timestamp_format, &str) ) { snprintf(s->log_timestamp_format, sizeof(s->log_timestamp_format), "%s", str); } config_setting_lookup_bool(setting, ui_strings.alerts, &s->alerts); config_setting_lookup_bool(setting, ui_strings.autolog, &s->autolog); config_setting_lookup_bool(setting, ui_strings.native_colors, &s->colour_theme); config_setting_lookup_int(setting, ui_strings.history_size, &s->history_size); config_setting_lookup_bool(setting, ui_strings.show_typing_self, &s->show_typing_self); config_setting_lookup_bool(setting, ui_strings.show_typing_other, &s->show_typing_other); config_setting_lookup_bool(setting, ui_strings.show_welcome_msg, &s->show_welcome_msg); if ( config_setting_lookup_string(setting, ui_strings.line_join, &str) ) { snprintf(s->line_join, sizeof(s->line_join), "%s", str); } if ( config_setting_lookup_string(setting, ui_strings.line_quit, &str) ) { snprintf(s->line_quit, sizeof(s->line_quit), "%s", str); } if ( config_setting_lookup_string(setting, ui_strings.line_alert, &str) ) { snprintf(s->line_alert, sizeof(s->line_alert), "%s", str); } if ( config_setting_lookup_string(setting, ui_strings.line_normal, &str) ) { snprintf(s->line_normal, sizeof(s->line_normal), "%s", str); } config_setting_lookup_bool (setting, ui_strings.mplex_away, &s->mplex_away); if (config_setting_lookup_string (setting, ui_strings.mplex_away_note, &str)) { snprintf (s->mplex_away_note, sizeof (s->mplex_away_note), "%s", str); } } /* paths */ if ((setting = config_lookup(cfg, tox_strings.self)) != NULL) { if ( config_setting_lookup_string(setting, tox_strings.download_path, &str) ) { snprintf(s->download_path, sizeof(s->download_path), "%s", str); int len = strlen(s->download_path); /* make sure path ends with a '/' */ if (len >= sizeof(s->download_path) - 2) s->download_path[0] = '\0'; else if (s->download_path[len - 1] != '/') strcat(&s->download_path[len - 1], "/"); } if ( config_setting_lookup_string(setting, tox_strings.chatlogs_path, &str) ) { snprintf(s->chatlogs_path, sizeof(s->chatlogs_path), "%s", str); int len = strlen(s->chatlogs_path); if (len >= sizeof(s->chatlogs_path) - 2) s->chatlogs_path[0] = '\0'; else if (s->chatlogs_path[len - 1] != '/') strcat(&s->chatlogs_path[len - 1], "/"); } if ( config_setting_lookup_string(setting, tox_strings.avatar_path, &str) ) { snprintf(s->avatar_path, sizeof(s->avatar_path), "%s", str); int len = strlen(str); if (len >= sizeof(s->avatar_path)) s->avatar_path[0] = '\0'; } } /* keys */ if ((setting = config_lookup(cfg, key_strings.self)) != NULL) { const char* tmp = NULL; if (config_setting_lookup_string(setting, key_strings.next_tab, &tmp)) s->key_next_tab = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.prev_tab, &tmp)) s->key_prev_tab = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.scroll_line_up, &tmp)) s->key_scroll_line_up = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.scroll_line_down, &tmp)) s->key_scroll_line_down= key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.half_page_up, &tmp)) s->key_half_page_up = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.half_page_down, &tmp)) s->key_half_page_down = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.page_bottom, &tmp)) s->key_page_bottom = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.peer_list_up, &tmp)) s->key_peer_list_up = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.peer_list_down, &tmp)) s->key_peer_list_down = key_parse(&tmp); if (config_setting_lookup_string(setting, key_strings.toggle_peerlist, &tmp)) s->key_toggle_peerlist = key_parse(&tmp); } #ifdef AUDIO if ((setting = config_lookup(cfg, audio_strings.self)) != NULL) { config_setting_lookup_int(setting, audio_strings.input_device, &s->audio_in_dev); s->audio_in_dev = s->audio_in_dev < 0 || s->audio_in_dev > MAX_DEVICES ? 0 : s->audio_in_dev; config_setting_lookup_int(setting, audio_strings.output_device, &s->audio_out_dev); s->audio_out_dev = s->audio_out_dev < 0 || s->audio_out_dev > MAX_DEVICES ? 0 : s->audio_out_dev; config_setting_lookup_float(setting, audio_strings.VAD_treshold, &s->VAD_treshold); } #endif #ifdef SOUND_NOTIFY if ((setting = config_lookup(cfg, sound_strings.self)) != NULL) { if ( (config_setting_lookup_string(setting, sound_strings.notif_error, &str) != CONFIG_TRUE) || !set_sound(notif_error, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.user_log_in, &str) || !set_sound(user_log_in, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ToxicContactOnline.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.user_log_out, &str) || !set_sound(user_log_out, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ToxicContactOffline.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.call_incoming, &str) || !set_sound(call_incoming, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(call_incoming, PACKAGE_DATADIR "/sounds/ToxicIncomingCall.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.call_outgoing, &str) || !set_sound(call_outgoing, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(call_outgoing, PACKAGE_DATADIR "/sounds/ToxicOutgoingCall.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.generic_message, &str) || !set_sound(generic_message, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(generic_message, PACKAGE_DATADIR "/sounds/ToxicRecvMessage.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.transfer_pending, &str) || !set_sound(transfer_pending, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/ToxicTransferStart.wav"); } if ( !config_setting_lookup_string(setting, sound_strings.transfer_completed, &str) || !set_sound(transfer_completed, str) ) { if (str && strcasecmp(str, NO_SOUND) != 0) set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/ToxicTransferComplete.wav"); } } else { set_sound(notif_error, PACKAGE_DATADIR "/sounds/ToxicError.wav"); set_sound(user_log_in, PACKAGE_DATADIR "/sounds/ToxicContactOnline.wav"); set_sound(user_log_out, PACKAGE_DATADIR "/sounds/ToxicContactOffline.wav"); set_sound(call_incoming, PACKAGE_DATADIR "/sounds/ToxicIncomingCall.wav"); set_sound(call_outgoing, PACKAGE_DATADIR "/sounds/ToxicOutgoingCall.wav"); set_sound(generic_message, PACKAGE_DATADIR "/sounds/ToxicRecvMessage.wav"); set_sound(transfer_pending, PACKAGE_DATADIR "/sounds/ToxicTransferStart.wav"); set_sound(transfer_completed, PACKAGE_DATADIR "/sounds/ToxicTransferComplete.wav"); } #endif config_destroy(cfg); return 0; }
static int processCommand(void *event_header, void *event) { int count = 0; int entry_count = 0; int total_root_entries = 0; int total_child_entries = 0; config_setting_t *config_root = NULL; config_setting_t *config_child = NULL; config_setting_t *config_entry = NULL; const char *current_header = NULL; const char *current_event = NULL; int int_setting = 0; int status_file; char status_file_path[MSQ_SIZE]; config_root = config_root_setting(&config); total_root_entries = config_setting_length(config_root); pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); pthread_mutex_lock(&lockConfig); for(count = 0; count < total_root_entries; count++) { config_child = config_setting_get_elem(config_root, count); if(!config_setting_is_group(config_child) || !config_setting_lookup_bool(config_child, "register", &int_setting) || int_setting == 0 || !(config_entry = config_setting_get_member(config_child, "header")) || (current_header = config_setting_get_string_elem(config_entry, common_data.diff_commands)) == NULL || strcmp(current_header, (char *)event_header) != 0) continue; current_header = config_setting_name(config_child); total_child_entries = config_setting_length(config_child); for(entry_count = 0; entry_count < total_child_entries; entry_count++) { config_entry = config_setting_get_elem(config_child, entry_count); if((current_event = config_setting_get_string_elem(config_entry, common_data.diff_commands)) == 0 || strcmp(current_event, (char *)event) != 0) continue; snprintf(status_file_path, MAX_PATH_LENGTH, "%s/%s.%s", TEMPLOCATION, PROGRAM_NAME, current_header); if((status_file = open(status_file_path, O_RDWR|O_CREAT|O_CLOEXEC, LOCKMODE)) < 0) { pthread_mutex_unlock(&lockConfig); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); return EXIT_FAILURE; } current_event = config_setting_name(config_entry); ftruncate(status_file, 0); write(status_file, current_event, strlen(current_event)); close(status_file); statusInfo.update(current_header, current_event); syslog(LOG_DEBUG, "Status update event (header): %s (%s)", current_event, current_header); pthread_mutex_unlock(&lockConfig); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); return EXIT_SUCCESS; } } pthread_mutex_unlock(&lockConfig); pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); return EXIT_SUCCESS; } /* serial_process_ascii */
void load_he_item(const char * filename, struct lt_db_t * db) { int i = 0; int cnt = 0; int status = 0; /* error reporting */ int offset = 0; char error[4096]; /* libconfig */ config_t * cfg = calloc(1, sizeof(config_t)); config_setting_t * item_db = NULL; config_setting_t * item_row = NULL; config_setting_t * item_sub = NULL; /* item_db */ he_item_t item; config_init(cfg); /* read item_db.conf */ status = config_read_file(cfg, filename); if(status != CONFIG_TRUE) { offset = sprintf(error, "%s;%d;%s", config_error_file(cfg), config_error_line(cfg), config_error_text(cfg)); error[offset] = '\0'; /*exit_abt(error);*/ } /* retrieve data */ item_db = config_lookup(cfg, "item_db"); if(config_setting_is_list(item_db)) { cnt = config_setting_length(item_db); sqlite3_exec(db->db, "BEGIN IMMEDIATE TRANSACTION;", NULL, NULL, NULL); for(i = 0; i < cnt; i++) { item_row = config_setting_get_elem(item_db, i); memset(&item, 0, sizeof(he_item_t)); config_setting_lookup_int(item_row, "Id", &item.id); config_setting_lookup_string(item_row, "AegisName", &item.aegis); config_setting_lookup_string(item_row, "Name", &item.name); config_setting_lookup_int(item_row, "Type", &item.type); config_setting_lookup_int(item_row, "Buy", &item.buy); config_setting_lookup_int(item_row, "Sell", &item.sell); config_setting_lookup_int(item_row, "Weight", &item.weight); config_setting_lookup_int(item_row, "Atk", &item.atk); config_setting_lookup_int(item_row, "Matk", &item.matk); config_setting_lookup_int(item_row, "Def", &item.def); config_setting_lookup_int(item_row, "Range", &item.range); config_setting_lookup_int(item_row, "Slots", &item.slots); config_setting_lookup_int(item_row, "Job", &item.job); config_setting_lookup_int(item_row, "Upper", &item.upper); config_setting_lookup_int(item_row, "Gender", &item.gender); config_setting_lookup_int(item_row, "Loc", &item.loc); config_setting_lookup_int(item_row, "WeaponLv", &item.weaponlv); item_sub = config_setting_get_member(item_row, "EquipLv"); if(item_sub != NULL && config_setting_is_list(item_sub) == CONFIG_TRUE) { item.equiplv[EQUIP_MIN] = config_setting_get_int_elem(item_sub, EQUIP_MIN); item.equiplv[EQUIP_MAX] = config_setting_get_int_elem(item_sub, EQUIP_MAX); } else if(item_sub != NULL) { config_setting_lookup_int(item_sub, "EquipLv", &item.equiplv[EQUIP_MIN]); item.equiplv[EQUIP_MAX] = item.equiplv[EQUIP_MIN]; } config_setting_lookup_bool(item_row, "Refine", &item.refine); config_setting_lookup_int(item_row, "View", &item.view); config_setting_lookup_bool(item_row, "BindOnEquip", &item.bindonequip); config_setting_lookup_bool(item_row, "BuyingStore", &item.buyingstore); config_setting_lookup_int(item_row, "Delay", &item.delay); item_sub = config_setting_get_member(item_row, "Trade"); if(item_sub != NULL && config_setting_is_group(item_sub) == CONFIG_TRUE) { config_setting_lookup_int(item_row, "override", &item.trade[TRADE_OVERRIDE]); config_setting_lookup_bool(item_row, "nodrop", &item.trade[TRADE_NODROP]); config_setting_lookup_bool(item_row, "notrade", &item.trade[TRADE_NOTRADE]); config_setting_lookup_bool(item_row, "partneroverride", &item.trade[TRADE_PARTNEROVERRIDE]); config_setting_lookup_bool(item_row, "noselltonpc", &item.trade[TRADE_NOSELLTONPC]); config_setting_lookup_bool(item_row, "nocart", &item.trade[TRADE_NOCART]); config_setting_lookup_bool(item_row, "nostorage", &item.trade[TRADE_NOSTORAGE]); config_setting_lookup_bool(item_row, "nogstorage", &item.trade[TRADE_NOGSTORAGE]); config_setting_lookup_bool(item_row, "nomail", &item.trade[TRADE_NOMAIL]); config_setting_lookup_bool(item_row, "noauction", &item.trade[TRADE_NOAUCTION]); } item_sub = config_setting_get_member(item_row, "Nouse"); if(item_sub != NULL && config_setting_is_group(item_sub) == CONFIG_TRUE) { config_setting_lookup_int(item_row, "override", &item.trade[NOUSE_OVERRIDE]); config_setting_lookup_bool(item_row, "sitting", &item.trade[NOUSE_SITTING]); } item_sub = config_setting_get_member(item_row, "Stack"); if(item_sub != NULL && config_setting_is_list(item_sub) == CONFIG_TRUE) { item.equiplv[STACK_AMOUNT] = config_setting_get_int_elem(item_sub, STACK_AMOUNT); item.equiplv[STACK_TYPE] = config_setting_get_int_elem(item_sub, STACK_TYPE); } config_setting_lookup_string(item_row, "Script", &item.script); config_setting_lookup_string(item_row, "OnEquipScript", &item.onequipscript); config_setting_lookup_string(item_row, "OnUnequipScript", &item.onunequipscript); if(item.script == NULL) item.script = ""; if(item.onequipscript == NULL) item.onequipscript = ""; if(item.onunequipscript == NULL) item.onunequipscript = ""; he_item_db_insert(db, &item); } sqlite3_exec(db->db, "COMMIT TRANSACTION;", NULL, NULL, NULL); } else { /*exit_abt("item configuration file root setting.");*/ } config_destroy(cfg); free(cfg); }
void SetTrackingParams( ConvUnits* calParams ){ //init parameters config_t cfg; config_setting_t *setting; char settingName[30]; char configFile[30]; char settingFather[30]; int EXITO; int DEFAULT = false; // Reservar memoria if( !trackParams){ trackParams = ( TrackingParams *) malloc( sizeof( TrackingParams) ); if(!trackParams) {error(4); return;} } fprintf(stderr, "\nCargando parámetros para Tracking..."); config_init(&cfg); sprintf( configFile, "config.cfg"); sprintf( settingFather,"TrackingParams" ); /* Leer archivo. si hay un error, informar y cargar configuración por defecto */ if(! config_read_file(&cfg, configFile)) { fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg)); fprintf(stderr, "Error al acceder al fichero de configuración %s .\n" " Estableciendo valores por defecto.\n" ,configFile); DEFAULT = true; } else { setting = config_lookup(&cfg, settingFather); /* Si no se se encuentra la setting o bien existe la variable hijo Auto y ésta es true, se establecen TODOS los valores por defecto.*/ if(setting != NULL) { sprintf(settingName,"Auto"); /* Obtener el valor */ EXITO = config_setting_lookup_bool ( setting, settingName, &DEFAULT); if(!EXITO) DEFAULT = true; else if( EXITO && DEFAULT ) fprintf(stderr, "\n Opción Auto activada para el campo %s.\n" " Estableciendo valores por defecto.\n",settingFather); else if( EXITO && !DEFAULT) fprintf(stderr, "\n Opción Auto desactivada para el campo %s.\n" " Estableciendo valores del fichero de configuración.\n",settingFather); } else { DEFAULT = true; fprintf(stderr, "Error.No se ha podido leer el campo %s.\n" " Estableciendo valores por defecto.\n",settingFather); } } if( DEFAULT ) SetDefaultTrackParams( ); /* Valores leídos del fichero de configuración. Algunos valores puedes ser establecidos por defecto si se indica * expresamente en el fichero de configuración. Si el valor es erroneo o no se encuentra la variable, se establecerán * a los valores por defecto. */ else{ double val; /* Get the store name. */ sprintf(settingName,"MaxBlobs"); if(! config_setting_lookup_int ( setting, settingName, &trackParams->MaxBlobs ) ){ trackParams->MaxBlobs = 10; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,trackParams->MaxBlobs ); } sprintf(settingName,"ShowKalmanData"); if(! config_setting_lookup_bool ( setting, settingName, &trackParams->ShowKalmanData ) ){ trackParams->ShowKalmanData = false; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,trackParams->ShowKalmanData ); } sprintf(settingName,"MaxTimeSlept"); if(! config_setting_lookup_int ( setting, settingName, &trackParams->MaxTimeSlept ) ){ trackParams->MaxTimeSlept = 200; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,trackParams->MaxTimeSlept ); } sprintf(settingName,"MaxBuffer"); if(! config_setting_lookup_int ( setting, settingName, &trackParams->MaxBuffer ) ){ trackParams->MaxBuffer = 50; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,trackParams->MaxBuffer); } sprintf(settingName,"NumberOfIdentities"); if(! config_setting_lookup_int ( setting, settingName, &trackParams->NumberOfIdentities ) ){ trackParams->NumberOfIdentities = 100; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d \n",settingName,trackParams->NumberOfIdentities); } sprintf(settingName, "PeriodoVelMed"); if (!config_setting_lookup_float(setting, settingName, &val)) { trackParams->PeriodoVelMed = 60; fprintf( stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %d frames\n", settingName, trackParams->PeriodoVelMed); } else if(!val || val < 0 ){ trackParams->PeriodoVelMed = 60; fprintf(stderr, "El valor de %s está fuera de límites\n " "Establecer por defecto %s a %d frames \n", settingName, settingName, trackParams->PeriodoVelMed); } else{ trackParams->PeriodoVelMed = cvRound( (float)val * calParams->FPS); // a frames } sprintf(settingName,"MediumActivityTh"); if(! config_setting_lookup_float ( setting, settingName, &trackParams->MediumActivityTh ) ){ trackParams->MediumActivityTh = 2.0 ; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %0.1f \n",settingName,trackParams->MediumActivityTh); } sprintf(settingName,"LowActivityTh"); if(! config_setting_lookup_float ( setting, settingName, &trackParams->LowActivityTh ) ){ trackParams->LowActivityTh = 0.5 ; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %0.1f \n",settingName,trackParams->LowActivityTh); } sprintf(settingName,"NullActivityTh"); if(! config_setting_lookup_float ( setting, settingName, &trackParams->NullActivityTh ) ){ trackParams->NullActivityTh = 0.2 ; fprintf(stderr, "No se encuentra la variable %s en el archivo de configuración o el tipo de dato es incorrecto.\n " "Establecer por defecto a %0.1f \n",settingName,trackParams->NullActivityTh); } } SetPrivateTrackParams( calParams ); ShowTrackParams( settingFather ); SetKalmanFilterParams( trackParams ); config_destroy(&cfg); }
int main(int argc, char **argv) { struct sockaddr_un sa_dom_srv; struct sockaddr_un sa_dom; struct Nano_Board nano[4]; ssize_t len; socklen_t sa_dom_len; fd_set rfds,rfd; int ret,maxfd,sd_in,sd_dom_srv,sd_dom,i,conn_boards=0; int conn_ctr[4]; char buffer[ETH_FRAME_LEN]; config_t conf; memset(&sa_dom,0,sizeof(sa_dom)); memset(&sa_dom_len,0,sizeof(sa_dom_len)); memset(nano,0,4*sizeof(struct Nano_Board)); (void)signal(SIGINT,cleanup); (void)signal(SIGTERM,cleanup); config_init(&conf); if(CONFIG_FALSE == config_read_file(&conf,"carserver.cfg")){ fprintf(stderr,"Problem with reading Configuration in line %d:\n%s\n", config_error_line(&conf), config_error_text(&conf)); config_destroy(&conf); return -1; } if (0 > config_lookup_int(&conf,"MIN_MSGS",&MIN_MSGS)) { fprintf(stderr,"could not read MIN_MSGS\n"); run = 0; } FD_ZERO(&rfds); //Initializes the descriptor to the null set. maxfd =-1; const char * addr; int port,led,W; int eCBC; config_setting_t *setting; setting = config_lookup(&conf, "Boards"); if( 4 != config_setting_length(setting)){ fprintf(stderr,"wrong number of boards configured"); return -1; } run = 1; for(i = 0; i< 4&& run; i++){ sd_in = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); if(sd_in < 0){ perror("opening Socket failed"); run=0; } config_setting_t *board = config_setting_get_elem(setting, i); if(!(config_setting_lookup_string(board, "Address", &addr)&& config_setting_lookup_int(board, "Port", &port)&& config_setting_lookup_int(board, "led", &led)&& config_setting_lookup_int(board, "W", &W)&& config_setting_lookup_bool(board, "enConnBrokenCtr",&eCBC))) { fprintf(stderr,"Could not read ip-Address and Port of board %d\n",i); run=0; } nano[i].sa.sin_family = AF_INET; printf("ip address and port of board number %d: %s, %d \n",i, addr,port); inet_aton(addr,&(nano[i].sa.sin_addr)); //Converts IP Address from char* to struct in_addr nano[i].sa.sin_port = htons(port); //converts unsigned short int from host byte order to network byte order nano[i].indat.values.led = led; nano[i].indat.values.W = W; nano[i].indat.values.setEnMotorController = TRUE; nano[i].indat.values.enConnBrokenCtr =eCBC; if(0 > connect(sd_in, (struct sockaddr *)&(nano[i].sa),sizeof(struct sockaddr))){ fprintf(stderr,"connect number %d failed\n",i); run=0; } nano[i].sd = sd_in; buffer[0]= 'I'; ret = send(sd_in,buffer,1,MSG_DONTWAIT); if(0 >= ret){ close(sd_in); printf("nano-board number %d did not receive." " closed connection.\n",i); run =0; } printf("sent I, this is %d byte\n",ret); nano[i].init = TRUE; FD_SET(sd_in,&rfds); //Adds the file descriptor sd_in to the set rfds maxfd = MAX(maxfd,sd_in); conn_boards |= 1<<i; conn_ctr[i] =0; // don't reconnect in the first 3 seconds: nano[i].last_conn_attempt = time(NULL)+3; } if (0 > config_lookup_string(&conf,"InitString",&nano_init)) { fprintf(stderr,"could not read InitString\n"); run = 0; } const char * str; if (config_lookup_string(&conf,"ClientSocket",&str)){ if (0 > (sd_dom_srv = open_dom(&sa_dom_srv,str))){ fprintf(stderr,"open_dom() failed\n"); return -1; } } else { printf("Could not read ClientSocket from config file\n"); } //init conn_timer 1sec in advance to make sure that there are enogh messages in the first second. time_t conn_timer = time(NULL)+1; struct timeval timeout; FD_SET(sd_dom_srv, &rfds); maxfd = MAX(maxfd,sd_dom_srv); timeout.tv_sec=1; timeout.tv_usec=0; sd_dom = -1; // battery power, battery compute , dist front, dist rear if(0 > init_car(nano,&conf,&conn_boards)){ return -1; } /* Event loop: runs while run == 1 */ while (run) { handle_car(); // make sure that all nanoboards stay connected if(conn_timer< time(NULL)){ for(i = 0; i< 4; i++){ if(conn_ctr[i] < MIN_MSGS){ conn_boards &= ~(1<<i); FD_CLR(nano[i].sd,&rfds); close(nano[i].sd); fprintf(stderr,"Board %d did not reach obligatory number of messages: only %d, not %d\n",i,conn_ctr[i],MIN_MSGS); } conn_ctr[i]=0; } conn_timer = time(NULL); } // if one board is disconnected, try to reconnect it for(i = 0; i<4;i++){ if((conn_boards & 1<<i)==0 && nano[i].last_conn_attempt+1<time(NULL)){ nano[i].last_conn_attempt= time(NULL); nano[i].sd = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); if(nano[i].sd < 0){ perror("opening Socket failed"); continue; } printf("reconnect board number %d\n",i); if(0 > (len = connect(nano[i].sd, (struct sockaddr *)&(nano[i].sa),sizeof(struct sockaddr)))){ fprintf(stderr,"reconnect number %d failed error: %s\n",i,strerror(len)); continue; } buffer[0]= 'I'; ret = send(nano[i].sd,buffer,1,MSG_DONTWAIT); if(0 >= ret){ printf("Was not able to send\n"); close(nano[i].sd); continue; } nano[i].init = TRUE; FD_SET(nano[i].sd,&rfds); maxfd = MAX(maxfd,nano[i].sd); } } rfd = rfds; //printf("Waiting for incoming connections\n"); ret = select(maxfd+1,&rfd,NULL,NULL,&timeout); if (0 > ret) { if (errno == EINTR) continue; perror("select() failed"); run = 0; } /* Check the listening socket for incoming connections. */ if (FD_ISSET(sd_dom_srv,&rfd)) { /* New client, accept() and add him. */ sd_dom=accept(sd_dom_srv,(struct sockaddr*)&sa_dom, &sa_dom_len); if (0 > sd_dom) { perror("accept() failed"); run = 0; } FD_SET(sd_dom,&rfds); maxfd = MAX(maxfd,sd_dom); fprintf(stdout,">> client connected to %s\n", sa_dom_srv.sun_path); } /* Read something from the client? */ if (sd_dom != -1 && FD_ISSET(sd_dom,&rfd)) { printf("Read something from the Client."); len = recv(sd_dom,buffer,ETH_FRAME_LEN,0); if (0 >= len) { FD_CLR(sd_dom,&rfds); close(sd_dom); sd_dom = -1; fprintf(stdout,"client disconnected from %s\n", sa_dom_srv.sun_path); continue; } fprintf(stdout,">> received command from %s:\n", sa_dom_srv.sun_path); // read command and //int resp = read_command(buffer,len) //if (0 > resp) // continue; len = parse_command(buffer); /*sprintf(buffer,"X:%d, W:%d, AccX:%d, AccY:%d\n",nano[0].outdat.values.X, nano[0].outdat.values.W, nano[0].outdat.values.Acc.sum[0], nano[0].outdat.values.Acc.sum[1]); */ printf("response to command is:\n%s\n(len:%d)\n",buffer,len); ret = send(sd_dom,buffer,len,MSG_DONTWAIT); if (0 >= ret) { FD_CLR(sd_dom,&rfds); close(sd_dom); sd_dom = -1; fprintf(stdout,"client disconnected from %s\n", sa_dom_srv.sun_path); continue; } } /* Read from a NanoBoard. */ for(i =0; i < 4 ; i++){ if (FD_ISSET(nano[i].sd,&rfd)){ conn_ctr[i]++; //printf("Received something from nanoboard #%d.\n",i); len = recv(nano[i].sd,buffer,ETH_FRAME_LEN,0); if(len < 0){ printf("recv did not work. sd: %d ;error: %s\n",nano[i].sd,strerror(len)); conn_boards &= ~(1<<i); FD_CLR(nano[i].sd,&rfds); close(nano[i].sd); continue; } else if(sizeof(outdata)+1!=len||buffer[0]!='R'){ if(nano[i].init == TRUE){ printf("Init frame received. Try to compare:\n"); nano[i].init=FALSE; buffer[len]='\0'; if(strcmp(nano_init,buffer)!=0){ printf("compared strings, but there is a" "fault:\nimx6:%sNano:%s\n",nano_init,buffer); printf("buffer[0] = %c, size of message: %d\n",buffer[0],len); if( buffer[0] == 'I' || buffer[0]== 'R'){ printf("Ignore this character.\n"); nano[i].init = TRUE; continue; }else run =0; }else{ printf("string is the same, connected!\n"); conn_boards |= (1<<i); } } else { FD_CLR(nano[i].sd,&rfds); close(nano[i].sd); fprintf(stderr,"nano-board number %d sent wrong data." "\n length is %d, should be %d. first char in buffer" " is %c. \n closed connection.\n", i,len,sizeof(outdata)+1,buffer[0]); conn_boards &= ~(1<<i); FD_CLR(nano[i].sd,&rfds); close(nano[i].sd); if(conn_boards==0){ printf("no more boards, stop running.\n"); run =0; } continue; } }else { memcpy(&(nano[i].outdat.serial),buffer+1,len-1); } // copy indat to buffer: memcpy(buffer+1,&(nano[i].indat.serial),sizeof(indata)); buffer[0]='S'; //printf("W: %d\n",nano[i].indat.values.W); ret = send(nano[i].sd,buffer, sizeof(indata)+1,MSG_DONTWAIT); if(0 >= ret){ FD_CLR(sd_dom,&rfds); close(nano[i].sd); printf("nano-board number %d did not receive." " closed connection.\n",i); run = 0; } } } } for(i =0; i< 4; i++) if(conn_boards & 1<<i) close(nano[i].sd); if (sd_dom > -1 && FD_ISSET(sd_dom,&rfds)) close(sd_dom); close(sd_dom_srv); unlink(sa_dom_srv.sun_path); config_destroy(&conf); fprintf(stderr,"Shutdown complete.\n\n"); return 0; }
// TODO: stop abusing NAME_MAX ;-) // TODO: proper bounds checking for all types static void config2options(const config_t * config, struct Options * options) { // generic group struct Options_generic gn_opt; { double frequency; int logging, silent; char logfile[NAME_MAX], create[NAME_MAX]; long long processes_begin, processes_end, threads_begin, threads_end; config_setting_t * generic = config_lookup(config, FLD_GENERIC_GROUP); config_setting_lookup_float(generic, FLD_GENERIC_GPU_FREQUENCY, &frequency); config_setting_lookup_bool(generic, FLD_GENERIC_LOGGING, &logging); c2o_strncpy(logfile, config_setting_get_member(generic, FLD_GENERIC_LOGFILE), NAME_MAX); c2o_strncpy(create, config_setting_get_member(generic, FLD_GENERIC_SPAWN), NAME_MAX); config_setting_lookup_int64(generic, FLD_GENERIC_PROCESSES_BEGIN, &processes_begin); config_setting_lookup_int64(generic, FLD_GENERIC_PROCESSES_END, &processes_end); config_setting_lookup_int64(generic, FLD_GENERIC_THREADS_BEGIN, &threads_begin); config_setting_lookup_int64(generic, FLD_GENERIC_THREADS_END, &threads_end); config_setting_lookup_bool(generic, FLD_GENERIC_SILENT, &silent); gn_opt = Options_generic { spawn_typeFromString(create), frequency, (bool)logging, "", // XXX strncpy ! (log filename) (unsigned)processes_begin, (unsigned)processes_end, (bool)silent, (unsigned)threads_begin, (unsigned)threads_end }; strncpy(gn_opt.csvlogname, logfile, NAME_MAX); } // walking array group struct Options_walkarray wa_opt; { long long aaccesses, begin, repetitions, end, step; char scaling[NAME_MAX], pattern[NAME_MAX]; config_setting_t * array = config_lookup(config, FLD_WALKARRAY_GROUP); config_setting_lookup_int64(array, FLD_WALKARRAY_ACCESSES, &aaccesses); config_setting_lookup_int64(array, FLD_WALKARRAY_REPEAT, &repetitions); config_setting_lookup_int64(array, FLD_WALKARRAY_BEGINLENGTH, &begin); config_setting_lookup_int64(array, FLD_WALKARRAY_ENDLENGTH, &end); config_setting_lookup_int64(array, FLD_WALKARRAY_INCREMENT, &step); c2o_strncpy(scaling, config_setting_get_member(array, FLD_WALKARRAY_SCALING), NAME_MAX); c2o_strncpy(pattern, config_setting_get_member(array, FLD_WALKARRAY_PATTERN), NAME_MAX); wa_opt = Options_walkarray { (unsigned)aaccesses, (walking_t)begin, (walking_t)end, pattern_typeFromString(pattern), (unsigned)repetitions, (walking_t)step }; } // streaming array group struct Options_streamarray sa_opt; { long long begin, end, step; char scaling[NAME_MAX]; config_setting_t * array = config_lookup(config, FLD_STREAMARRAY_GROUP); config_setting_lookup_int64(array, FLD_STREAMARRAY_BEGINLENGTH, &begin); config_setting_lookup_int64(array, FLD_STREAMARRAY_ENDLENGTH, &end); config_setting_lookup_int64(array, FLD_STREAMARRAY_INCREMENT, &step); c2o_strncpy(scaling, config_setting_get_member(array, FLD_STREAMARRAY_SCALING), NAME_MAX); sa_opt = Options_streamarray { (unsigned)begin, (unsigned)end, (unsigned)step }; } // flops array group struct Options_flopsarray fa_opt; { long long begin, end, step, calculations; char scaling[NAME_MAX]; config_setting_t * array = config_lookup(config, FLD_FLOPSARRAY_GROUP); config_setting_lookup_int64(array, FLD_FLOPSARRAY_BEGINLENGTH, &begin); config_setting_lookup_int64(array, FLD_FLOPSARRAY_ENDLENGTH, &end); config_setting_lookup_int64(array, FLD_FLOPSARRAY_INCREMENT, &step); config_setting_lookup_int64(array, FLD_FLOPSARRAY_CALCULATIONS, &calculations); c2o_strncpy(scaling, config_setting_get_member(array, FLD_FLOPSARRAY_SCALING), NAME_MAX); fa_opt = Options_flopsarray { (unsigned)begin, (unsigned)end, (unsigned long long)calculations, (unsigned)step }; } options->generic = gn_opt; options->walkArray = wa_opt; options->streamArray = sa_opt; options->flopsArray = fa_opt; }
/** * Loads group configuration from config file into memory. * @private */ static void read_config(void) { config_setting_t *groups = NULL; const char *config_filename = "conf/groups.conf"; // FIXME hardcoded name int group_count = 0; if (conf_read_file(&pc_group_config, config_filename)) return; groups = config_lookup(&pc_group_config, "groups"); if (groups != NULL) { GroupSettings *group_settings = NULL; DBIterator *iter = NULL; int i, loop = 0; group_count = config_setting_length(groups); for (i = 0; i < group_count; ++i) { int id = 0, level = 0; const char *groupname = NULL; int log_commands = 0; config_setting_t *group = config_setting_get_elem(groups, i); if (!config_setting_lookup_int(group, "id", &id)) { ShowConfigWarning(group, "pc_groups:read_config: \"groups\" list member #%d has undefined id, removing...", i); config_setting_remove_elem(groups, i); --i; --group_count; continue; } if (id2group(id) != NULL) { ShowConfigWarning(group, "pc_groups:read_config: duplicate group id %d, removing...", i); config_setting_remove_elem(groups, i); --i; --group_count; continue; } config_setting_lookup_int(group, "level", &level); config_setting_lookup_bool(group, "log_commands", &log_commands); if (!config_setting_lookup_string(group, "name", &groupname)) { char temp[20]; config_setting_t *name = NULL; snprintf(temp, sizeof(temp), "Group %d", id); if ((name = config_setting_add(group, "name", CONFIG_TYPE_STRING)) == NULL || !config_setting_set_string(name, temp)) { ShowError("pc_groups:read_config: failed to set missing group name, id=%d, skipping... (%s:%d)\n", id, config_setting_source_file(group), config_setting_source_line(group)); continue; } config_setting_lookup_string(group, "name", &groupname); // Retrieve the pointer } if (name2group(groupname) != NULL) { ShowConfigWarning(group, "pc_groups:read_config: duplicate group name %s, removing...", groupname); config_setting_remove_elem(groups, i); --i; --group_count; continue; } CREATE(group_settings, GroupSettings, 1); group_settings->id = id; group_settings->level = level; group_settings->name = groupname; group_settings->log_commands = (bool)log_commands; group_settings->inherit = config_setting_get_member(group, "inherit"); group_settings->commands = config_setting_get_member(group, "commands"); group_settings->permissions = config_setting_get_member(group, "permissions"); group_settings->inheritance_done = false; group_settings->root = group; group_settings->group_pos = i; strdb_put(pc_groupname_db, groupname, group_settings); idb_put(pc_group_db, id, group_settings); } group_count = config_setting_length(groups); // Save number of groups // Check if all commands and permissions exist iter = db_iterator(pc_group_db); for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) { config_setting_t *commands = group_settings->commands, *permissions = group_settings->permissions; int count = 0, j; // Make sure there is "commands" group if (commands == NULL) commands = group_settings->commands = config_setting_add(group_settings->root, "commands", CONFIG_TYPE_GROUP); count = config_setting_length(commands); for (j = 0; j < count; ++j) { config_setting_t *command = config_setting_get_elem(commands, j); const char *name = config_setting_name(command); if (!atcommand_exists(name)) { ShowConfigWarning(command, "pc_groups:read_config: non-existent command name '%s', removing...", name); config_setting_remove(commands, name); --j; --count; } } // Make sure there is "permissions" group if (permissions == NULL) permissions = group_settings->permissions = config_setting_add(group_settings->root, "permissions", CONFIG_TYPE_GROUP); count = config_setting_length(permissions); for(j = 0; j < count; ++j) { config_setting_t *permission = config_setting_get_elem(permissions, j); const char *name = config_setting_name(permission); int p; ARR_FIND(0, ARRAYLENGTH(pc_g_permission_name), p, strcmp(pc_g_permission_name[p].name, name) == 0); if (p == ARRAYLENGTH(pc_g_permission_name)) { ShowConfigWarning(permission, "pc_groups:read_config: non-existent permission name '%s', removing...", name); config_setting_remove(permissions, name); --p; --count; } } } dbi_destroy(iter); // Apply inheritance i = 0; // counter for processed groups while (i < group_count) { iter = db_iterator(pc_group_db); for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) { config_setting_t *inherit = NULL, *commands = group_settings->commands, *permissions = group_settings->permissions; int j, inherit_count = 0, done = 0; if (group_settings->inheritance_done) // group already processed continue; if ((inherit = group_settings->inherit) == NULL || (inherit_count = config_setting_length(inherit)) <= 0) { // this group does not inherit from others ++i; group_settings->inheritance_done = true; continue; } for (j = 0; j < inherit_count; ++j) { GroupSettings *inherited_group = NULL; const char *groupname = config_setting_get_string_elem(inherit, j); if (groupname == NULL) { ShowConfigWarning(inherit, "pc_groups:read_config: \"inherit\" array member #%d is not a name, removing...", j); config_setting_remove_elem(inherit,j); continue; } if ((inherited_group = name2group(groupname)) == NULL) { ShowConfigWarning(inherit, "pc_groups:read_config: non-existent group name \"%s\", removing...", groupname); config_setting_remove_elem(inherit,j); continue; } if (!inherited_group->inheritance_done) continue; // we need to do that group first // Copy settings (commands/permissions) that are not defined yet if (inherited_group->commands != NULL) { int l = 0, commands_count = config_setting_length(inherited_group->commands); for (l = 0; l < commands_count; ++l) config_setting_copy(commands, config_setting_get_elem(inherited_group->commands, l)); } if (inherited_group->permissions != NULL) { int l = 0, permissions_count = config_setting_length(inherited_group->permissions); for (l = 0; l < permissions_count; ++l) config_setting_copy(permissions, config_setting_get_elem(inherited_group->permissions, l)); } ++done; // copied commands and permissions from one of inherited groups } if (done == inherit_count) { // copied commands from all of inherited groups ++i; group_settings->inheritance_done = true; // we're done with this group } } dbi_destroy(iter); if (++loop > group_count) { ShowWarning("pc_groups:read_config: Could not process inheritance rules, check your config '%s' for cycles...\n", config_filename); break; } } // while(i < group_count) // Pack permissions into GroupSettings.e_permissions for faster checking iter = db_iterator(pc_group_db); for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) { config_setting_t *permissions = group_settings->permissions; int c, count = config_setting_length(permissions); for (c = 0; c < count; ++c) { config_setting_t *perm = config_setting_get_elem(permissions, c); const char *name = config_setting_name(perm); int val = config_setting_get_bool(perm); int j; if (val == 0) // does not have this permission continue; ARR_FIND(0, ARRAYLENGTH(pc_g_permission_name), j, strcmp(pc_g_permission_name[j].name, name) == 0); group_settings->e_permissions |= pc_g_permission_name[j].permission; } } dbi_destroy(iter); } ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' groups in '"CL_WHITE"%s"CL_RESET"'.\n", group_count, config_filename); if( ( pc_group_max = group_count ) ) { DBIterator *iter = db_iterator(pc_group_db); GroupSettings *group_settings = NULL; int* group_ids = aMalloc( pc_group_max * sizeof(int) ); int i = 0; for (group_settings = dbi_first(iter); dbi_exists(iter); group_settings = dbi_next(iter)) { group_ids[i++] = group_settings->id; } atcommand_db_load_groups(group_ids); aFree(group_ids); dbi_destroy(iter); } }
int parse_config(char *config_file) { config_t config; int ret = -1; config_setting_t *rtdal,*dac; const char *tmp; int single_timer; int time_slot_us; config_init(&config); if (!config_read_file(&config, config_file)) { aerror_msg("line %d - %s: \n", config_error_line(&config), config_error_text(&config)); goto destroy; } rtdal = config_lookup(&config, "rtdal"); if (!rtdal) { aerror("Error parsing config file: rtdal section not found.\n"); goto destroy; } if (!config_setting_lookup_int(rtdal, "time_slot_us", &time_slot_us)) { aerror("time_slot_us field not defined\n"); goto destroy; } if (!config_setting_lookup_string(rtdal, "cores", &tmp)) { aerror("cores field not defined\n"); goto destroy; } nof_cores = parse_cores((char*) tmp); if (nof_cores < 0) { printf("Error invalid cores %s\n",tmp); exit(0); } if (!config_setting_lookup_bool(rtdal, "enable_usrp", &using_uhd)) { aerror("enable_usrp field not defined\n"); goto destroy; } if (!config_setting_lookup_bool(rtdal, "timer_mode_single", &single_timer)) { aerror("timer_mode_single field not defined\n"); goto destroy; } if (using_uhd) { if (single_timer) { clock_source = SINGLE_TIMER; } else { clock_source = DAC; } } else { if (single_timer) { clock_source = SINGLE_TIMER; } else { clock_source = MULTI_TIMER; } } if (!config_setting_lookup_string(rtdal, "path_to_libs", &tmp)) { aerror("path_to_libs field not defined\n"); goto destroy; } strcpy(libs_path,tmp); if (using_uhd) { dac = config_lookup(&config, "dac"); if (!dac) { aerror("Error parsing config file: dac section not found.\n"); goto destroy; } #ifdef HAVE_UHD double tmp; if (!config_setting_lookup_float(dac, "samp_freq", &dac_cfg.inputFreq)) { aerror("samp_freq field not defined\n"); goto destroy; } dac_cfg.outputFreq = dac_cfg.inputFreq; if (!config_setting_lookup_float(dac, "rf_freq", &dac_cfg.inputRFFreq)) { aerror("rf_freq field not defined\n"); goto destroy; } dac_cfg.outputRFFreq = dac_cfg.inputRFFreq; if (!config_setting_lookup_float(dac, "rf_gain", &tmp)) { aerror("rf_gain field not defined\n"); goto destroy; } dac_cfg.tx_gain = tmp; dac_cfg.rx_gain = tmp; if (!config_setting_lookup_float(dac, "if_bw", &tmp)) { aerror("rf_gain field not defined\n"); goto destroy; } dac_cfg.tx_bw = tmp; dac_cfg.rx_bw = tmp; if (!config_setting_lookup_bool(dac, "sample_is_short", &dac_cfg.sampleType)) { aerror("rf_gain field not defined\n"); goto destroy; } if (!config_setting_lookup_int(dac, "block_size", &dac_cfg.NsamplesIn)) { aerror("block_size field not defined\n"); goto destroy; } dac_cfg.NsamplesOut = dac_cfg.NsamplesIn; if (!config_setting_lookup_bool(dac, "chain_is_tx", &dac_cfg.chain_is_tx)) { aerror("chain_is_tx field not defined\n"); goto destroy; } dac_cfg.sampleType = 0; dac_cfg.nof_channels = 1; uhd_readcfg(&dac_cfg); #endif } if (using_uhd) { #ifdef HAVE_UHD timeslot_us = (long int) 1000000*((float) dac_cfg.NsamplesOut/dac_cfg.outputFreq); #endif } else { timeslot_us = time_slot_us; } ret=0; destroy: config_destroy(&config); return ret; }