static int config_parse_file(mme_config_t *mme_config_p)
{
config_t cfg;
config_setting_t *setting_mme = NULL;
config_setting_t *setting = NULL;
config_setting_t *subsetting = NULL;
config_setting_t *sub2setting = NULL;
long int alongint;
int i, num;
char *astring = NULL;
char *address = NULL;
char *cidr = NULL;
const char* tac = NULL;
const char* mcc = NULL;
const char* mnc = NULL;
char *sgw_ip_address_for_S1u_S12_S4_up = NULL;
char *mme_interface_name_for_S1_MME = NULL;
char *mme_ip_address_for_S1_MME = NULL;
char *mme_interface_name_for_S11 = NULL;
char *mme_ip_address_for_S11 = NULL;
char *sgw_ip_address_for_S11 = NULL;
config_init(&cfg);
if(mme_config_p->config_file != NULL)
{
/* Read the file. If there is an error, report it and exit. */
if(! config_read_file(&cfg, mme_config_p->config_file))
{
fprintf(stdout, "ERROR: %s:%d - %s\n", mme_config_p->config_file, config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
AssertFatal (1 == 0, "Failed to parse MME configuration file %s!\n", mme_config_p->config_file);
}
}
else
{
fprintf(stdout, "ERROR No MME configuration file provided!\n");
config_destroy(&cfg);
AssertFatal (0, "No MME configuration file provided!\n");
}
setting_mme = config_lookup(&cfg, MME_CONFIG_STRING_MME_CONFIG);
if(setting_mme != NULL) {
// GENERAL MME SETTINGS
if( (config_setting_lookup_string( setting_mme, MME_CONFIG_STRING_REALM, (const char **)&astring) )) {
mme_config_p->realm = strdup(astring);
mme_config_p->realm_length = strlen(mme_config_p->realm);
}
if( (config_setting_lookup_int( setting_mme, MME_CONFIG_STRING_MAXENB, &alongint) )) {
mme_config_p->max_eNBs = (uint32_t)alongint;
}
if( (config_setting_lookup_int( setting_mme, MME_CONFIG_STRING_MAXUE, &alongint) )) {
mme_config_p->max_ues = (uint32_t)alongint;
}
if( (config_setting_lookup_int( setting_mme, MME_CONFIG_STRING_RELATIVE_CAPACITY, &alongint) )) {
mme_config_p->relative_capacity = (uint8_t)alongint;
}
if( (config_setting_lookup_int( setting_mme, MME_CONFIG_STRING_STATISTIC_TIMER, &alongint) )) {
mme_config_p->mme_statistic_timer = (uint32_t)alongint;
}
if( (config_setting_lookup_string( setting_mme, MME_CONFIG_STRING_EMERGENCY_ATTACH_SUPPORTED, (const char **)&astring) )) {
if (strcasecmp(astring , "yes") == 0)
mme_config_p->emergency_attach_supported = 1;
else
mme_config_p->emergency_attach_supported = 0;
}
if( (config_setting_lookup_string( setting_mme, MME_CONFIG_STRING_UNAUTHENTICATED_IMSI_SUPPORTED, (const char **)&astring) )) {
if (strcasecmp(astring , "yes") == 0)
mme_config_p->unauthenticated_imsi_supported = 1;
else
mme_config_p->unauthenticated_imsi_supported = 0;
}
if( (config_setting_lookup_string( setting_mme, MME_CONFIG_STRING_ASN1_VERBOSITY, (const char **)&astring) )) {
if (strcasecmp(astring , MME_CONFIG_STRING_ASN1_VERBOSITY_NONE) == 0)
mme_config_p->verbosity_level = 0;
else if (strcasecmp(astring , MME_CONFIG_STRING_ASN1_VERBOSITY_ANNOYING) == 0)
mme_config_p->verbosity_level = 2;
else if (strcasecmp(astring , MME_CONFIG_STRING_ASN1_VERBOSITY_INFO) == 0)
mme_config_p->verbosity_level = 1;
else
mme_config_p->verbosity_level = 0;
}
// ITTI SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_INTERTASK_INTERFACE_CONFIG);
if (setting != NULL) {
if( (config_setting_lookup_int( setting, MME_CONFIG_STRING_INTERTASK_INTERFACE_QUEUE_SIZE, &alongint) )) {
mme_config_p->itti_config.queue_size = (uint32_t)alongint;
}
}
// S6A SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_S6A_CONFIG);
if (setting != NULL) {
if( (config_setting_lookup_string( setting, MME_CONFIG_STRING_S6A_CONF_FILE_PATH, (const char **)&astring) )) {
if (astring != NULL)
mme_config_p->s6a_config.conf_file = strdup(astring);
}
}
// SCTP SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_SCTP_CONFIG);
if (setting != NULL) {
if( (config_setting_lookup_int( setting, MME_CONFIG_STRING_SCTP_INSTREAMS, &alongint) )) {
mme_config_p->sctp_config.in_streams = (uint16_t)alongint;
}
if( (config_setting_lookup_int( setting, MME_CONFIG_STRING_SCTP_OUTSTREAMS, &alongint) )) {
mme_config_p->sctp_config.out_streams = (uint16_t)alongint;
}
}
// S1AP SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_S1AP_CONFIG);
if (setting != NULL) {
if( (config_setting_lookup_int( setting, MME_CONFIG_STRING_S1AP_OUTCOME_TIMER, &alongint) )) {
mme_config_p->s1ap_config.outcome_drop_timer_sec = (uint8_t)alongint;
}
if( (config_setting_lookup_int( setting, MME_CONFIG_STRING_S1AP_PORT, &alongint) )) {
mme_config_p->s1ap_config.port_number = (uint16_t)alongint;
}
}
// GUMMEI SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_GUMMEI_CONFIG);
if (setting != NULL) {
subsetting = config_setting_get_member (setting, MME_CONFIG_STRING_MME_CODE);
if (subsetting != NULL) {
num = config_setting_length(subsetting);
if (mme_config_p->gummei.nb_mmec != num) {
if (mme_config_p->gummei.mmec != NULL) {
free(mme_config_p->gummei.mmec);
}
mme_config_p->gummei.mmec = calloc(num, sizeof(*mme_config_p->gummei.mmec));
}
mme_config_p->gummei.nb_mmec = num;
for (i = 0; i < num; i++) {
mme_config_p->gummei.mmec[i] = config_setting_get_int_elem(subsetting, i);
}
}
subsetting = config_setting_get_member (setting, MME_CONFIG_STRING_MME_GID);
if (subsetting != NULL) {
num = config_setting_length(subsetting);
if (mme_config_p->gummei.nb_mme_gid != num) {
if (mme_config_p->gummei.mme_gid != NULL) {
free(mme_config_p->gummei.mme_gid);
}
mme_config_p->gummei.mme_gid = calloc(num, sizeof(*mme_config_p->gummei.mme_gid));
}
mme_config_p->gummei.nb_mme_gid = num;
for (i = 0; i < num; i++) {
mme_config_p->gummei.mme_gid[i] = config_setting_get_int_elem(subsetting, i);
}
}
subsetting = config_setting_get_member (setting, MME_CONFIG_STRING_PLMN);
if (subsetting != NULL) {
num = config_setting_length(subsetting);
if (mme_config_p->gummei.nb_plmns != num) {
if (mme_config_p->gummei.plmn_mcc != NULL) free(mme_config_p->gummei.plmn_mcc);
if (mme_config_p->gummei.plmn_mnc != NULL) free(mme_config_p->gummei.plmn_mnc);
if (mme_config_p->gummei.plmn_mnc_len != NULL) free(mme_config_p->gummei.plmn_mnc_len);
if (mme_config_p->gummei.plmn_tac != NULL) free(mme_config_p->gummei.plmn_tac);
mme_config_p->gummei.plmn_mcc = calloc(num, sizeof(*mme_config_p->gummei.plmn_mcc));
mme_config_p->gummei.plmn_mnc = calloc(num, sizeof(*mme_config_p->gummei.plmn_mnc));
mme_config_p->gummei.plmn_mnc_len = calloc(num, sizeof(*mme_config_p->gummei.plmn_mnc_len));
mme_config_p->gummei.plmn_tac = calloc(num, sizeof(*mme_config_p->gummei.plmn_tac));
}
mme_config_p->gummei.nb_plmns = num;
for (i = 0; i < num; i++) {
sub2setting = config_setting_get_elem(subsetting, i);
if (sub2setting != NULL) {
if( (config_setting_lookup_string( sub2setting, MME_CONFIG_STRING_MCC, &mcc) )) {
mme_config_p->gummei.plmn_mcc[i] = (uint16_t)atoi(mcc);
}
if( (config_setting_lookup_string( sub2setting, MME_CONFIG_STRING_MNC, &mnc) )) {
mme_config_p->gummei.plmn_mnc[i] = (uint16_t)atoi(mnc);
mme_config_p->gummei.plmn_mnc_len[i] = strlen(mnc);
AssertFatal((mme_config_p->gummei.plmn_mnc_len[i] == 2) || (mme_config_p->gummei.plmn_mnc_len[i] == 3),
"Bad MNC length %u, must be 2 or 3", mme_config_p->gummei.plmn_mnc_len[i]);
}
if( (config_setting_lookup_string( sub2setting, MME_CONFIG_STRING_TAC, &tac) )) {
mme_config_p->gummei.plmn_tac[i] = (uint16_t)atoi(tac);
AssertFatal(mme_config_p->gummei.plmn_tac[i] != 0,
"TAC must not be 0");
}
}
}
}
}
// NETWORK INTERFACE SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_NETWORK_INTERFACES_CONFIG);
if(setting != NULL) {
if( (
config_setting_lookup_string( setting, MME_CONFIG_STRING_INTERFACE_NAME_FOR_S1_MME,
(const char **)&mme_interface_name_for_S1_MME)
&& config_setting_lookup_string( setting, MME_CONFIG_STRING_IPV4_ADDRESS_FOR_S1_MME,
(const char **)&mme_ip_address_for_S1_MME)
&& config_setting_lookup_string( setting, MME_CONFIG_STRING_INTERFACE_NAME_FOR_S11_MME,
(const char **)&mme_interface_name_for_S11)
&& config_setting_lookup_string( setting, MME_CONFIG_STRING_IPV4_ADDRESS_FOR_S11_MME,
(const char **)&mme_ip_address_for_S11)
)
) {
mme_config_p->ipv4.mme_interface_name_for_S1_MME = strdup(mme_interface_name_for_S1_MME);
cidr = strdup(mme_ip_address_for_S1_MME);
address = strtok(cidr, "/");
IPV4_STR_ADDR_TO_INT_NWBO ( address, mme_config_p->ipv4.mme_ip_address_for_S1_MME, "BAD IP ADDRESS FORMAT FOR MME S1_MME !\n" )
free(cidr);
mme_config_p->ipv4.mme_interface_name_for_S11 = strdup(mme_interface_name_for_S11);
cidr = strdup(mme_ip_address_for_S11);
address = strtok(cidr, "/");
IPV4_STR_ADDR_TO_INT_NWBO ( address, mme_config_p->ipv4.mme_ip_address_for_S11, "BAD IP ADDRESS FORMAT FOR MME S11 !\n" )
free(cidr);
}
}
// NAS SETTING
setting = config_setting_get_member (setting_mme, MME_CONFIG_STRING_NAS_CONFIG);
if (setting != NULL) {
subsetting = config_setting_get_member (setting, MME_CONFIG_STRING_NAS_SUPPORTED_INTEGRITY_ALGORITHM_LIST);
if (subsetting != NULL) {
num = config_setting_length(subsetting);
if (num <= 8) {
for (i = 0; i < num; i++) {
astring = config_setting_get_string_elem(subsetting, i);
if (strcmp("EIA0", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
else if (strcmp("EIA1", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA1;
else if (strcmp("EIA2", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA2;
else if (strcmp("EIA3", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
else if (strcmp("EIA4", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
else if (strcmp("EIA5", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
else if (strcmp("EIA6", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
else if (strcmp("EIA7", astring) == 0) mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
}
for (i = num; i < 8; i++) {
mme_config_p->nas_config.prefered_integrity_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EIA0;
}
}
}
subsetting = config_setting_get_member (setting, MME_CONFIG_STRING_NAS_SUPPORTED_CIPHERING_ALGORITHM_LIST);
if (subsetting != NULL) {
num = config_setting_length(subsetting);
if (num <= 8) {
for (i = 0; i < num; i++) {
astring = config_setting_get_string_elem(subsetting, i);
if (strcmp("EEA0", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
else if (strcmp("EEA1", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA1;
else if (strcmp("EEA2", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA2;
else if (strcmp("EEA3", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
else if (strcmp("EEA4", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
else if (strcmp("EEA5", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
else if (strcmp("EEA6", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
else if (strcmp("EEA7", astring) == 0) mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
}
for (i = num; i < 8; i++) {
mme_config_p->nas_config.prefered_ciphering_algorithm[i] = NAS_CONFIG_SECURITY_ALGORITHMS_EEA0;
}
}
}
}
}
setting = config_lookup(&cfg, SGW_CONFIG_STRING_SGW_CONFIG);
if(setting != NULL) {
subsetting = config_setting_get_member (setting, SGW_CONFIG_STRING_NETWORK_INTERFACES_CONFIG);
if(subsetting != NULL) {
if( (
config_setting_lookup_string( subsetting, SGW_CONFIG_STRING_SGW_IPV4_ADDRESS_FOR_S1U_S12_S4_UP,
(const char **)&sgw_ip_address_for_S1u_S12_S4_up)
&& config_setting_lookup_string( subsetting, SGW_CONFIG_STRING_SGW_IPV4_ADDRESS_FOR_S11,
(const char **)&sgw_ip_address_for_S11)
&& config_setting_lookup_int( setting, SGW_CONFIG_STRING_SGW_PORT_FOR_S1U_S12_S4_UP, &alongint)
)
) {
cidr = strdup(sgw_ip_address_for_S1u_S12_S4_up);
address = strtok(cidr, "/");
IPV4_STR_ADDR_TO_INT_NWBO ( address, mme_config_p->ipv4.sgw_ip_address_for_S1u_S12_S4_up, "BAD IP ADDRESS FORMAT FOR SGW S1u_S12_S4 !\n" )
free(cidr);
cidr = strdup(sgw_ip_address_for_S11);
address = strtok(cidr, "/");
IPV4_STR_ADDR_TO_INT_NWBO ( address, mme_config_p->ipv4.sgw_ip_address_for_S11, "BAD IP ADDRESS FORMAT FOR SGW S11 !\n" )
free(cidr);
mme_config_p->gtpv1u_config.port_number = (uint16_t) alongint;
}
}
}
return 0;
}
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;
}
/* This reads the configuration file, and returns a struct server_conf_s with:
*an error number:
*-1 = file wasn't read, for whatever reason
*-2 = no bootstrap servers found
*the port
*the location of the keys file
*the location of the PID file
*the list of bootstrap servers
*/
struct server_conf_s configure_server(char *cfg_file)
{
config_t cfg;
config_setting_t *server_list;
/* This one will be strcpy'd into the pid_file array in server_conf */
const char *pid_file_tmp;
const char *keys_file_tmp;
/* Remote bootstrap server variables */
int bs_port;
const char *bs_ip;
const char *bs_pk;
/* The big struct */
static struct server_conf_s server_conf;
/* Set both to their default values. If there's an error
with opening/reading the config file, we return right away */
server_conf.port = DEFAULT_PORT;
strcpy(server_conf.pid_file, DEFAULT_PID_FILE);
strcpy(server_conf.keys_file, DEFAULT_KEYS_FILE);
config_init(&cfg);
/* Read the file. If there is an error, report it and exit. */
if (! config_read_file(&cfg, cfg_file)) {
fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
server_conf.err = -1;
return server_conf;
}
/* Get the port to listen on */
if (config_lookup_int(&cfg, "port", &server_conf.port)) {
//printf("Port: %d\n", port);
} else {
fprintf(stderr, "No 'port' setting in configuration file.\n");
}
/* Get PID file location */
if (config_lookup_string(&cfg, "pid_file", &pid_file_tmp)) {
//printf("PID file: %s\n", pid_file_tmp);
strcpy(server_conf.pid_file, pid_file_tmp);
} else {
fprintf(stderr, "No 'pid_file' setting in configuration file.\n");
}
/* Get keys file location */
if (config_lookup_string(&cfg, "keys_file", &keys_file_tmp)) {
//printf("Keys file: %s\n", keys_file_tmp);
strcpy(server_conf.keys_file, keys_file_tmp);
} else {
fprintf(stderr, "No 'keys_file' setting in configuration file.\n");
}
/* Get all the servers in the list */
server_list = config_lookup(&cfg, "bootstrap_servers");
if (server_list != NULL) {
int count = config_setting_length(server_list);
int i;
char tmp_ip[30]; /* IP */
char tmp_pk[64]; /* bs_pk */
for (i = 0; i < count; ++i) {
config_setting_t *server = config_setting_get_elem(server_list, i);
/* Get a pointer on the key aray */
uint8_t *bs_pk_p = server_conf.info[i].bs_pk;
/* Only output the record if all of the expected fields are present. */
if (!(config_setting_lookup_string(server, "ip", &bs_ip)
&& config_setting_lookup_int(server, "port", &bs_port)
&& config_setting_lookup_string(server, "bs_pk", &bs_pk)))
continue;
/* Converting all that stuff into usable formats and storing
it away in the server_info struct */
server_conf.info[i].valid = 1;
if (resolve_addr(strcpy(tmp_ip, bs_ip)) == 0) {
server_conf.info[i].valid = 0;
printf("bootstrap_server %d: Invalid IP\n", i);
}
if (strlen(bs_pk) != 64) {
server_conf.info[i].valid = 0;
printf("bootstrap_server %d: Invalid public key\n", i);
}
if (!bs_port) {
server_conf.info[i].valid = 0;
printf("bootstrap_server %d: Invalid port\n", i);
}
server_conf.info[i].conn.ip.i = resolve_addr(strcpy(tmp_ip, bs_ip));
server_conf.info[i].conn.port = htons(bs_port);
b16_to_key(strcpy(tmp_pk, bs_pk), bs_pk_p);
}
/* Check if at least one server entry is valid */
for (i = 0; i < 32; ++i) {
if (server_conf.info[i].valid)
break;
else
server_conf.err = -2;
}
} else {
server_conf.err = -2;
}
config_destroy(&cfg);
return server_conf;
}
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);
}
struct node_parameters read_node_parameters(int node, char *scenario_file) {
// string pointing to scenario file
char scenario[100];
strcpy(scenario, "scenarios/");
strcat(scenario, scenario_file);
config_t cfg;
config_init(&cfg);
// Read the file. If there is an error, report it and exit.
if (!config_read_file(&cfg, scenario)) {
printf("Error reading config file on line %i\n", config_error_line(&cfg));
config_destroy(&cfg);
exit(1);
}
int tmpI;
double tmpD;
const char *tmpS;
// scenario info struct for node
struct node_parameters np = {};
char nodestr[100];
std::string node_num;
std::stringstream out;
out << node;
node_num = out.str();
// lookup specific node
strcpy(nodestr, "node");
strcat(nodestr, node_num.c_str());
config_setting_t *node_config = config_lookup(&cfg, nodestr);
// read CORNET IP address for the node
if (config_setting_lookup_string(node_config, "TARGET_IP", &tmpS))
strcpy(np.TARGET_IP, tmpS);
else
strcpy(np.TARGET_IP, "10.0.0.3");
// read CORNET IP address for the node
if (config_setting_lookup_string(node_config, "CORNET_IP", &tmpS))
strcpy(np.CORNET_IP, tmpS);
else
strcpy(np.CORNET_IP, "192.168.1.12");
// read type of node
if (config_setting_lookup_string(node_config, "type", &tmpS)) {
// printf("\nNode type: %s\n", tmpS);
if (strcmp(tmpS, "CR") == 0) {
np.type = CR;
np.cr_type = ecr;
// If node is a CR, lookup whether is uses the ECR or python
if (config_setting_lookup_string(node_config, "cr_type", &tmpS)) {
if (strcmp(tmpS, "python") == 0) {
np.cr_type = python;
// python radios are specified by the "python_file" field in the
// scenario file
if (config_setting_lookup_string(node_config, "python_file", &tmpS)) {
strcpy(np.python_file, tmpS);
// check for optional command line arguments and add them to
// np.arguments if found
const config_setting_t *arguments;
char path[100];
strcpy(path, nodestr);
strcat(path, ".arguments");
arguments = config_lookup(&cfg, path);
np.num_arguments = 0;
if (arguments != NULL) {
np.num_arguments = config_setting_length(arguments);
for (int i = 0; i < np.num_arguments; i++) {
tmpS = config_setting_get_string_elem(arguments, i);
strcpy(np.arguments[i], tmpS);
}
} else
printf("arguments not found\n");
} else {
printf("A python radio requires a python file.\n");
}
}
// Possibly add more types later, but for now if not python, then radio
// must be ECR-based
// and the engine to use is specified by the "CE" field
else {
if (config_setting_lookup_string(node_config, "CE", &tmpS))
strcpy(np.CE, tmpS);
else {
printf(
"Configuration of a node did not specify a cognitive engine");
exit(1);
}
}
}
} else if (strcmp(tmpS, "interferer") == 0)
np.type = interferer;
}
// read all possible node settings
if (config_setting_lookup_string(node_config, "CRTS_IP", &tmpS))
strcpy(np.CRTS_IP, tmpS);
else
strcpy(np.CRTS_IP, "10.0.0.2");
if (config_setting_lookup_int(node_config, "print_metrics", &tmpI))
np.print_metrics = (int)tmpI;
if (config_setting_lookup_int(node_config, "log_phy_rx", &tmpI))
np.log_phy_rx = (int)tmpI;
if (config_setting_lookup_int(node_config, "log_phy_tx", &tmpI))
np.log_phy_tx = (int)tmpI;
if (config_setting_lookup_int(node_config, "log_net_rx", &tmpI))
np.log_net_rx = (int)tmpI;
if (config_setting_lookup_string(node_config, "phy_rx_log_file", &tmpS))
strcpy(np.phy_rx_log_file, tmpS);
if (config_setting_lookup_string(node_config, "phy_tx_log_file", &tmpS))
strcpy(np.phy_tx_log_file, tmpS);
if (config_setting_lookup_string(node_config, "net_rx_log_file", &tmpS))
strcpy(np.net_rx_log_file, tmpS);
if (config_setting_lookup_int(node_config, "generate_octave_logs", &tmpI))
np.generate_octave_logs = (int)tmpI;
if (config_setting_lookup_int(node_config, "generate_python_logs", &tmpI))
np.generate_python_logs = (int)tmpI;
if (config_setting_lookup_float(node_config, "ce_timeout_ms", &tmpD))
np.ce_timeout_ms = tmpD;
if (config_setting_lookup_string(node_config, "duplex", &tmpS)) {
if (!strcmp(tmpS, "FDD"))
np.duplex = FDD;
else if (!strcmp(tmpS, "TDD"))
np.duplex = TDD;
else if (!strcmp(tmpS, "HD"))
np.duplex = HD;
else
np.duplex = FDD;
}
if (config_setting_lookup_float(node_config, "rx_freq", &tmpD))
np.rx_freq = tmpD;
if (config_setting_lookup_float(node_config, "rx_rate", &tmpD))
np.rx_rate = tmpD;
else
np.rx_rate = 1e6;
if (config_setting_lookup_float(node_config, "rx_gain", &tmpD))
np.rx_gain = tmpD;
else
np.rx_gain = 20.0;
if (config_setting_lookup_int(node_config, "rx_subcarriers", &tmpI))
np.rx_subcarriers = (int)tmpI;
else
np.rx_subcarriers = 64;
if (config_setting_lookup_string(node_config, "rx_subcarrier_alloc_method",
&tmpS)) {
// subcarrier allocation is being defined in a standard way
if (!strcmp(tmpS, "standard")) {
np.rx_subcarrier_alloc_method = STANDARD_SUBCARRIER_ALLOC;
int rx_guard_subcarriers;
int rx_central_nulls;
int rx_pilot_freq;
if (config_setting_lookup_int(node_config, "rx_guard_subcarriers", &tmpI))
rx_guard_subcarriers = tmpI;
if (config_setting_lookup_int(node_config, "rx_central_nulls", &tmpI))
rx_central_nulls = tmpI;
if (config_setting_lookup_int(node_config, "rx_pilot_freq", &tmpI))
rx_pilot_freq = tmpI;
for (int i = 0; i < np.rx_subcarriers; i++) {
// central band nulls
if (i < rx_central_nulls / 2 ||
np.rx_subcarriers - i - 1 < rx_central_nulls / 2)
np.rx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_NULL;
// guard band nulls
else if (i + 1 > np.rx_subcarriers / 2 - rx_guard_subcarriers &&
i < np.rx_subcarriers / 2 + rx_guard_subcarriers)
np.rx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_NULL;
// pilot subcarriers (based on distance from center)
else if (abs((int)((float)np.rx_subcarriers / 2.0 - (float)i - 0.5)) %
rx_pilot_freq ==
0)
np.rx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_PILOT;
// data subcarriers
else
np.rx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_DATA;
}
}
// subcarrier allocation is completely custom
else if (!strcmp(tmpS, "custom")) {
np.rx_subcarrier_alloc_method = CUSTOM_SUBCARRIER_ALLOC;
config_setting_t *rx_subcarrier_alloc =
config_setting_get_member(node_config, "rx_subcarrier_alloc");
char type_str[9] = "sc_type_";
char num_str[8] = "sc_num_";
char sc_type[16];
char sc_num[16];
int i = 1;
int j = 0;
int offset = np.rx_subcarriers / 2;
sprintf(sc_type, "%s%d", type_str, i);
// read in a custom initial subcarrier allocation
while (
config_setting_lookup_string(rx_subcarrier_alloc, sc_type, &tmpS)) {
// read the number of subcarriers into tmpI
sprintf(sc_num, "%s%d", num_str, i);
tmpI = 1;
config_setting_lookup_int(rx_subcarrier_alloc, sc_num, &tmpI);
// set the subcarrier type based on the number specified
if (!strcmp(tmpS, "null")) {
for (int k = 0; k < tmpI; k++) {
if (j >= (np.rx_subcarriers) / 2)
offset = -(np.rx_subcarriers / 2);
np.rx_subcarrier_alloc[j + offset] = OFDMFRAME_SCTYPE_NULL;
j++;
}
}
if (!strcmp(tmpS, "pilot")) {
for (int k = 0; k < tmpI; k++) {
if (j >= (np.rx_subcarriers) / 2)
offset = -(np.rx_subcarriers / 2);
np.rx_subcarrier_alloc[j + offset] = OFDMFRAME_SCTYPE_PILOT;
j++;
}
}
if (!strcmp(tmpS, "data")) {
for (int k = 0; k < tmpI; k++) {
if (j >= (np.rx_subcarriers) / 2)
offset = -(np.rx_subcarriers / 2);
np.rx_subcarrier_alloc[j + offset] = OFDMFRAME_SCTYPE_DATA;
j++;
}
}
if (j > 2048) {
printf("The number of subcarriers specified was too high!\n");
exit(1);
}
i++;
sprintf(sc_type, "%s%d", type_str, i);
}
} else
np.rx_subcarrier_alloc_method = LIQUID_DEFAULT_SUBCARRIER_ALLOC;
}
if (config_setting_lookup_int(node_config, "rx_cp_len", &tmpI))
np.rx_cp_len = (int)tmpI;
else
np.rx_cp_len = 16;
if (config_setting_lookup_int(node_config, "rx_taper_len", &tmpI))
np.rx_taper_len = (int)tmpI;
else
np.rx_taper_len = 4;
if (config_setting_lookup_float(node_config, "tx_freq", &tmpD))
np.tx_freq = tmpD;
if (config_setting_lookup_float(node_config, "tx_rate", &tmpD))
np.tx_rate = tmpD;
else
np.rx_rate = 1e6;
if (config_setting_lookup_float(node_config, "tx_gain_soft", &tmpD))
np.tx_gain_soft = tmpD;
else
np.tx_gain_soft = -12.0;
if (config_setting_lookup_float(node_config, "tx_gain", &tmpD))
np.tx_gain = tmpD;
else
np.tx_gain = 20.0;
if (config_setting_lookup_int(node_config, "tx_subcarriers", &tmpI))
np.tx_subcarriers = (int)tmpI;
else
np.tx_subcarriers = 64;
if (config_setting_lookup_string(node_config, "tx_subcarrier_alloc_method",
&tmpS)) {
// subcarrier allocation is being defined in a standard way
if (!strcmp(tmpS, "standard")) {
np.tx_subcarrier_alloc_method = STANDARD_SUBCARRIER_ALLOC;
int tx_guard_subcarriers;
int tx_central_nulls;
int tx_pilot_freq;
if (config_setting_lookup_int(node_config, "tx_guard_subcarriers", &tmpI))
tx_guard_subcarriers = tmpI;
if (config_setting_lookup_int(node_config, "tx_central_nulls", &tmpI))
tx_central_nulls = tmpI;
if (config_setting_lookup_int(node_config, "tx_pilot_freq", &tmpI))
tx_pilot_freq = tmpI;
for (int i = 0; i < np.tx_subcarriers; i++) {
// central band nulls
if (i < tx_central_nulls / 2 ||
np.tx_subcarriers - i - 1 < tx_central_nulls / 2)
np.tx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_NULL;
// guard band nulls
else if (i + 1 > np.tx_subcarriers / 2 - tx_guard_subcarriers &&
i < np.tx_subcarriers / 2 + tx_guard_subcarriers)
np.tx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_NULL;
// pilot subcarriers
else if (abs((int)((float)np.tx_subcarriers / 2.0 - (float)i - 0.5)) %
tx_pilot_freq ==
0)
np.tx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_PILOT;
// data subcarriers
else
np.tx_subcarrier_alloc[i] = OFDMFRAME_SCTYPE_DATA;
}
}
// subcarrier allocation is completely custom
else if (!strcmp(tmpS, "custom")) {
np.tx_subcarrier_alloc_method = CUSTOM_SUBCARRIER_ALLOC;
config_setting_t *tx_subcarrier_alloc =
config_setting_get_member(node_config, "tx_subcarrier_alloc");
char type_str[9] = "sc_type_";
char num_str[8] = "sc_num_";
char sc_type[16];
char sc_num[16];
int i = 1;
int j = 0;
int offset = np.tx_subcarriers / 2;
sprintf(sc_type, "%s%d", type_str, i);
// read in a custom initial subcarrier allocation
while (
config_setting_lookup_string(tx_subcarrier_alloc, sc_type, &tmpS)) {
// read the number of subcarriers into tmpI
sprintf(sc_num, "%s%d", num_str, i);
tmpI = 1;
config_setting_lookup_int(tx_subcarrier_alloc, sc_num, &tmpI);
// set the subcarrier type based on the number specified
if (!strcmp(tmpS, "null")) {
for (int k = 0; k < tmpI; k++) {
if (j >= (np.tx_subcarriers) / 2)
offset = -(np.tx_subcarriers / 2);
np.tx_subcarrier_alloc[j + offset] = OFDMFRAME_SCTYPE_NULL;
j++;
}
}
if (!strcmp(tmpS, "pilot")) {
for (int k = 0; k < tmpI; k++) {
if (j >= (np.tx_subcarriers) / 2)
offset = -(np.tx_subcarriers / 2);
np.tx_subcarrier_alloc[j + offset] = OFDMFRAME_SCTYPE_PILOT;
j++;
}
}
if (!strcmp(tmpS, "data")) {
for (int k = 0; k < tmpI; k++) {
if (j >= (np.tx_subcarriers) / 2)
offset = -(np.tx_subcarriers / 2);
np.tx_subcarrier_alloc[j + offset] = OFDMFRAME_SCTYPE_DATA;
j++;
}
}
if (j > 2048) {
printf("The number of subcarriers specified was too high!\n");
exit(1);
}
i++;
sprintf(sc_type, "%s%d", type_str, i);
}
} else
np.tx_subcarrier_alloc_method = LIQUID_DEFAULT_SUBCARRIER_ALLOC;
}
if (config_setting_lookup_int(node_config, "tx_cp_len", &tmpI))
np.tx_cp_len = (int)tmpI;
else
np.tx_cp_len = 16;
if (config_setting_lookup_int(node_config, "tx_taper_len", &tmpI))
np.tx_taper_len = (int)tmpI;
else
np.tx_taper_len = 4;
// default tx modulation is BPSK
np.tx_modulation = LIQUID_MODEM_BPSK;
if (config_setting_lookup_string(node_config, "tx_modulation", &tmpS)) {
// Iterate through every liquid modulation scheme
// and if the string matches, then assign that scheme.
// See liquid soruce: src/modem/src/modem_utilities.c
// for definition of modulation_types
for (int k = 0; k < LIQUID_MODEM_NUM_SCHEMES; k++) {
if (!strcmp(tmpS, modulation_types[k].name))
np.tx_modulation = modulation_types[k].scheme;
}
}
// default tx CRC32
np.tx_crc = LIQUID_CRC_32;
if (config_setting_lookup_string(node_config, "tx_crc", &tmpS)) {
// Iterate through every liquid CRC
// and if the string matches, then assign that CRC.
// See liquid soruce: src/fec/src/crc.c
// for definition of crc_scheme_str
for (int k = 0; k < LIQUID_CRC_NUM_SCHEMES; k++) {
if (!strcmp(tmpS, crc_scheme_str[k][0]))
np.tx_crc = k;
}
}
// default tx FEC0 is Hamming 12/8
np.tx_fec0 = LIQUID_FEC_HAMMING128;
if (config_setting_lookup_string(node_config, "tx_fec0", &tmpS)) {
// Iterate through every liquid FEC
// and if the string matches, then assign that FEC.
// See liquid soruce: src/fec/src/fec.c
// for definition of fec_scheme_str
for (int k = 0; k < LIQUID_FEC_NUM_SCHEMES; k++) {
if (!strcmp(tmpS, fec_scheme_str[k][0]))
np.tx_fec0 = k;
}
}
// default rx FEC1 is none
np.tx_fec1 = LIQUID_FEC_NONE;
if (config_setting_lookup_string(node_config, "tx_fec1", &tmpS)) {
// Iterate through every liquid FEC
// and if the string matches, then assign that FEC.
// See liquid soruce: src/fec/src/fec.c
// for definition of fec_scheme_str
for (int k = 0; k < LIQUID_FEC_NUM_SCHEMES; k++) {
if (!strcmp(tmpS, fec_scheme_str[k][0]))
np.tx_fec1 = k;
}
}
if (config_setting_lookup_float(node_config, "tx_delay_us", &tmpD))
np.tx_delay_us = tmpD;
else
np.tx_delay_us = 1e3;
if (config_setting_lookup_string(node_config, "interference_type", &tmpS)) {
if (!strcmp(tmpS, "CW"))
np.interference_type = CW;
if (!strcmp(tmpS, "AWGN"))
np.interference_type = NOISE;
if (!strcmp(tmpS, "GMSK"))
np.interference_type = GMSK;
if (!strcmp(tmpS, "RRC"))
np.interference_type = RRC;
if (!strcmp(tmpS, "OFDM"))
np.interference_type = OFDM;
}
if (config_setting_lookup_float(node_config, "period", &tmpD))
np.period = tmpD;
if (config_setting_lookup_float(node_config, "duty_cycle", &tmpD))
np.duty_cycle = tmpD;
// ======================================================
// process frequency hopping parameters
// ======================================================
if (config_setting_lookup_string(node_config, "tx_freq_hop_type", &tmpS)) {
if (!strcmp(tmpS, "NONE"))
np.tx_freq_hop_type = NONE;
if (!strcmp(tmpS, "ALTERNATING"))
np.tx_freq_hop_type = ALTERNATING;
if (!strcmp(tmpS, "SWEEP"))
np.tx_freq_hop_type = SWEEP;
if (!strcmp(tmpS, "RANDOM"))
np.tx_freq_hop_type = RANDOM;
}
if (config_setting_lookup_float(node_config, "tx_freq_hop_min", &tmpD))
np.tx_freq_hop_min = tmpD;
if (config_setting_lookup_float(node_config, "tx_freq_hop_max", &tmpD))
np.tx_freq_hop_max = tmpD;
if (config_setting_lookup_float(node_config, "tx_freq_hop_dwell_time", &tmpD))
np.tx_freq_hop_dwell_time = tmpD;
if (config_setting_lookup_float(node_config, "tx_freq_hop_increment", &tmpD))
np.tx_freq_hop_increment = tmpD;
return np;
}
int consensus_read_config(node* cur_node,const char* config_path){
config_t config_file;
config_init(&config_file);
if(!config_read_file(&config_file,config_path)){
goto goto_config_error;
}
uint32_t group_size;
if(!config_lookup_int(&config_file,"group_size",(int*)&group_size)){
goto goto_config_error;
}
cur_node->group_size = group_size;
cur_node->peer_pool = (peer*)malloc(group_size*sizeof(peer));
if(NULL==cur_node->peer_pool){
goto goto_config_error;
}
if(group_size<=cur_node->node_id){
err_log("CONSENSUS : Configuration Reading Error : Invalid Node Id.\n");
goto goto_config_error;
}
config_setting_t *consensus_global_config = NULL;
consensus_global_config = config_lookup(&config_file,"consensus_global_config");
if(NULL!=consensus_global_config){
long long temp;
if(config_setting_lookup_int64(consensus_global_config,"progress_timeval_s",&temp)){
cur_node->config.make_progress_timeval.tv_sec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"progress_timeval_us",&temp)){
cur_node->config.make_progress_timeval.tv_usec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"reconnect_timeval_s",&temp)){
cur_node->config.reconnect_timeval.tv_sec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"reconnect_timeval_us",&temp)){
cur_node->config.reconnect_timeval.tv_usec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"ping_timeval_s",&temp)){
cur_node->config.ping_timeval.tv_sec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"ping_timeval_us",&temp)){
cur_node->config.ping_timeval.tv_usec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"expected_ping_timeval_s",&temp)){
cur_node->config.expect_ping_timeval.tv_sec = temp;
}
if(config_setting_lookup_int64(consensus_global_config,"expected_ping_timeval_us",&temp)){
cur_node->config.expect_ping_timeval.tv_usec = temp;
}
}
config_setting_t *nodes_config;
nodes_config = config_lookup(&config_file,"consensus_config");
if(NULL==nodes_config){
err_log("CONSENSUS : Cannot Find Nodes Settings.\n");
goto goto_config_error;
}
if(NULL==nodes_config){
err_log("CONSENSUS : Cannot Find Net Address Section.\n");
goto goto_config_error;
}
peer* peer_pool = cur_node->peer_pool;
for(uint32_t i=0;i<group_size;i++){
config_setting_t *node_config = config_setting_get_elem(nodes_config,i);
if(NULL==node_config){
err_log("CONSENSUS : Cannot Find Node%u's Address.\n",i);
goto goto_config_error;
}
const char* peer_ipaddr;
int peer_port;
if(!config_setting_lookup_string(node_config,"ip_address",&peer_ipaddr)){
goto goto_config_error;
}
if(!config_setting_lookup_int(node_config,"port",&peer_port)){
goto goto_config_error;
}
peer_pool[i].my_node = cur_node;
peer_pool[i].peer_id = i;
peer_pool[i].base = cur_node->base;
peer_pool[i].reconnect = NULL;
peer_pool[i].active = 0;
peer_pool[i].my_buff_event = NULL;
peer_pool[i].sock_id = -1;
peer_pool[i].peer_address = (struct sockaddr_in*)malloc(sizeof(struct
sockaddr_in));
peer_pool[i].sock_len = sizeof(struct sockaddr_in);
peer_pool[i].peer_address->sin_family =AF_INET;
inet_pton(AF_INET,peer_ipaddr,&peer_pool[i].peer_address->sin_addr);
peer_pool[i].peer_address->sin_port = htons(peer_port);
if(i==cur_node->node_id){
config_setting_lookup_int(node_config,"sys_log",&cur_node->sys_log);
config_setting_lookup_int(node_config,"stat_log",&cur_node->stat_log);
const char* db_name;
if(!config_setting_lookup_string(node_config,"db_name",&db_name)){
goto goto_config_error;
}
size_t db_name_len = strlen(db_name);
cur_node->db_name = (char*)malloc(sizeof(char)*(db_name_len+1));
if(cur_node->db_name==NULL){
goto goto_config_error;
}
if(NULL==strncpy(cur_node->db_name,db_name,db_name_len)){
free(cur_node->db_name);
goto goto_config_error;
}
cur_node->db_name[db_name_len] = '\0';
cur_node->my_address.sin_port = htons(peer_port);
cur_node->my_address.sin_family = AF_INET;
inet_pton(AF_INET,peer_ipaddr,&cur_node->my_address.sin_addr);
}
}
config_destroy(&config_file);
return 0;
goto_config_error:
err_log("CONSENSUS : %s:%d - %s\n", config_error_file(&config_file),
config_error_line(&config_file), config_error_text(&config_file));
config_destroy(&config_file);
return -1;
};
/**
Load interfaces section.
* @param[in] cfg Config section.
* @param[in] option Option name.
* @param[in,out] array Resulting array.
* @return Zero on success.
*/
int load_interfaces(const config_setting_t *cfg, const char *option, UT_array *array)
{
config_setting_t *cfg_list = config_setting_get_member(cfg, option);
if (!cfg_list) {
ZERO_LOG(LOG_ERR, "config: missing %s entry", option);
return -1;
}
if (config_setting_type(cfg_list) != CONFIG_TYPE_LIST) {
ZERO_LOG(LOG_ERR, "config: invalid %s entry", option);
return -1;
}
int count = config_setting_length(cfg_list);
if (0 >= count) {
ZERO_LOG(LOG_ERR, "config: empty %s entry", option);
return -1;
}
utarray_init(array, &ut_zif_pair_icd);
for (int i = 0; i < count; i++) {
struct zif_pair if_pair;
const char *str;
config_setting_t *entry = config_setting_get_elem(cfg_list, i);
if (NULL == entry) {
ZERO_LOG(LOG_ERR, "config: failed to read %u-th group of %s entry", i, option);
goto fail;
}
if (!config_setting_lookup_string(entry, ZCFG_LAN, &str)) {
ZERO_LOG(LOG_ERR, "config: failed to read '%s' property of %u-th group of %s entry", ZCFG_LAN, i, option);
goto fail;
}
strncpy(if_pair.lan, str, sizeof(if_pair.lan));
if (!config_setting_lookup_string(entry, ZCFG_WAN, &str)) {
ZERO_LOG(LOG_ERR, "config: failed to read '%s' property of %u-th group of %s entry", ZCFG_WAN, i, option);
goto fail;
}
strncpy(if_pair.wan, str, sizeof(if_pair.wan));
int affinity = 0;
if (!config_setting_lookup_int(entry, ZCFG_AFFINITY, &affinity)) {
ZERO_LOG(LOG_ERR, "config: failed to read '%s' property of %u-th group of %s entry", ZCFG_AFFINITY, i, option);
goto fail;
}
if ((affinity < 0) || affinity >= UINT16_MAX) {
ZERO_LOG(LOG_ERR, "config: invalid value in '%s' property of %u-th group of %s entry", ZCFG_AFFINITY, i, option);
goto fail;
}
if_pair.affinity = (uint16_t)affinity;
utarray_push_back(array, &if_pair);
}
return 0;
fail:
utarray_done(array);
return -1;
}
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 mst_read_policy_details(config_t *pconfig)
{
int rv = -1;
const char *strval;
int intval;
int index;
int index_2;
int count, count_2;
config_setting_t *policy;
config_setting_t *links_setting;
config_setting_t *nw_conf_setting;
config_setting_t *link_up_setting;
config_setting_t *link_down_setting;
char lookup_string[D_LOOKUP_STR_LEN + 1] = {0};
rv = config_lookup_string(pconfig, "policy", &strval);
if (CONFIG_FALSE == rv) {
fprintf(stderr, "No active policy is chosen.\n");
return -1;
}
g_mst_conf.policy = strdup(strval);
policy = config_lookup(pconfig, g_mst_conf.policy);
if (!policy) {
fprintf(stderr, "Chosen policy is not configured.\n");
return -1;
}
if (0 == g_mst_conf.mst_type) {
g_mst_conf.lbmode = 0;
rv = config_setting_lookup_int(policy, "lbmode", &intval);
if (CONFIG_TRUE == rv) {
g_mst_conf.lbmode = intval;
}
}
snprintf(lookup_string, D_LOOKUP_STR_LEN, "%s.links", g_mst_conf.policy);
links_setting = config_lookup(pconfig, lookup_string);
if (!links_setting) {
fprintf(stderr, "No links section is present.\n");
return -1;
}
count = config_setting_length(links_setting);
if (!count) {
fprintf(stderr, "Empty links section is not accepted.\n");
return -1;
}
g_mst_conf.links_cnt = count;
g_mst_conf.links = (mst_links_t *) malloc(count * sizeof(mst_links_t));
assert(g_mst_conf.links);
for(index = 0; index < count; index++) {
config_setting_t *links = config_setting_get_elem(links_setting, index);
rv = config_setting_lookup_string(links, "leftip", &strval);
if (CONFIG_FALSE == rv) {
fprintf(stderr, "Leftip is not configured.\n");
return -1;
}
g_mst_conf.links[index].leftip = strdup(strval);
rv = config_setting_lookup_string(links, "rightip", &strval);
if (CONFIG_TRUE == rv) {
g_mst_conf.links[index].rightip = strdup(strval);
}
else {
g_mst_conf.links[index].rightip = NULL;
if (0 == g_mst_conf.mst_type) {
fprintf(stderr, "rightip is not configured.\n");
return -1;
}
}
rv = config_setting_lookup_int(links, "leftport", &intval);
if (CONFIG_FALSE == rv) {
fprintf(stderr, "Leftport is not configured.\n");
return -1;
}
g_mst_conf.links[index].leftport = intval;
rv = config_setting_lookup_int(links, "rightport", &intval);
if (CONFIG_TRUE == rv) {
g_mst_conf.links[index].rightport = intval;
}
else {
g_mst_conf.links[index].rightport = 0;
if (0 == g_mst_conf.mst_type) {
fprintf(stderr, "rightport is not configured.\n");
return -1;
}
}
}
snprintf(lookup_string, D_LOOKUP_STR_LEN, "%s.nw_conf", g_mst_conf.policy);
nw_conf_setting = config_lookup(pconfig, lookup_string);
if (!nw_conf_setting) {
fprintf(stderr, "No nw_conf section is present.\n");
return -1;
}
count = config_setting_length(nw_conf_setting);
if (!count || (count > 1)) {
fprintf(stderr, "Not more than one nw_conf section must be present\n");
return -1;
}
g_mst_conf.nw_conf_cnt = count;
g_mst_conf.nw_conf = (mst_nw_ctrl_t *)malloc(count * sizeof(mst_nw_ctrl_t));
assert(g_mst_conf.nw_conf);
for(index = 0; index < count; index++) {
config_setting_t *nw_conf = config_setting_get_elem(nw_conf_setting, index);
rv = config_setting_lookup_int(nw_conf, "nw_id", &intval);
if (CONFIG_FALSE == rv) {
fprintf(stderr, "nw_id is not configured in %s\n", lookup_string);
return -1;
}
g_mst_conf.nw_conf[index].nw_id = intval;
link_up_setting = config_setting_get_member(nw_conf, "link_up");
if (link_up_setting) {
count_2 = config_setting_length(link_up_setting);
g_mst_conf.nw_conf[index].link_up_cnt = count_2;
if (count_2) {
g_mst_conf.nw_conf[index].link_up = (char **)malloc(count_2 * sizeof(char *));
assert(g_mst_conf.nw_conf[index].link_up);
}
for(index_2 = 0; index_2 < count_2; index_2++) {
config_setting_t *link_up = config_setting_get_elem(link_up_setting, index_2);
rv = config_setting_lookup_string(link_up, "cmd", &strval);
if (CONFIG_TRUE == rv) {
g_mst_conf.nw_conf[index].link_up[index_2] = strdup(strval);
}
else {
g_mst_conf.nw_conf[index].link_up[index_2] = NULL;
}
}
}
link_down_setting = config_setting_get_member(nw_conf, "link_down");
if (link_down_setting) {
count_2 = config_setting_length(link_down_setting);
g_mst_conf.nw_conf[index].link_down_cnt = count_2;
if (count_2) {
g_mst_conf.nw_conf[index].link_down = (char **)malloc(count_2 * sizeof(char *));
assert(g_mst_conf.nw_conf[index].link_down);
}
for(index_2 = 0; index_2 < count_2; index_2++) {
config_setting_t *link_down = config_setting_get_elem(link_down_setting, index_2);
rv = config_setting_lookup_string(link_down, "cmd", &strval);
if (CONFIG_TRUE == rv) {
g_mst_conf.nw_conf[index].link_down[index_2] = strdup(strval);
}
else {
g_mst_conf.nw_conf[index].link_down[index_2] = NULL;
}
}
}
}
return CONFIG_TRUE;
}
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;
}
void init(CodecConfiguration *configuration) {
// Need to initialize loggers.
// Then need to pre-allocate pinned memory and Cuda Global Memory.
gpuTunerCategory = log4c_category_get("performance_tuning_gpu_logger");
cpuTunerCategory = log4c_category_get("performance_tuning_cpu_logger");
log4c_init();
currentMode = PRODUCTION;
config_t propConfig;
config_init(&propConfig);
if (!config_read_file(&propConfig, configuration->propertyFilePath)) {
fprintf(stderr, "%s:%d - %s\n",
config_error_file(&propConfig), config_error_line(&propConfig), config_error_text(&propConfig));
config_destroy(&propConfig);
return;
}
config_lookup_bool(&propConfig, "isUseGpu", &useGpu);
config_lookup_bool(&propConfig, "isUseDynamicParallelism", &useDynamicParallelism);
config_lookup_int(&propConfig, "max_packet_size", &maxPacketSize);
config_lookup_int(&propConfig, "max_batch_size", &maxBatchSize);
config_lookup_int(&propConfig, "tuner_loop_count", &tunerLoopCount);
config_lookup_int(&propConfig, "number_of_cpu_cores", &nCpuCores);
config_lookup_int(&propConfig, "cuda_stream_count", &cudaStreamCount);
config_lookup_bool(&propConfig, "print_accuracy_log", &printAccuracyLog);
currentCudaContextSize = (uint32_t) maxBatchSize;
cudaPduContext = allocatePinnedPduContext(maxBatchSize);
initCudaParameters((uint32_t) maxBatchSize, ((uint64_t) maxPacketSize * (uint64_t) maxBatchSize));
int isTunerMode = 0;
config_lookup_bool(&propConfig, "isTunerMode", &isTunerMode);
currentMode = isTunerMode ? TUNER : PRODUCTION;
printf("Is Use GPU %d | Max Packet Size %d | Max Batch Size %d | Tuner Mode %d | Accuracy Log %d\n",
useGpu, maxPacketSize, maxBatchSize, currentMode, printAccuracyLog);
fflush(stdout);
switch (currentMode) {
case TUNER: {
configureTuner(&propConfig);
break;
}
default: {
int x, y, z;
config_setting_t *block = config_lookup(&propConfig, "production.block");
config_setting_t *grid = config_lookup(&propConfig, "production.grid");
config_setting_lookup_int(block, "x", &x);
config_setting_lookup_int(block, "y", &y);
config_setting_lookup_int(block, "z", &z);
blockDimProdction.x = (uint32_t) x;
blockDimProdction.y = (uint32_t) y;
blockDimProdction.z = (uint32_t) z;
config_setting_lookup_int(grid, "x", &x);
config_setting_lookup_int(grid, "y", &y);
config_setting_lookup_int(grid, "z", &z);
gridDimProduction.x = (uint32_t) x;
gridDimProduction.y = (uint32_t) y;
gridDimProduction.z = (uint32_t) z;
config_lookup_int(&propConfig, "production.cpu_decode_threshold", &cpuDecodeThreshold);
}
}
}
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;
}
int main(int argc, char*argv[]) {
//variables
const config_setting_t *figuras, *figura_actual;
int count, n;
int xInit, yInit, xIncremento, yIncremento, xDir, yDir, xFinal, yFinal, rotacion, animacion, colorIn, colorOut, tiempoInicio, tiempoIntervalo,tiempoVida, tipoScheduler, tiquetes;
//init socket ***
cantidad_sockets = 3;
struct sigaction sa;
sa.sa_handler = &sig_int;
// Block every signal during the handler
sigfillset(&sa.sa_mask);
if (sigaction(SIGINT, &sa, NULL) == -1) {
printf("Error: cannot handle SIGINT");
}
int sock = open_socket();
if (sock == -1) {
printf("error occured\n");
return -1;
}
/*Inicializa los sockets de los monitores 1 y 2*/
/*Inicializa los sockets de los monitores 1 y 2*/
int contador_sockets;
for (contador_sockets = 0; contador_sockets < cantidad_sockets; contador_sockets++) {
if (contador_sockets == 0) {
socket_monitor_1 = listener((void*) &sock);
printf("creo monitor 1\n");
} else if (contador_sockets == 1) {
socket_monitor_2 = listener((void*) &sock);
printf("creo monitor 2\n");
} else if (contador_sockets == 2) {
socket_monitor_3 = listener((void*) &sock);
printf("creo monitor 3\n");
}
}
printf("ya cree todos los sockets\n");
my_thread_init();
printf("se hizo el init de my_thread\n");
//init lista
initLista();
printf("se hizo el init de la lista figuras\n");
//Lectura figuras
config_t cfg, *cf;
cf = &cfg;
config_init(cf);
if (!config_read_file(cf, "Archivos de Configuracion/test.cfg")) { //directorio archivo
fprintf(stderr, "%s:%d - %s\n",
config_error_file(cf),
config_error_line(cf),
config_error_text(cf));
config_destroy(cf);
return (EXIT_FAILURE);
}
figuras = config_lookup(cf, "Figuras");
count = config_setting_length(figuras);
for (n = 0; n < count; n++) {
figura_actual = config_setting_get_elem(figuras, n);
config_setting_lookup_int(figura_actual, "Xinit", &xInit);
config_setting_lookup_int(figura_actual, "Yinit", &yInit);
config_setting_lookup_int(figura_actual, "Xincremento", &xIncremento);
config_setting_lookup_int(figura_actual, "Yincremento", &yIncremento);
config_setting_lookup_int(figura_actual, "Xdir", &xDir);
config_setting_lookup_int(figura_actual, "Ydir", &yDir);
config_setting_lookup_int(figura_actual, "XFinal", &xFinal);
config_setting_lookup_int(figura_actual, "YFinal", &yFinal);
config_setting_lookup_int(figura_actual, "RotacionInit", &rotacion);
config_setting_lookup_int(figura_actual, "Animacion", &animacion);
config_setting_lookup_int(figura_actual, "ColorIn", &colorIn);
config_setting_lookup_int(figura_actual, "ColorOut", &colorOut);
config_setting_lookup_int(figura_actual, "TiempoInicio", &tiempoInicio);
config_setting_lookup_int(figura_actual, "TiempoIntervalo", &tiempoIntervalo);
config_setting_lookup_int(figura_actual, "TiempoVida", &tiempoVida);
config_setting_lookup_int(figura_actual, "TipoScheduler", &tipoScheduler);
config_setting_lookup_int(figura_actual, "Tiquetes", &tiquetes);
pFigura* fig = figura_create(n,xInit,yInit,rotacion,colorIn,colorOut,1,tiempoIntervalo,xIncremento,yIncremento,xDir,yDir,xFinal,yFinal,tiempoVida,asignarMonitor(xInit),tiempoInicio,animacion);
agregarFiguraLista(fig);
my_thread_create(pintame, 1, (void*) fig, tipoScheduler, tiquetes);
}
config_destroy(cf);
/*
//pFigura* fig1 = figura_create(1, 0, 0, 0, 1, 2, 1, 100, 1, 0, 1, 1, 90, 0, 45000, asignarMonitor(0), 0, 1);
//pFigura* fig2 = figura_create(2, 40, 0, 0, 5, 6, 1, 1000, 1, 0, 1, 1, 80, 0, 45000, asignarMonitor(40), 0, 1);
//pFigura* fig3 = figura_create(3, 0, 8, 0, 3, 4, 1, 500, 1, 0, 1, 1, 80, 8, 40000, asignarMonitor(0), 5000, 0);
//pFigura* fig4 = figura_create(4, 120, 8, 0, 6, 7, 1, 700, 1, 0, -1, 1, 0, 8, 60000, asignarMonitor(120), 2000, 0);
agregarFiguraLista(fig1);
agregarFiguraLista(fig2);
//agregarFiguraLista(fig3);
//agregarFiguraLista(fig4);
my_thread_create(pintame, 1, (void*) fig1, 1, 0);
my_thread_create(pintame, 1, (void*) fig2, 1, 0);
//my_thread_create(pintame, 1, (void*) fig3, 1, 0);
//my_thread_create(pintame, 1, (void*) fig4, 1, 0);
*/
while (1);
//my_thread_join(t3);
printf("Exit\n");
exit(0);
}
/**
* 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_int(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;
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 = pc_group_db->iterator(pc_group_db);
for (group_settings = (GroupSettings*)iter->first(iter, NULL);
iter->exists(iter);
group_settings = (GroupSettings*)iter->next(iter, NULL)) {
config_setting_t *commands = group_settings->commands, *permissions = group_settings->permissions;
int count = 0, i;
// 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 (i = 0; i < count; ++i) {
config_setting_t *command = config_setting_get_elem(commands, i);
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);
--i;
--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(i = 0; i < count; ++i) {
config_setting_t *permission = config_setting_get_elem(permissions, i);
const char *name = config_setting_name(permission);
int j;
ARR_FIND(0, ARRAYLENGTH(permission_name), j, strcmp(permission_name[j].name, name) == 0);
if (j == ARRAYLENGTH(permission_name)) {
ShowConfigWarning(permission, "pc_groups:read_config: non-existent permission name '%s', removing...", name);
config_setting_remove(permissions, name);
--i;
--count;
}
}
}
iter->destroy(iter);
// Apply inheritance
i = 0; // counter for processed groups
while (i < group_count) {
iter = pc_group_db->iterator(pc_group_db);
for (group_settings = (GroupSettings*)iter->first(iter, NULL);
iter->exists(iter);
group_settings = (GroupSettings*)iter->next(iter, NULL)) {
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 i = 0, commands_count = config_setting_length(inherited_group->commands);
for (i = 0; i < commands_count; ++i)
config_setting_copy(commands, config_setting_get_elem(inherited_group->commands, i));
}
if (inherited_group->permissions != NULL) {
int i = 0, permissions_count = config_setting_length(inherited_group->permissions);
for (i = 0; i < permissions_count; ++i)
config_setting_copy(permissions, config_setting_get_elem(inherited_group->permissions, i));
}
++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
}
}
iter->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 = (GroupSettings*)dbi_first(iter);
dbi_exists(iter);
group_settings = (GroupSettings*)dbi_next(iter)) {
config_setting_t *permissions = group_settings->permissions;
int i, count = config_setting_length(permissions);
for (i = 0; i < count; ++i) {
config_setting_t *perm = config_setting_get_elem(permissions, i);
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(permission_name), j, strcmp(permission_name[j].name, name) == 0);
group_settings->e_permissions |= permission_name[j].permission;
}
}
iter->destroy(iter);
}
ShowStatus("Done reading '"CL_WHITE"%d"CL_RESET"' groups in '"CL_WHITE"%s"CL_RESET"'.\n", group_count, config_filename);
}
void load_params(int argc, char **argv) {
config_t cfg;
config_setting_t *setting, *interrupt_setting;
char const *config_socket, *inter_name, *inter_type_string, *inter_pud;
char *config_file_name;
int ch, inter_pin, inter_type, inter_wait, r, pud;
int lcd_di, lcd_led, lcd_spics, read_config = 0;
InterruptInfo *interrupt_info;
while ((ch = getopt(argc, argv, "dhvs:a:l:c:i:")) != -1) {
switch (ch) {
case 'd':
set_flag_dont_detach(1);
break;
case 'h':
usage();
exit(EXIT_SUCCESS);
break;
case 'v':
set_flag_verbose(1);
break;
case 's':
set_socket_filename(optarg);
break;
case 'a':
if (is_valid_pin_num(atoi(optarg))) {
set_lcd_di(atoi(optarg));
} else {
printf("Only valid Pinnumber between 1 and 16 allowed!\n");
usage();
exit(EXIT_FAILURE);
}
break;
case 'l':
if (is_valid_pin_num(atoi(optarg))) {
set_lcd_led(atoi(optarg));
} else {
printf("Only valid Pinnumber between 1 and 16 allowed!\n");
usage();
exit(EXIT_FAILURE);
}
break;
case 'c':
if (is_valid_pin_num(atoi(optarg))) {
set_lcd_spics(atoi(optarg));
} else {
printf("Only 0 or 1 allowed!\n");
usage();
exit(EXIT_FAILURE);
}
break;
case 'i':
read_config = 1;
config_file_name = optarg;
break;
default:
usage();
exit(1);
}
}
if (read_config) {
config_init(&cfg);
/* Read the config file and about on error */
if (!config_read_file(&cfg, config_file_name)) {
printf("\n%s:%d - %s\n", config_file_name, config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
exit(1);
}
if (config_lookup_string(&cfg, "socket", &config_socket)) {
set_socket_filename(strndup(config_socket, strlen(config_socket)));
printf("Socket file configured from config file as: %s\n", get_socket_filename());
}
setting = config_lookup(&cfg, "lcd");
if (setting != NULL) {
if (!config_setting_lookup_int(setting, "di_pin", &lcd_di)) {
set_lcd_di(lcd_di);
if (get_flag_verbose()) {
printf("Set DI Pin of the LCD Display to %i with config file\n", lcd_di);
}
}
if (!config_setting_lookup_int(setting, "led_pin", &lcd_led)) {
set_lcd_led(lcd_led);
if (get_flag_verbose()) {
printf("Set PWM LED Pin of the LCD Display to %i with config file\n", lcd_led);
}
}
if (!config_setting_lookup_int(setting, "spi_cs", &lcd_spics)) {
set_lcd_spics(lcd_spics);
if (get_flag_verbose()) {
printf("Set SPI CS Pin of the LCD Display to %i with config file\n", lcd_spics);
}
}
}
setting = config_lookup(&cfg, "interrupt");
if (setting != NULL)
{
if (config_setting_type(setting) == CONFIG_TYPE_LIST) {
set_interrupts_count(config_setting_length(setting));
// Max interrupts are 10 if more configured only the first 10 are used!
if (get_interrupts_count() > 10) {
set_interrupts_count(10);
}
for (r=0; r < get_interrupts_count(); r++) {
interrupt_setting = config_setting_get_elem(setting, r);
if (!(config_setting_lookup_int(interrupt_setting, "pin", &inter_pin)
&& config_setting_lookup_string(interrupt_setting, "type", &inter_type_string)
&& config_setting_lookup_string(interrupt_setting, "name", &inter_name)
&& config_setting_lookup_int(interrupt_setting, "wait", &inter_wait)
&& config_setting_lookup_string(interrupt_setting, "pud", &inter_pud))) {
// TODO: Error message if configuration is not valid
continue;
}
if(strncmp(inter_pud, "none", strlen("none")) == 0) {
pud = PUD_OFF;
} else if (strncmp(inter_pud, "up", strlen("up")) == 0) {
pud = PUD_UP;
} else if (strncmp(inter_pud, "down", strlen("down")) == 0) {
pud = PUD_DOWN;
} else {
// TODO: Error message if configuration is not valid
continue;
}
if(strncmp(inter_type_string, "falling", strlen("falling")) == 0) {
inter_type = INT_EDGE_FALLING;
} else if (strncmp(inter_type_string, "rising", strlen("rising")) == 0) {
inter_type = INT_EDGE_RISING;
} else if (strncmp(inter_type_string, "both", strlen("both")) == 0) {
inter_type = INT_EDGE_BOTH;
} else {
// TODO: Error message if configuration is not valid
continue;
}
interrupt_info = malloc(sizeof(InterruptInfo));
if (r <= 10) {
interrupt_info->pin = inter_pin;
interrupt_info->wait = inter_wait;
interrupt_info->type = inter_type;
interrupt_info->name = strndup(inter_name, strlen(inter_name));
interrupt_info->occure = 0;
interrupt_info->pud = pud;
set_interrupt_info(r, *interrupt_info);
}
}
}
}
config_destroy(&cfg);
}
}
void core_main(uint8_t *envi_name, uint8_t *stack_name, uint32_t seed) {
PRINT_IMPORTANT("Core Initiation: Starting ************");
#ifdef BUILD_FOR_ANDROID
library_dummies();
#endif
register_to_signal(SIGRTMIN);
if (seed == DEFAULT_SEED_NUM) {
srand((unsigned int) time(NULL));
} else {
srand(seed);
}
sem_init(&global_control_serial_sem, 0, 1); //TODO remove after gen_control_serial_num() converted to RNG
signal(SIGINT, core_termination_handler); //register termination handler
int status;
int i, j, k;
metadata_element *list_elem;
int list_num;
metadata_element *elem;
metadata_element *ip_elem;
uint32_t ip_num;
//######################################################################
overall = (struct fins_overall *) secure_malloc(sizeof(struct fins_overall));
sem_init(&overall->sem, 0, 1);
//######################################################################
overall->envi = (struct envi_record *) secure_malloc(sizeof(struct envi_record));
PRINT_IMPORTANT("########################## loading environment: '%s'", (char *) envi_name);
metadata *meta_envi = (metadata *) secure_malloc(sizeof(metadata));
metadata_create(meta_envi);
status = config_read_file(meta_envi, (char *) envi_name);
if (status == META_FALSE) {
PRINT_ERROR("file='%s', %s:%d - %s\n", envi_name, config_error_file(meta_envi), config_error_line(meta_envi), config_error_text(meta_envi));
metadata_destroy(meta_envi);
PRINT_ERROR("todo error");
exit(-1);
}
//############# if_list
PRINT_IMPORTANT("############# Configuring List of Interfaces");
overall->envi->if_list = list_create(MAX_INTERFACES);
list_elem = config_lookup(meta_envi, "environment.interfaces");
if (list_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
list_num = config_setting_length(list_elem);
int32_t if_index;
uint8_t *name;
uint64_t mac;
uint32_t mode;
uint32_t mtu;
uint32_t flags;
struct if_record *ifr;
for (i = 0; i < list_num; i++) {
elem = config_setting_get_elem(list_elem, i);
if (elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "index", (int *) &if_index);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_string(elem, "name", (const char **) &name);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int64(elem, "mac", (long long *) &mac);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "mode", (int *) &mode);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "mtu", (int *) &mtu);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "flags", (int *) &flags);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
//#############
ifr = (struct if_record *) list_find1(overall->envi->if_list, ifr_index_test, &if_index);
if (ifr == NULL) {
ifr = (struct if_record *) secure_malloc(sizeof(struct if_record));
ifr->index = if_index;
strcpy((char *) ifr->name, (char *) name);
ifr->mac = mac;
ifr->mode = (uint8_t) mode;
ifr->mtu = mtu;
ifr->flags = flags;
ifr->addr_list = list_create(MAX_FAMILIES);
if (list_has_space(overall->envi->if_list)) {
PRINT_IMPORTANT("Adding interface: ifr=%p, index=%u, name='%s', mac=0x%012llx", ifr, ifr->index, ifr->name, ifr->mac);
list_append(overall->envi->if_list, ifr);
} else {
//TODO error
PRINT_ERROR("todo error");
exit(-1);
}
if (flags & IFF_LOOPBACK) {
overall->envi->if_loopback = ifr;
}
} else {
PRINT_ERROR("todo error");
exit(-1);
}
}
PRINT_IMPORTANT("if_list: list=%p, max=%u, len=%u", overall->envi->if_list, overall->envi->if_list->max, overall->envi->if_list->len);
//############# if_loopback
PRINT_IMPORTANT("############# Configuring Loopback Interface");
if (overall->envi->if_loopback != NULL) {
PRINT_IMPORTANT("loopback: name='%s', addr_list->len=%u", overall->envi->if_loopback->name, overall->envi->if_loopback->addr_list->len);
} else {
PRINT_WARN("todo error");
}
//############# if_main
PRINT_IMPORTANT("############# Configuring Main Interface");
uint32_t if_main;
status = config_lookup_int(meta_envi, "environment.main_interface", (int *) &if_main);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
overall->envi->if_main = (struct if_record *) list_find1(overall->envi->if_list, ifr_index_test, &if_main);
if (overall->envi->if_main != NULL) {
PRINT_IMPORTANT("main interface: name='%s', addr_list->len=%u", overall->envi->if_main->name, overall->envi->if_main->addr_list->len);
if (!ifr_running_test(overall->envi->if_main)) {
PRINT_WARN("!!!!Selected main interface is NOT running: name='%s', flagx->len=0x%x", overall->envi->if_main->name, overall->envi->if_main->flags);
}
} else {
PRINT_WARN("todo error");
}
//############# addr_list
PRINT_IMPORTANT("############# Configuring List of Host Addresses");
//overall->envi->addr_list = list_create(MAX_INTERFACES * MAX_FAMILIES); //TODO use?
list_elem = config_lookup(meta_envi, "environment.addresses");
if (list_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
list_num = config_setting_length(list_elem);
uint32_t family; //atm only AF_INET, but eventually also AF_INET6
uint32_t ip[4]; //SIOCGIFADDR //ip
uint32_t mask[4]; //SIOCGIFNETMASK //mask
uint32_t gw[4]; //? //(ip & mask) | 1;
uint32_t bdc[4]; //SIOCGIFBRDADDR //(ip & mask) | ~mask
uint32_t dst[4]; //SIOCGIFDSTADDR //dst
struct addr_record *addr;
for (i = 0; i < list_num; i++) {
elem = config_setting_get_elem(list_elem, i);
if (elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "if_index", (int *) &if_index);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "family", (int *) &family);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_elem = config_setting_get_member(elem, "ip");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
ip[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
ip_elem = config_setting_get_member(elem, "mask");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
mask[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
ip_elem = config_setting_get_member(elem, "gw");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
gw[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
ip_elem = config_setting_get_member(elem, "bdc");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
bdc[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
ip_elem = config_setting_get_member(elem, "dst");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
dst[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
//############
ifr = (struct if_record *) list_find1(overall->envi->if_list, ifr_index_test, &if_index);
if (ifr != NULL) {
if (ifr_running_test(ifr)) {
if (family == AF_INET) {
addr = (struct addr_record *) list_find(ifr->addr_list, addr_is_v4);
} else {
addr = (struct addr_record *) list_find(ifr->addr_list, addr_is_v6);
}
if (addr == NULL) {
addr = (struct addr_record *) secure_malloc(sizeof(struct addr_record));
addr->if_index = if_index;
addr->family = AF_INET;
if (family == AF_INET) {
addr4_set_ip(&addr->ip, IP4_ADR_P2H(ip[0], ip[1], ip[2],ip[3]));
addr4_set_ip(&addr->mask, IP4_ADR_P2H(mask[0], mask[1], mask[2],mask[3]));
addr4_set_ip(&addr->gw, IP4_ADR_P2H(gw[0], gw[1], gw[2], gw[3]));
addr4_set_ip(&addr->bdc, IP4_ADR_P2H(bdc[0], bdc[1], bdc[2], bdc[3]));
addr4_set_ip(&addr->dst, IP4_ADR_P2H(dst[0], dst[1], dst[2], dst[3]));
} else if (family == AF_INET6) {
//TODO
//addr_set_addr6(&addr->ip, ip);
PRINT_WARN("todo");
} else {
//TODO error?
PRINT_ERROR("todo error");
exit(-1);
}
if (list_has_space(ifr->addr_list)) {
PRINT_IMPORTANT(
"Adding address: if_index=%d, family=%u, ip='%u.%u.%u.%u', mask='%u.%u.%u.%u', gw='%u.%u.%u.%u', bdc='%u.%u.%u.%u', dst='%u.%u.%u.%u'",
if_index, family, ip[0], ip[1], ip[2], ip[3], mask[0], mask[1], mask[2], mask[3], gw[0], gw[1], gw[2], gw[3], bdc[0], bdc[1], bdc[2], bdc[3], dst[0], dst[1], dst[2], dst[3]);
list_append(ifr->addr_list, addr);
} else {
//TODO error
PRINT_ERROR("todo error");
exit(-1);
}
} else {
//TODO error
PRINT_ERROR("todo: previous address found, replace or add new?");
}
} else {
if (family == AF_INET) {
PRINT_WARN(
"Ignoring address, no active interface: if_index=%d, family=%u, ip='%u.%u.%u.%u', mask='%u.%u.%u.%u', gw='%u.%u.%u.%u', bdc='%u.%u.%u.%u', dst='%u.%u.%u.%u'",
if_index, family, ip[0], ip[1], ip[2], ip[3], mask[0], mask[1], mask[2], mask[3], gw[0], gw[1], gw[2], gw[3], bdc[0], bdc[1], bdc[2], bdc[3], dst[0], dst[1], dst[2], dst[3]);
} else if (family == AF_INET6) {
//TODO
PRINT_WARN("todo");
} else {
//TODO error?
PRINT_ERROR("todo error");
exit(-1);
}
}
} else {
//TODO error
PRINT_ERROR("todo error");
exit(-1);
}
}
//############# route_list
PRINT_IMPORTANT("############# Configuring List of Routes");
overall->envi->route_list = list_create(MAX_ROUTES);
list_elem = config_lookup(meta_envi, "environment.routes");
if (list_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
list_num = config_setting_length(list_elem);
uint32_t metric; //SIOCGIFMETRIC
uint32_t timeout;
//struct timeval route_stamp;
struct route_record *route;
for (i = 0; i < list_num; i++) {
elem = config_setting_get_elem(list_elem, i);
if (elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "if_index", (int *) &if_index);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "family", (int *) &family);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_elem = config_setting_get_member(elem, "dst");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
dst[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
ip_elem = config_setting_get_member(elem, "mask");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
mask[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
ip_elem = config_setting_get_member(elem, "gw");
if (ip_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
ip_num = config_setting_length(ip_elem);
for (j = 0; j < ip_num; j++) {
gw[j] = (uint32_t) config_setting_get_int_elem(ip_elem, j);
}
status = config_setting_lookup_int(elem, "metric", (int *) &metric);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(elem, "timeout", (int *) &timeout);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
//############
ifr = (struct if_record *) list_find1(overall->envi->if_list, ifr_index_test, &if_index);
if (ifr != NULL) {
if (ifr_running_test(ifr)) {
route = (struct route_record *) secure_malloc(sizeof(struct route_record));
route->if_index = if_index;
route->family = family;
if (family == AF_INET) {
addr4_set_ip(&route->dst, IP4_ADR_P2H(dst[0], dst[1], dst[2], dst[3]));
addr4_set_ip(&route->mask, IP4_ADR_P2H(mask[0], mask[1], mask[2],mask[3]));
addr4_set_ip(&route->gw, IP4_ADR_P2H(gw[0], gw[1], gw[2], gw[3]));
//addr4_set_addr(&route->ip, IP4_ADR_P2H(ip[0], ip[1], ip[2],ip[3]));
} else if (family == AF_INET6) {
//TODO
//addr_set_addr6(&route->ip, ip);
} else {
//TODO error?
}
route->metric = metric;
route->timeout = timeout;
if (list_has_space(overall->envi->route_list)) {
PRINT_IMPORTANT( "Adding route: if_index=%d, family=%u, dst='%u.%u.%u.%u', mask='%u.%u.%u.%u', gw='%u.%u.%u.%u', metric=%u, timeout=%u",
route->if_index, route->family, dst[0], dst[1], dst[2], dst[3], mask[0], mask[1], mask[2], mask[3], gw[0], gw[1], gw[2], gw[3], metric, timeout);
list_append(overall->envi->route_list, route);
} else {
//TODO error
PRINT_ERROR("todo error");
exit(-1);
}
} else {
if (family == AF_INET) {
PRINT_WARN(
"Ignoring route, no active interface: if_index=%d, family=%u, dst='%u.%u.%u.%u', mask='%u.%u.%u.%u', gw='%u.%u.%u.%u', metric=%u, timeout=%u",
if_index, family, dst[0], dst[1], dst[2], dst[3], mask[0], mask[1], mask[2], mask[3], gw[0], gw[1], gw[2], gw[3], metric, timeout);
} else if (family == AF_INET6) {
//TODO
PRINT_WARN("todo");
} else {
//TODO error?
PRINT_ERROR("todo error");
}
}
}
}
PRINT_IMPORTANT("route_list: list=%p, max=%u, len=%u", overall->envi->route_list, overall->envi->route_list->max, overall->envi->route_list->len);
metadata_destroy(meta_envi);
//######################################################################
PRINT_IMPORTANT("########################## loading stack: '%s'", (char *) stack_name);
metadata *meta_stack = (metadata *) secure_malloc(sizeof(metadata));
metadata_create(meta_stack);
status = config_read_file(meta_stack, (char *) stack_name);
if (status == META_FALSE) {
PRINT_ERROR("file='%s', %s:%d - %s\n", stack_name, config_error_file(meta_stack), config_error_line(meta_stack), config_error_text(meta_stack));
metadata_destroy(meta_stack);
PRINT_ERROR("todo error");
exit(-1);
}
//############# module_list
PRINT_IMPORTANT("############# Configuring List of Modules");
overall->lib_list = list_create(MAX_MODULES);
memset(overall->modules, 0, MAX_MODULES * sizeof(struct fins_module *));
overall->admin_list = list_create(MAX_MODULES);
struct linked_list *mt_list = list_create(MAX_MODULES);
uint8_t base_path[100];
memset((char *) base_path, 0, 100);
#ifdef BUILD_FOR_ANDROID
strcpy((char *) base_path, FINS_TMP_ROOT);
//strcpy((char *) base_path, ".");
#else
strcpy((char *) base_path, ".");
#endif
metadata_element *mods_elem = config_lookup(meta_stack, "stack.modules");
if (mods_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
int mods_num = config_setting_length(mods_elem);
metadata_element *mod_elem;
uint32_t mod_id;
uint8_t *mod_lib;
uint8_t *mod_name;
metadata_element *flows_elem;
uint32_t mod_flows[MAX_MOD_FLOWS];
uint32_t mod_flows_num;
metadata_element *mod_params;
metadata_element *mod_admin;
struct fins_library *library;
struct fins_module *module;
struct fins_module_table *mt;
for (i = 0; i < mods_num; i++) {
mod_elem = config_setting_get_elem(mods_elem, i);
if (mod_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(mod_elem, "id", (int *) &mod_id);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_string(mod_elem, "lib", (const char **) &mod_lib);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_string(mod_elem, "name", (const char **) &mod_name);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
flows_elem = config_setting_get_member(mod_elem, "flows");
if (flows_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
mod_flows_num = config_setting_length(flows_elem);
for (j = 0; j < mod_flows_num; j++) {
mod_flows[j] = (uint32_t) config_setting_get_int_elem(flows_elem, j);
}
mod_params = config_setting_get_member(mod_elem, "params");
if (mod_params == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
mod_admin = config_setting_get_member(mod_elem, "admin");
PRINT_DEBUG("admin=%u", mod_admin != NULL);
//############
library = (struct fins_library *) list_find1(overall->lib_list, library_name_test, mod_lib);
if (library == NULL) {
#ifdef BUILD_FOR_ANDROID
library = library_fake_load(mod_lib, base_path);
#else
//library = library_load(mod_lib, base_path);
library = library_fake_load(mod_lib, base_path);
#endif
if (library == NULL) {
PRINT_ERROR("Failed in loading library: lib='%s', base_path='%s'", mod_lib, base_path);
exit(-1);
}
if (list_has_space(overall->lib_list)) {
PRINT_IMPORTANT("Adding library: library=%p, name='%s'", library, library->name);
list_append(overall->lib_list, library);
} else {
PRINT_ERROR("Failed in init sequence, too many libraries: lib_list->len=%u", overall->lib_list->len);
exit(-1);
}
}
module = library->create(i, mod_id, mod_name);
if (module == NULL) {
//TODO error
PRINT_ERROR("Failed to create module: library=%p, index=%u, id=%u, name='%s'", library, i, mod_id, mod_name);
exit(-1);
}
library->num_mods++;
//TODO move flow to update? or links here?
status = module->ops->init(module, mod_params, overall->envi); //TODO merge init into create?
if (status != 0) {
overall->modules[i] = module;
if (module->flows_max < mod_flows_num) {
PRINT_ERROR("Loading module parameters failed, too many flows for this library: specified=%u, max=%u", mod_flows_num, module->flows_max);
exit(-1);
}
mt = (struct fins_module_table *) secure_malloc(sizeof(struct fins_module_table));
mt->flows_num = mod_flows_num;
for (j = 0; j < mt->flows_num; j++) {
mt->flows[j].link_id = mod_flows[j];
}
list_append(mt_list, mt);
if (mod_admin != NULL) {
PRINT_IMPORTANT("Adding admin module: module=%p, lib='%s', name='%s', id=%d, index=%u",
module, module->lib, module->name, module->id, module->index);
list_append(overall->admin_list, module);
} else {
PRINT_IMPORTANT("Adding module: module=%p, lib='%s', name='%s', id=%d, index=%u", module, module->lib, module->name, module->id, module->index);
}
} else {
PRINT_ERROR("Initialization of module failed: module=%p, lib='%s', name='%s', flows_num=%u, flows=%p, params=%p, envi=%p",
module, module->lib, module->name, mod_flows_num, mod_flows, mod_params, overall->envi);
exit(-1);
}
//free(mod_lib); //don't free, string from libconfig points to metadata memory
//free(mod_name);
}
//############# admin_list //TODO change to admin_list?
list_for_each1(overall->admin_list, assign_overall, overall);
//############# linking_list
PRINT_IMPORTANT("############# Configuring Linking Table");
overall->link_list = list_create(MAX_TABLE_LINKS);
metadata_element *links_elem = config_lookup(meta_stack, "stack.links");
if (links_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
int links_num = config_setting_length(links_elem);
metadata_element *link_elem;
uint32_t link_id;
uint32_t link_src;
metadata_element *dsts_elem;
uint32_t link_dsts[MAX_MODULES];
int link_dsts_num;
struct link_record *link;
for (i = 0; i < links_num; i++) {
link_elem = config_setting_get_elem(links_elem, i);
if (link_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(link_elem, "id", (int *) &link_id);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
status = config_setting_lookup_int(link_elem, "src", (int *) &link_src);
if (status == META_FALSE) {
PRINT_ERROR("todo error");
exit(-1);
}
dsts_elem = config_setting_get_member(link_elem, "dsts");
if (dsts_elem == NULL) {
PRINT_ERROR("todo error");
exit(-1);
}
link_dsts_num = config_setting_length(dsts_elem);
for (j = 0; j < link_dsts_num; j++) {
link_dsts[j] = (uint32_t) config_setting_get_int_elem(dsts_elem, j);
}
//############
link = (struct link_record *) secure_malloc(sizeof(struct link_record));
link->id = link_id;
//module = (struct fins_module *) list_find1(overall->envi->module_list, mod_id_test, &link_src);
link->src_index = -1;
for (j = 0; j < MAX_MODULES; j++) {
if (overall->modules[j] != NULL && overall->modules[j]->id == link_src) {
link->src_index = overall->modules[j]->index;
}
}
if (link->src_index == -1) {
PRINT_ERROR("todo error");
exit(-1);
}
link->dsts_num = link_dsts_num;
for (j = 0; j < link_dsts_num; j++) {
//module = (struct fins_module *) list_find1(overall->envi->module_list, mod_id_test, &link_dsts[j]);
link->dsts_index[j] = -1;
for (k = 0; k < MAX_MODULES; k++) {
if (overall->modules[k] != NULL && overall->modules[k]->id == link_dsts[j]) {
link->dsts_index[j] = overall->modules[k]->index;
}
}
if (link->dsts_index[j] == (uint32_t) -1) {
PRINT_ERROR("todo error");
exit(-1);
}
}
if (list_has_space(overall->link_list)) {
uint8_t buf[1000];
uint8_t *pt = buf;
int ret;
int i;
for (i = 0; i < link->dsts_num; i++) {
ret = sprintf((char *) pt, "%u, ", link->dsts_index[i]);
pt += ret;
}
*pt = '\0';
PRINT_IMPORTANT("Adding link: link=%p, id=%u, src_index=%u, dsts_num=%u, ['%s']", link, link->id, link->src_index, link->dsts_num, buf);
list_append(overall->link_list, link);
} else {
//TODO error
PRINT_ERROR("todo error");
exit(-1);
}
}
metadata_destroy(meta_stack);
//######################################################################
PRINT_IMPORTANT("############# Updating modules with correct flows & links");
//send out subset of linking table to each module as update
//TODO table subset update
metadata *meta_update;
struct finsFrame *ff_update;
for (i = 0; i < MAX_MODULES; i++) {
if (overall->modules[i] != NULL) {
mt = (struct fins_module_table *) list_remove_front(mt_list);
mt->link_list = list_filter1(overall->link_list, link_src_test, &overall->modules[i]->index, link_clone); //was link_involved_test, decide which better?
PRINT_IMPORTANT("Module link table subset: name='%s' index=%d, link_list=%p, len=%d",
overall->modules[i]->name, i, mt->link_list, mt->link_list->len);
for (j = 0; j < mt->flows_num; j++) {
mt->flows[j].link = (struct link_record *) list_find1(mt->link_list, link_id_test, &mt->flows[j].link_id);
}
//#ifdef DEBUG
uint8_t buf[1000];
uint8_t *pt = buf;
int ret;
for (j = 0; j < mt->flows_num; j++) {
ret = sprintf((char *) pt, "%u (%p), ", mt->flows[j].link_id, mt->flows[j].link);
pt += ret;
}
*pt = '\0';
PRINT_IMPORTANT("Module flows: num=%u, ['%s']", mt->flows_num, buf);
list_for_each(mt->link_list, link_print);
//#endif
meta_update = (metadata *) secure_malloc(sizeof(metadata));
metadata_create(meta_update);
ff_update = (struct finsFrame*) secure_malloc(sizeof(struct finsFrame));
ff_update->dataOrCtrl = FF_CONTROL;
ff_update->destinationID = i;
ff_update->metaData = meta_update;
ff_update->ctrlFrame.sender_id = 0;
ff_update->ctrlFrame.serial_num = gen_control_serial_num();
ff_update->ctrlFrame.opcode = CTRL_SET_PARAM;
ff_update->ctrlFrame.param_id = MOD_SET_PARAM_DUAL;
ff_update->ctrlFrame.data_len = sizeof(struct fins_module_table);
ff_update->ctrlFrame.data = (uint8_t *) mt;
module_to_switch(overall->modules[0], ff_update);
//module_set_param_dual(overall->modules[i], ff_update);
}
}
list_free(mt_list, free);
//############ say by this point envi var completely init'd
//assumed always connect/init to switch first
pthread_attr_init(&overall->attr);
pthread_attr_setdetachstate(&overall->attr, PTHREAD_CREATE_JOINABLE);
PRINT_IMPORTANT("############# Calling run() for modules");
for (i = 0; i < MAX_MODULES; i++) {
if (overall->modules[i] != NULL) {
overall->modules[i]->ops->run(overall->modules[i], &overall->attr);
}
}
PRINT_IMPORTANT("Core Initiation: Finished ************");
}
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 parse_config(char *file)
{
config_t cfg;
config_setting_t *setting;
const char *str;
config_init(&cfg);
/* Read the file. If there is an error, report it and exit. */
if (!config_read_file(&cfg, file))
{
fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return(EXIT_FAILURE);
}
/* Get the store name. */
if (config_lookup_string(&cfg, "name", &str))
printf("Store name: %s\n\n", str);
else
fprintf(stderr, "No 'name' setting in configuration file.\n");
/* Output a list of all books in the inventory. */
setting = config_lookup(&cfg, "inventory.books");
if(setting != NULL)
{
int count = config_setting_length(setting);
int i;
printf("%-30s %-30s %-6s %s\n", "TITLE", "AUTHOR", "PRICE", "QTY");
for(i = 0; i < count; ++i)
{
config_setting_t *book = config_setting_get_elem(setting, i);
/* Only output the record if all of the expected fields are present. */
const char *title, *author;
double price;
int qty;
if(!(config_setting_lookup_string(book, "title", &title)
&& config_setting_lookup_string(book, "author", &author)
&& config_setting_lookup_float(book, "price", &price)
&& config_setting_lookup_int(book, "qty", &qty)))
continue;
printf("%-30s %-30s $%6.2f %3d\n", title, author, price, qty);
}
putchar('\n');
}
/* Output a list of all movies in the inventory. */
setting = config_lookup(&cfg, "inventory.movies");
if(setting != NULL)
{
unsigned int count = config_setting_length(setting);
unsigned int i;
printf("%-30s %-10s %-6s %s\n", "TITLE", "MEDIA", "PRICE", "QTY");
for(i = 0; i < count; ++i)
{
config_setting_t *movie = config_setting_get_elem(setting, i);
/* Only output the record if all of the expected fields are present. */
const char *title, *media;
double price;
int qty;
if(!(config_setting_lookup_string(movie, "title", &title)
&& config_setting_lookup_string(movie, "media", &media)
&& config_setting_lookup_float(movie, "price", &price)
&& config_setting_lookup_int(movie, "qty", &qty)))
continue;
printf("%-30s %-10s $%6.2f %3d\n", title, media, price, qty);
}
putchar('\n');
}
config_destroy(&cfg);
return(EXIT_SUCCESS);
}
void Level::LoadLevel( char* FileName )
{
config_t cfg;
config_setting_t *setting;
config_setting_t *list;
config_init(&cfg);
config_read_file( &cfg, FileName );
setting = config_lookup( &cfg, "LevelInfo" );
const char* tmpStr;
config_setting_lookup_string( setting, "LevelName", &tmpStr );
LevelName = (char*)malloc( strlen(tmpStr) + 2 );
sprintf( LevelName, "%s", tmpStr );
config_setting_t* trackData = config_setting_get_member( setting, "Music" );
for( int idx = 0; idx < config_setting_length( trackData ); idx++ )
{
char* tempElem;
tmpStr = config_setting_get_string_elem( trackData, idx );
tempElem = (char*)malloc( strlen(tmpStr) + 2 );
sprintf( tempElem, "%s", tmpStr );
MusicTracks->AddToEnd( (void*)tempElem );
}
config_setting_lookup_string( setting, "IntroScreenImage", &tmpStr );
IntroDisplay = (char*)malloc( strlen(tmpStr) + 2 );
sprintf( IntroDisplay, "%s", tmpStr );
config_setting_lookup_int( setting, "IntroMusicTrack", &IntroMusicTrack );
list = config_lookup( &cfg, "Layers" );
for( int eidx = 0; eidx < config_setting_length( list ); eidx++ )
{
Layer* newLayer = new Layer( this, config_setting_get_elem( list, eidx ) );
Layers->AddToEnd( newLayer );
}
list = config_lookup( &cfg, "Events" );
for( int eidx = 0; eidx < config_setting_length( list ); eidx++ )
{
Event* newEvent = new Event( this, config_setting_get_elem( list, eidx ) );
// Are we a pre-game activation? If so, process and delete
if( newEvent->ActivatePosition == -1 )
{
newEvent->Activate();
delete newEvent;
} else {
Events->AddToEnd( newEvent );
}
}
list = config_lookup( &cfg, "Scripts" );
for( int eidx = 0; eidx < config_setting_length( list ); eidx++ )
{
Uint16* scriptBuffer;
config_setting_t* scriptArray = config_setting_get_elem( list, eidx );
scriptBuffer = (Uint16*)malloc( config_setting_length( scriptArray ) * 2 );
for( int aidx = 0; aidx < config_setting_length( scriptArray ); aidx++ )
{
int scriptOpCode;
scriptOpCode = config_setting_get_int_elem( scriptArray, aidx );
scriptBuffer[aidx] = (Uint16)(scriptOpCode & 0x0000FFFF);
}
Scripts->AddToEnd( (void*)scriptBuffer );
}
list = config_lookup( &cfg, "Templates" );
for( int eidx = 0; eidx < config_setting_length( list ); eidx++ )
{
EnemyCraftTemplate* newTemplate = new EnemyCraftTemplate( Owner, config_setting_get_elem( list, eidx ) );
EnemyTemplates->AddToEnd( newTemplate );
}
setting = config_lookup( &cfg, "LayerInfo" );
config_setting_lookup_int( setting, "CollisionIndex", &LayerCollisionIndex );
config_setting_lookup_int( setting, "GameIndex", &LayerGameIndex );
config_destroy(&cfg);
}
int bootstrap_from_config(char *cfg_file_path, DHT *dht, int enable_ipv6)
{
const char *NAME_BOOTSTRAP_NODES = "bootstrap_nodes";
const char *NAME_PUBLIC_KEY = "public_key";
const char *NAME_PORT = "port";
const char *NAME_ADDRESS = "address";
config_t cfg;
config_init(&cfg);
if (config_read_file(&cfg, cfg_file_path) == CONFIG_FALSE) {
syslog(LOG_ERR, "%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return 0;
}
config_setting_t *node_list = config_lookup(&cfg, NAME_BOOTSTRAP_NODES);
if (node_list == NULL) {
syslog(LOG_WARNING, "No '%s' setting in the configuration file. Skipping bootstrapping.\n", NAME_BOOTSTRAP_NODES);
config_destroy(&cfg);
return 1;
}
if (config_setting_length(node_list) == 0) {
syslog(LOG_WARNING, "No bootstrap nodes found. Skipping bootstrapping.\n");
config_destroy(&cfg);
return 1;
}
int bs_port;
const char *bs_address;
const char *bs_public_key;
config_setting_t *node;
int i = 0;
while (config_setting_length(node_list)) {
node = config_setting_get_elem(node_list, 0);
if (node == NULL) {
config_destroy(&cfg);
return 0;
}
// Check that all settings are present
if (config_setting_lookup_string(node, NAME_PUBLIC_KEY, &bs_public_key) == CONFIG_FALSE) {
syslog(LOG_WARNING, "Bootstrap node #%d: Couldn't find '%s' setting. Skipping the node.\n", i, NAME_PUBLIC_KEY);
goto next;
}
if (config_setting_lookup_int(node, NAME_PORT, &bs_port) == CONFIG_FALSE) {
syslog(LOG_WARNING, "Bootstrap node #%d: Couldn't find '%s' setting. Skipping the node.\n", i, NAME_PORT);
goto next;
}
if (config_setting_lookup_string(node, NAME_ADDRESS, &bs_address) == CONFIG_FALSE) {
syslog(LOG_WARNING, "Bootstrap node #%d: Couldn't find '%s' setting. Skipping the node.\n", i, NAME_ADDRESS);
goto next;
}
// Process settings
if (strlen(bs_public_key) != crypto_box_PUBLICKEYBYTES * 2) {
syslog(LOG_WARNING, "Bootstrap node #%d: Invalid '%s': %s. Skipping the node.\n", i, NAME_PUBLIC_KEY,
bs_public_key);
goto next;
}
if (bs_port < MIN_ALLOWED_PORT || bs_port > MAX_ALLOWED_PORT) {
syslog(LOG_WARNING, "Bootstrap node #%d: Invalid '%s': %d, should be in [%d, %d]. Skipping the node.\n", i, NAME_PORT,
bs_port, MIN_ALLOWED_PORT, MAX_ALLOWED_PORT);
goto next;
}
uint8_t *bs_public_key_bin = hex_string_to_bin((char *)bs_public_key);
const int address_resolved = DHT_bootstrap_from_address(dht, bs_address, enable_ipv6, htons(bs_port),
bs_public_key_bin);
free(bs_public_key_bin);
if (!address_resolved) {
syslog(LOG_WARNING, "Bootstrap node #%d: Invalid '%s': %s. Skipping the node.\n", i, NAME_ADDRESS, bs_address);
goto next;
}
syslog(LOG_DEBUG, "Successfully added bootstrap node #%d: %s:%d %s\n", i, bs_address, bs_port, bs_public_key);
next:
// config_setting_lookup_string() allocates string inside and doesn't allow us to free it direcly
// though it's freed when the element is removed, so we free it right away in order to keep memory
// consumption minimal
config_setting_remove_elem(node_list, 0);
i++;
}
config_destroy(&cfg);
return 1;
}
//------------------------------------------------------------------------------
const Enb_properties_array_t *enb_config_init(char* lib_config_file_name_pP)
//------------------------------------------------------------------------------
{
config_t cfg;
config_setting_t *setting = NULL;
config_setting_t *subsetting = NULL;
config_setting_t *setting_srb1 = NULL;
config_setting_t *setting_mme_addresses = NULL;
config_setting_t *setting_mme_address = NULL;
config_setting_t *setting_enb = NULL;
int num_enb_properties = 0;
int enb_properties_index = 0;
int num_enbs = 0;
int num_mme_address = 0;
int num_otg_elements =0;
int num_component_carriers =0;
int i = 0;
int j = 0;
int parse_errors = 0;
libconfig_int enb_id = 0;
const char* cell_type = NULL;
const char* tac = 0;
const char* enb_name = NULL;
const char* mcc = 0;
const char* mnc = 0;
const char* frame_type = NULL;
const char* prefix_type = NULL;
libconfig_int Nid_cell = 0;
libconfig_int my_int;
char* ipv4 = NULL;
char* ipv6 = NULL;
char* active = NULL;
char* preference = NULL;
const char* active_enb[EPC_TEST_SCENARIO_MAX_ENB];
char* enb_interface_name_for_S1U = NULL;
char* enb_ipv4_address_for_S1U = NULL;
libconfig_int enb_port_for_S1U = 0;
char* enb_interface_name_for_S1_MME = NULL;
char* enb_ipv4_address_for_S1_MME = NULL;
char *address = NULL;
char *cidr = NULL;
char *astring = NULL;
memset((char*)active_enb, 0 , EPC_TEST_SCENARIO_MAX_ENB * sizeof(char*));
config_init(&cfg);
if (lib_config_file_name_pP != NULL) {
/* Read the file. If there is an error, report it and exit. */
if (! config_read_file(&cfg, lib_config_file_name_pP)) {
config_destroy(&cfg);
AssertFatal (0, "Failed to parse eNB configuration file %s!\n", lib_config_file_name_pP);
}
} else {
config_destroy(&cfg);
AssertFatal (0, "No eNB configuration file provided!\n");
}
// Get list of active eNBs, (only these will be configured)
setting = config_lookup(&cfg, ENB_CONFIG_STRING_ACTIVE_ENBS);
if (setting != NULL) {
num_enbs = config_setting_length(setting);
for (i = 0; i < num_enbs; i++) {
setting_enb = config_setting_get_elem(setting, i);
active_enb[i] = config_setting_get_string (setting_enb);
AssertFatal (active_enb[i] != NULL,
"Failed to parse config file %s, %uth attribute %s \n",
lib_config_file_name_pP, i, ENB_CONFIG_STRING_ACTIVE_ENBS);
active_enb[i] = strdup(active_enb[i]);
num_enb_properties += 1;
}
}
/* Output a list of all eNBs. */
setting = config_lookup(&cfg, ENB_CONFIG_STRING_ENB_LIST);
if (setting != NULL) {
enb_properties_index = 0;
parse_errors = 0;
num_enbs = config_setting_length(setting);
for (i = 0; i < num_enbs; i++) {
setting_enb = config_setting_get_elem(setting, i);
if (! config_setting_lookup_int(setting_enb, ENB_CONFIG_STRING_ENB_ID, &enb_id)) {
/* Calculate a default eNB ID */
# if defined(ENABLE_USE_MME)
uint32_t hash;
hash = s1ap_generate_eNB_id ();
enb_id = i + (hash & 0xFFFF8);
# else
enb_id = i;
# endif
}
if ( !( config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_CELL_TYPE, &cell_type)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_ENB_NAME, &enb_name)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_TRACKING_AREA_CODE, &tac)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_MOBILE_COUNTRY_CODE, &mcc)
&& config_setting_lookup_string(setting_enb, ENB_CONFIG_STRING_MOBILE_NETWORK_CODE, &mnc)
)
) {
AssertError (0, parse_errors ++,
"Failed to parse eNB configuration file %s, %u th enb\n",
lib_config_file_name_pP, i);
continue; // FIXME this prevents segfaults below, not sure what happens after function exit
}
// search if in active list
for (j=0; j < num_enb_properties; j++) {
if (strcmp(active_enb[j], enb_name) == 0) {
g_enb_properties.properties[enb_properties_index] = calloc(1, sizeof(Enb_properties_t));
g_enb_properties.properties[enb_properties_index]->eNB_id = enb_id;
if (strcmp(cell_type, "CELL_MACRO_ENB") == 0) {
g_enb_properties.properties[enb_properties_index]->cell_type = CELL_MACRO_ENB;
} else if (strcmp(cell_type, "CELL_HOME_ENB") == 0) {
g_enb_properties.properties[enb_properties_index]->cell_type = CELL_HOME_ENB;
} else {
AssertError (0, parse_errors ++,
"Failed to parse eNB configuration file %s, enb %d unknown value \"%s\" for cell_type choice: CELL_MACRO_ENB or CELL_HOME_ENB !\n",
lib_config_file_name_pP, i, cell_type);
}
g_enb_properties.properties[enb_properties_index]->eNB_name = strdup(enb_name);
g_enb_properties.properties[enb_properties_index]->tac = (uint16_t)atoi(tac);
g_enb_properties.properties[enb_properties_index]->mcc = (uint16_t)atoi(mcc);
g_enb_properties.properties[enb_properties_index]->mnc = (uint16_t)atoi(mnc);
g_enb_properties.properties[enb_properties_index]->mnc_digit_length = strlen(mnc);
AssertFatal((g_enb_properties.properties[enb_properties_index]->mnc_digit_length == 2) ||
(g_enb_properties.properties[enb_properties_index]->mnc_digit_length == 3),
"BAD MNC DIGIT LENGTH %d",
g_enb_properties.properties[i]->mnc_digit_length);
setting_mme_addresses = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_MME_IP_ADDRESS);
num_mme_address = config_setting_length(setting_mme_addresses);
g_enb_properties.properties[enb_properties_index]->nb_mme = 0;
for (j = 0; j < num_mme_address; j++) {
setting_mme_address = config_setting_get_elem(setting_mme_addresses, j);
if ( !(
config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IPV4_ADDRESS, (const char **)&ipv4)
&& config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IPV6_ADDRESS, (const char **)&ipv6)
&& config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_ACTIVE, (const char **)&active)
&& config_setting_lookup_string(setting_mme_address, ENB_CONFIG_STRING_MME_IP_ADDRESS_PREFERENCE, (const char **)&preference)
)
) {
AssertError (0, parse_errors ++,
"Failed to parse eNB configuration file %s, %u th enb %u th mme address !\n",
lib_config_file_name_pP, i, j);
continue; // FIXME will prevent segfaults below, not sure what happens at function exit...
}
g_enb_properties.properties[enb_properties_index]->nb_mme += 1;
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4_address = strdup(ipv4);
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6_address = strdup(ipv6);
if (strcmp(active, "yes") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].active = 1;
} // else { (calloc)
if (strcmp(preference, "ipv4") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4 = 1;
} else if (strcmp(preference, "ipv6") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6 = 1;
} else if (strcmp(preference, "no") == 0) {
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv4 = 1;
g_enb_properties.properties[enb_properties_index]->mme_ip_address[j].ipv6 = 1;
}
}
// NETWORK_INTERFACES
subsetting = config_setting_get_member (setting_enb, ENB_CONFIG_STRING_NETWORK_INTERFACES_CONFIG);
if (subsetting != NULL) {
if ( (
config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1_MME,
(const char **)&enb_interface_name_for_S1_MME)
&& config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_IPV4_ADDRESS_FOR_S1_MME,
(const char **)&enb_ipv4_address_for_S1_MME)
&& config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_INTERFACE_NAME_FOR_S1U,
(const char **)&enb_interface_name_for_S1U)
&& config_setting_lookup_string( subsetting, ENB_CONFIG_STRING_ENB_IPV4_ADDR_FOR_S1U,
(const char **)&enb_ipv4_address_for_S1U)
&& config_setting_lookup_int(subsetting, ENB_CONFIG_STRING_ENB_PORT_FOR_S1U,
&enb_port_for_S1U)
)
) {
g_enb_properties.properties[enb_properties_index]->enb_interface_name_for_S1U = strdup(enb_interface_name_for_S1U);
cidr = enb_ipv4_address_for_S1U;
address = strtok(cidr, "/");
if (address) {
IPV4_STR_ADDR_TO_INT_NWBO ( address, g_enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1U, "BAD IP ADDRESS FORMAT FOR eNB S1_U !\n" );
}
g_enb_properties.properties[enb_properties_index]->enb_port_for_S1U = enb_port_for_S1U;
g_enb_properties.properties[enb_properties_index]->enb_interface_name_for_S1_MME = strdup(enb_interface_name_for_S1_MME);
cidr = enb_ipv4_address_for_S1_MME;
address = strtok(cidr, "/");
if (address) {
IPV4_STR_ADDR_TO_INT_NWBO ( address, g_enb_properties.properties[enb_properties_index]->enb_ipv4_address_for_S1_MME, "BAD IP ADDRESS FORMAT FOR eNB S1_MME !\n" );
}
}
}
}
}
}
}
g_enb_properties.number = num_enb_properties;
AssertError (enb_properties_index == num_enb_properties, parse_errors ++,
"Failed to parse eNB configuration file %s, mismatch between %u active eNBs and %u corresponding defined eNBs !\n",
lib_config_file_name_pP, num_enb_properties, enb_properties_index);
AssertFatal (parse_errors == 0,
"Failed to parse eNB configuration file %s, found %d error%s !\n",
lib_config_file_name_pP, parse_errors, parse_errors > 1 ? "s" : "");
enb_config_display();
return &g_enb_properties;
}
