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