std::string iniparser_getstring(dictionary * d, std::string key, std::string def){
printf("ini Requesting key=%s\n", key.c_str());
char* value = iniparser_getstring(d, key.c_str(), NULL);
printf("ini %s=%s\n", key.c_str(), value);
if(value == NULL){
return def;
}
return std::string(value);
}
void JalousieEinstellungen::updateJalEinstellungen()
{
dictionary *hsconf;
QByteArray hsconfByteArray = hsconfFile->fileName().toLatin1();
hsconf = iniparser_load(hsconfByteArray.data());
ui->spinBox_Auf_Offset->setValue(0);
ui->spinBox_Zu_Offset->setValue(0);
ui->timeEdit_Auf->setTime(QTime::fromString("00:00"));
ui->timeEdit_Zu->setTime(QTime::fromString("00:00"));
for(int i = 0; i < 8; i++)
{
if(confWidgetsJal[i].isBool)
{
QAbstractButton *foo = (QAbstractButton*)confWidgetsJal[i].object;
confWidgetsJal[i].boolValue = iniparser_getboolean(hsconf, QString(confWidgetsJal[i].section + ":" + confWidgetsJal[i].key).toLatin1(), false);
foo->setChecked(confWidgetsJal[i].boolValue);
}else if(confWidgetsJal[i].isTime)
{
QSpinBox *spinBox_Offset = confWidgetsJal[i].object->findChild<QSpinBox *>();
QTimeEdit *timeEdit_Uhrzeit = confWidgetsJal[i].object->findChild<QTimeEdit *>();
QList<QRadioButton *> listRadioButton = confWidgetsJal[i].object->findChildren<QRadioButton *>();
confWidgetsJal[i].strValue = QString(iniparser_getstring(hsconf, QString(confWidgetsJal[i].section + ":" + confWidgetsJal[i].key).toLatin1(), NULL));
if(confWidgetsJal[i].strValue.contains(":")) //Uhrzeit
{
timeEdit_Uhrzeit->setTime(QTime::fromString(confWidgetsJal[i].strValue, "h:m"));
for(int k = 0; k < 3; k++)
{
listRadioButton[k]->setChecked(listRadioButton[k]->objectName().contains("Uhrzeit"));
}
}
else
{
if(confWidgetsJal[i].strValue.contains("SA"))
{
for(int k = 0; k < 3; k++)
{
listRadioButton[k]->setChecked(listRadioButton[k]->objectName().contains("SA"));
}
}
else if(confWidgetsJal[i].strValue.contains("SU"))
{
for(int k = 0; k < 3; k++)
{
listRadioButton[k]->setChecked(listRadioButton[k]->objectName().contains("SU"));
}
}
spinBox_Offset->setValue(confWidgetsJal[i].strValue.right(confWidgetsJal[i].strValue.size() - 2).toInt());
}
}
}
iniparser_freedict(hsconf);
validData(true);
}
static inline int alloc_cmd(const char *cmd, dictionary *dict, char **to_be_malloc)
{
char *def = "";
int len = strlen(iniparser_getstring(dict, cmd, def));
*to_be_malloc = (char*)malloc(sizeof(char*) * len + 1);
if (*to_be_malloc == NULL)
{
return -1;
}
memset(*to_be_malloc,'\0',len);
return 0;
}
void finiparser_getDbl(double* out,char *key,int *ifnd,int key_len)
{
const char* str;
*ifnd = 0;
str = iniparser_getstring(dic,addchar0(key,key_len),NULL);
if (str != NULL) {
*out = atof(str);
*ifnd = 1;
}
return;
}
uint32_t ReadPrefHex(const char* pref_key, int default_value)
{
std::stringstream ss;
std::string default_string;
ss.setf(std::ios::hex|std::ios::showbase, std::ios::basefield);
ss << default_value;
ss >> default_string;
LoadConfigFile();
std::string pref = "preferences:";
pref.append(pref_key);
return fromHex(iniparser_getstring(preferences, pref.c_str(), default_string.c_str()));
}
NTSTATUS parse_gpt_ini(TALLOC_CTX *mem_ctx,
const char *filename,
uint32_t *version,
char **display_name)
{
NTSTATUS result;
uint32_t v = 0;
char *name = NULL;
dictionary *dict = NULL;
if (!filename) {
return NT_STATUS_INVALID_PARAMETER;
}
dict = iniparser_load(filename);
if (!dict) {
return NT_STATUS_NO_SUCH_FILE;
}
if ((name = iniparser_getstring(dict, GPT_INI_SECTION_GENERAL
":"GPT_INI_PARAMETER_DISPLAYNAME, NULL)) == NULL) {
/* the default domain policy and the default domain controller
* policy never have a displayname in their gpt.ini file */
DEBUG(10,("parse_gpt_ini: no name in %s\n", filename));
}
if (name && display_name) {
*display_name = talloc_strdup(mem_ctx, name);
if (*display_name == NULL) {
result = NT_STATUS_NO_MEMORY;
goto out;
}
}
if ((v = iniparser_getint(dict, GPT_INI_SECTION_GENERAL
":"GPT_INI_PARAMETER_VERSION, Undefined)) == Undefined) {
DEBUG(10,("parse_gpt_ini: no version\n"));
result = NT_STATUS_INTERNAL_DB_CORRUPTION;
goto out;
}
if (version) {
*version = v;
}
result = NT_STATUS_OK;
out:
if (dict) {
iniparser_freedict(dict);
}
return result;
}
void set_config( void *self, dictionary *config )
{
debug("reading configuration file options");
if (config) {
cim_namespace = iniparser_getstr (config, "cim:default_cim_namespace");
char *namespaces = iniparser_getstr (config, "cim:vendor_namespaces");
cim_host = iniparser_getstring(config, "cim:host", "localhost");
cim_client_frontend = iniparser_getstring(config, "cim:cim_client_frontend", "XML");
cim_port = iniparser_getstring(config, "cim:port", DEFAULT_HTTP_CIMOM_PORT);
server_port = iniparser_getstring(config, "server:port", server_port);
cim_ssl = iniparser_getboolean(config, "cim:ssl", 0);
cim_trust_store = iniparser_getstring(config, "cim:trust_store", "/etc/ssl/certs");
cim_verify = iniparser_getboolean(config, "cim:verify_cert", 0);
omit_schema_optional = iniparser_getboolean(config, "cim:omit_schema_optional", 0);
indication_profile_implementation_ns = iniparser_getstring(config, "cim:indication_profile_implementation_ns", "root/interop");
debug("vendor namespaces: %s", namespaces);
if (namespaces) {
hash_t * t = u_parse_query(namespaces);
if (t) {
vendor_namespaces = t;
}
else
vendor_namespaces = NULL;
}
debug("cim namespace: %s", cim_namespace);
}
return;
}
void Test_dictionary_wrapper(CuTest *tc)
{
dictionary *dic;
dic = dictionary_new(10);
CuAssertIntEquals(tc, -1, iniparser_set(dic, NULL, NULL));
CuAssertIntEquals(tc, -1, iniparser_set(NULL, "section", "value"));
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section", NULL));
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", "value"));
CuAssertStrEquals(tc, "value", iniparser_getstring(dic, "section:key", NULL));
/* reset the key's value*/
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", NULL));
CuAssertStrEquals(tc, NULL, iniparser_getstring(dic, "section:key", "dummy"));
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", "value"));
CuAssertStrEquals(tc, "value", iniparser_getstring(dic, "section:key", NULL));
iniparser_unset(dic, "section:key");
CuAssertStrEquals(tc, "dummy", iniparser_getstring(dic, "section:key", "dummy"));
CuAssertStrEquals(tc, NULL, iniparser_getstring(dic, "section", "dummy"));
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key", NULL));
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key1", NULL));
CuAssertIntEquals(tc, 0, iniparser_set(dic, "section:key2", NULL));
iniparser_unset(dic, "section");
CuAssertStrEquals(tc, NULL, iniparser_getstring(dic, "section", NULL));
iniparser_freedict(dic);
}
int cfg_init()
{
dict = iniparser_load(CONFIG_FILE);
config.memsize = iniparser_getint(dict, "mem:memsize", config.memsize);
config.entry_offset = iniparser_getint(dict, "mem:entry_offset", config.entry_offset);
config.sbase_offset = iniparser_getint(dict, "mem:sbase_offset", config.sbase_offset);
config.endianess = iniparser_getint(dict, "misc:endianess", config.endianess);
config.display_refresh_interval = iniparser_getint(dict, "misc:display_refresh_interval", config.display_refresh_interval);
config.timer_interval = iniparser_getint(dict, "misc:timer_interval", config.timer_interval);
config.log_filename = strdup(iniparser_getstring(dict, "misc:log_file", config.log_filename));
config.hdd_size = iniparser_getint(dict, "hdd:hdd_size", config.hdd_size);
config.hdd_filecnt = iniparser_getint(dict, "hdd:hdd_filecnt", config.hdd_filecnt);
config.hdd_filelist = malloc(config.hdd_filecnt * sizeof(hddfile_t));
int i;
for (i = 0; i < config.hdd_filecnt; i++)
{
char *s;
asprintf(&s, "hdd:filename_%d", i);
config.hdd_filelist[i].filename = strdup(iniparser_getstring(dict, s, NULL));
free(s);
asprintf(&s, "hdd:secstart_%d", i);
config.hdd_filelist[i].secstart = iniparser_getint(dict, s, 0);
free(s);
asprintf(&s, "hdd:secsize_%d", i);
config.hdd_filelist[i].secsize = iniparser_getint(dict, s, 0);
free(s);
}
iniparser_freedict(dict);
config.log_file = fopen(config.log_filename, "w");
assert(config.log_file);
return MEMU_SUCCESS;
}
char *faptime_config_getstring(const char *key) {
if (config == NULL) {
errno = FT_NO_CONFIG;
return NULL;
}
char default_val[] = "";
char *result = iniparser_getstring(config, key, default_val);
if (!result || result == default_val) {
return NULL;
}
return strdup(result);
}
/* All gen_* functions, except gen_iua(), return size as multiples of 8 */
int gen_iua(dictionary *ini, char **iua_data)
{
int fd, flags, size;
struct stat st;
char *binkey, *filename, *data;
struct internal_use_area *iua;
/* initialize some sane values */
fd = -1;
flags = size = 0;
data = NULL;
/* We expect this section to have a single key - "binfile", with a value
* of the absolute path to the binary file to write to in the IUA
*/
binkey = get_key(IUA, BINFILE);
filename = iniparser_getstring(ini, binkey, NULL);
if (!filename) {
fprintf(stderr, "\n%s not found!\n\n", binkey);
exit(EXIT_FAILURE);
}
/* Get size of file */
stat(filename, &st);
size = get_aligned_size((sizeof(struct internal_use_area)+st.st_size), 8);
data = (char *) malloc(size);
/* Write format version */
iua = ((struct internal_use_area *) data);
iua->format_version = 0x01;
flags = O_RDONLY;
if((fd = open(filename, flags)) == -1) {
fprintf(stderr, "\nUnable to open %s for reading!\n\n", filename);
exit(EXIT_FAILURE);
}
int result = read(fd, iua->data, st.st_size);
if (result != st.st_size) {
fprintf(stdout, "\nError reading entire file content!\n\n");
exit(EXIT_FAILURE);
}
close(fd);
*iua_data = data;
return size;
}
static void load_inifile(dictionary * d)
{
const char *reportdir = reportpath();
const char *datadir = datapath();
const char *basedir = basepath();
const char *str;
assert(d);
str = iniparser_getstring(d, "eressea:base", basedir);
if (str != basedir) {
set_basepath(str);
}
str = iniparser_getstring(d, "eressea:report", reportdir);
if (str != reportdir) {
set_reportpath(str);
}
str = iniparser_getstring(d, "eressea:data", datadir);
if (str != datadir) {
set_datapath(str);
}
lomem = iniparser_getint(d, "eressea:lomem", lomem) ? 1 : 0;
str = iniparser_getstring(d, "eressea:encoding", NULL);
if (str && (_strcmpl(str, "utf8") == 0 || _strcmpl(str, "utf-8") == 0)) {
enc_gamedata = ENCODING_UTF8;
}
verbosity = iniparser_getint(d, "eressea:verbose", 2);
battledebug = iniparser_getint(d, "eressea:debug", battledebug) ? 1 : 0;
str = iniparser_getstring(d, "eressea:locales", "de,en");
make_locales(str);
if (global.inifile) iniparser_freedict(global.inifile);
global.inifile = d;
}
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen){
static ssize_t (*sys_recvfrom)(int, void *, size_t, int, struct sockaddr *, socklen_t *) = NULL;
if (!sys_recvfrom) {
if (!(*(void **)(&sys_recvfrom) = dlsym(RTLD_NEXT,"recvfrom"))){
perror("cannot fetch system recvfrom\n");
exit(1);
}
}
if (iniparser_getstring(ini, "recvfrom:allow", NULL))
return sys_recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
printf("Forbidden use of recvfrom\n");
return -1;
}
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen) {
static ssize_t (*sys_sendto)(int, const void *, size_t, int, const struct sockaddr *, socklen_t) = NULL;
if (!sys_sendto) {
if (!(*(void **)(&sys_sendto) = dlsym(RTLD_NEXT,"sendto"))){
perror("cannot fetch system sendto\n");
exit(1);
}
}
if (iniparser_getstring(ini, "sendto:allow", NULL))
return sys_sendto(sockfd, buf, len, flags, dest_addr, addrlen);
printf("Forbidden use of sendto\n");
return -1;
}
frame_t *frame_factory_get(const char *key)
{
frame_t *frame;
char *addr_str;
// try to load frame using config from config cache
static char key_buf[MAX_TEXTURE_NAME+4+1];
static char addr_buff[16+1];
char *file;
int pf, loc;
int namelen = strlen(key);
if (frame_cache == NULL) {
printf("frame factory not inited!\n");
return NULL;
}
addr_str = dictionary_get(frame_cache, (char *)key, "0x0");
frame = (frame_t *)(strtol(addr_str, NULL, 0));
if (frame != 0) {
return frame;
}
if (strlen(key) > MAX_TEXTURE_NAME) {
oslFatalError("config key too long! %s", key);
}
strcpy(key_buf, key);
strcat(key_buf, ":f");
file = iniparser_getstring(texture_cfg, key_buf, NULL);
printf("search key %s, value %s\n", key_buf, file);
printf("texture cfg %p\n", texture_cfg);
key_buf[namelen] = '\0';
strcat(key_buf, ":pf");
pf = iniparser_getint(texture_cfg, key_buf, OSL_IN_VRAM);
key_buf[namelen] = '\0';
strcat(key_buf, ":loc");
loc = iniparser_getint(texture_cfg, key_buf, TAIKO_PF);
printf("ok so far!\n");;
frame = frame_create_simple(file, pf, loc);
if (frame != NULL) {
key_buf[namelen] = '\0';
sprintf(addr_buff, "%d", (int)frame);
dictionary_set(frame_cache, key_buf, addr_buff);
}
return frame;
}
int MSG_db1_data::get_channel_number(char *chname)
{
int ich = 0;
char *iname;
while (ich < MAXCH)
{
ich ++;
snprintf(infochuse, INFOCHLEN, "Channel%d:Name", ich);
iname = iniparser_getstring(INFO, infochuse, "Undefined");
if (! strncmp(chname, iname, CHLEN))
return ich;
}
return 0;
}
ssize_t recv(int sockfd, void *buf, size_t len, int flags){
static ssize_t (*sys_recv)(int, void *, size_t, int) = NULL;
if (!sys_recv) {
if (!(*(void **)(&sys_recv) = dlsym(RTLD_NEXT,"recv"))){
perror("cannot fetch system recv\n");
exit(1);
}
}
if (iniparser_getstring(ini, "recv:allow", NULL))
return sys_recv(sockfd, buf, len, flags);
printf("Forbidden use of recv\n");
return -1;
}
ssize_t send(int sockfd, const void *buf, size_t len, int flags){
static ssize_t (*sys_send)(int, const void *, size_t, int) = NULL;
if (!sys_send) {
if (!(*(void **)(&sys_send) = dlsym(RTLD_NEXT,"send"))){
perror("cannot fetch system send\n");
exit(1);
}
}
if (iniparser_getstring(ini, "send:allow", NULL))
return sys_send(sockfd, buf, len, flags);
printf("Forbidden use of send\n");
return -1;
}
static char*
getIniString (IniDictionary *dictionary,
const char *section,
const char *entry)
{
char *sectionName;
char *retValue;
asprintf (§ionName, "%s:%s", section, entry);
retValue = iniparser_getstring (dictionary, sectionName, NULL);
free (sectionName);
return retValue;
}
configuration_t read_config(const char *filename) {
configuration_t result;
clean_config(&result);
dictionary *ini = iniparser_load(filename);
char *touch_device_path = iniparser_getstring(ini, "general:touchdevice", NULL);
if (touch_device_path) {
if (result.touch_device_path = malloc(strlen(touch_device_path) + 1)) {
strcpy(result.touch_device_path, touch_device_path);
}
} else {
errno = EINVAL;
die("error: no touch device defined");
}
result.scroll.vert = iniparser_getboolean(ini, "scroll:vertical", false);
result.scroll.horz = iniparser_getboolean(ini, "scroll:horizontal", false);
result.scroll.vert_delta = (int8_t) iniparser_getint(ini, "scroll:verticaldelta", 79);
result.scroll.horz_delta = (int8_t) iniparser_getint(ini, "scroll:horizontaldelta", 30);
result.scroll.invert_vert = iniparser_getboolean(ini, "scroll:invertvertical", false);
result.scroll.invert_horz = iniparser_getboolean(ini, "scroll:inverthorizontal", false);
result.vert_threshold_percentage = iniparser_getint(ini, "thresholds:vertical", 15);
result.horz_threshold_percentage = iniparser_getint(ini, "thresholds:horizontal", 15);
result.zoom.enabled = iniparser_getboolean(ini, "zoom:enabled", false);
result.zoom.delta = (uint8_t) iniparser_getint(ini, "zoom:delta", 200);
uint8_t i, j;
for (i = 0; i < MAX_FINGERS; i++) {
for (j = 0; j < DIRECTIONS_COUNT; j++) {
char ini_key[16];
sprintf(ini_key, "%d-fingers:%s", INDEX_TO_FINGER(i), directions[j]);
fill_keys_array(&result.swipe_keys[i][j].keys, iniparser_getstring(ini, ini_key, NULL));
}
}
iniparser_freedict(ini);
return result;
}
char* INIGetString(char* stringname)
{
char* fetchedValue;
fetchedValue = iniparser_getstring(ConfigINI, stringname, KEY_NOT_FOUND_STR);
if(strcmp(fetchedValue, KEY_NOT_FOUND_STR) == 0)
{
printf("Cannot find str key for %s in %s\n", stringname, DICT_NAME);
exit(EXIT_FAILURE);
}
fetchedValue = INIVariableReplace(fetchedValue);
return fetchedValue;
}
/*--------------------------------------------------------------------------*/
int iniparser_getboolean(dictionary * d, const char * key, int notfound)
{
char * c ;
int ret ;
c = iniparser_getstring(d, key, INI_INVALID_KEY);
if (c==INI_INVALID_KEY) return notfound ;
if (c[0]=='y' || c[0]=='Y' || c[0]=='1' || c[0]=='t' || c[0]=='T') {
ret = 1 ;
} else if (c[0]=='n' || c[0]=='N' || c[0]=='0' || c[0]=='f' || c[0]=='F') {
ret = 0 ;
} else {
ret = notfound ;
}
return ret;
}
void *settings_parse_ini_file(struct SiteSettings *ros_settings) {
char ini_name[80]="/root/test.ini";
char entry_name[80]="";
char entry_value[256]="";
int exists_flag;
pthread_mutex_unlock(&settings_lock);
if(Site_INI!=NULL) {
iniparser_freedict(Site_INI);
Site_INI=NULL;
}
sprintf(ini_name,"%s/site.ini",SITE_DIR);
fprintf(stderr, "parsing file: %s\n", ini_name);
Site_INI=iniparser_load(ini_name);
if (Site_INI==NULL) {
fprintf(stderr, "cannot parse file: %s\n", ini_name);
pthread_mutex_unlock(&settings_lock);
pthread_exit(NULL);
}
ros_settings->ifmode=iniparser_getboolean(Site_INI,"site_settings:ifmode",IF_ENABLED);
ros_settings->use_beam_table=iniparser_getboolean(Site_INI,"beam_lookup_table:use_table",0);
sprintf(ros_settings->beam_table_1,iniparser_getstring(Site_INI,"beam_lookup_table:beam_table_1",""));
sprintf(ros_settings->beam_table_2,iniparser_getstring(Site_INI,"beam_lookup_table:beam_table_2",""));
trigger_type=iniparser_getint(Site_INI,"site_settings:trigger_type",0);
fprintf(stdout,"Trigger_type: %d\n",trigger_type);
switch(trigger_type) {
case 0:
gpsrate=0;
gpsrate=iniparser_getint(Site_INI,"gps:trigger_rate",GPS_DEFAULT_TRIGRATE);
fprintf(stdout,"GPSrate: %d\n",gpsrate);
break;
case 1:
case 2:
gpsrate=iniparser_getint(Site_INI,"gps:trigger_rate",GPS_DEFAULT_TRIGRATE);
fprintf(stdout,"GPSrate: %d\n",gpsrate);
break;
default:
break;
}
sprintf(ros_settings->name,"%s",iniparser_getstring(Site_INI,"site_settings:name",SITE_NAME));
sprintf(entry_value,"%s",iniparser_getstring(Site_INI,"beam_lookup_table:use_table","ERROR"));
printf("beam_lookup: %s\n",entry_value);
sprintf(entry_value,"%s",iniparser_getstring(Site_INI,"beam_lookup_table:beam_table_1","ERROR"));
printf("radar_1: %s\n",entry_value);
sprintf(entry_value,"%s",iniparser_getstring(Site_INI,"beam_lookup_table:beam_table_2","ERROR"));
printf("radar_2: %s\n",entry_value);
pthread_mutex_unlock(&settings_lock);
pthread_exit(NULL);
}
char * get_cfg(char *section, char *key) {
char *value;
char *query = malloc(strlen(section) + strlen(key) + strlen(":") + 1);
if (!snprintf(query, (strlen(section) + strlen(key) + strlen(":") + 1), "%s:%s", section, key)) {
write_to_log(WARNING, "%s - %d - %s - %s:%s", __LINE__, __func__, "Unable to set config query for", section, key);
goto err;
}
if ((value = iniparser_getstring(ini, query, NULL)) == NULL) {
write_to_log(WARNING, "%s - %d - %s - %s:%s", __LINE__, __func__, "Unable to get config value for", section, key);
}
free(query);
return value;
err:
free(query);
return NULL;
}
/******************* FUNCTION *********************/
std::string CMRCmdOptions::getConfigString ( const std::string& key, const std::string& defaultValue )
{
std::string res;
if (iniDic == NULL)
{
res = defaultValue;
} else {
char * tmp = iniparser_getstring(iniDic,key.c_str(),strdup(defaultValue.c_str()));
res = tmp;
free(tmp);
}
if (dumpUsedDic)
setupDumpEntry(key,res.c_str());
return res;
}
char * iniparser_getsecstring(dictionary * d, char * sec, char * key, char * def)
{
char * ret = NULL;
char * sec_key = NULL;
if( sec != NULL )
{
sec_key = (char*) malloc(sizeof(char)*(strlen(sec)+strlen(key)+2));
sprintf(sec_key, "%s:%s\0", sec, key);
} else
{
sec_key = (char*) malloc(sizeof(char)*(strlen(key)+2));
sprintf(sec_key, ":%s\0", key);
}
ret = iniparser_getstring(d, sec_key, def);
free(sec_key);
return ret;
}
bool parse_config(const char* conf_path)
{
dictionary *ini ;
char *t = NULL ;
bool ret = true;
// Open config file.
ini = iniparser_load(conf_path);
if (ini==NULL)
{
fprintf(stderr, "Can't load config file: %s\n", conf_path);
return false;
}
t = iniparser_getstring(ini, "dnsconf:filter", REFLECTOR_BPFILTER);
if(strlen(t)){
bpfilter = strdup(t);
}
/*
t = iniparser_getstring(ini,"reflector:squid_ip",NULL);
if( NULL==t || !strlen(t) || strlen(t)>15 )
{
fprintf(stderr,"No squid_ip in configure,quit.\n");
ret = false ;
goto exit ;
}
else
{
memcpy(squid_ip,t,strlen(t));
}
t = iniparser_getstring(ini,"reflector:dns_reflector","on");
if(strcmp("on",t)) dns_reflector = false;
t = iniparser_getstring(ini,"reflector:url_reflector","on");
if(strcmp("on",t)) url_reflector = false;
debug("dns_reflector:%d,url_reflector:%d",dns_reflector,url_reflector);
*/
if(NULL != ini)
iniparser_freedict(ini);
return ret ;
}
int config_load(char *ini_file, struct config *config)
{
assert(config);
assert(ini_file);
memset(config, 0, sizeof(struct config));
dictionary *ini;
ini = iniparser_load(ini_file);
if (ini == NULL) {
DEBUG("cannot parse config file\n");
return -1;
}
config->daemon = iniparser_getint(ini, "sys:daemon", DEAMON);
config->debug_info = iniparser_getint(ini, "sys:debug_info", DEBUG_INFO);
config->debug_warning = iniparser_getint(ini, "sys:debug_warning", DEBUG_WARNING);
config->debug_trace = iniparser_getint(ini, "sys:debug_trace", DEBUG_TRACE);
config->debug_err = iniparser_getint(ini, "sys:debug_err", DEBUG_ERR);
char *remote_ip = iniparser_getstring(ini, "sys:remote_ip", NULL);
assert(remote_ip);
sprintf(config->remote_ip, "%s", remote_ip);
config->remote_port = iniparser_getint(ini, "sys:remote_port", -1);
sprintf(config->serial_path, "%s", iniparser_getstring(ini, "sys:serial", SERIAL_PATH));
sprintf(config->db_path, "%s", iniparser_getstring(ini, "sys:db", DB_PATH));
sprintf(config->log_info_path, "%s", iniparser_getstring(ini, "sys:log_info", LOG_INFO_PATH));
sprintf(config->log_warning_path, "%s", iniparser_getstring(ini, "sys:log_warning", LOG_WARNING_PATH));
sprintf(config->log_trace_path, "%s", iniparser_getstring(ini, "sys:log_trace", LOG_TRACE_PATH));
sprintf(config->log_err_path, "%s", iniparser_getstring(ini, "sys:log_err", LOG_ERR_PATH));
config->heartbeat = iniparser_getint(ini, "param:heartbeat", HEARTBEAT);
config->time_sync_freq = iniparser_getint(ini, "param:time_sync_freq", TIME_SYNC_FREQ);
config->read_plc_freq = iniparser_getint(ini, "param:read_plc_freq", READ_PLC_FREQ);
config->sensor_data_push_freq = iniparser_getint(ini, "param:sensor_data_push_freq", SENSOR_DATA_PUSH_FREQ);
iniparser_freedict(ini);
config->BASE.magic = MAGIC_NUMBER;
return 0;
}
static void parse_config(const char *filename)
{
dictionary *d = iniparser_new(filename);
if (d) {
load_inifile(d);
log_debug("reading from configuration file %s\n", filename);
memdebug = iniparser_getint(d, "eressea:memcheck", memdebug);
#ifdef USE_CURSES
/* only one value in the [editor] section */
force_color = iniparser_getint(d, "editor:color", force_color);
#endif
/* excerpt from [config] (the rest is used in bindings.c) */
game_name = iniparser_getstring(d, "config:game", game_name);
} else {
log_warning("could not open configuration file %s\n", filename);
}
global.inifile = d;
}
void frame_factory_init(const char *tex_cfg_file)
{
if (frame_cache != NULL) {
return;
}
frame_cache = dictionary_new(0);
if (frame_cache == NULL) {
oslFatalError("Not enough memory! %s %d", __FILE__, __LINE__);
}
texture_cfg = iniparser_load(tex_cfg_file);
if (texture_cfg == NULL) {
oslFatalError("can't load texture config!");
}
printf("%s\n", iniparser_getstring(texture_cfg, "bg:f", "not found"));
return;
}
