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;
}
int gui_preferences_open(const char *filename,struct gui_preferences *preferences) {
static struct gui_preferences default_preferences = {
.auto_white_balance = 0,
.auto_adjust_mode = 0,
.flourescent_light_filter = 0,
.device = NXTCAM_OS_DEFAULT_DEVICE
};
dictionary *ini;
ini = iniparser_load(filename);
if (ini!=NULL) {
preferences->auto_white_balance = iniparser_getboolean(ini,"nxtcam:auto_white_balance",default_preferences.auto_white_balance);
preferences->auto_adjust_mode = iniparser_getboolean(ini,"nxtcam:auto_adjust_mode",default_preferences.auto_adjust_mode);
preferences->flourescent_light_filter = iniparser_getboolean(ini,"nxtcam:flourescent_light_filter",default_preferences.flourescent_light_filter);
preferences->device = strdup(iniparser_getstring(ini,"local:device",default_preferences.device));
}
else {
memcpy(preferences,&default_preferences,sizeof(struct gui_preferences));
preferences->device = strdup(default_preferences.device);
printf("Default device: %s\n",default_preferences.device);
}
// always return 0, because if file does not exist, we use default
return 0;
}
static int gui_preferences_upload(struct gui_preferences *preferences) {
/*********************************************
* Register function * reg * on * off *
*********************************************
* auto white balance * 45 * 7 * 3 *
* auto adjust mode * 19 * 1 * 0 *
* flourescent light filter * 18 * 44 * 40 *
*********************************************/
if (nxtcam_com_is_connected()) {
if (nxtcam_dev_req_regw(45,preferences->auto_white_balance?7:3)==-1) {
return -1;
}
if (nxtcam_dev_req_regw(19,preferences->auto_adjust_mode?1:0)==-1) {
return -1;
}
if (nxtcam_dev_req_regw(18,preferences->flourescent_light_filter?44:40)==-1) {
return -1;
}
return 0;
}
else {
return -1;
}
}
static void gui_preferences_gui2data(gui_gd_t *gd,struct gui_preferences *preferences) {
preferences->auto_white_balance = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gd->preferences.chkbtn_whitebalance));
preferences->auto_adjust_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gd->preferences.chkbtn_adjustmode));
preferences->flourescent_light_filter = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(gd->preferences.chkbtn_lightfilter));
free(preferences->device);
preferences->device = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(gd->preferences.btn_device));
}
int parse_ini_file(char * ini_name)
{
dictionary * ini=NULL ;
dictionary * test_dict=NULL;
/* Some temporary variables to hold query results */
int b ;
int i ;
double d ;
char * s ;
char *out_str=NULL;
fprintf(stderr,"Loading...\n");
ini = iniparser_load(ini_name);
if (ini==NULL) {
fprintf(stderr, "cannot parse file: %s\n", ini_name);
return -1 ;
}
fprintf(stderr,"Dumping...\n");
iniparser_dump_ini(ini, stderr);
fprintf(stdout,"To_stringi...\n");
out_str=iniparser_to_string(ini);
fprintf(stdout,"\nstring:\n");
fprintf(stdout,"%s\n",out_str);
fprintf(stdout,"From_string\n");
test_dict=iniparser_load_from_string(test_dict,out_str);
fprintf(stderr,"Dict from string:\n");
iniparser_dump_ini(test_dict, stderr);
/* Get pizza attributes */
printf("Pizza:\n");
b = iniparser_getboolean(ini, "pizza:ham", -1);
printf("Ham: [%d]\n", b);
b = iniparser_getboolean(ini, "pizza:mushrooms", -1);
printf("Mushrooms: [%d]\n", b);
b = iniparser_getboolean(ini, "pizza:capres", -1);
printf("Capres: [%d]\n", b);
b = iniparser_getboolean(ini, "pizza:cheese", -1);
printf("Cheese: [%d]\n", b);
/* Get wine attributes */
printf("Wine:\n");
s = iniparser_getstring(ini, "wine:grape", NULL);
printf("Grape: [%s]\n", s ? s : "UNDEF");
i = iniparser_getint(ini, "wine:year", -1);
printf("Year: [%d]\n", i);
s = iniparser_getstring(ini, "wine:country", NULL);
printf("Country: [%s]\n", s ? s : "UNDEF");
d = iniparser_getdouble(ini, "wine:alcohol", -1.0);
printf("Alcohol: [%g]\n", d);
iniparser_freedict(ini);
return 0 ;
}
bool INI::GetBoolean(dictionary* ini, const TCHAR* section, const TCHAR* key, bool defValue, bool defFromMainSection)
{
char tmp[MAX_PATH];
tmp[0] = 0;
if(section)
strcat(tmp, section);
strcat(tmp, key);
if(section && defFromMainSection) defValue = iniparser_getboolean(ini, key, defValue);
return iniparser_getboolean(ini, tmp, defValue);
}
void _enforce_priority(int radar,struct ControlProgram *priority_cprog,struct Thread_List_Item *thread_list) {
struct ControlProgram *cprog=NULL;
if(priority_cprog!=NULL) {
if(priority_cprog->parameters!=NULL) {
while(thread_list!=NULL){
cprog=thread_list->data;
if (cprog!=NULL && (cprog!=priority_cprog)) {
if (cprog->parameters!=NULL) {
if (cprog->state!=NULL) {
if (cprog->state->active==1) {
if (cprog->parameters!=NULL) {
if ((cprog->parameters->radar==radar) || (radar==0)) {
printf("Enforcing Control Program Priority Policy\n");
if(iniparser_getboolean(Site_INI,"priority:enforce_tfreq",0)){
cprog->parameters->tfreq=priority_cprog->parameters->tfreq;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_rfreq",0)){
cprog->parameters->rfreq=priority_cprog->parameters->rfreq;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_tbeam",0)){
cprog->parameters->tbeam=priority_cprog->parameters->tbeam;
cprog->parameters->tbeamcode=priority_cprog->parameters->tbeamcode;
cprog->parameters->tbeamazm=priority_cprog->parameters->tbeamazm;
cprog->parameters->tbeamwidth=priority_cprog->parameters->tbeamwidth;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_rbeam",0)){
cprog->parameters->rbeam=priority_cprog->parameters->rbeam;
cprog->parameters->rbeamcode=priority_cprog->parameters->rbeamcode;
cprog->parameters->rbeamazm=priority_cprog->parameters->rbeamazm;
cprog->parameters->rbeamwidth=priority_cprog->parameters->rbeamwidth;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_seq_index",0)){
cprog->parameters->pulseseq_index[0]=priority_cprog->parameters->pulseseq_index[0];
cprog->parameters->pulseseq_index[1]=priority_cprog->parameters->pulseseq_index[1];
cprog->parameters->pulseseq_index[2]=priority_cprog->parameters->pulseseq_index[2];
}
if(iniparser_getboolean(Site_INI,"priority:enforce_trise",0)){
cprog->parameters->trise=priority_cprog->parameters->trise;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_samplerate",0)){
cprog->parameters->baseband_samplerate=priority_cprog->parameters->baseband_samplerate;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_filter_bandwidth",0)){
cprog->parameters->filter_bandwidth=priority_cprog->parameters->filter_bandwidth;
}
if(iniparser_getboolean(Site_INI,"priority:enforce_match_filter",0)){
cprog->parameters->match_filter=priority_cprog->parameters->match_filter;
}
}
}
}
}
}
}
thread_list=thread_list->prev;
}
}
}
return ;
}
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);
}
bool InitParser::get_boolean(const string& key) const
{
int b = iniparser_getboolean(dico, key.c_str(), -10);
// To be sure :) (bugfree)
if (b==-10) {
b = iniparser_getboolean(dico, key.c_str(), 0);
if (b==0) {
cerr << "WARNING : Can't find the configuration key \"" << key << "\", default 0 value returned\n";
}
}
return b;
}
bool InitParser::get_boolean(const string& key) const
{
int b = iniparser_getboolean(dico, key.c_str(), -10);
// To be sure :) (bugfree)
if (b==-10) {
b = iniparser_getboolean(dico, key.c_str(), 0);
if (b==0) {
//cerr << "WARNING : Can't find the configuration key \"" << key << "\", default 0 value returned\n";
Log.write("Init_parser : can't find the configuration key \"" + key + "\", default 0 value returned", cLog::eLOG_TYPE_WARNING);
}
}
return b;
}
int wsmand_read_config(dictionary * ini)
{
if (!iniparser_find_entry(ini, "server")) {
return 0;
}
server_port = iniparser_getint(ini, "server:port", 5985);
server_ssl_port = iniparser_getint(ini, "server:ssl_port", 5986);
debug_level = iniparser_getint(ini, "server:debug_level", 0);
enumIdleTimeout =
(unsigned long) iniparser_getint(ini,
"server:enum_idle_timeout",
100);
service_path =
iniparser_getstring(ini, "server:service_path", "/wsman");
ssl_key_file = iniparser_getstr(ini, "server:ssl_key_file");
ssl_cert_file = iniparser_getstr(ini, "server:ssl_cert_file");
use_ipv4 = iniparser_getboolean(ini, "server:ipv4", 1);
#ifdef ENABLE_IPV6
use_ipv6 = iniparser_getboolean(ini, "server:ipv6", 1);
if (! (use_ipv4 || use_ipv6)) {
fprintf(stderr, "Neither ipv4 nor ipv6 is enabled in openwsman.conf !\n");
exit(1);
}
#endif
use_digest = iniparser_getboolean(ini, "server:use_digest", 0);
digest_password_file = iniparser_getstr(ini,
"server:digest_password_file");
basic_password_file =
iniparser_getstr(ini, "server:basic_password_file");
custom_identify_file =
iniparser_getstr(ini, "server:identify_file");
custom_anon_identify_file =
iniparser_getstr(ini, "server:anon_identify_file");
basic_authenticator =
iniparser_getstr(ini, "server:basic_authenticator");
basic_authenticator_arg =
iniparser_getstr(ini, "server:basic_authenticator_arg");
log_location = iniparser_getstr(ini, "server:log_location");
min_threads = iniparser_getint(ini, "server:min_threads", 1);
max_threads = iniparser_getint(ini, "server:max_threads", 0);
uri_subscription_repository = iniparser_getstring(ini, "server:subs_repository", DEFAULT_SUBSCRIPTION_REPOSITORY);
max_connections_per_thread = iniparser_getint(ini, "server:max_connextions_per_thread", 20);
thread_stack_size = iniparser_getstring(ini, "server:thread_stack_size", "0");
#ifdef ENABLE_EVENTING_SUPPORT
wsman_server_set_subscription_repos(uri_subscription_repository);
#endif
return 1;
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
if(fdwReason == DLL_PROCESS_ATTACH) {
// Store reference to handle for later use
g_hinstance = hinstDLL;
// Initialise the logger using std streams
Log::Init(hinstDLL, NULL, NULL, NULL);
// Load our (optional) ini file
g_ini = INI::LoadIniFile(hinstDLL);
// Init error message
g_errorMessage.xltype = xltypeStr;
g_errorMessage.val.str = XLUtil::MakeExcelString("#Unknown function");
// Read config
g_sendCallerInfo = iniparser_getboolean(g_ini, FS_SEND_CALLER_INFO, 0) != 0;
// Initialise the log
Log::Init(hinstDLL, iniparser_getstr(g_ini, LOG_FILE), iniparser_getstr(g_ini, LOG_LEVEL), g_ini);
g_debugLogging = Log::GetLevel() == debug;
// Initialise timeout feature
Timeout::Initialise(hinstDLL, g_ini);
}
// OK
return TRUE;
}
void setupRTPServers()
{
int i,j;
int numServers;
dictionary *ini ;
int b ;
char *s ;
ini = iniparser_load(CONFIG_FILE);
if (ini==NULL) {
fprintf(stderr, "cannot parse file: %s\n", CONFIG_FILE);
return -1 ;
}
iniparser_dump(ini, stderr);
numServers = iniparser_getboolean(ini, "Rec Servers:numServers", -1);
printf("numServers: [%d]\n", b);
rtpServers.server = (struct rtpServer*)malloc(sizeof(struct rtpServer)*numServers);
rtpServers.numServers = numServers;
for(j=0;j<numServers;j++)
{
rtpServers.server[j].minPort = MIN_PORT_NO;
rtpServers.server[j].numActiveChannels = 0;
for(i=0;i<CHANNELS_PER_SERVER;i++)
rtpServers.server[j].portActive[i] = 0;
s = iniparser_getstring(ini,"Rec Servers:ipAddress","NULL");
strcpy(rtpServers.server[j].ip,s);
}
}
/*
* Sends a message to the server to indicate a new session has been created
*/
void InitializeSession(int index)
{
bool sendUserInfo = iniparser_getboolean(g_ini, FS_SEND_USER_INFO, 1) != 0;
if(sendUserInfo) {
char username[MAX_PATH];
DWORD usize= MAX_PATH;
GetUserName(username, &usize);
LPXLOPER uname = XLUtil::MakeExcelString2(username);
gethostname(username, MAX_PATH);
LPXLOPER hostname = XLUtil::MakeExcelString2(username);
char* userKey = iniparser_getstr(g_ini, FS_USER_KEY);
if(userKey) {
LPXLOPER ukey = XLUtil::MakeExcelString2(userKey);
g_protocol[index]->execute(AF_INITIALIZE, false, 3, uname, hostname, ukey);
XLUtil::FreeContents(ukey);
free(ukey);
} else {
g_protocol[index]->execute(AF_INITIALIZE, false, 2, uname, hostname);
}
XLUtil::FreeContents(uname);
XLUtil::FreeContents(hostname);
free(uname);
free(hostname);
}
}
static NTSTATUS parse_gpttmpl(dictionary *d, uint32 *version_out)
{
const char *signature = NULL;
uint32 version;
if ((signature = iniparser_getstring(d, GPTTMPL_SECTION_VERSION
":"GPTTMPL_PARAMETER_SIGNATURE, NULL)) == NULL) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
if (!strequal(signature, GPTTMPL_CHICAGO)) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
if ((version = iniparser_getint(d, GPTTMPL_SECTION_VERSION
":"GPTTMPL_PARAMETER_REVISION, Undefined)) == Undefined) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
if (version_out) {
*version_out = version;
}
/* treat that as boolean */
if ((!iniparser_getboolean(d, GPTTMPL_SECTION_UNICODE
":"GPTTMPL_PARAMETER_UNICODE, Undefined)) == Undefined) {
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
return NT_STATUS_OK;
}
wr_errorcode_t wr_gamma_delay_filter_notify(wr_rtp_filter_t * filter, wr_event_type_t event, wr_rtp_packet_t * packet)
{
switch(event){
case TRANSMISSION_START: {
wr_gamma_delay_filter_state_t * state = calloc(1, sizeof(*state));
state->enabled = iniparser_getboolean(wr_options.output_options, "gamma_delay:enabled", 1);
state->shape = iniparser_getpositiveint(wr_options.output_options, "gamma_delay:shape", 0);
state->scale = iniparser_getpositiveint(wr_options.output_options, "gamma_delay:scale", 0);
filter->state = (void*)state;
wr_rtp_filter_notify_observers(filter, event, packet);
return WR_OK;
}
case NEW_PACKET: {
wr_gamma_delay_filter_state_t * state = (wr_gamma_delay_filter_state_t * ) (filter->state);
int delay;
if (!state->enabled){
wr_rtp_filter_notify_observers(filter, event, packet);
return WR_OK;
}
delay = (int)gengam(1/(float)state->scale, state->shape);
wr_rtp_packet_t new_packet;
wr_rtp_packet_copy(&new_packet, packet);
timeval_increment(&new_packet.lowlevel_timestamp, delay);
wr_rtp_filter_notify_observers(filter, event, &new_packet);
return WR_OK;
}
case TRANSMISSION_END: {
free(filter->state);
wr_rtp_filter_notify_observers(filter, event, packet);
return WR_OK;
}
}
}
static int ini_get_boolean(struct config *c, ...)
{
dictionary *ini = (dictionary *)c->priv;
char **key = NULL;
char *tmp = NULL;
int ret;
int cnt = 0;
va_list ap;
va_start(ap, c);
tmp = va_arg(ap, char *);
while (tmp) {//last argument must be NULL
cnt++;
key = (char **)realloc(key, cnt*sizeof(char**));
key[cnt-1] = tmp;
tmp = va_arg(ap, char *);
}
va_end(ap);
switch (cnt) {
case 1:
ret = iniparser_getboolean(ini, key[0], -1);
break;
default:
break;
}
free(key);
return ret;
}
int
ini_getbool (int *value, char *key)
{
if (!ini_find (key))
return 0;
*value = iniparser_getboolean (yap_config, key, -1);
return 1;
}
int parse_ini_file(char * ini_name)
{
dictionary * ini ;
/* Some temporary variables to hold query results */
int b ;
int i ;
double d ;
char * s ;
ini = iniparser_load(ini_name);
if (ini==NULL) {
fprintf(stderr, "cannot parse file: %s\n", ini_name);
return -1 ;
}
iniparser_dump(ini, stderr);
/* Get pizza attributes */
printf("Pizza:\n");
b = iniparser_getboolean(ini, "pizza:ham", -1);
printf("Ham: [%d]\n", b);
b = iniparser_getboolean(ini, "pizza:mushrooms", -1);
printf("Mushrooms: [%d]\n", b);
b = iniparser_getboolean(ini, "pizza:capres", -1);
printf("Capres: [%d]\n", b);
b = iniparser_getboolean(ini, "pizza:cheese", -1);
printf("Cheese: [%d]\n", b);
/* Get wine attributes */
printf("Wine:\n");
s = iniparser_getstring(ini, "wine:grape", NULL);
printf("Grape: [%s]\n", s ? s : "UNDEF");
i = iniparser_getint(ini, "wine:year", -1);
printf("Year: [%d]\n", i);
s = iniparser_getstring(ini, "wine:country", NULL);
printf("Country: [%s]\n", s ? s : "UNDEF");
d = iniparser_getdouble(ini, "wine:alcohol", -1.0);
printf("Alcohol: [%g]\n", d);
iniparser_freedict(ini);
return 0 ;
}
void *settings_rxfe_update_if(struct RXFESettings *rxfe_if_settings)
{
pthread_mutex_lock(&settings_lock);
if( verbose > 1 ) fprintf(stderr,"RXFE IF Mode Settings from INI File ::\n");
rxfe_if_settings->ifmode=1;
if( verbose > 1 ) fprintf(stderr,"RXFE :: IF: %d\n",rxfe_if_settings->ifmode);
rxfe_if_settings->amp1=iniparser_getboolean(Site_INI,"rxfe_if:enable_amp1",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: amp1: %d\n",rxfe_if_settings->amp1);
rxfe_if_settings->amp2=iniparser_getboolean(Site_INI,"rxfe_if:enable_amp2",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: amp2: %d\n",rxfe_if_settings->amp2);
rxfe_if_settings->amp3=iniparser_getboolean(Site_INI,"rxfe_if:enable_amp3",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: amp3: %d\n",rxfe_if_settings->amp3);
rxfe_if_settings->att1=iniparser_getboolean(Site_INI,"rxfe_if:enable_att1",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: att1: %d\n",rxfe_if_settings->att1);
rxfe_if_settings->att2=iniparser_getboolean(Site_INI,"rxfe_if:enable_att2",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: att2: %d\n",rxfe_if_settings->att2);
rxfe_if_settings->att3=iniparser_getboolean(Site_INI,"rxfe_if:enable_att3",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: att3: %d\n",rxfe_if_settings->att3);
rxfe_if_settings->att4=iniparser_getboolean(Site_INI,"rxfe_if:enable_att4",0);
if( verbose > 1 ) fprintf(stderr,"RXFE :: att4: %d\n",rxfe_if_settings->att4);
pthread_mutex_unlock(&settings_lock);
pthread_exit(NULL);
}
int ReadBool( Props *p, const char *name, int def )
{
if( p != NULL )
{
return iniparser_getboolean( p->p_Dict, name, def );
}
return 0;
}
int load_config(const char *filename)
{
char *nopriv_uid_name;
char *nopriv_gid_name;
dictionary* ini_dict;
const char *s;
ini_dict = iniparser_load(filename);
if (ini_dict == NULL){
log_error("Unable to load config file '%s': %s", filename, strerror(errno));
}
io_sched_realtime = iniparser_getboolean(ini_dict, "sched:realtime_io", 0);
if (server_str_id == NULL){
s = iniparser_getstring(ini_dict, "general:server_id", "192.168.0.1");
server_str_id = strdup(s);
}
high_prio_sockets = iniparser_getboolean(ini_dict, "general:high_prio_sockets", 1);
recv_socket_bufsize = iniparser_getint(ini_dict, "general:socket_rxbufsize", 0);
s = iniparser_getstring(ini_dict, "general:user", "nobody");
nopriv_uid_name = xmalloc(strlen(s)+1);
strcpy(nopriv_uid_name, s);
s = iniparser_getstring(ini_dict, "general:group", "nobody");
nopriv_gid_name = xmalloc(strlen(s)+1);
strcpy(nopriv_gid_name, s);
get_pw_uids(nopriv_uid_name, nopriv_gid_name);
xfree(nopriv_uid_name);
xfree(nopriv_gid_name);
if (rtsp_load_config(rtsp_server, ini_dict))
return 1;
if (ini_dict)
iniparser_freedict(ini_dict);
return 0;
}
bool parameters_get_boolean(struct parameters *params, const char *key, bool def)
{
if (params) {
if (!parameters_check_key(params, key)) return false;
return iniparser_getboolean(params->iniparser_dict, params->key, def);
}
else {
return def;
}
}
static int VdecVdis_getCfgArray(dictionary *ini, VdecVdis_Config *cfg)
{
UInt32 totalChnlNum,i;
char temp[256];
char *name;
totalChnlNum = iniparser_getnsec(ini);
cfg->fileNum = totalChnlNum;
printf(" *** a new param codec is needed for ini, if you not sure about this\n");
printf(" *** please reference demo_ini/704x576_02_32CH.ini \n");
printf(" *** H264: codec = h264\n");
printf(" *** MPEG4: codec = mpeg4\n");
printf(" *** MJPEG: codec = mjpeg\n");
printf(" *** Two new params numbuf & displaydelay has been added for ini, if not defaults are set\n");
for (i = 0; i < totalChnlNum; i++)
{
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_PATH);
name = iniparser_getstring(ini,temp,NULL);
strcpy(cfg->fileInfo[i].path,name);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_WIDTH);
cfg->fileInfo[i].width = iniparser_getint(ini,temp,0);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_HEIGHT);
cfg->fileInfo[i].height = iniparser_getint(ini,temp,0);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_ENABLE);
cfg->fileInfo[i].enable = iniparser_getboolean(ini,temp,1);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_CODEC);
name = iniparser_getstring(ini,temp,NULL);
if(name != NULL )
strcpy(cfg->fileInfo[i].codec,name);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_NUMBUF);
cfg->fileInfo[i].numbuf = iniparser_getint(ini,temp,0);
name = iniparser_getsecname(ini,i);
sprintf(temp,"%s:%s",name,MCFW_IPC_BITS_INI_FILE_DISPLAYDELAY);
cfg->fileInfo[i].displaydelay = iniparser_getint(ini,temp,0);
}
return 0;
}
static NTSTATUS parse_gpttmpl_kerberos_policy(const char *filename)
{
NTSTATUS status;
dictionary *d = NULL;
uint32 tkt_max_age, tkt_max_renew, tgs_max_age, max_clock_skew;
BOOL tkt_validate;
uint32 version;
d = iniparser_load(filename);
if (d == NULL) {
return NT_STATUS_NO_SUCH_FILE;
}
status = parse_gpttmpl(d, &version);
if (!NT_STATUS_IS_OK(status)) {
goto out;
}
status = NT_STATUS_INVALID_PARAMETER;
if ((tkt_max_age = iniparser_getint(d, GPTTMPL_SECTION_KERBEROS_POLICY
":"GPTTMPL_PARAMETER_MAXTKTAGE, Undefined)) != Undefined) {
goto out;
}
if ((tkt_max_renew = iniparser_getint(d, GPTTMPL_SECTION_KERBEROS_POLICY
":"GPTTMPL_PARAMETER_MAXRENEWAGE, Undefined)) != Undefined) {
goto out;
}
if ((tgs_max_age = iniparser_getint(d, GPTTMPL_SECTION_KERBEROS_POLICY
":"GPTTMPL_PARAMETER_MAXTGSAGE, Undefined)) != Undefined) {
goto out;
}
if ((max_clock_skew = iniparser_getint(d, GPTTMPL_SECTION_KERBEROS_POLICY
":"GPTTMPL_PARAMETER_MAXCLOCKSKEW, Undefined)) != Undefined) {
goto out;
}
if ((tkt_validate = iniparser_getboolean(d, GPTTMPL_SECTION_KERBEROS_POLICY
":"GPTTMPL_PARAMETER_TKTVALIDATECLIENT, Undefined)) != Undefined) {
goto out;
}
status = NT_STATUS_OK;
out:
if (d) {
iniparser_freedict(d);
}
return status;
}
void finiparser_getBool(int* out,char *key,int* ifnd,int key_len)
{
int tmp;
*ifnd = 0;
tmp = iniparser_getboolean(dic,addchar0(key,key_len),-1);
if (tmp != -1) {
*out = tmp;
*ifnd = 1;
}
return;
}
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);
}
void Timeout::Initialise(HINSTANCE hInstance, dictionary* ini)
{
if(g_Initialised)
return;
// Check if the user wants this feature
bool disable = iniparser_getboolean(ini, DISABLE_OPTION, false);
if(disable) return;
g_CanCancel = !iniparser_getboolean(ini, DISABLE_CANCEL, false);
// Do some background stuff
RegisterWindowClass(hInstance);
LoadBitmaps(hInstance);
// Create our font
HDC hDC = GetDC(NULL);
DWORD h = -MulDiv(10, GetDeviceCaps(hDC, LOGPIXELSY), 72);
g_Font = CreateFont(h, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "Arial");
g_hInstance = hInstance;
g_Initialised = true;
}
/******************* FUNCTION *********************/
bool CMRCmdOptions::getConfigBoolean ( const std::string& key, bool defaultValue )
{
bool res = defaultValue;
if (iniDic != NULL)
return iniparser_getboolean(iniDic,key.c_str(),defaultValue);
if (dumpUsedDic != NULL)
setupDumpEntry(key,defaultValue?"true":"false");
return res;
}
bool INI::get(std::string where, bool default_value)
{
int test = -666;
test = iniparser_getboolean(this->ini, where.c_str(), test);
if (test == -666)
return default_value;
return ((test == 1) ?
true:
false);
}
void SegmenterManager::loadconfig(const char* confile)
{
if(confile == NULL)
return;
dictionary * ini;
char * s;
int sl = 0;
//m_config
ini = iniparser_load(confile);
if (ini==NULL) {
return; // not exist or not a valid ini file
}
/*
u1 merge_number_and_ascii;
u1 seperate_number_ascii;
u1 compress_space;
u1 number_and_ascii_joint[512];
*/
m_config.merge_number_and_ascii =
iniparser_getboolean(ini, "mmseg:merge_number_and_ascii", 0);
m_config.seperate_number_ascii =
iniparser_getboolean(ini, "mmseg:seperate_number_ascii", 0);
m_config.compress_space =
iniparser_getboolean(ini, "mmseg:compress_space", 0);
s =
iniparser_getstring(ini, "mmseg:number_and_ascii_joint", NULL);
if(s){
sl = strlen(s);
if(sl>511){
memcpy(m_config.number_and_ascii_joint,s,sl);
m_config.number_and_ascii_joint[511] = 0;
}else{
memcpy(m_config.number_and_ascii_joint,s,sl);
m_config.number_and_ascii_joint[sl] = 0;
}
}
m_config.omni_segmentation =
iniparser_getint(ini, "mmseg:omni_segmentation", 2); //output this only when term weight over 2
}
int getCfgValueBool(const char *fileName, const char *fieldName, int defaultvalue)
{
int val;
dictionary *ini;
if ((ini = iniparser_load(getCfgFilePath(fileName))) == NULL)
return defaultvalue;
val = iniparser_getboolean(ini, fieldName, defaultvalue);
iniparser_freedict(ini);
return val;
}
