void Test_iniparser_getseckeys(CuTest *tc)
{
unsigned i;
char key_name[64];
dictionary *dic;
const char ** sections;
/* NULL test */
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy"));
/* Empty dictionary */
dic = dictionary_new(10);
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy"));
dictionary_del(dic);
/* Generic dictionary */
dic = generate_dictionary(100, 10);
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy"));
sections = iniparser_getseckeys(dic, "sec42");
CuAssertPtrNotNull(tc, sections);
for (i = 0; i < 10; ++i) {
sprintf(key_name, "sec42:key%d", i);
CuAssertStrEquals(tc, key_name, sections[i]);
}
free(sections);
/* Remove some keys to make the dictionary more real */
dictionary_unset(dic, "sec42");
dictionary_unset(dic, "sec99:key9");
dictionary_unset(dic, "sec0:key0");
dictionary_unset(dic, "sec0:key1");
dictionary_unset(dic, "sec0:key2");
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec42"));
sections = iniparser_getseckeys(dic, "sec99");
CuAssertPtrNotNull(tc, sections);
for (i = 0; i < 9; ++i) {
sprintf(key_name, "sec99:key%d", i);
CuAssertStrEquals(tc, key_name, sections[i]);
}
free(sections);
sections = iniparser_getseckeys(dic, "sec0");
CuAssertPtrNotNull(tc, sections);
for (i = 0; i < 7; ++i) {
sprintf(key_name, "sec0:key%d", i + 3);
CuAssertStrEquals(tc, key_name, sections[i]);
}
free(sections);
dictionary_del(dic);
}
/*--------------------------------------------------------------------------*/
void _get_keys(TSection *section)
{
TKeys *keys = malloc(sizeof(struct sectionkeys));
if ((keys->num = iniparser_getsecnkeys(ini, section->section_name)) == -1){
write_to_log(WARNING, "%s - %d - %s", __LINE__, __func__, "Unable to count config section key");
return;
}
keys->names = iniparser_getseckeys(ini, section->section_name);
section->keys = keys;
return;
}
char *flib_ini_get_keyname(flib_ini *ini, int number) {
char *result = NULL;
if(!log_badargs_if3(ini==NULL, ini->currentSection==NULL, number<0)) {
int keyCount = iniparser_getsecnkeys(ini->inidict, ini->currentSection);
char **keys = iniparser_getseckeys(ini->inidict, ini->currentSection);
if(keys && keyCount>number) {
// The keys are in the format section:key, so we have to skip the section and colon.
result = flib_strdupnull(keys[number]+strlen(ini->currentSection)+1);
}
free(keys);
}
return result;
}
void Test_iniparser_getseckeys(CuTest *tc)
{
unsigned i;
char key_name[64];
dictionary *dic;
int nkeys;
const char * keys[10]; /* At most 10 elements per section */
/* NULL test */
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, NULL, NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy", NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(NULL, "dummy", keys));
/* Empty dictionary */
dic = dictionary_new(10);
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL, keys));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy", keys));
dictionary_del(dic);
/* Generic dictionary */
dic = generate_dictionary(100, 10);
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, NULL, keys));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "dummy", keys));
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec0", NULL));
nkeys = iniparser_getsecnkeys(dic, "sec42");
CuAssertIntEquals(tc, nkeys, 10);
CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec42", keys));
for (i = 0; i < 10; ++i) {
sprintf(key_name, "sec42:key%d", i);
CuAssertStrEquals(tc, key_name, keys[i]);
}
/* Remove some keys to make the dictionary more real */
dictionary_unset(dic, "sec42");
dictionary_unset(dic, "sec99:key9");
dictionary_unset(dic, "sec0:key0");
dictionary_unset(dic, "sec0:key1");
dictionary_unset(dic, "sec0:key2");
CuAssertPtrEquals(tc, NULL, iniparser_getseckeys(dic, "sec42", keys));
nkeys = iniparser_getsecnkeys(dic, "sec99");
CuAssertIntEquals(tc, nkeys, 9);
CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec99", keys));
for (i = 0; i < 9; ++i) {
sprintf(key_name, "sec99:key%d", i);
CuAssertStrEquals(tc, key_name, keys[i]);
}
nkeys = iniparser_getsecnkeys(dic, "sec0");
CuAssertIntEquals(tc, nkeys, 7);
CuAssertPtrEquals(tc, keys, iniparser_getseckeys(dic, "sec0", keys));
for (i = 0; i < 7; ++i) {
sprintf(key_name, "sec0:key%d", i + 3);
CuAssertStrEquals(tc, key_name, keys[i]);
}
dictionary_del(dic);
}
int gen_pia(dictionary *ini, char **pia_data)
{
struct product_info_area *pia;
char *data,
*str_data,
*packed_ascii,
*mfg_packed,
*name_packed,
*part_num_packed,
*version_packed,
*serial_num_packed,
*asset_tag_packed,
*key,
**sec_keys;
int lang_code,
size,
offset,
mfg_size,
name_size,
part_num_size,
version_size,
serial_num_size,
asset_tag_size,
packed_size,
num_keys,
i;
uint8_t end_marker, empty_marker, cksum;
pia = NULL;
size = offset = cksum = empty_marker = 0;
end_marker = 0xc1;
lang_code = iniparser_getint(ini, get_key(PIA, LANGUAGE_CODE), -1);
if (lang_code == -1) {
fprintf(stdout, "Product language code not specified. "
"Defaulting to English\n");
lang_code = 0;
}
size += sizeof(struct product_info_area);
str_data = iniparser_getstring(ini, get_key(PIA, MANUFACTURER), NULL);
if (str_data && strlen(str_data)) {
mfg_size = (*packer)(str_data, &mfg_packed);
size += mfg_size;
} else {
mfg_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(PIA, PRODUCT_NAME), NULL);
if (str_data && strlen(str_data)) {
name_size = (*packer)(str_data, &name_packed);
size += name_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
name_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(PIA, PART_NUMBER), NULL);
if (str_data && strlen(str_data)) {
part_num_size = (*packer)(str_data, &part_num_packed);
size += part_num_size;
} else {
part_num_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(PIA, VERSION), NULL);
if (str_data && strlen(str_data)) {
version_size = (*packer)(str_data, &version_packed);
size += version_size;
} else {
version_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(PIA, SERIAL_NUMBER), NULL);
if (str_data && strlen(str_data)) {
serial_num_size = (*packer)(str_data, &serial_num_packed);
size += serial_num_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
serial_num_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(PIA, ASSET_TAG), NULL);
if (str_data && strlen(str_data)) {
asset_tag_size = (*packer)(str_data, &asset_tag_packed);
size += asset_tag_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
asset_tag_packed = NULL;
size += 1;
}
/* We don't handle FRU File ID for now... */
size += 1;
num_keys = iniparser_getsecnkeys(ini, PIA);
sec_keys = iniparser_getseckeys(ini, PIA);
/* first iteration calculates the amount of space needed */
for (i = 0; i < num_keys; i++) {
key = sec_keys[i];
/* Skip keys we've already accounted for */
if (!strcmp(key, get_key(PIA, LANGUAGE_CODE)) ||
!strcmp(key, get_key(PIA, MANUFACTURER)) ||
!strcmp(key, get_key(PIA, PRODUCT_NAME)) ||
!strcmp(key, get_key(PIA, PART_NUMBER)) ||
!strcmp(key, get_key(PIA, VERSION)) ||
!strcmp(key, get_key(PIA, SERIAL_NUMBER)) ||
!strcmp(key, get_key(PIA, ASSET_TAG)) ||
!strcmp(key, get_key(PIA, FRU_FILE_ID))) {
continue;
}
str_data = iniparser_getstring(ini, key, NULL);
if (str_data && strlen(str_data)) {
size += (*packer)(str_data, &packed_ascii);
}
}
size = get_aligned_size(size + 2, 8);
data = (char *) calloc(size, 1);
pia = (struct product_info_area *) data;
/* Fill up PIA */
pia->format_version = 0x01;
/* Length is in multiples of 8 bytes */
pia->area_length = size / 8;
pia->language_code = lang_code;
if (mfg_packed) {
memcpy(pia->tl + offset, mfg_packed, mfg_size);
offset += mfg_size;
} else {
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (name_packed) {
memcpy(pia->tl + offset, name_packed, name_size);
offset += name_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (part_num_packed) {
memcpy(pia->tl + offset, part_num_packed, part_num_size);
offset += part_num_size;
} else {
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (version_packed) {
memcpy(pia->tl + offset, version_packed, version_size);
offset += version_size;
} else {
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (serial_num_packed) {
memcpy(pia->tl + offset, serial_num_packed, serial_num_size);
offset += serial_num_size;
} else {
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (asset_tag_packed) {
memcpy(pia->tl + offset, asset_tag_packed, asset_tag_size);
offset += asset_tag_size;
} else {
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
}
/* We don't handle FRU File ID for now... */
memcpy(pia->tl + offset, &empty_marker, 1);
offset += 1;
/* Second iteration copies packed contents into final buffer */
for (i = 0; i < num_keys; i++) {
key = sec_keys[i];
/* Skip keys we've already accounted for */
if (!strcmp(key, get_key(PIA, LANGUAGE_CODE)) ||
!strcmp(key, get_key(PIA, MANUFACTURER)) ||
!strcmp(key, get_key(PIA, PRODUCT_NAME)) ||
!strcmp(key, get_key(PIA, PART_NUMBER)) ||
!strcmp(key, get_key(PIA, VERSION)) ||
!strcmp(key, get_key(PIA, SERIAL_NUMBER)) ||
!strcmp(key, get_key(PIA, ASSET_TAG)) ||
!strcmp(key, get_key(PIA, FRU_FILE_ID))) {
continue;
}
str_data = iniparser_getstring(ini, key, NULL);
if (str_data && strlen(str_data)) {
packed_size = (*packer)(str_data, &packed_ascii);
memcpy(pia->tl + offset, packed_ascii, packed_size);
offset += packed_size;
}
}
/* write the end marker 'C1' */
memcpy(pia->tl + offset, &end_marker, 1);
/* Calculate checksum of entire PIA */
cksum = get_zero_cksum((uint8_t *)data, size-1);
memcpy(data+size-1, &cksum, 1);
*pia_data = data;
return pia->area_length;
}
int gen_bia(dictionary *ini, char **bia_data)
{
struct board_info_area *bia;
char *data,
*str_data,
*packed_ascii,
*mfg_packed,
*name_packed,
*serial_num_packed,
*part_num_packed,
*key,
**sec_keys;
int lang_code,
mfg_date,
size,
offset,
mfg_size,
name_size,
serial_num_size,
part_num_size,
num_keys,
packed_size,
i;
uint8_t end_marker, empty_marker, cksum;
bia = NULL;
size = offset = cksum = empty_marker = 0;
end_marker = 0xc1;
lang_code = iniparser_getint(ini, get_key(BIA, LANGUAGE_CODE), -1);
if (lang_code == -1) {
fprintf(stdout, "Board language code not specified. "
"Defaulting to English\n");
lang_code = 0;
}
mfg_date = iniparser_getint(ini, get_key(BIA, MFG_DATETIME), -1);
if (mfg_date == -1) {
fprintf(stdout, "Manufacturing time not specified. "
"Defaulting to unspecified\n");
mfg_date = 0;
}
size += sizeof(struct board_info_area);
str_data = iniparser_getstring(ini, get_key(BIA, MANUFACTURER), NULL);
if (str_data && strlen(str_data)) {
mfg_size = (*packer)(str_data, &mfg_packed);
size += mfg_size;
} else {
mfg_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(BIA, PRODUCT_NAME), NULL);
if (str_data && strlen(str_data)) {
name_size = (*packer)(str_data, &name_packed);
size += name_size;
} else {
name_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(BIA, SERIAL_NUMBER), NULL);
if (str_data && strlen(str_data)) {
serial_num_size = (*packer)(str_data, &serial_num_packed);
size += serial_num_size;
} else {
serial_num_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(BIA, PART_NUMBER), NULL);
if (str_data && strlen(str_data)) {
part_num_size = (*packer)(str_data, &part_num_packed);
size += part_num_size;
} else {
part_num_packed = NULL;
size += 1;
}
/* We don't handle FRU File ID for now... */
size += 1;
num_keys = iniparser_getsecnkeys(ini, BIA);
sec_keys = iniparser_getseckeys(ini, BIA);
for (i = 0; i < num_keys; i++) {
key = sec_keys[i];
/* Skip keys we've already accounted for */
if (!strcmp(key, get_key(BIA, LANGUAGE_CODE)) ||
!strcmp(key, get_key(BIA, MFG_DATETIME)) ||
!strcmp(key, get_key(BIA, MANUFACTURER)) ||
!strcmp(key, get_key(BIA, PRODUCT_NAME)) ||
!strcmp(key, get_key(BIA, SERIAL_NUMBER)) ||
!strcmp(key, get_key(BIA, PART_NUMBER)) ||
!strcmp(key, get_key(BIA, FRU_FILE_ID))) {
continue;
}
str_data = iniparser_getstring(ini, key, NULL);
if (str_data && strlen(str_data)) {
size += (*packer)(str_data, &packed_ascii);
}
}
size = get_aligned_size(size + 2, 8);
data = (char *) calloc(size, 1);
bia = (struct board_info_area *) data;
/* Fill up BIA */
bia->format_version = 0x01;
/* Length is in multiples of 8 bytes */
bia->area_length = size / 8;
bia->language_code = lang_code;
mfg_date = htole32(mfg_date);
memcpy(bia->mfg_date, &mfg_date, 3);
if (mfg_packed) {
memcpy(bia->tl + offset, mfg_packed, mfg_size);
offset += mfg_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
memcpy(bia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (name_packed) {
memcpy(bia->tl + offset, name_packed, name_size);
offset += name_size;
} else {
memcpy(bia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (serial_num_packed) {
memcpy(bia->tl + offset, serial_num_packed, serial_num_size);
offset += serial_num_size;
} else {
memcpy(bia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (part_num_packed) {
memcpy(bia->tl + offset, part_num_packed, part_num_size);
offset += part_num_size;
} else {
memcpy(bia->tl + offset, &empty_marker, 1);
offset += 1;
}
/* We don't handle FRU File ID for now... */
memcpy(bia->tl + offset, &empty_marker, 1);
offset += 1;
for (i = 0; i < num_keys; i++) {
key = sec_keys[i];
/* Skip keys we've already accounted for */
if (!strcmp(key, get_key(BIA, LANGUAGE_CODE)) ||
!strcmp(key, get_key(BIA, MFG_DATETIME)) ||
!strcmp(key, get_key(BIA, MANUFACTURER)) ||
!strcmp(key, get_key(BIA, PRODUCT_NAME)) ||
!strcmp(key, get_key(BIA, SERIAL_NUMBER)) ||
!strcmp(key, get_key(BIA, PART_NUMBER)) ||
!strcmp(key, get_key(BIA, FRU_FILE_ID))) {
continue;
}
str_data = iniparser_getstring(ini, key, NULL);
if (str_data && strlen(str_data)) {
packed_size = (*packer)(str_data, &packed_ascii);
memcpy(bia->tl + offset, packed_ascii, packed_size);
offset += packed_size;
}
}
/* write the end marker 'C1' */
memcpy(bia->tl + offset, &end_marker, 1);
/* Calculate checksum of entire BIA */
cksum = get_zero_cksum((uint8_t *) data, size-1);
memcpy(data+size-1, &cksum, 1);
*bia_data = data;
return bia->area_length;
}
int gen_cia(dictionary *ini, char **cia_data)
{
struct chassis_info_area *cia;
char *data,
*str_data,
*packed_ascii,
*key,
**sec_keys,
*part_num_packed,
*serial_num_packed;
int chassis_type,
size,
offset,
num_keys,
part_num_size,
serial_num_size,
packed_size,
i;
uint8_t end_marker, empty_marker, cksum;
cia = NULL;
size = offset = cksum = empty_marker = 0;
end_marker = 0xc1;
chassis_type = iniparser_getint(ini, get_key(CIA, CHASSIS_TYPE), 0);
if (!chassis_type) {
/* 0 is an illegal chassis type */
fprintf(stderr, "\nInvalid chassis type! Aborting\n\n");
exit(EXIT_FAILURE);
}
size += sizeof(struct chassis_info_area);
str_data = iniparser_getstring(ini, get_key(CIA, PART_NUMBER), NULL);
if (str_data && strlen(str_data)) {
part_num_size = (*packer)(str_data, &part_num_packed);
size += part_num_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
part_num_packed = NULL;
size += 1;
}
str_data = iniparser_getstring(ini, get_key(CIA, SERIAL_NUMBER), NULL);
if (str_data && strlen(str_data)) {
serial_num_size = (*packer)(str_data, &serial_num_packed);
size += serial_num_size;
} else {
serial_num_packed = NULL;
size += 1;
}
num_keys = iniparser_getsecnkeys(ini, CIA);
sec_keys = iniparser_getseckeys(ini, CIA);
for (i = 0; i < num_keys; i++) {
key = sec_keys[i];
/* Skip keys we've already accounted for */
if (!strcmp(key, get_key(CIA, CHASSIS_TYPE)) ||
!strcmp(key, get_key(CIA, PART_NUMBER)) ||
!strcmp(key, get_key(CIA, SERIAL_NUMBER))) {
continue;
}
str_data = iniparser_getstring(ini, key, NULL);
if (str_data && strlen(str_data)) {
size += (*packer)(str_data, &packed_ascii);
}
}
/* 2 bytes added for chksum & and end marker */
size = get_aligned_size(size + 2, 8);
data = (char *) calloc(size, 1);
cia = (struct chassis_info_area *) data;
/* Fill up CIA */
cia->format_version = 0x01;
/* Length is in multiples of 8 bytes */
cia->area_length = size / 8;
cia->chassis_type = chassis_type;
if (part_num_packed) {
memcpy(cia->tl + offset, part_num_packed, part_num_size);
offset += part_num_size;
} else {
/* predfined fields with no data take 1 byte (for type/length) */
memcpy(cia->tl + offset, &empty_marker, 1);
offset += 1;
}
if (serial_num_packed) {
memcpy(cia->tl + offset, serial_num_packed, serial_num_size);
offset += serial_num_size;
} else {
memcpy(cia->tl + offset, &empty_marker, 1);
offset += 1;
}
for (i = 0; i < num_keys; i++) {
key = sec_keys[i];
/* Skip keys we've already accounted for */
if (!strcmp(key, get_key(CIA, CHASSIS_TYPE)) ||
!strcmp(key, get_key(CIA, PART_NUMBER)) ||
!strcmp(key, get_key(CIA, SERIAL_NUMBER))) {
continue;
}
str_data = iniparser_getstring(ini, key, NULL);
if (str_data && strlen(str_data)) {
packed_size = (*packer)(str_data, &packed_ascii);
memcpy(cia->tl + offset, packed_ascii, packed_size);
offset += packed_size;
}
}
/* write the end marker 'C1' */
memcpy(cia->tl + offset, &end_marker, 1);
/* Calculate checksum of entire CIA */
cksum = get_zero_cksum((uint8_t *) data, size-1);
memcpy(data+size-1, &cksum, 1);
*cia_data = data;
return cia->area_length;
}
void load_config(char configPath[255], char supportedInput[255], void* params)
{
struct config_params *p = (struct config_params *)params;
FILE *fp;
//config: creating path to default config file
if (configPath[0] == '\0') {
char *configFile = "config";
char *configHome = getenv("XDG_CONFIG_HOME");
if (configHome != NULL) {
sprintf(configPath,"%s/%s/", configHome, PACKAGE);
} else {
configHome = getenv("HOME");
if (configHome != NULL) {
sprintf(configPath,"%s/%s/%s/", configHome, ".config", PACKAGE);
} else {
printf("No HOME found (ERR_HOMELESS), exiting...");
exit(EXIT_FAILURE);
}
}
// config: create directory
mkdir(configPath, 0777);
// config: adding default filename file
strcat(configPath, configFile);
fp = fopen(configPath, "ab+");
if (fp) {
fclose(fp);
} else {
printf("Unable to access config '%s', exiting...\n", configPath);
exit(EXIT_FAILURE);
}
} else { //opening specified file
fp = fopen(configPath, "rb+");
if (fp) {
fclose(fp);
} else {
printf("Unable to open file '%s', exiting...\n", configPath);
exit(EXIT_FAILURE);
}
}
// config: parse ini
dictionary* ini;
ini = iniparser_load(configPath);
//setting fifo to defaualt if no other input modes supported
inputMethod = (char *)iniparser_getstring(ini, "input:method", "fifo");
//setting alsa to defaualt if supported
#ifdef ALSA
inputMethod = (char *)iniparser_getstring(ini, "input:method", "alsa");
#endif
//setting pulse to defaualt if supported
#ifdef PULSE
inputMethod = (char *)iniparser_getstring(ini, "input:method", "pulse");
#endif
#ifdef NCURSES
outputMethod = (char *)iniparser_getstring(ini, "output:method", "ncurses");
#endif
#ifndef NCURSES
outputMethod = (char *)iniparser_getstring(ini, "output:method", "noncurses");
#endif
p->monstercat = 1.5 * iniparser_getdouble(ini, "smoothing:monstercat", 1);
p->waves = iniparser_getint(ini, "smoothing:waves", 0);
p->integral = iniparser_getdouble(ini, "smoothing:integral", 90);
p->gravity = iniparser_getdouble(ini, "smoothing:gravity", 100);
p->ignore = iniparser_getdouble(ini, "smoothing:ignore", 0);
p->color = (char *)iniparser_getstring(ini, "color:foreground", "default");
p->bcolor = (char *)iniparser_getstring(ini, "color:background", "default");
p->gradient = iniparser_getint(ini, "color:gradient", 0);
if (p->gradient) {
p->gradient_color_1 = (char *)iniparser_getstring(ini, "color:gradient_color_1", "#0099ff");
p->gradient_color_2 = (char *)iniparser_getstring(ini, "color:gradient_color_2", "#ff3399");
}
p->fixedbars = iniparser_getint(ini, "general:bars", 0);
p->bw = iniparser_getint(ini, "general:bar_width", 2);
p->bs = iniparser_getint(ini, "general:bar_spacing", 1);
p->framerate = iniparser_getint(ini, "general:framerate", 60);
p->sens = iniparser_getint(ini, "general:sensitivity", 100);
p->autosens = iniparser_getint(ini, "general:autosens", 1);
p->overshoot = iniparser_getint(ini, "general:overshoot", 20);
p->lowcf = iniparser_getint(ini, "general:lower_cutoff_freq", 50);
p->highcf = iniparser_getint(ini, "general:higher_cutoff_freq", 10000);
// config: output
channels = (char *)iniparser_getstring(ini, "output:channels", "stereo");
p->raw_target = (char *)iniparser_getstring(ini, "output:raw_target", "/dev/stdout");
data_format = (char *)iniparser_getstring(ini, "output:data_format", "binary");
p->bar_delim = (char)iniparser_getint(ini, "output:bar_delimiter", 59);
p->frame_delim = (char)iniparser_getint(ini, "output:frame_delimiter", 10);
p->ascii_range = iniparser_getint(ini, "output:ascii_max_range", 1000);
p->bit_format = iniparser_getint(ini, "output:bit_format", 16);
// read & validate: eq
p->smooth = smoothDef;
p->smcount = iniparser_getsecnkeys(ini, "eq");
if (p->smcount > 0) {
p->customEQ = 1;
p->smooth = malloc(p->smcount*sizeof(p->smooth));
#ifndef LEGACYINIPARSER
const char *keys[p->smcount];
iniparser_getseckeys(ini, "eq", keys);
#endif
#ifdef LEGACYINIPARSER
char **keys = iniparser_getseckeys(ini, "eq");
#endif
for (int sk = 0; sk < p->smcount; sk++) {
p->smooth[sk] = iniparser_getdouble(ini, keys[sk], 1);
}
} else {
p->customEQ = 0;
p->smcount = 64; //back to the default one
}
// config: input
p->im = 0;
if (strcmp(inputMethod, "alsa") == 0) {
p->im = 1;
p->audio_source = (char *)iniparser_getstring(ini, "input:source", "hw:Loopback,1");
}
if (strcmp(inputMethod, "fifo") == 0) {
p->im = 2;
p->audio_source = (char *)iniparser_getstring(ini, "input:source", "/tmp/mpd.fifo");
}
if (strcmp(inputMethod, "pulse") == 0) {
p->im = 3;
p->audio_source = (char *)iniparser_getstring(ini, "input:source", "auto");
}
validate_config(supportedInput, params);
//iniparser_freedict(ini);
}
