void MSG_db1_data::open( char *directory )
{
char iname[PATH_MAX];
this->dirname = strdup(directory);
snprintf(iname, PATH_MAX, "%s/%s", directory, "AoI");
AoI = iniparser_new(iname);
if (AoI == 0)
std::cerr << "No such file: " << iname << std::endl;
snprintf(iname, PATH_MAX, "%s/%s", directory, "INFO.DBI");
INFO = iniparser_new(iname);
if (INFO == 0)
std::cerr << "No such file: " << iname << std::endl;
return;
}
debugger_t *debugger_creator(char *ini_file_name)
{
debugger_t *debugger;
int8_t type;
dictionary *d;
FILE *f;
debugger =(debugger_t *)malloc(sizeof(debugger_t));
debugger->d = d = iniparser_new(ini_file_name);
memcpy(debugger->ini_file_name,ini_file_name,strlen(ini_file_name));
type = iniparser_getint(d, (char *)"debugger:type", 0);
if(access(debugger->ini_file_name,F_OK)){
printf("ini file not exsit\n");
f = fopen(debugger->ini_file_name, "w");
iniparser_setstr(d, (char *)"debugger", NULL);
/*
*itoa(type,type_str,10);
*/
iniparser_setstr(d, (char *)"debugger:type","0");
iniparser_dump_ini(d, f);
fclose(f);
}
printf("debugger type =%d\n",type);
debugger->debugger_type = type;
debugger->dbg_ops = &debugger_modules[type].dbg_ops;
debugger_set_level_infos(debugger);
debugger_set_businesses(debugger);
return debugger;
}
ConfigObject::ConfigObject(const std::string& filename)
{
d = iniparser_new(filename.c_str());
if (!d) {
throw std::runtime_error("ConfigObject: Could not parse config file " + filename + "!");
}
}
static int mod_init(void)
{
int ld_count = 0, i = 0;
char* section_name;
char* ldap_version;
LM_INFO("LDAP_H350 module - initializing\n");
/*
* read config file
*/
if (strlen(ldap_config.s) == 0)
{
LM_ERR("config_file is empty - this module param is mandatory\n");
return -2;
}
if ((config_vals = iniparser_new(ldap_config.s)) == NULL)
{
LM_ERR("failed to read config_file [%s]\n", ldap_config.s);
return -2;
}
if ((ld_count = iniparser_getnsec(config_vals)) < 1)
{
LM_ERR("no section found in config_file [%s]\n", ldap_config.s);
return -2;
}
/* check if mandatory settings are present */
for (i = 0; i < ld_count; i++)
{
section_name = iniparser_getsecname(config_vals, i);
if (strlen(section_name) > 255)
{
LM_ERR( "config_file section name [%s]"
" longer than allowed 255 characters",
section_name);
return -2;
}
if (!iniparser_find_entry(config_vals,
get_ini_key_name(section_name, CFG_N_LDAP_HOST)))
{
LM_ERR( "mandatory %s not defined in [%s]\n",
CFG_N_LDAP_HOST,
section_name);
return -2;
}
}
/*
* print ldap version string
*/
if (ldap_get_vendor_version(&ldap_version) != 0)
{
LM_ERR("ldap_get_vendor_version failed\n");
return -2;
}
LM_INFO("%s\n", ldap_version);
return 0;
}
/* Initialize from ini file */
int sbase_initialize(SBASE *sbase, char *conf)
{
char *p = NULL, *cacert_file = NULL, *privkey_file = NULL;
if((dict = iniparser_new(conf)) == NULL)
{
fprintf(stderr, "Initializing conf:%s failed, %s\n", conf, strerror(errno));
_exit(-1);
}
/* SBASE */
sbase->nchilds = iniparser_getint(dict, "SBASE:nchilds", 0);
sbase->connections_limit = iniparser_getint(dict, "SBASE:connections_limit", SB_CONN_MAX);
sbase->usec_sleep = iniparser_getint(dict, "SBASE:usec_sleep", SB_USEC_SLEEP);
sbase->set_log(sbase, iniparser_getstr(dict, "SBASE:logfile"));
sbase->set_log_level(sbase, iniparser_getint(dict, "SBASE:log_level", 2));
sbase->set_evlog(sbase, iniparser_getstr(dict, "SBASE:evlogfile"));
/* NOWD */
if((nowd = service_init()) == NULL)
{
fprintf(stderr, "Initialize service failed, %s", strerror(errno));
_exit(-1);
}
nowd->family = iniparser_getint(dict, "NOWD:inet_family", AF_INET);
nowd->sock_type = iniparser_getint(dict, "NOWD:socket_type", SOCK_STREAM);
nowd->ip = iniparser_getstr(dict, "NOWD:service_ip");
nowd->port = iniparser_getint(dict, "NOWD:service_port", 80);
nowd->working_mode = iniparser_getint(dict, "NOWD:working_mode", WORKING_PROC);
nowd->service_type = iniparser_getint(dict, "NOWD:service_type", S_SERVICE);
nowd->service_name = iniparser_getstr(dict, "NOWD:service_name");
nowd->nprocthreads = iniparser_getint(dict, "NOWD:nprocthreads", 8);
nowd->niodaemons = iniparser_getint(dict, "NOWD:niodaemons", 1);
nowd->ndaemons = iniparser_getint(dict, "NOWD:ndaemons", 0);
nowd->session.packet_type=iniparser_getint(dict, "NOWD:packet_type", PACKET_PROXY);
nowd->session.buffer_size = iniparser_getint(dict, "NOWD:buffer_size", SB_BUF_SIZE);
nowd->session.welcome_handler = &nowd_welcome_handler;
nowd->session.exchange_handler = &nowd_exchange_handler;
cacert_file = iniparser_getstr(dict, "NOWD:cacert_file");
privkey_file = iniparser_getstr(dict, "NOWD:privkey_file");
if(cacert_file && privkey_file && iniparser_getint(dict, "NOWD:is_use_SSL", 0))
{
nowd->is_use_SSL = 1;
nowd->cacert_file = cacert_file;
nowd->privkey_file = privkey_file;
}
if((p = iniparser_getstr(dict, "NOWD:logfile")))
{
nowd->set_log(nowd, p);
nowd->set_log_level(nowd, iniparser_getint(dict, "NOWD:log_level", 0));
}
/* server */
fprintf(stdout, "Parsing for server...\n");
return sbase->add_service(sbase, nowd);
}
IniDictionary * ccsIniOpen (const char * fileName)
{
FILE *file;
if (!ccsCreateDirFor(fileName))
return NULL;
/* create file if it doesn't exist or is desired */
file = fopen (fileName, "a+");
if (file)
fclose (file);
return iniparser_new ((char*) fileName);
}
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 MSG_db1_data::set_channel(char *chname)
{
if (! this->has_channel(chname))
{
if (dirname)
std::cerr << "Channel not present in " << dirname << std::endl;
}
char iname[PATH_MAX];
sprintf(iname, "%s/%s.Calibration", dirname, chname);
Calibration = iniparser_new(iname);
if (Calibration == 0)
{
std::cerr << "No such file: " << iname << std::endl;
std::cerr << "No Calibration performed for " << chname << std::endl;
}
sprintf(iname, "%s/%s.RAW", dirname, chname);
FILE *fp = fopen(iname, "r");
if (! fp)
{
std::cerr << "Cannot open file: " << iname << std::endl;
return;
}
rawdata = (unsigned short *) (new unsigned char[chfstat.st_size]);
if (fread(rawdata, chfstat.st_size, 1, fp) != 1)
{
std::cerr << "Cannot read file: " << iname << std::endl;
return;
}
fclose(fp);
this->chnum = get_channel_number(chname);
ncalval = (int) (pow(2.0, (double) get_INFO_image_bitsperpixel( )));
cal_values = new float[ncalval];
for (int i = 0; i < ncalval; i ++)
cal_values[i] = get_channel_Calibration_value_calibrated(i);
return;
}
static void *
init_curl_transport(WsManClient *cl)
{
CURL *curl;
CURLcode r = CURLE_OK;
char *sslhack;
long sslversion;
dictionary *ini = iniparser_new(wsmc_get_conffile(cl));
#define curl_err(str) debug("Error = %d (%s); %s", \
r, curl_easy_strerror(r), str);
curl = curl_easy_init();
if (curl == NULL) {
r = CURLE_FAILED_INIT;
debug("Could not init easy curl");
goto DONE;
}
// client:curlopt_nosignal
if (ini) {
int nosignal = iniparser_getint(ini, "client:curlopt_nosignal", 0);
r = curl_easy_setopt(curl, CURLOPT_NOSIGNAL, nosignal);
if (r != 0) {
curl_err("curl_easy_setopt(CURLOPT_NOSIGNAL) failed");
goto DONE;
}
}
debug("cl->authentication.verify_peer: %d", cl->authentication.verify_peer );
// verify peer
r = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, wsman_transport_get_verify_peer(cl)?1:0);
if (r != 0) {
curl_err("curl_easy_setopt(CURLOPT_SSL_VERIFYPEER) failed");
goto DONE;
}
// verify host
r = curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, wsman_transport_get_verify_host(cl)?2:0);
if (r != 0) {
curl_err("curl_easy_setopt(CURLOPT_SSL_VERIFYHOST) failed");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_PROXY, cl->proxy_data.proxy);
if (r != 0) {
curl_err("Could notcurl_easy_setopt(curl, CURLOPT_PROXY, ...)");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_TIMEOUT, cl->transport_timeout);
if (r != 0) {
curl_err("Could notcurl_easy_setopt(curl, CURLOPT_TIMEOUT, ...)");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, cl->proxy_data.proxy_auth);
if (r != 0) {
curl_err("Could notcurl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, ...)");
goto DONE;
}
if (0 != cl->authentication.verify_peer && 0 != cl->authentication.crl_check)
{
if (cl->authentication.crl_file == NULL)
{
if (ini != NULL)
{
char *crlfile = iniparser_getstr(ini, "client:crlfile");
wsman_transport_set_crlfile(cl, crlfile);
}
}
if (cl->authentication.crl_file != NULL)
{
debug("wsman-curl-client-transport.c: init_curl_transport() : CRL file = %s\n",cl->authentication.crl_file);
r = curl_easy_setopt(curl, CURLOPT_CRLFILE, cl->authentication.crl_file);
}
}
if (cl->authentication.capath) {
r = curl_easy_setopt(curl, CURLOPT_CAPATH, cl->authentication.capath);
if (r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_CAPATH, ..)");
goto DONE;
}
}
// cainfo
if (cl->authentication.cainfo) {
r = curl_easy_setopt(curl, CURLOPT_CAINFO, cl->authentication.cainfo);
if (r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_CAINFO, ..)");
goto DONE;
}
}
// certificate thumbprint
#ifdef ENABLE_EVENTING_SUPPORT
/* Bug in e.g. Fedora: [ curl-Bugs-1924441 ] SSL callback option with NSS-linked libcurl */
#ifndef NO_SSL_CALLBACK
else if (strlen((char *)cl->authentication.certificatethumbprint) > 0 && 0 != cl->authentication.verify_peer) {
r = curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION, sslctxfun);
if(r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_SSL_CTX_FUNCTION)");
goto DONE;
}
r = curl_easy_setopt(curl, CURLOPT_SSL_CTX_DATA, (void *)cl->authentication.certificatethumbprint);
if(r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_SSL_CTX_DATA)");
goto DONE;
}
}
#endif
#endif
// sslkey
r = curl_easy_setopt(curl, CURLOPT_SSLKEY, cl->authentication.sslkey);
if (r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_SSLKEY, ..)");
goto DONE;
}
// sslcert
r = curl_easy_setopt(curl, CURLOPT_SSLCERT, cl->authentication.sslcert );
if (r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_SSLCERT, ..)");
goto DONE;
}
/* enforce specific ssl version if requested */
sslhack = getenv("OPENWSMAN_CURL_TRANSPORT_SSLVERSION");
if (sslhack == NULL) {
sslversion = CURL_SSLVERSION_DEFAULT;
} else if (!strcmp(sslhack,"tlsv1")) {
sslversion = CURL_SSLVERSION_TLSv1;
} else if (!strcmp(sslhack,"sslv2")) {
sslversion = CURL_SSLVERSION_SSLv2;
} else if (!strcmp(sslhack,"sslv3")) {
sslversion = CURL_SSLVERSION_SSLv3;
#if LIBCURL_VERSION_NUM >= 0x072200
} else if (!strcmp(sslhack,"tlsv1.0")) {
sslversion = CURL_SSLVERSION_TLSv1_0;
} else if (!strcmp(sslhack,"tlsv1.1")) {
sslversion = CURL_SSLVERSION_TLSv1_1;
} else if (!strcmp(sslhack,"tlsv1.2")) {
sslversion = CURL_SSLVERSION_TLSv1_2;
#endif
}
else {
sslversion = CURL_SSLVERSION_DEFAULT;
}
r = curl_easy_setopt(curl, CURLOPT_SSLVERSION, sslversion );
if (r != 0) {
curl_err("Could not curl_easy_setopt(curl, CURLOPT_SSLVERSION, ..)");
goto DONE;
}
iniparser_free(ini);
return (void *)curl;
DONE:
cl->last_error = convert_to_last_error(r);
curl_easy_cleanup(curl);
iniparser_free(ini);
return NULL;
#undef curl_err
}
/* Initialize from ini file */
int sbase_initialize(SBASE *sbase, char *conf)
{
char *logfile = NULL, *s = NULL, *p = NULL;
int n = 0;
SERVICE *service = NULL;
if((dict = iniparser_new(conf)) == NULL)
{
fprintf(stderr, "Initializing conf:%s failed, %s\n", conf, strerror(errno));
_exit(-1);
}
/* SBASE */
sbase->nchilds = iniparser_getint(dict, "SBASE:nchilds", 0);
sbase->connections_limit = iniparser_getint(dict, "SBASE:connections_limit", SB_CONN_MAX);
sbase->usec_sleep = iniparser_getint(dict, "SBASE:usec_sleep", SB_USEC_SLEEP);
sbase->set_log(sbase, iniparser_getstr(dict, "SBASE:logfile"));
sbase->set_evlog(sbase, iniparser_getstr(dict, "SBASE:evlogfile"));
/* LECHOD */
if((service = service_init()) == NULL)
{
fprintf(stderr, "Initialize service failed, %s", strerror(errno));
_exit(-1);
}
service->family = iniparser_getint(dict, "LECHOD:inet_family", AF_INET);
service->sock_type = iniparser_getint(dict, "LECHOD:socket_type", SOCK_STREAM);
service->ip = iniparser_getstr(dict, "LECHOD:service_ip");
service->port = iniparser_getint(dict, "LECHOD:service_port", 80);
service->working_mode = iniparser_getint(dict, "LECHOD:working_mode", WORKING_PROC);
service->service_type = iniparser_getint(dict, "LECHOD:service_type", C_SERVICE);
service->service_name = iniparser_getstr(dict, "LECHOD:service_name");
service->nprocthreads = iniparser_getint(dict, "LECHOD:nprocthreads", 1);
service->ndaemons = iniparser_getint(dict, "LECHOD:ndaemons", 0);
service->set_log(service, iniparser_getstr(dict, "LECHOD:logfile"));
service->session.packet_type = iniparser_getint(dict, "LECHOD:packet_type",PACKET_DELIMITER);
service->session.packet_delimiter = iniparser_getstr(dict, "LECHOD:packet_delimiter");
p = s = service->session.packet_delimiter;
while(*p != 0 )
{
if(*p == '\\' && *(p+1) == 'n')
{
*s++ = '\n';
p += 2;
}
else if (*p == '\\' && *(p+1) == 'r')
{
*s++ = '\r';
p += 2;
}
else
*s++ = *p++;
}
*s++ = 0;
service->session.packet_delimiter_length = strlen(service->session.packet_delimiter);
service->session.buffer_size = iniparser_getint(dict, "LECHOD:buffer_size", SB_BUF_SIZE);
service->session.packet_reader = &lechod_packet_reader;
service->session.packet_handler = &lechod_packet_handler;
service->session.data_handler = &lechod_data_handler;
service->session.oob_handler = &lechod_oob_handler;
/* server */
fprintf(stdout, "Parsing for server...\n");
return sbase->add_service(sbase, service);
}
int GetConfig(char * ini_name)
{
//char *_MxAdress,*_MxPort,*_GradFile,*_CLPath;
int i;
char eventname[MAXSTRSIZE];
int debug;
dictionary * ini ;
ini = iniparser_new(ini_name);
if (ini==NULL)
{
Log(LOG_ERR, "cannot parse file [%s]\n", ini_name);
return(1) ;
}
/* Main Section*/
DEAMON=iniparser_getboolean(ini, "Main:Daemon", DEAMON);
debug=iniparser_getint(ini, "Main:Log", debuglevel);
switch (debug)
{
case 3:debuglevel=LOG_DEBUG;break;
case 2:debuglevel=LOG_INFO;break;
case 1:debuglevel=LOG_WARNING;break;
case 0:debuglevel=LOG_ERR;break;
default:debuglevel=LOG_WARNING;break;
}
/* Db section */
strncpy(DBHOST,iniparser_getstring(ini,"Db:DbHost" ,""),sizeof(DBHOST));
strncpy(DB,iniparser_getstring(ini,"Db:DbName" ,""),sizeof(DB));
strncpy(USER,iniparser_getstring(ini,"Db:DbUserName" ,""),sizeof(USER));
strncpy(PASS,iniparser_getstring(ini,"Db:DbPassword" ,""),sizeof(PASS));
/* Measurex section */
strncpy(MXNAME,iniparser_getstring(ini,"Measurex:MxId" ,""),sizeof(MXNAME));
strncpy(MXADDRESS,iniparser_getstring(ini,"Measurex:MxAdress" ,""),sizeof(MXADDRESS));
strncpy(MXPORT,iniparser_getstring(ini,"Measurex:MxPort" ,""),sizeof(MXPORT));
/* PLC Section */
CLPath=strdup(iniparser_getstring(ini,"PLC:CLPath" ,NULL));
plc=GetPlc(CLPath);
/* Variables Section*/
AB_VARCOUNT=0;
for(i=0;i<ini->n;i++)
{
char *section=iniparser_getsectionname(ini,i);
if (strcasecmp("Variables",section)==0)
{
char *key=iniparser_getkeyname(ini,i);
if (key!=NULL)
{
AB_VARCOUNT++;
TAG *var=malloc(sizeof(TAG));
AddListe(&variables,var);
memset(var,0,sizeof(TAG));
strncpy((char *)(var->TagName),key,MAXALIASSIZE);
strncpy((char *)(var->Value_Address),ini->val[i],MAXALIASSIZE);
snprintf(eventname,MAXSTRSIZE-1,"Events:%s",var->TagName);
char *temp=iniparser_getstring(ini,eventname,NULL);
if (temp!=NULL) strncpy((char *)(var->Reset_Address),temp,MAXALIASSIZE);
free(key);
}
}
free(section);
}
iniparser_free(ini);
return(0);
}
bool readIniFile(char *iniFilePathAndName)
{
dictionary *dict;
int ii;
char tmpBuf[MY_TMP_BUF_LEN];
char tmpBuf2[MY_TMP_BUF_LEN];
dict = iniparser_new(iniFilePathAndName);
if (dict != NULL) {
//General settings
//General settings
viewerPort = iniparser_getint(dict, "general:viewerport", 5900);
serverPort = iniparser_getint(dict, "general:serverport", 5500);
maxSessions = iniparser_getint(dict, "general:maxsessions", MAX_SESSIONS_DEFAULT);
if (maxSessions > MAX_SESSIONS_MAX)
maxSessions = MAX_SESSIONS_DEFAULT;
if (maxSessions < MAX_SESSIONS_MIN)
maxSessions = MAX_SESSIONS_DEFAULT;
allowedModes = iniparser_getint(dict, "general:allowedmodes", (CONN_MODE1 | CONN_MODE2));
strlcpy(ownIpAddress, iniparser_getstring(dict, "general:ownipaddress", "0.0.0.0"), MY_TMP_BUF_LEN);
loggingLevel = iniparser_getint(dict, "general:logginglevel", DEFAULT_LOGGING_LEVEL);
if (loggingLevel > LEVEL_3)
loggingLevel = DEFAULT_LOGGING_LEVEL;
if (loggingLevel < LEVEL_0)
loggingLevel = DEFAULT_LOGGING_LEVEL;
//Mode 1 settings
allowedMode1ServerPort = iniparser_getint(dict, "mode1:allowedmode1serverport", 0);
requireListedServer = iniparser_getint(dict, "mode1:requirelistedserver", 0);
if (requireListedServer == 1) {
//Allowed servers
for(ii = 0; ii < SERVERS_LIST_SIZE; ii++) {
snprintf(tmpBuf, MY_TMP_BUF_LEN, "%s%d", "mode1:srvListAllow", ii);
strlcpy(tmpBuf2, iniparser_getstring(dict, tmpBuf, "255.255.255.255"), MY_TMP_BUF_LEN);
srvListAllow[ii] = getAddrPartsFromString(tmpBuf2);
}
//Denied servers
for(ii = 0; ii < SERVERS_LIST_SIZE; ii++) {
snprintf(tmpBuf, MY_TMP_BUF_LEN, "%s%d", "mode1:srvListDeny", ii);
strlcpy(tmpBuf2, iniparser_getstring(dict, tmpBuf, "255.255.255.255"), MY_TMP_BUF_LEN);
srvListDeny[ii] = getAddrPartsFromString(tmpBuf2);
}
}
//Mode 2 settings
requireListedId = iniparser_getint(dict, "mode2:requirelistedid", 0);
if (requireListedId == 1) {
for(ii = 0; ii < ID_LIST_SIZE; ii++) {
snprintf(tmpBuf, MY_TMP_BUF_LEN, "%s%d", "mode2:idlist", ii);
idList[ii] = iniparser_getint(dict, tmpBuf, 0);
}
}
iniparser_free(dict);
return true;
}
else
return false;
return true;
}
bool readIniFile(char *iniFilePathAndName)
{
dictionary *dict;
int ii;
char tmpBuf[MY_TMP_BUF_LEN];
char tmpBuf2[MY_TMP_BUF_LEN];
/* initialize Allow/Deny lists */
memset(srvListDeny, 255, sizeof(srvListDeny));
memset(srvListAllow, 255, sizeof(srvListAllow));
dict = iniparser_new(iniFilePathAndName);
if (dict != NULL) {
/* General settings */
/* General settings */
viewerPort = iniparser_getint(dict, "general:viewerport", 5900);
serverPort = iniparser_getint(dict, "general:serverport", 5500);
maxSessions = iniparser_getint(dict, "general:maxsessions", MAX_SESSIONS_DEFAULT);
if (maxSessions > MAX_SESSIONS_MAX)
maxSessions = MAX_SESSIONS_DEFAULT;
if (maxSessions < MAX_SESSIONS_MIN)
maxSessions = MAX_SESSIONS_DEFAULT;
allowedModes = iniparser_getint(dict, "general:allowedmodes", (CONN_MODE1 | CONN_MODE2));
strlcpy(ownIpAddress, iniparser_getstring(dict, "general:ownipaddress", "0.0.0.0"), MY_TMP_BUF_LEN);
strlcpy(runAsUser, iniparser_getstring(dict, "general:runasuser", "uvncrep"), MY_TMP_BUF_LEN);
loggingLevel = iniparser_getint(dict, "general:logginglevel", DEFAULT_LOGGING_LEVEL);
if (loggingLevel > LEVEL_3)
loggingLevel = DEFAULT_LOGGING_LEVEL;
if (loggingLevel < LEVEL_0)
loggingLevel = DEFAULT_LOGGING_LEVEL;
/* Mode 1 settings */
/* Mode 1 settings */
allowedMode1ServerPort = iniparser_getint(dict, "mode1:allowedmode1serverport", 0);
requireListedServer = iniparser_getint(dict, "mode1:requirelistedserver", 0);
if (requireListedServer == 1) {
/* Allowed servers */
for(ii = 0; ii < SERVERS_LIST_SIZE; ii++) {
snprintf(tmpBuf, MY_TMP_BUF_LEN, "%s%d", "mode1:srvListAllow", ii);
strlcpy(tmpBuf2, iniparser_getstring(dict, tmpBuf, "255.255.255.255"), MY_TMP_BUF_LEN);
inet46_pton(tmpBuf2, &srvListAllow[ii]);
}
/* Denied servers */
for(ii = 0; ii < SERVERS_LIST_SIZE; ii++) {
snprintf(tmpBuf, MY_TMP_BUF_LEN, "%s%d", "mode1:srvListDeny", ii);
strlcpy(tmpBuf2, iniparser_getstring(dict, tmpBuf, "255.255.255.255"), MY_TMP_BUF_LEN);
inet46_pton(tmpBuf2, &srvListDeny[ii]);
}
}
/* Mode 2 settings */
/* Mode 2 settings */
requireListedId = iniparser_getint(dict, "mode2:requirelistedid", 0);
if (requireListedId == 1) {
for(ii = 0; ii < ID_LIST_SIZE; ii++) {
snprintf(tmpBuf, MY_TMP_BUF_LEN, "%s%d", "mode2:idlist", ii);
idList[ii] = iniparser_getint(dict, tmpBuf, 0);
}
}
/* Event interface settings */
/* Event interface settings */
useEventInterface = (bool) iniparser_getboolean(dict, "eventinterface:useeventinterface", 0);
strlcpy(eventListenerHost, iniparser_getstring(dict,
"eventinterface:eventlistenerhost", "localhost"), MY_TMP_BUF_LEN);
eventListenerPort = iniparser_getint(dict, "eventinterface:eventlistenerport", 2002);
useHttpForEventListener = (bool) iniparser_getboolean(dict,"eventinterface:usehttp", 0);
iniparser_free(dict);
return true;
}
else
return false;
return true;
}
