void Test_iniparser_getsecname(CuTest *tc)
{
unsigned i;
char sec_name[32];
dictionary *dic;
/* NULL test */
CuAssertTrue(tc, iniparser_getsecname(NULL, 0) == NULL);
/* Empty dictionary */
dic = dictionary_new(10);
CuAssertPtrEquals(tc, NULL, iniparser_getsecname(dic, 0));
dictionary_del(dic);
/* Sections without entries dictionary */
dic = generate_dictionary(100, 0);
for (i = 0; i < 100; ++i) {
sprintf(sec_name, "sec%d", i);
CuAssertStrEquals(tc, sec_name, iniparser_getsecname(dic, i));
}
dictionary_del(dic);
/* Generic dictionary */
dic = generate_dictionary(10, 100);
for (i = 0; i < 10; ++i) {
sprintf(sec_name, "sec%d", i);
CuAssertStrEquals(tc, sec_name, iniparser_getsecname(dic, i));
}
dictionary_del(dic);
}
void Test_iniparser_getnsec(CuTest *tc)
{
int i;
char sec_name[32];
dictionary *dic;
/* NULL test */
CuAssertIntEquals(tc, -1, iniparser_getnsec(NULL));
/* Empty dictionary */
dic = dictionary_new(10);
CuAssertIntEquals(tc, 0, iniparser_getnsec(dic));
dictionary_del(dic);
/* Regular dictionary */
dic = generate_dictionary(512, 0);
CuAssertIntEquals(tc, 512, iniparser_getnsec(dic));
/* Check after removing sections */
for (i = 1; i < 512; ++i) {
sprintf(sec_name, "sec%d", i);
dictionary_unset(dic, sec_name);
CuAssertIntEquals(tc, 512 - i, iniparser_getnsec(dic));
}
dictionary_del(dic);
/* Mix sections and regular keys */
dic = generate_dictionary(10, 512);
CuAssertIntEquals(tc, 10, iniparser_getnsec(dic));
dictionary_del(dic);
}
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);
}
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);
}
/**
* Signal handler for HUP which tells us to swap the log file
* and reload configuration file if specified
*
* @param sig
*/
void
do_signal_sighup(RunTimeOpts * rtOpts, PtpClock * ptpClock)
{
NOTIFY("SIGHUP received\n");
#ifdef RUNTIME_DEBUG
if(rtOpts->transport == UDP_IPV4 && rtOpts->ipMode != IPMODE_UNICAST) {
DBG("SIGHUP - running an ipv4 multicast based mode, re-sending IGMP joins\n");
netRefreshIGMP(&ptpClock->netPath, rtOpts, ptpClock);
}
#endif /* RUNTIME_DEBUG */
/* if we don't have a config file specified, we're done - just reopen log files*/
if(strlen(rtOpts->configFile) != 0) {
dictionary* tmpConfig = dictionary_new(0);
/* Try reloading the config file */
NOTIFY("Reloading configuration file: %s\n",rtOpts->configFile);
if(!loadConfigFile(&tmpConfig, rtOpts)) {
dictionary_del(&tmpConfig);
} else {
dictionary_merge(rtOpts->cliConfig, tmpConfig, 1, 1, "from command line");
applyConfig(tmpConfig, rtOpts, ptpClock);
dictionary_del(&tmpConfig);
}
}
/* tell the service it can perform any HUP-triggered actions */
ptpClock->timingService.reloadRequested = TRUE;
if(rtOpts->recordLog.logEnabled ||
rtOpts->eventLog.logEnabled ||
(rtOpts->statisticsLog.logEnabled))
INFO("Reopening log files\n");
restartLogging(rtOpts);
if(rtOpts->statisticsLog.logEnabled)
ptpClock->resetStatisticsLog = TRUE;
}
void registry_free(void) {
if(!registry.enabled) return;
// we need to destroy the dictionaries ourselves
// since the dictionaries use memory we allocated
while(registry.persons->values_index.root) {
REGISTRY_PERSON *p = ((NAME_VALUE *)registry.persons->values_index.root)->value;
registry_person_del(p);
}
while(registry.machines->values_index.root) {
REGISTRY_MACHINE *m = ((NAME_VALUE *)registry.machines->values_index.root)->value;
// fprintf(stderr, "\nMACHINE: '%s', first: %u, last: %u, usages: %u\n", m->guid, m->first_t, m->last_t, m->usages);
while(m->machine_urls->values_index.root) {
REGISTRY_MACHINE_URL *mu = ((NAME_VALUE *)m->machine_urls->values_index.root)->value;
// fprintf(stderr, "\tURL: '%s', first: %u, last: %u, usages: %u, flags: 0x%02x\n", mu->url->url, mu->first_t, mu->last_t, mu->usages, mu->flags);
//debug(D_REGISTRY, "Registry: destroying persons dictionary from url '%s'", mu->url->url);
//dictionary_destroy(mu->persons);
debug(D_REGISTRY, "Registry: deleting url '%s' from person '%s'", mu->url->url, m->guid);
dictionary_del(m->machine_urls, mu->url->url);
debug(D_REGISTRY, "Registry: unlinking url '%s' from machine", mu->url->url);
registry_url_unlink(mu->url);
debug(D_REGISTRY, "Registry: freeing machine url");
freez(mu);
}
debug(D_REGISTRY, "Registry: deleting machine '%s' from machines registry", m->guid);
dictionary_del(registry.machines, m->guid);
debug(D_REGISTRY, "Registry: destroying URL dictionary of machine '%s'", m->guid);
dictionary_destroy(m->machine_urls);
debug(D_REGISTRY, "Registry: freeing machine '%s'", m->guid);
freez(m);
}
// and free the memory of remaining dictionary structures
debug(D_REGISTRY, "Registry: destroying persons dictionary");
dictionary_destroy(registry.persons);
debug(D_REGISTRY, "Registry: destroying machines dictionary");
dictionary_destroy(registry.machines);
}
void close_config(dictionary *dict)
{
if (dict != NULL) {
dictionary_del(dict);
dict = NULL;
}
}
void Test_dictionary_growing(CuTest *tc)
{
int i, j;
char sec_name[32];
char key_name[64];
dictionary *dic;
dic = dictionary_new(DICTMINSZ);
CuAssertPtrNotNull(tc, dic);
CuAssertIntEquals(tc, 0, dic->n);
/* Makes the dictionary grow */
for (i = 1 ; i < 101; ++i) {
sprintf(sec_name, "sec%d", i);
CuAssertIntEquals(tc, 0, dictionary_set(dic, sec_name, ""));
for (j = 1 ; j < 11; ++j) {
sprintf(key_name, "%s:key%d", sec_name, j);
CuAssertIntEquals(tc, 0, dictionary_set(dic, key_name, "dummy_value"));
CuAssertIntEquals(tc, i + (i - 1) * 10 + j, dic->n);
}
}
/* Shrink the dictionary */
for (i = 100 ; i > 0; --i) {
sprintf(sec_name, "sec%d", i);
for (j = 10 ; j > 0; --j) {
sprintf(key_name, "%s:key%d", sec_name, j);
dictionary_unset(dic, key_name);
}
dictionary_unset(dic, sec_name);
CuAssertIntEquals(tc, (i - 1) * (11), dic->n);
}
dictionary_del(dic);
}
void camera_control_backup_system_settings(CameraControl* cc, const char* file) {
int AutoAEC = 0;
int AutoAGC = 0;
int Gain = 0;
int Exposure = 0;
int Contrast = 0;
int Brightness = 0;
int fd = open_v4l2_device(cc->cameraID);
if (fd != -1) {
AutoAEC = v4l2_get_control(fd, V4L2_CID_EXPOSURE_AUTO);
AutoAGC = v4l2_get_control(fd, V4L2_CID_AUTOGAIN);
Gain = v4l2_get_control(fd, V4L2_CID_GAIN);
Exposure = v4l2_get_control(fd, V4L2_CID_EXPOSURE);
Contrast = v4l2_get_control(fd, V4L2_CID_CONTRAST);
Brightness = v4l2_get_control(fd, V4L2_CID_BRIGHTNESS);
v4l2_close(fd);
dictionary* ini = dictionary_new(0);
iniparser_set(ini, "PSEye", 0);
iniparser_set_int(ini, "PSEye:AutoAEC", AutoAEC);
iniparser_set_int(ini, "PSEye:AutoAGC", AutoAGC);
iniparser_set_int(ini, "PSEye:Gain", Gain);
iniparser_set_int(ini, "PSEye:Exposure", Exposure);
iniparser_set_int(ini, "PSEye:Contrast", Contrast);
iniparser_set_int(ini, "PSEye:Brightness", Brightness);
iniparser_save_ini(ini, file);
dictionary_del(ini);
}
}
void registry_person_del(REGISTRY_PERSON *p) {
debug(D_REGISTRY, "Registry: registry_person_del('%s'): creating dictionary of urls", p->guid);
while(p->person_urls.root)
registry_person_unlink_from_url(p, (REGISTRY_PERSON_URL *)p->person_urls.root);
debug(D_REGISTRY, "Registry: deleting person '%s' from persons registry", p->guid);
dictionary_del(registry.persons, p->guid);
debug(D_REGISTRY, "Registry: freeing person '%s'", p->guid);
freez(p);
}
void Test_iniparser_load(CuTest *tc)
{
DIR *dir;
struct dirent *curr;
struct stat curr_stat;
dictionary *dic;
char ini_path[256];
/* Dummy tests */
dic = iniparser_load("/you/shall/not/path");
CuAssertPtrEquals(tc, NULL, dic);
/* Test all the good .ini files */
dir = opendir(GOOD_INI_PATH);
CuAssertPtrNotNullMsg(tc, "Cannot open good .ini conf directory", dir);
for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
sprintf(ini_path, "%s/%s", GOOD_INI_PATH, curr->d_name);
stat(ini_path, &curr_stat);
if (S_ISREG(curr_stat.st_mode)) {
dic = iniparser_load(ini_path);
CuAssertPtrNotNullMsg(tc, ini_path, dic);
dictionary_del(dic);
}
}
closedir(dir);
/* Test all the bad .ini files */
dir = opendir(BAD_INI_PATH);
CuAssertPtrNotNullMsg(tc, "Cannot open bad .ini conf directory", dir);
for (curr = readdir(dir); curr != NULL; curr = readdir(dir)) {
sprintf(ini_path, "%s/%s", BAD_INI_PATH, curr->d_name);
stat(ini_path, &curr_stat);
if (S_ISREG(curr_stat.st_mode)) {
dic = iniparser_load(ini_path);
CuAssertPtrEquals_Msg(tc, ini_path, NULL, dic);
dictionary_del(dic);
}
}
closedir(dir);
}
int main(int argc, char* argv[])
{
dictionary* d ;
char* val ;
int i ;
char cval[90] ;
/* Allocate dictionary */
printf("allocating...\n");
d = dictionary_new(0);
/* Set values in dictionary */
printf("setting %d values...\n", NVALS);
for (i=0 ; i<NVALS ; i++)
{
sprintf(cval, "%04d", i);
dictionary_set(d, cval, "salut");
}
printf("getting %d values...\n", NVALS);
for (i=0 ; i<NVALS ; i++)
{
sprintf(cval, "%04d", i);
val = dictionary_get(d, cval, DICT_INVALID_KEY);
if (val==DICT_INVALID_KEY)
{
printf("cannot get value for key [%s]\n", cval);
}
}
printf("unsetting %d values...\n", NVALS);
for (i=0 ; i<NVALS ; i++)
{
sprintf(cval, "%04d", i);
dictionary_unset(d, cval);
}
if (d->n != 0)
{
printf("error deleting values\n");
}
printf("deallocating...\n");
dictionary_del(d);
return 0 ;
}
void Test_dictionary_dump(CuTest *tc)
{
int i, j;
char sec_name[32];
char key_name[64];
dictionary *dic;
char *dump_buff;
const char dump_real[] = "\
sec1\t[]\n\
sec1:key1\t[dummy_value]\n\
sec1:key2\t[dummy_value]\n\
sec1:key3\t[dummy_value]\n\
sec1:key4\t[dummy_value]\n\
sec2\t[]\n\
sec2:key1\t[dummy_value]\n\
sec2:key2\t[dummy_value]\n\
sec2:key3\t[dummy_value]\n\
sec2:key4\t[dummy_value]\n\
";
dic = dictionary_new(DICTMINSZ);
CuAssertPtrNotNull(tc, dic);
/* Try dummy values */
dictionary_dump(NULL, NULL);
dictionary_dump(dic, NULL);
/* Try with empty dictionary first */
dump_buff = get_dump(dic);
CuAssertStrEquals(tc, "empty dictionary\n", dump_buff);
free(dump_buff);
/* Populate the dictionary */
for (i = 1 ; i < 3; ++i) {
sprintf(sec_name, "sec%d", i);
dictionary_set(dic, sec_name, "");
for (j = 1 ; j < 5; ++j) {
sprintf(key_name, "%s:key%d", sec_name, j);
dictionary_set(dic, key_name, "dummy_value");
}
}
/* Check the dump file */
dump_buff = get_dump(dic);
CuAssertStrEquals(tc, dump_real, dump_buff);
free(dump_buff);
dictionary_del(dic);
}
void Test_iniparser_getstring(CuTest *tc)
{
dictionary *dic;
/* NULL test */
CuAssertPtrEquals(tc, NULL, iniparser_getstring(NULL, NULL, NULL));
CuAssertPtrEquals(tc, NULL, iniparser_getstring(NULL, "dummy", NULL));
/* Check the def return element */
dic = dictionary_new(10);
CuAssertPtrEquals(tc, NULL, iniparser_getstring(dic, "dummy", NULL));
CuAssertStrEquals(tc, "def", iniparser_getstring(dic, NULL, "def"));
CuAssertStrEquals(tc, "def", iniparser_getstring(dic, "dummy", "def"));
dictionary_del(dic);
/* Generic dictionary */
dic = generate_dictionary(100, 10);
CuAssertStrEquals(tc, "value-0/0",
iniparser_getstring(dic, "sec0:key0", NULL));
CuAssertStrEquals(tc, "value-42/5",
iniparser_getstring(dic, "sec42:key5", NULL));
CuAssertStrEquals(tc, "value-99/9",
iniparser_getstring(dic, "sec99:key9", NULL));
dictionary_del(dic);
}
int main
(int argc,
char *argv[])
{
LPDICTIONARY lpDict; // Ptr to workspace dictionary
LPWCHAR lpwVal;
int i;
WCHAR cval[90];
/* Allocate dictionary */
printf ("allocating...\n");
lpDict = dictionary_new (0);
/* Set values in dictionary */
printf ("setting %d values...\n", NVALS);
for (i = 0; i < NVALS; i++)
{
wsprintfW (cval, L"%04d", i);
dictionary_set (lpDict, cval, L"salut");
} // End FOR
printf ("getting %d values...\n", NVALS);
for (i = 0; i < NVALS; i++)
{
wsprintfW (cval, L"%04d", i);
lpwVal = dictionary_get (lpDict, cval, DICT_INVALID_KEY, NULL);
if (lpwVal EQ DICT_INVALID_KEY)
printf ("cannot get value for key [%s]\n", cval);
} // End FOR
printf ("unsetting %d values...\n", NVALS);
for (i = 0; i < NVALS; i++)
{
wsprintfW (cval, L"%04d", i);
dictionary_unset (lpDict, cval);
} // End FOR
if (lpDict->n NE 0)
printf ("error deleting values\n");
printf ("deallocating...\n");
dictionary_del (lpDict); lpDict = NULL;
return 0;
} // End main
int
config_load(void)
{
int n;
config = iniparser_load("spoold.conf");
if(!config)
{
return -1;
}
for(n = 0; n < overrides->n; n++)
{
iniparser_set(config, overrides->key[n], overrides->val[n]);
}
dictionary_del(overrides);
overrides = NULL;
return 0;
}
void camera_control_backup_system_settings(CameraControl* cc, const char* file) {
#if !defined(CAMERA_CONTROL_USE_CL_DRIVER) && !defined(CAMERA_CONTROL_USE_PS3EYE_DRIVER) && defined(PSMOVE_USE_PSEYE)
HKEY hKey;
DWORD l = sizeof(DWORD);
DWORD AutoAEC = 0;
DWORD AutoAGC = 0;
DWORD AutoAWB = 0;
DWORD Exposure = 0;
DWORD Gain = 0;
DWORD wbB = 0;
DWORD wbG = 0;
DWORD wbR = 0;
char* PATH = CL_DRIVER_REG_PATH;
int err = RegOpenKeyEx(HKEY_CURRENT_USER, PATH, 0, KEY_ALL_ACCESS, &hKey);
if (err != ERROR_SUCCESS) {
printf("Error: %d Unable to open reg-key: [HKCU]\\%s!", err, PATH);
return;
}
RegQueryValueEx(hKey, "AutoAEC", NULL, NULL, (LPBYTE) &AutoAEC, &l);
RegQueryValueEx(hKey, "AutoAGC", NULL, NULL, (LPBYTE) &AutoAGC, &l);
RegQueryValueEx(hKey, "AutoAWB", NULL, NULL, (LPBYTE) &AutoAWB, &l);
RegQueryValueEx(hKey, "Exposure", NULL, NULL, (LPBYTE) &Exposure, &l);
RegQueryValueEx(hKey, "Gain", NULL, NULL, (LPBYTE) &Gain, &l);
RegQueryValueEx(hKey, "WhiteBalanceB", NULL, NULL, (LPBYTE) &wbB, &l);
RegQueryValueEx(hKey, "WhiteBalanceG", NULL, NULL, (LPBYTE) &wbG, &l);
RegQueryValueEx(hKey, "WhiteBalanceR", NULL, NULL, (LPBYTE) &wbR, &l);
dictionary* ini = dictionary_new(0);
iniparser_set(ini, "PSEye", 0);
iniparser_set_int(ini, "PSEye:AutoAEC", AutoAEC);
iniparser_set_int(ini, "PSEye:AutoAGC", AutoAGC);
iniparser_set_int(ini, "PSEye:AutoAWB", AutoAWB);
iniparser_set_int(ini, "PSEye:Exposure", Exposure);
iniparser_set_int(ini, "PSEye:Gain", Gain);
iniparser_set_int(ini, "PSEye:WhiteBalanceB", wbB);
iniparser_set_int(ini, "PSEye:WhiteBalanceG", wbG);
iniparser_set_int(ini, "PSEye:WhiteBalanceR", wbG);
iniparser_save_ini(ini, file);
dictionary_del(ini);
#endif
}
void Test_iniparser_getdouble(CuTest *tc)
{
dictionary *dic;
/* NULL test */
CuAssertDblEquals(tc, -42, iniparser_getdouble(NULL, NULL, -42), 0);
CuAssertDblEquals(tc, 4.2, iniparser_getdouble(NULL, "dummy", 4.2), 0);
/* Check the def return element */
dic = dictionary_new(10);
CuAssertDblEquals(tc, 3.1415, iniparser_getdouble(dic, "dummy", 3.1415), 0);
CuAssertDblEquals(tc, 0xFFFFFFFF, iniparser_getdouble(dic, NULL, 0xFFFFFFFF), 0);
CuAssertDblEquals(tc, -0xFFFFFFFF, iniparser_getdouble(dic, "dummy", -0xFFFFFFFF), 0);
/* Insert some values */
dictionary_set(dic, "double", "");
dictionary_set(dic, "double:good0", "0");
dictionary_set(dic, "double:good1", "-0");
dictionary_set(dic, "double:good2", "1.0");
dictionary_set(dic, "double:good3", "3.1415");
dictionary_set(dic, "double:good4", "6.6655957");
dictionary_set(dic, "double:good5", "-123456789.123456789");
/* Add dummy stuff too */
dictionary_set(dic, "double:bad0", "foo");
/* Get back the values */
CuAssertDblEquals(tc, 0, iniparser_getdouble(dic, "double:good0", 0xFF), 0);
CuAssertDblEquals(tc, 0, iniparser_getdouble(dic, "double:good1", 0xFF), 0);
CuAssertDblEquals(tc, 1.0, iniparser_getdouble(dic, "double:good2", 0xFF), 0);
CuAssertDblEquals(tc, 3.1415, iniparser_getdouble(dic, "double:good3", 0xFF), 0);
CuAssertDblEquals(tc, 6.6655957, iniparser_getdouble(dic, "double:good4", 0xFF), 0);
CuAssertDblEquals(tc, -123456789.123456789,
iniparser_getdouble(dic, "double:good5", 0xFF), 0);
CuAssertDblEquals(tc, 0, iniparser_getdouble(dic, "double:bad0", 42.42), 0);
dictionary_del(dic);
}
void frame_factory_destroy(void)
{
if (texture_cfg != NULL) {
iniparser_freedict(texture_cfg);
texture_cfg = NULL;
}
if (frame_cache != NULL) {
int i;
frame_t *frame;
for (i = 0; i < frame_cache->size; ++ i) {
if (frame_cache->key[i] != NULL) {
frame = frame_factory_get(frame_cache->key[i]);
frame_destroy(frame);
}
}
dictionary_del(frame_cache);
frame_cache = NULL;
}
return;
}
/*--------------------------------------------------------------------------*/
dictionary * iniparser_load(const char * ininame)
{
FILE * in ;
char line [ASCIILINESZ+1] ;
char section [ASCIILINESZ+1] ;
char key [ASCIILINESZ+1] ;
char tmp [ASCIILINESZ+1] ;
char val [ASCIILINESZ+1] ;
int last=0 ;
int len ;
int lineno=0 ;
int errs=0;
dictionary * dict ;
if ((in=fopen(ininame, "r"))==NULL) {
fprintf(stderr, "iniparser: cannot open %s\n", ininame);
return NULL ;
}
dict = dictionary_new(0) ;
if (!dict) {
fclose(in);
return NULL ;
}
memset(line, 0, ASCIILINESZ);
memset(section, 0, ASCIILINESZ);
memset(key, 0, ASCIILINESZ);
memset(val, 0, ASCIILINESZ);
last=0 ;
while (fgets(line+last, ASCIILINESZ-last, in)!=NULL) {
lineno++ ;
len = (int)strlen(line)-1;
/* Safety check against buffer overflows */
if (line[len]!='\n') {
fprintf(stderr,
"iniparser: input line too long in %s (%d)\n",
ininame,
lineno);
dictionary_del(dict);
fclose(in);
return NULL ;
}
/* Get rid of \n and spaces at end of line */
while ((len>=0) &&
((line[len]=='\n') || (isspace(line[len])))) {
line[len]=0 ;
len-- ;
}
/* Detect multi-line */
if (line[len]=='\\') {
/* Multi-line value */
last=len ;
continue ;
} else {
last=0 ;
}
switch (iniparser_line(line, section, key, val)) {
case LINE_EMPTY:
case LINE_COMMENT:
break ;
case LINE_SECTION:
errs = dictionary_set(dict, section, NULL);
break ;
case LINE_VALUE:
sprintf(tmp, "%s:%s", section, key);
errs = dictionary_set(dict, tmp, val) ;
break ;
case LINE_ERROR:
fprintf(stderr, "iniparser: syntax error in %s (%d):\n",
ininame,
lineno);
fprintf(stderr, "-> %s\n", line);
errs++ ;
break;
default:
break ;
}
memset(line, 0, ASCIILINESZ);
last=0;
if (errs<0) {
fprintf(stderr, "iniparser: memory allocation failure\n");
break ;
}
}
if (errs) {
dictionary_del(dict);
dict = NULL ;
}
fclose(in);
return dict ;
}
void Test_iniparser_getboolean(CuTest *tc)
{
unsigned i;
char key_name[64];
dictionary *dic;
const char *token_true[] = {
"1",
"true",
"t",
"TRUE",
"T",
"yes",
"y",
"YES"
"Y",
NULL
};
const char *token_false[] = {
"0",
"false",
"f",
"FALSE",
"F",
"no",
"n",
"NO",
"N",
NULL
};
/* NULL test */
CuAssertIntEquals(tc, 1, iniparser_getboolean(NULL, NULL, 1));
CuAssertIntEquals(tc, 1, iniparser_getboolean(NULL, "dummy", 1));
/* Check the def return element */
dic = dictionary_new(10);
CuAssertIntEquals(tc, 1, iniparser_getboolean(dic, "dummy", 1));
CuAssertIntEquals(tc, 0, iniparser_getboolean(dic, NULL, 0));
CuAssertIntEquals(tc, 1, iniparser_getboolean(dic, "dummy", 1));
for (i = 0; token_true[i] != NULL; ++i) {
sprintf(key_name, "bool:true%d", i);
iniparser_set(dic, key_name, token_true[i]);
}
for (i = 0; token_false[i] != NULL; ++i) {
sprintf(key_name, "bool:false%d", i);
iniparser_set(dic, key_name, token_false[i]);
}
for (i = 0; token_true[i] != NULL; ++i) {
sprintf(key_name, "bool:true%d", i);
CuAssertIntEquals(tc, 1, iniparser_getboolean(dic, key_name, 0));
}
for (i = 0; token_false[i] != NULL; ++i) {
sprintf(key_name, "bool:false%d", i);
CuAssertIntEquals(tc, 0, iniparser_getboolean(dic, key_name, 1));
}
/* Test bad boolean */
iniparser_set(dic, "bool:bad0", "");
iniparser_set(dic, "bool:bad1", "m'kay");
iniparser_set(dic, "bool:bad2", "42");
iniparser_set(dic, "bool:bad3", "_true");
CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad0", 0xFF));
CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad1", 0xFF));
CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad2", 0xFF));
CuAssertIntEquals(tc, 0xFF, iniparser_getboolean(dic, "bool:bad3", 0xFF));
dictionary_del(dic);
}
void Test_iniparser_getint(CuTest *tc)
{
unsigned i;
char key_name[64];
dictionary *dic;
const struct { int num; const char *value; } good_val[] = {
{ 0, "0" },
{ 1, "1" },
{ -1, "-1" },
{ 1000, "1000" },
{ 077, "077" },
{ -01000, "-01000" },
{ 0xFFFF, "0xFFFF" },
{ -0xFFFF, "-0xFFFF" },
{ 0x4242, "0x4242" },
{ 0, NULL} /* must be last */
};
const char *bad_val[] = {
"",
"notanumber",
"0x",
"k2000",
" ",
"0xG1"
};
/* NULL test */
CuAssertIntEquals(tc, -42, iniparser_getint(NULL, NULL, -42));
CuAssertIntEquals(tc, -42, iniparser_getint(NULL, "dummy", -42));
/* Check the def return element */
dic = dictionary_new(10);
CuAssertIntEquals(tc, 42, iniparser_getint(dic, "dummy", 42));
CuAssertIntEquals(tc, 0xFFFF, iniparser_getint(dic, NULL, 0xFFFF));
CuAssertIntEquals(tc, -0xFFFF, iniparser_getint(dic, "dummy", -0xFFFF));
dictionary_del(dic);
/* Generic dictionary */
dic = dictionary_new(10);
for (i = 0; good_val[i].value != NULL; ++i) {
sprintf(key_name, "int:value%d", i);
dictionary_set(dic, key_name, good_val[i].value);
}
for (i = 0; good_val[i].value != NULL; ++i) {
sprintf(key_name, "int:value%d", i);
CuAssertIntEquals(tc, good_val[i].num,
iniparser_getint(dic, key_name, 0));
}
dictionary_del(dic);
/* Test bad names */
dic = dictionary_new(10);
for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
sprintf(key_name, "int:bad%d", i);
dictionary_set(dic, key_name, bad_val[i]);
}
for (i = 0; i < sizeof (bad_val) / sizeof (char *); ++i) {
sprintf(key_name, "int:bad%d", i);
CuAssertIntEquals(tc, 0,
iniparser_getint(dic, key_name, 0));
}
dictionary_del(dic);
}
int main(int argc, char **argv) {
if(argc || argv) {;}
// DICTIONARY *dict = dictionary_create(DICTIONARY_FLAG_SINGLE_THREADED|DICTIONARY_FLAG_WITH_STATISTICS);
DICTIONARY *dict = dictionary_create(DICTIONARY_FLAG_WITH_STATISTICS);
if(!dict) fatal("Cannot create dictionary.");
struct rusage start, end;
unsigned long long dt;
char buf[100 + 1];
struct myvalue value, *v;
int i, max = 100000, max2;
// ------------------------------------------------------------------------
getrusage(RUSAGE_SELF, &start);
dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
fprintf(stderr, "Inserting %d entries in the dictionary\n", max);
for(i = 0; i < max; i++) {
value.i = i;
snprintf(buf, 100, "%d", i);
dictionary_set(dict, buf, &value, sizeof(struct myvalue));
}
getrusage(RUSAGE_SELF, &end);
dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
fprintf(stderr, "Added %d entries in %llu nanoseconds: %llu inserts per second\n", max, dt, max * 1000000ULL / dt);
fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
// ------------------------------------------------------------------------
getrusage(RUSAGE_SELF, &start);
dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
fprintf(stderr, "Retrieving %d entries from the dictionary\n", max);
for(i = 0; i < max; i++) {
value.i = i;
snprintf(buf, 100, "%d", i);
v = dictionary_get(dict, buf);
if(!v)
fprintf(stderr, "ERROR: cannot get value %d from the dictionary\n", i);
else if(v->i != i)
fprintf(stderr, "ERROR: expected %d but got %d\n", i, v->i);
}
getrusage(RUSAGE_SELF, &end);
dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
fprintf(stderr, "Read %d entries in %llu nanoseconds: %llu searches per second\n", max, dt, max * 1000000ULL / dt);
fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
// ------------------------------------------------------------------------
getrusage(RUSAGE_SELF, &start);
dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
fprintf(stderr, "Resetting %d entries in the dictionary\n", max);
for(i = 0; i < max; i++) {
value.i = i;
snprintf(buf, 100, "%d", i);
dictionary_set(dict, buf, &value, sizeof(struct myvalue));
}
getrusage(RUSAGE_SELF, &end);
dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
fprintf(stderr, "Reset %d entries in %llu nanoseconds: %llu resets per second\n", max, dt, max * 1000000ULL / dt);
fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
// ------------------------------------------------------------------------
getrusage(RUSAGE_SELF, &start);
dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
fprintf(stderr, "Searching %d non-existing entries in the dictionary\n", max);
max2 = max * 2;
for(i = max; i < max2; i++) {
value.i = i;
snprintf(buf, 100, "%d", i);
v = dictionary_get(dict, buf);
if(v)
fprintf(stderr, "ERROR: cannot got non-existing value %d from the dictionary\n", i);
}
getrusage(RUSAGE_SELF, &end);
dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
fprintf(stderr, "Searched %d non-existing entries in %llu nanoseconds: %llu not found searches per second\n", max, dt, max * 1000000ULL / dt);
fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
// ------------------------------------------------------------------------
getrusage(RUSAGE_SELF, &start);
dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
fprintf(stderr, "Deleting %d entries from the dictionary\n", max);
for(i = 0; i < max; i++) {
value.i = i;
snprintf(buf, 100, "%d", i);
dictionary_del(dict, buf);
}
getrusage(RUSAGE_SELF, &end);
dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
fprintf(stderr, "Deleted %d entries in %llu nanoseconds: %llu deletes per second\n", max, dt, max * 1000000ULL / dt);
fprintf(stderr, " > Dictionary: %llu inserts, %llu deletes, %llu searches\n\n", dict->stats->inserts, dict->stats->deletes, dict->stats->searches);
// ------------------------------------------------------------------------
getrusage(RUSAGE_SELF, &start);
dict->stats->inserts = dict->stats->deletes = dict->stats->searches = 0ULL;
fprintf(stderr, "Destroying dictionary\n");
dictionary_destroy(dict);
getrusage(RUSAGE_SELF, &end);
dt = (end.ru_utime.tv_sec * 1000000ULL + end.ru_utime.tv_usec) - (start.ru_utime.tv_sec * 1000000ULL + start.ru_utime.tv_usec);
fprintf(stderr, "Destroyed in %llu nanoseconds\n", dt);
return 0;
}
dictionary * iniparser_new(char *ininame)
{
dictionary * d ;
char lin[ASCIILINESZ+1];
char sec[ASCIILINESZ+1];
char key[ASCIILINESZ+1];
char val[ASCIILINESZ+1];
char * where ;
FILE * ini ;
int lineno ;
if ((ini=fopen(ininame, "r"))==NULL) {
return NULL ;
}
sec[0]=0;
/*
* Initialize a new dictionary entry
*/
d = dictionary_new(0);
if (d == NULL) {
fclose(ini);
return d;
}
lineno = 0 ;
while (fgets(lin, ASCIILINESZ, ini)!=NULL) {
lineno++ ;
where = strskp(lin); /* Skip leading spaces */
if (*where==';' || *where=='#' || *where==0)
continue ; /* Comment lines */
else {
char lc_key[ASCIILINESZ+1];
if (sscanf(where, "[%[^]]", sec)==1) {
/* Valid section name */
strcpy(sec, strlwc(sec, lc_key));
if (iniparser_add_entry(d, sec, NULL, NULL) != 0) {
dictionary_del(d);
fclose(ini);
return NULL;
}
} else if (sscanf (where, "%[^=] = \"%[^\"]\"", key, val) == 2
|| sscanf (where, "%[^=] = '%[^\']'", key, val) == 2
|| sscanf (where, "%[^=] = %[^;#]", key, val) == 2) {
char crop_key[ASCIILINESZ+1];
strcpy(key, strlwc(strcrop(key, crop_key), lc_key));
/*
* sscanf cannot handle "" or '' as empty value,
* this is done here
*/
if (!strcmp(val, "\"\"") || !strcmp(val, "''")) {
val[0] = (char)0;
} else {
strcpy(val, strcrop(val, crop_key));
}
if (iniparser_add_entry(d, sec, key, val) != 0) {
dictionary_del(d);
fclose(ini);
return NULL;
}
}
}
}
fclose(ini);
return d ;
}
extern bool ini_conf_save(p_conf conf)
{
dictionary *dict;
FILE *fp;
char buf[PATH_MAX];
int i;
if (conf == NULL) {
return false;
}
conf->confver = XREADER_VERSION_NUM;
dict = dictionary_new(0);
if (dict == NULL)
return false;
fp = fopen(conf_filename, "w");
if (fp == NULL) {
return false;
}
if (iniparser_setstring(dict, "Global", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "UI", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Text", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Image", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Music", NULL) != 0)
goto error;
iniparser_setstring(dict, "Global:path", conf->path);
iniparser_setstring(dict, "UI:forecolor",
hexToString(buf, sizeof(buf), conf->forecolor));
iniparser_setstring(dict, "Image:giftranscolor",
hexToString(buf, sizeof(buf), conf->giftranscolor));
iniparser_setstring(dict, "UI:bgcolor",
hexToString(buf, sizeof(buf), conf->bgcolor));
iniparser_setstring(dict, "UI:have_bg",
booleanToString(buf, sizeof(buf), conf->have_bg));
iniparser_setstring(dict, "UI:titlecolor",
hexToString(buf, sizeof(buf), conf->titlecolor));
iniparser_setstring(dict, "UI:menutextcolor",
hexToString(buf, sizeof(buf), conf->menutextcolor));
iniparser_setstring(dict, "UI:menubcolor",
hexToString(buf, sizeof(buf), conf->menubcolor));
iniparser_setstring(dict, "UI:selicolor",
hexToString(buf, sizeof(buf), conf->selicolor));
iniparser_setstring(dict, "UI:selbcolor",
hexToString(buf, sizeof(buf), conf->selbcolor));
iniparser_setstring(dict, "UI:msgbcolor",
hexToString(buf, sizeof(buf), conf->msgbcolor));
iniparser_setstring(dict, "UI:usedyncolor",
booleanToString(buf, sizeof(buf), conf->usedyncolor));
iniparser_setstring(dict, "Text:rowspace",
dwordToString(buf, sizeof(buf), conf->rowspace));
iniparser_setstring(dict, "Text:infobar",
infobarToString(buf, sizeof(buf), conf->infobar));
iniparser_setstring(dict, "Text:infobar_style",
intToString(buf, sizeof(buf), conf->infobar_style));
iniparser_setstring(dict, "Text:rlastrow",
booleanToString(buf, sizeof(buf), conf->rlastrow));
iniparser_setstring(dict, "Text:autobm",
booleanToString(buf, sizeof(buf), conf->autobm));
iniparser_setstring(dict, "Text:vertread",
vertreadToString(buf, sizeof(buf), conf->vertread));
iniparser_setstring(dict, "Text:encode",
encodeToString(buf, sizeof(buf), conf->encode));
iniparser_setstring(dict, "Image:fit",
fitToString(buf, sizeof(buf), conf->fit));
iniparser_setstring(dict, "Image:imginfobar",
booleanToString(buf, sizeof(buf), conf->imginfobar));
iniparser_setstring(dict, "Text:scrollbar",
booleanToString(buf, sizeof(buf), conf->scrollbar));
iniparser_setstring(dict, "Image:scale",
dwordToString(buf, sizeof(buf), conf->scale));
iniparser_setstring(dict, "Image:rotate",
rotateToString(buf, sizeof(buf), conf->rotate));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->txtkey[i]));
SPRINTF_S(key, "Image:imgkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->imgkey[i]));
}
iniparser_setstring(dict, "Global:shortpath", conf->shortpath);
iniparser_setstring(dict, "Global:confver",
hexToString(buf, sizeof(buf), conf->confver));
iniparser_setstring(dict, "Image:bicubic",
booleanToString(buf, sizeof(buf), conf->bicubic));
iniparser_setstring(dict, "Text:wordspace",
dwordToString(buf, sizeof(buf), conf->wordspace));
iniparser_setstring(dict, "Text:borderspace",
dwordToString(buf, sizeof(buf), conf->borderspace));
iniparser_setstring(dict, "Global:lastfile", conf->lastfile);
iniparser_setstring(dict, "Music:mp3encode",
encodeToString(buf, sizeof(buf), conf->mp3encode));
iniparser_setstring(dict, "Music:lyricencode",
encodeToString(buf, sizeof(buf), conf->lyricencode));
iniparser_setstring(dict, "Music:mp3cycle",
cycleToString(buf, sizeof(buf), conf->mp3cycle));
iniparser_setstring(dict, "Global:isreading",
booleanToString(buf, sizeof(buf), conf->isreading));
iniparser_setstring(dict, "UI:bgarch", conf->bgarch);
iniparser_setstring(dict, "UI:bgfile", conf->bgfile);
iniparser_setstring(dict, "UI:bgwhere",
intToString(buf, sizeof(buf), conf->bgwhere));
iniparser_setstring(dict, "Image:slideinterval",
dwordToString(buf, sizeof(buf), conf->slideinterval));
iniparser_setstring(dict, "Music:hprmctrl",
booleanToString(buf, sizeof(buf), conf->hprmctrl));
iniparser_setstring(dict, "UI:grayscale",
intToString(buf, sizeof(buf), conf->grayscale));
iniparser_setstring(dict, "Global:showhidden",
booleanToString(buf, sizeof(buf), conf->showhidden));
iniparser_setstring(dict, "Global:showunknown",
booleanToString(buf, sizeof(buf), conf->showunknown));
iniparser_setstring(dict, "Global:showfinfo",
booleanToString(buf, sizeof(buf), conf->showfinfo));
iniparser_setstring(dict, "Global:allowdelete",
booleanToString(buf, sizeof(buf), conf->allowdelete));
iniparser_setstring(dict, "Global:arrange",
arrangeToString(buf, sizeof(buf), conf->arrange));
iniparser_setstring(dict, "Global:enableusb",
booleanToString(buf, sizeof(buf), conf->enableusb));
iniparser_setstring(dict, "Image:viewpos",
viewposToString(buf, sizeof(buf), conf->viewpos));
iniparser_setstring(dict, "Image:imgmvspd",
dwordToString(buf, sizeof(buf), conf->imgmvspd));
iniparser_setstring(dict, "Image:imgpaging",
imgpagingToString(buf, sizeof(buf), conf->imgpaging));
iniparser_setstring(dict, "Image:imgpaging_spd",
dwordToString(buf, sizeof(buf), conf->imgpaging_spd));
iniparser_setstring(dict, "Image:imgpaging_interval",
dwordToString(buf, sizeof(buf),
conf->imgpaging_interval));
iniparser_setstring(dict, "Image:imgpaging_duration",
dwordToString(buf, sizeof(buf),
conf->imgpaging_duration));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Global:flkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->flkey[i]));
}
iniparser_setstring(dict, "UI:fontsize",
intToString(buf, sizeof(buf), conf->fontsize));
iniparser_setstring(dict, "Text:reordertxt",
booleanToString(buf, sizeof(buf), conf->reordertxt));
iniparser_setstring(dict, "Text:pagetonext",
booleanToString(buf, sizeof(buf), conf->pagetonext));
iniparser_setstring(dict, "Text:autopage",
intToString(buf, sizeof(buf), conf->autopage));
iniparser_setstring(dict, "Text:prev_autopage",
intToString(buf, sizeof(buf), conf->prev_autopage));
iniparser_setstring(dict, "Text:autopagetype",
intToString(buf, sizeof(buf), conf->autopagetype));
iniparser_setstring(dict, "Text:autolinedelay",
intToString(buf, sizeof(buf), conf->autolinedelay));
iniparser_setstring(dict, "Image:thumb",
thumbToString(buf, sizeof(buf), conf->thumb));
iniparser_setstring(dict, "Text:bookfontsize",
intToString(buf, sizeof(buf), conf->bookfontsize));
iniparser_setstring(dict, "Text:enable_analog",
booleanToString(buf, sizeof(buf), conf->enable_analog));
iniparser_setstring(dict, "Image:img_enable_analog",
booleanToString(buf, sizeof(buf),
conf->img_enable_analog));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->txtkey2[i]));
SPRINTF_S(key, "Image:imgkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->imgkey2[i]));
SPRINTF_S(key, "Global:flkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->flkey2[i]));
}
iniparser_setstring(dict, "Image:imgpagereserve",
dwordToString(buf, sizeof(buf), conf->imgpagereserve));
iniparser_setstring(dict, "Music:lyricex",
dwordToString(buf, sizeof(buf), conf->lyricex));
iniparser_setstring(dict, "Music:autoplay",
booleanToString(buf, sizeof(buf), conf->autoplay));
iniparser_setstring(dict, "Text:usettf",
booleanToString(buf, sizeof(buf), conf->usettf));
iniparser_setstring(dict, "Text:cttfarch", conf->cttfarch);
iniparser_setstring(dict, "Text:cttfpath", conf->cttfpath);
iniparser_setstring(dict, "Text:ettfarch", conf->ettfarch);
iniparser_setstring(dict, "Text:ettfpath", conf->ettfpath);
for (i = 0; i < 3; ++i) {
char key[20];
SPRINTF_S(key, "Global:freqs_%d", i);
iniparser_setstring(dict, key,
intToString(buf, sizeof(buf), conf->freqs[i]));
}
iniparser_setstring(dict, "Image:imgbrightness",
intToString(buf, sizeof(buf), conf->imgbrightness));
iniparser_setstring(dict, "Global:dis_scrsave",
booleanToString(buf, sizeof(buf), conf->dis_scrsave));
iniparser_setstring(dict, "Global:autosleep",
intToString(buf, sizeof(buf), conf->autosleep));
iniparser_setstring(dict, "Image:load_exif",
booleanToString(buf, sizeof(buf), conf->load_exif));
iniparser_setstring(dict, "Global:launchtype",
intToString(buf, sizeof(buf), conf->launchtype));
iniparser_setstring(dict, "Text:infobar_use_ttf_mode",
booleanToString(buf, sizeof(buf),
conf->infobar_use_ttf_mode));
iniparser_setstring(dict, "Text:infobar_fontsize",
dwordToString(buf, sizeof(buf),
conf->infobar_fontsize));
iniparser_setstring(dict, "Image:no_repeat",
booleanToString(buf, sizeof(buf), conf->img_no_repeat));
iniparser_setstring(dict, "Global:hide_flash",
booleanToString(buf, sizeof(buf), conf->hide_flash));
iniparser_setstring(dict, "Text:tabstop",
dwordToString(buf, sizeof(buf), conf->tabstop));
iniparser_setstring(dict, "Music:apetagorder",
booleanToString(buf, sizeof(buf), conf->apetagorder));
iniparser_setstring(dict, "UI:language", conf->language);
iniparser_setstring(dict, "UI:filelistwidth",
intToString(buf, sizeof(buf), conf->filelistwidth));
iniparser_setstring(dict, "Text:ttf_load_to_memory",
booleanToString(buf, sizeof(buf),
conf->ttf_load_to_memory));
iniparser_setstring(dict, "Global:save_password",
booleanToString(buf, sizeof(buf), conf->save_password));
iniparser_setstring(dict, "Text:scrollbar_width",
intToString(buf, sizeof(buf), conf->scrollbar_width));
iniparser_setstring(dict, "Text:hide_last_row",
booleanToString(buf, sizeof(buf), conf->hide_last_row));
iniparser_setstring(dict, "Text:infobar_show_timer",
booleanToString(buf, sizeof(buf),
conf->infobar_show_timer));
iniparser_setstring(dict, "Text:englishtruncate",
booleanToString(buf, sizeof(buf),
conf->englishtruncate));
iniparser_setstring(dict, "Image:image_scroll_chgn_speed",
booleanToString(buf, sizeof(buf),
conf->image_scroll_chgn_speed));
iniparser_setstring(dict, "Text:ttf_haste_up",
booleanToString(buf, sizeof(buf), conf->ttf_haste_up));
iniparser_setstring(dict, "Text:linenum_style",
booleanToString(buf, sizeof(buf), conf->linenum_style));
iniparser_setstring(dict, "Text:infobar_align",
alignToString(buf, sizeof(buf), conf->infobar_align));
iniparser_setstring(dict, "Music:musicdrv_opts", conf->musicdrv_opts);
iniparser_setstring(dict, "Image:magnetic_scrolling",
booleanToString(buf, sizeof(buf),
conf->magnetic_scrolling));
iniparser_setstring(dict, "Image:use_image_queue",
booleanToString(buf, sizeof(buf),
conf->use_image_queue));
iniparser_setstring(dict, "Image:max_cache_img",
dwordToString(buf, sizeof(buf), conf->max_cache_img));
iniparser_setstring(dict, "Music:show_encoder_msg",
booleanToString(buf, sizeof(buf),
conf->show_encoder_msg));
iniparser_dump_ini(dict, fp);
fclose(fp);
dictionary_del(dict);
return true;
error:
if (fp != NULL)
fclose(fp);
return false;
}
/*--------------------------------------------------------------------------*/
void iniparser_freedict(dictionary * d)
{
dictionary_del(d);
}
/*--------------------------------------------------------------------------*/
dictionary * iniparser_load(const char * ininame)
{
FILE * in = NULL ;
char line [ASCIILINESZ+1] ;
char *section = xstrdup("");
char *current_section = NULL;
char *key = NULL;
char *val = NULL;
char* full_line = NULL;
char* prev_line = NULL;
int len ;
int lineno=0 ;
int errs=0;
int seckey_size=0;
dictionary * dict = NULL ;
if ((in=fopen(ininame, "r"))==NULL) {
fprintf(stderr, "iniparser: cannot open %s\n", ininame);
goto out;
}
dict = dictionary_new(0) ;
if (!dict) {
goto out;
}
memset(line, 0, ASCIILINESZ);
while (fgets(line, ASCIILINESZ, in)!=NULL) {
int prev_line_len = 0;
int multi_line = 0;
int total_size = 0;
if (key) {
free(key);
key = NULL;
}
if (val) {
free(val);
val = NULL;
}
lineno++ ;
len = (int)strlen(line)-1;
if (len==0)
continue;
/* Safety check against buffer overflows */
if (line[len]!='\n' && !feof(in)) {
fprintf(stderr,
"iniparser: input line too long in %s (%d)\n",
ininame,
lineno);
errs++;
goto out;
}
/* Get rid of \n and spaces at end of line */
while ((len>=0) &&
((line[len]=='\n') || (isspace(line[len])))) {
line[len]=0 ;
len-- ;
}
if (len < 0) { /* Line was entirely \n and/or spaces */
len = 0;
}
/* Detect multi-line */
if (line[len]=='\\') {
multi_line = 1;
}
if (multi_line) {
/* Multi-line value */
/* length without trailing '\' */
/* remove multi-line indicator before appending*/
line[len] = 0;
len--;
}
/*
* If processing a multi-line then append it the previous portion,
* at this point 'full_line' has the previously read portion of a
* multi-line line (or NULL)
*/
prev_line = full_line;
prev_line_len=0;
if (prev_line) {
prev_line_len = (int)strlen(prev_line);
}
/* len is not strlen(line) but strlen(line) -1 */
total_size = (len+1) + prev_line_len + 1;
full_line = malloc(total_size);
if (!full_line) {
fprintf(stderr,
"iniparser: out of mem\n");
errs++;
goto out;
}
memset(full_line, 0, total_size);
if (prev_line) {
strcpy(full_line, prev_line);
}
strcpy(full_line + prev_line_len, line);
free(prev_line);
prev_line = NULL;
if (multi_line) {
continue ;
}
switch (iniparser_line(total_size, full_line, ¤t_section, &key, &val)) {
case LINE_EMPTY:
case LINE_COMMENT:
break ;
case LINE_SECTION:
if (section) {
free(section);
section=NULL;
}
errs = dictionary_set(dict, current_section, NULL);
section = current_section;
break ;
case LINE_VALUE:
{
char *seckey;
/* section + ':' + key + eos */
seckey_size = (int)strlen(section) + (int)strlen(key) +2;
seckey = malloc(seckey_size);
if (!seckey) {
errs++;
fprintf(stderr,
"iniparser: out of mem\n");
goto out;
}
snprintf(seckey, seckey_size, "%s:%s", section, key);
errs = dictionary_set(dict, seckey, val) ;
free(seckey);
seckey = NULL;
}
break ;
case LINE_ERROR:
fprintf(stderr, "iniparser: syntax error in %s (%d):\n",
ininame,
lineno);
fprintf(stderr, "-> %s\n", full_line);
errs++ ;
break;
default:
break ;
}
memset(line, 0, ASCIILINESZ);
if (full_line) {
free(full_line);
full_line = NULL;
}
if (errs<0) {
fprintf(stderr, "iniparser: memory allocation failure\n");
break ;
}
}
out:
if (errs) {
dictionary_del(dict);
dict = NULL ;
}
if (val) {
free(val);
val = NULL;
}
if (key) {
free(key);
key = NULL;
}
if (section) {
free(section);
section = NULL;
}
if (full_line) {
free(full_line);
full_line = NULL;
}
if (prev_line) {
free(prev_line);
prev_line = NULL;
}
if (in) {
fclose(in);
}
return dict ;
}
int validate_token(bstring token)
{
int i;
OpenSSL_add_all_algorithms();
struct bstrList *parts = bsplit(token, '|');
dictionary *dict = dictionary_new(10);
bstring sig = bfromcstr("sig");
bstring to_sign = bfromcstr("");
for (i = 0; i < parts->qty; i++)
{
printf("%d: %s\n", i, parts->entry[i]->data);
struct bstrList *x = bsplit(parts->entry[i], '=');
if (x->qty == 2)
{
if (bstrcmp(x->entry[0], sig) != 0)
{
if (blength(to_sign) > 0)
bconchar(to_sign, '|');
bconcat(to_sign, parts->entry[i]);
}
dictionary_set(dict, bdata(x->entry[0]), bdata(x->entry[1]));
}
bstrListDestroy(x);
}
bstrListDestroy(parts);
parts = 0;
bdestroy(sig);
dictionary_dump(dict, stdout);
printf("to sign: '%s'\n", bdata(to_sign));
// Check signing subject (need to know the valid values)
char *subj = dictionary_get(dict, "SigningSubject", 0);
if (!subj)
{
fprintf(stderr, "could not get signing subject\n");
return 0;
}
char *sigstr = dictionary_get(dict, "sig", 0);
printf("sig to verify is %s\n", sigstr);
bstring binsig = bfromcstralloc(strlen(sigstr) / 2, "");
char *s, *e;
for (s = sigstr, e = sigstr + strlen(sigstr); s < e; s += 2)
{
char n[3];
n[0] = s[0];
n[1] = s[1];
n[2] = 0;
long int v = strtol(n, 0, 16);
// printf("n=%s v=%ld %lx\n", n, v, v);
bconchar(binsig, (char) v);
}
unsigned char *sha = SHA1((const unsigned char *) to_sign->data, to_sign->slen, 0);
bdestroy(to_sign);
bstring bsubj = bfromcstr(subj);
bstring pubkey = get_signer_pubkey(bsubj);
BIO *bio = BIO_new(BIO_s_mem());
BIO_puts(bio, bdata(pubkey));
RSA *rsa = PEM_read_bio_RSAPublicKey(bio, 0, 0, 0);
int rc = RSA_verify(NID_sha1, sha, SHA_DIGEST_LENGTH, binsig->data, binsig->slen, rsa);
printf("rc=%d\n", rc);
bdestroy(bsubj);
bdestroy(binsig);
bdestroy(pubkey);
BIO_free(bio);
RSA_free(rsa);
dictionary_del(dict);
EVP_cleanup();
return rc;
}
extern bool ini_conf_load(const char *inifilename, p_conf conf)
{
dictionary *dict;
char buf[80];
int i;
extern void get_language(void);
if (conf == NULL || inifilename == NULL) {
return false;
}
dict = iniparser_load(inifilename);
if (dict == NULL)
return false;
conf_default(conf);
STRCPY_S(conf->path, iniparser_getstring(dict, "Global:path", conf->path));
conf->forecolor =
iniparser_getunsigned(dict, "UI:forecolor", conf->forecolor);
conf->giftranscolor =
iniparser_getunsigned(dict, "Image:giftranscolor", conf->giftranscolor);
conf->bgcolor = iniparser_getunsigned(dict, "UI:bgcolor", conf->bgcolor);
conf->have_bg = iniparser_getboolean(dict, "UI:have_bg", conf->have_bg);
conf->titlecolor =
iniparser_getunsigned(dict, "UI:titlecolor", conf->titlecolor);
conf->menutextcolor =
iniparser_getunsigned(dict, "UI:menutextcolor", conf->menutextcolor);
conf->menubcolor =
iniparser_getunsigned(dict, "UI:menubcolor", conf->menubcolor);
conf->selicolor =
iniparser_getunsigned(dict, "UI:selicolor", conf->selicolor);
conf->selbcolor =
iniparser_getunsigned(dict, "UI:selbcolor", conf->selbcolor);
conf->msgbcolor =
iniparser_getunsigned(dict, "UI:msgbcolor", conf->msgbcolor);
conf->usedyncolor =
iniparser_getboolean(dict, "UI:usedyncolor", conf->usedyncolor);
conf->rowspace = iniparser_getint(dict, "Text:rowspace", conf->rowspace);
conf->infobar =
stringToInfobar(iniparser_getstring
(dict, "Text:infobar",
infobarToString(buf, sizeof(buf), conf->infobar)));
conf->infobar_style =
iniparser_getint(dict, "Text:infobar_style", conf->infobar_style);
conf->infobar_fontsize =
iniparser_getunsigned(dict, "Text:infobar_fontsize",
conf->infobar_fontsize);
conf->rlastrow =
iniparser_getboolean(dict, "Text:rlastrow", conf->rlastrow);
conf->autobm = iniparser_getboolean(dict, "Text:autobm", conf->autobm);
conf->vertread =
stringToVertread(iniparser_getstring
(dict, "Text:vertread",
vertreadToString(buf, sizeof(buf), conf->vertread)));
conf->encode =
stringToEncode(iniparser_getstring
(dict, "Text:encode",
encodeToString(buf, sizeof(buf), conf->encode)));
conf->fit =
stringToFit(iniparser_getstring
(dict, "Image:fit",
fitToString(buf, sizeof(buf), conf->fit)));
conf->imginfobar =
iniparser_getboolean(dict, "Image:imginfobar", conf->imginfobar);
conf->scrollbar =
iniparser_getboolean(dict, "Text:scrollbar", conf->scrollbar);
conf->scale = iniparser_getint(dict, "Image:scale", conf->scale);
conf->rotate =
stringToRotate(iniparser_getstring
(dict, "Image:rotate",
rotateToString(buf, sizeof(buf), conf->rotate)));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey1_%02d", i);
conf->txtkey[i] = iniparser_getint(dict, key, conf->txtkey[i]);
SPRINTF_S(key, "Image:imgkey1_%02d", i);
conf->imgkey[i] = iniparser_getint(dict, key, conf->imgkey[i]);
}
check_empty_imgkey(conf);
STRCPY_S(conf->shortpath,
iniparser_getstring(dict, "Global:shortpath", conf->shortpath));
conf->confver = iniparser_getint(dict, "Global:confver", conf->confver);
conf->bicubic = iniparser_getboolean(dict, "Image:bicubic", conf->bicubic);
conf->wordspace = iniparser_getint(dict, "Text:wordspace", conf->wordspace);
conf->borderspace =
iniparser_getunsigned(dict, "Text:borderspace", conf->borderspace);
STRCPY_S(conf->lastfile,
iniparser_getstring(dict, "Global:lastfile", conf->lastfile));
conf->mp3encode =
stringToEncode(iniparser_getstring
(dict, "Music:mp3encode",
encodeToString(buf, sizeof(buf), conf->mp3encode)));
conf->lyricencode =
stringToEncode(iniparser_getstring
(dict, "Music:lyricencode",
encodeToString(buf, sizeof(buf), conf->lyricencode)));
conf->mp3cycle =
stringToCycle(iniparser_getstring
(dict, "Music:mp3cycle",
cycleToString(buf, sizeof(buf), conf->mp3cycle)));
conf->isreading =
iniparser_getboolean(dict, "Global:isreading", conf->isreading);
STRCPY_S(conf->bgarch,
iniparser_getstring(dict, "UI:bgarch", conf->bgarch));
STRCPY_S(conf->bgfile,
iniparser_getstring(dict, "UI:bgfile", conf->bgfile));
conf->bgwhere = iniparser_getint(dict, "UI:bgwhere", conf->bgwhere);
conf->slideinterval =
iniparser_getint(dict, "Image:slideinterval", conf->slideinterval);
conf->hprmctrl =
iniparser_getboolean(dict, "Music:hprmctrl", conf->hprmctrl);
conf->grayscale = iniparser_getint(dict, "UI:grayscale", conf->grayscale);
conf->showhidden =
iniparser_getboolean(dict, "Global:showhidden", conf->showhidden);
conf->showunknown =
iniparser_getboolean(dict, "Global:showunknown", conf->showunknown);
conf->showfinfo =
iniparser_getboolean(dict, "Global:showfinfo", conf->showfinfo);
conf->allowdelete =
iniparser_getboolean(dict, "Global:allowdelete", conf->allowdelete);
conf->arrange =
stringToArrange(iniparser_getstring
(dict, "Global:arrange",
arrangeToString(buf, sizeof(buf), conf->arrange)));
conf->enableusb =
iniparser_getboolean(dict, "Global:enableusb", conf->enableusb);
conf->viewpos =
stringToViewpos(iniparser_getstring
(dict, "Image:viewpos",
viewposToString(buf, sizeof(buf), conf->viewpos)));
conf->imgmvspd = iniparser_getint(dict, "Image:imgmvspd", conf->imgmvspd);
conf->imgpaging =
stringToImgpaging(iniparser_getstring
(dict, "Image:imgpaging",
imgpagingToString(buf, sizeof(buf),
conf->imgpaging)));
conf->imgpaging_spd =
iniparser_getint(dict, "Image:imgpaging_spd", conf->imgpaging_spd);
conf->imgpaging_interval =
iniparser_getint(dict, "Image:imgpaging_interval",
conf->imgpaging_interval);
conf->imgpaging_duration =
iniparser_getint(dict, "Image:imgpaging_duration",
conf->imgpaging_duration);
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Global:flkey1_%02d", i);
conf->flkey[i] = iniparser_getint(dict, key, conf->flkey[i]);
}
conf->fontsize = iniparser_getint(dict, "UI:fontsize", conf->fontsize);
conf->reordertxt =
iniparser_getboolean(dict, "Text:reordertxt", conf->reordertxt);
conf->pagetonext =
iniparser_getboolean(dict, "Text:pagetonext", conf->pagetonext);
conf->autopage = iniparser_getint(dict, "Text:autopage", conf->autopage);
conf->prev_autopage =
iniparser_getint(dict, "Text:prev_autopage", conf->prev_autopage);
conf->autopagetype =
iniparser_getint(dict, "Text:autopagetype", conf->autopagetype);
conf->autolinedelay =
iniparser_getint(dict, "Text:autolinedelay", conf->autolinedelay);
conf->thumb =
stringToThumb(iniparser_getstring
(dict, "Image:thumb",
thumbToString(buf, sizeof(buf), conf->thumb)));
conf->bookfontsize =
iniparser_getint(dict, "Text:bookfontsize", conf->bookfontsize);
conf->enable_analog =
iniparser_getboolean(dict, "Text:enable_analog", conf->enable_analog);
conf->img_enable_analog =
iniparser_getboolean(dict, "Image:img_enable_analog",
conf->img_enable_analog);
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey2_%02d", i);
conf->txtkey2[i] = iniparser_getint(dict, key, conf->txtkey2[i]);
SPRINTF_S(key, "Image:imgkey2_%02d", i);
conf->imgkey2[i] = iniparser_getint(dict, key, conf->imgkey2[i]);
SPRINTF_S(key, "Global:flkey2_%02d", i);
conf->flkey2[i] = iniparser_getint(dict, key, conf->flkey2[i]);
}
conf->imgpagereserve =
iniparser_getint(dict, "Image:imgpagereserve", conf->imgpagereserve);
conf->lyricex = iniparser_getint(dict, "Music:lyricex", conf->lyricex);
conf->autoplay =
iniparser_getboolean(dict, "Music:autoplay", conf->autoplay);
conf->usettf = iniparser_getboolean(dict, "Text:usettf", conf->usettf);
STRCPY_S(conf->cttfarch,
iniparser_getstring(dict, "Text:cttfarch", conf->cttfarch));
STRCPY_S(conf->cttfpath,
iniparser_getstring(dict, "Text:cttfpath", conf->cttfpath));
STRCPY_S(conf->ettfarch,
iniparser_getstring(dict, "Text:ettfarch", conf->ettfarch));
STRCPY_S(conf->ettfpath,
iniparser_getstring(dict, "Text:ettfpath", conf->ettfpath));
for (i = 0; i < 3; ++i) {
char key[20];
SPRINTF_S(key, "Global:freqs_%d", i);
conf->freqs[i] = iniparser_getint(dict, key, conf->freqs[i]);
}
conf->imgbrightness =
iniparser_getint(dict, "Image:imgbrightness", conf->imgbrightness);
conf->dis_scrsave =
iniparser_getboolean(dict, "Global:dis_scrsave", conf->dis_scrsave);
conf->autosleep =
iniparser_getint(dict, "Global:autosleep", conf->autosleep);
conf->load_exif =
iniparser_getboolean(dict, "Image:load_exif", conf->load_exif);
conf->launchtype =
iniparser_getint(dict, "Global:launchtype", conf->launchtype);
conf->infobar_use_ttf_mode =
iniparser_getboolean(dict, "Text:infobar_use_ttf_mode",
conf->infobar_use_ttf_mode);
conf->img_no_repeat =
iniparser_getboolean(dict, "Image:no_repeat", conf->img_no_repeat);
conf->hide_flash =
iniparser_getboolean(dict, "Global:hide_flash", conf->hide_flash);
conf->tabstop = iniparser_getunsigned(dict, "Text:tabstop", conf->tabstop);
conf->apetagorder =
iniparser_getboolean(dict, "Music:apetagorder", conf->apetagorder);
STRCPY_S(conf->language,
iniparser_getstring(dict, "UI:language", conf->language));
get_language();
conf->filelistwidth =
iniparser_getint(dict, "UI:filelistwidth", conf->filelistwidth);
if (conf->filelistwidth < 0 || conf->filelistwidth > 240)
conf->filelistwidth = 160;
conf->ttf_load_to_memory =
iniparser_getboolean(dict, "Text:ttf_load_to_memory",
conf->ttf_load_to_memory);
conf->save_password =
iniparser_getboolean(dict, "Global:save_password", conf->save_password);
conf->scrollbar_width =
iniparser_getint(dict, "Text:scrollbar_width", conf->scrollbar_width);
conf->hide_last_row =
iniparser_getboolean(dict, "Text:hide_last_row", conf->hide_last_row);
conf->infobar_show_timer =
iniparser_getboolean(dict, "Text:infobar_show_timer",
conf->infobar_show_timer);
conf->englishtruncate =
iniparser_getboolean(dict, "Text:englishtruncate",
conf->englishtruncate);
conf->image_scroll_chgn_speed =
iniparser_getboolean(dict, "Image:image_scroll_chgn_speed",
conf->image_scroll_chgn_speed);
conf->ttf_haste_up =
iniparser_getboolean(dict, "Text:ttf_haste_up", conf->ttf_haste_up);
conf->linenum_style =
iniparser_getboolean(dict, "Text:linenum_style", conf->linenum_style);
conf->infobar_align =
stringToAlign(iniparser_getstring(dict, "Text:infobar_align", ""));
STRCPY_S(conf->musicdrv_opts,
iniparser_getstring(dict, "Music:musicdrv_opts",
conf->musicdrv_opts));
conf->magnetic_scrolling =
iniparser_getboolean(dict, "Image:magnetic_scrolling",
conf->magnetic_scrolling);
conf->use_image_queue =
iniparser_getboolean(dict, "Image:use_image_queue",
conf->use_image_queue);
conf->max_cache_img =
iniparser_getunsigned(dict, "Image:max_cache_img", conf->max_cache_img);
conf->show_encoder_msg =
iniparser_getboolean(dict, "Music:show_encoder_msg",
conf->show_encoder_msg);
if (conf->max_cache_img == 0) {
conf->use_image_queue = false;
}
dictionary_del(dict);
return true;
}
/*--------------------------------------------------------------------------*/
dictionary * iniparser_load(const char * ininame)
{
FILE *in, *include = NULL, *inifile;
char line [ASCIILINESZ+1] ;
char section [ASCIILINESZ+1] ;
char key [ASCIILINESZ+1] ;
char tmp [ASCIILINESZ+1] ;
char val [ASCIILINESZ+1] ;
int last=0 ;
int len ;
int lineno=0 ;
int errs=0;
dictionary * dict ;
if ((inifile=fopen(ininame, "r"))==NULL) {
LOG(log_error, logtype_default, "iniparser: cannot open \"%s\"", ininame);
return NULL ;
}
dict = dictionary_new(0) ;
if (!dict) {
fclose(inifile);
return NULL ;
}
memset(line, 0, ASCIILINESZ);
memset(section, 0, ASCIILINESZ);
memset(key, 0, ASCIILINESZ);
memset(val, 0, ASCIILINESZ);
last=0 ;
in = inifile;
while (1) {
if (fgets(line+last, ASCIILINESZ-last, in) == NULL) {
if (include) {
fclose(include);
include = NULL;
in = inifile;
continue;
}
break;
}
lineno++ ;
len = (int)strlen(line)-1;
if (len==0)
continue;
/* Safety check against buffer overflows */
if (line[len]!='\n') {
LOG(log_error, logtype_default, "iniparser: input line too long in \"%s\" (lineno: %d)",
ininame, lineno);
dictionary_del(dict);
fclose(in);
return NULL ;
}
/* Get rid of \n and spaces at end of line */
while ((len>=0) &&
((line[len]=='\n') || (isspace(line[len])))) {
line[len]=0 ;
len-- ;
}
/* Detect multi-line */
if (line[len]=='\\') {
/* Multi-line value */
last=len ;
continue ;
} else {
last=0 ;
}
switch (iniparser_line(line, section, key, val)) {
case LINE_EMPTY:
case LINE_COMMENT:
break ;
case LINE_SECTION:
if (strchr(section, ':') != NULL)
LOG(log_error, logtype_default, "iniparser: syntax error \"%s\" section name must not contain \":\".", section);
errs = dictionary_set(dict, section, NULL, NULL);
break ;
case LINE_VALUE:
if (strcmp(key, "include") == 0) {
if ((include = fopen(val, "r")) == NULL) {
LOG(log_error, logtype_default, "iniparser: cannot open \"%s\"", val);
continue;
}
in = include;
continue;
}
errs = dictionary_set(dict, section, key, val) ;
break ;
case LINE_ERROR:
LOG(log_error, logtype_default, "iniparser: syntax error in %s (lineno: %d): %s",
ininame, lineno, line);
errs++ ;
break;
default:
break ;
}
memset(line, 0, ASCIILINESZ);
last=0;
if (errs<0) {
LOG(log_error, logtype_default, "iniparser: memory allocation failure");
break ;
}
}
if (errs) {
dictionary_del(dict);
dict = NULL ;
}
fclose(in);
return dict ;
}