/**
******************************************************************************
* @brief 从配置文件中获取服务器ip字符串
* @param[out] *pserverip : 返回服务器ip字符串
*
* @retval -1 失败
* @retval 0 成功
******************************************************************************
*/
int
ini_get_server_ip(char * pserverip)
{
dictionary * ini ;
char *pstr = NULL;
ini = iniparser_load(DEFAULT_INI_FILE);
if (NULL == ini)
{
create_example_ini_file();
ini = iniparser_load(DEFAULT_INI_FILE);
if (ini == NULL)
{
return -1;
}
}
iniparser_dump(ini, NULL);
pstr = iniparser_getstring(ini, "client:ip", NULL);
if (pstr == NULL)
{
return -1;
}
strncpy(pserverip, pstr, 16); //ip字符串最长16字节
iniparser_freedict(ini);
return 0;
}
void loadControlConfiguration(char* filename)
{
char str[255];
sprintf(str,"%s/%s",basePath,filename);
dictionary* dic=iniparser_load(str);
if(!dic)dic=iniparser_load(filename);
int i; for(i=0;i<INPUT_NUMBER;i++)
{
char str[255];
sprintf(str,"controls:%s",inputStrings[i]);
currentConfiguration[i]=actionByString(dictionary_get(dic, str, inputDefaults[i]));
if(currentConfiguration[i]==CONTROL_NUMBER)currentConfiguration[i]=actionByString(inputDefaults[i]);
}
iniparser_freedict(dic);
}
struct cras_card_config *cras_card_config_create(const char *config_path,
const char *card_name)
{
struct cras_card_config *card_config = NULL;
char ini_name[MAX_INI_NAME_LEN + 1];
dictionary *ini;
snprintf(ini_name, MAX_INI_NAME_LEN, "%s/%s", config_path, card_name);
ini_name[MAX_INI_NAME_LEN] = '\0';
ini = iniparser_load(ini_name);
if (ini == NULL) {
syslog(LOG_DEBUG, "No ini file %s", ini_name);
return NULL;
}
card_config = calloc(1, sizeof(*card_config));
if (card_config == NULL) {
iniparser_freedict(ini);
return NULL;
}
card_config->ini = ini;
syslog(LOG_DEBUG, "Loaded ini file %s", ini_name);
return card_config;
}
void update_ini_file(char *ini_name)
{
dictionary *ini ;
char bstr[33];
FILE *fini ;
ini = iniparser_load(ini_name);
if (ini==NULL){
logErrDate("update_ini_file: cannot parse ini-file: %s!\n Exit!\n", ini_name);
exit_all(-1);
}
sprintf(bstr,"%i",pga[0]);
iniparser_set(ini, "default:pga_ch1", bstr);
sprintf(bstr,"%i",pga[1]);
iniparser_set(ini, "default:pga_ch2", bstr);
sprintf(bstr,"%i",pga[2]);
iniparser_set(ini, "default:pga_ch3", bstr);
sprintf(bstr,"%i",pga[3]);
iniparser_set(ini, "default:pga_ch4", bstr);
fini = fopen(ini_name, "w");
if (fini==NULL){
logErrDate("update_ini_file: cannot open ini-file %s to update!\nExit!\n", ini_name);
exit_all(-1);
}
fprintf(fini,"%s\n",ini_comments);
iniparser_dumpsection_ini(ini, "default", fini);
iniparser_dumpsection_ini(ini, "output", fini);
fclose(fini);
iniparser_freedict(ini);
}
//--------------------------------------------------
// read the conf file
//--------------------------------------------------
int configfile_Read(char * ini_name, ALARMCENTER* ptAlarmCenter)
{
dictionary * ini ;
ini = iniparser_load(ini_name);
if (ini==NULL) {
fprintf(stderr, "cannot parse file: %s\n", ini_name);
return -1 ;
}
ptAlarmCenter->iOnOff = iniparser_getint(ini, "main:onoff", 0);
ptAlarmCenter->iAlarmMode = iniparser_getint(ini, "main:alarmmode", 1);
ptAlarmCenter->iAlarmTime = iniparser_getint(ini, "main:alarmtime", 10);
ptAlarmCenter->iWarningMode = iniparser_getint(ini, "main:warningmode", 1);
ptAlarmCenter->iWarningTime = iniparser_getint(ini, "main:warningtime", 5);
ptAlarmCenter->iAlarmSchwelle1 = iniparser_getint(ini, "main:alarmschwelle1", 1);
ptAlarmCenter->iAlarmSchwelle2 = iniparser_getint(ini, "main:alarmschwelle2", 50);
ptAlarmCenter->iOnDelay = iniparser_getint(ini, "main:ondelay", 50);
ptAlarmCenter->iAlarmDelay = iniparser_getint(ini, "main:alarmdelay", 50);
ptAlarmCenter->iWarningDelay = iniparser_getint(ini, "main:warningdelay", 50);
ptAlarmCenter->iStartHour = iniparser_getint(ini, "main:starthour", 2);
ptAlarmCenter->iStopHour = iniparser_getint(ini, "main:stophour", 23);
ptAlarmCenter->iTcpPort = iniparser_getint(ini, "tcp:port", 1234);
iniparser_freedict(ini);
return 0 ;
}
void finiparser_load(char * fname,int* ierr,int fname_len)
{
*ierr = 0;
dic = iniparser_load(addchar0(fname,fname_len));
if (dic == NULL) *ierr = 1;
return;
}
void con_load_from_file(char_t *filename)
{
dictionary *conf ;
int32_t index;
char_t section[128];
char_t *read_str;
FILE *fd;
char_t line[128];
int32_t conn_id;
fd = fopen(filename, "r");
if (fd == NULL)
{ sprintf(line , "File read open error: %s\n",filename);
EXERROR(line, 3);
}
fclose(fd);
conf = iniparser_load(filename);
if (conf==NULL) {
fprintf(stdout, "cannot parse file: %s\n", filename);
EXERROR("Critical error.", 3);
}
//iniparser_dump(conf, stderr);
dmap_lock_sysdat();
dmap_wrlock_table_pcapls();
conf_load(conf);
iniparser_freedict(conf);
dmap_wrunlock_table_pcapls();
dmap_unlock_sysdat();
}
static int configuration_load_config_file( struct configuration_data *c)
{
dictionary *Mydict;
Mydict=iniparser_load( c->config_file);
char *cc;
if ( Mydict == NULL ) return -1;
cc = iniparser_getstring( Mydict, "network:smbta_port_number",NULL);
if (cc != NULL) c->port = (int) common_myatoi(cc);
cc = iniparser_getstring( Mydict, "network:smbta_host_name",NULL);
if (cc != NULL) c->host = strdup(cc);
cc = iniparser_getstring(Mydict,"general:debug_level",NULL);
if (cc != NULL) {
c->debug_level = (int) common_myatoi(cc);
}
cc = iniparser_getstring(Mydict,"general:keyfile",NULL);
if (cc != NULL) {
common_load_key_from_file( c);
}
cc = iniparser_getstring(Mydict,"general:identify",NULL);
if (cc != NULL) {
c->identify = (int) common_myatoi(cc);
}
return 0;
}
int log_manager::load_config()
{
if (this->ini_obj_)
{
iniparser_freedict(this->ini_obj_);
this->ini_obj_ = 0;
}
this->ini_obj_ = iniparser_load(this->config_filename_.c_str());
if (this->ini_obj_ == 0)
{
::fprintf(stderr, "cannot parse file: %s",
this->config_filename_.c_str());
return -1;
}
#ifdef NDK_LOG_DEBUG
iniparser_dump(this->ini_obj_, stderr);
#endif
// Global config
if (this->load_cfg_global() != 0)
return -1;
if (this->load_cfg_modules() != 0)
return -1;
return 0;
}
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);
}
}
DialogRecepti::DialogRecepti(QWidget *parent) : QDialog(parent), ui(new Ui::DialogRecepti)
{
ui->setupUi(this);
ui->listWidget->setSelectionMode(QAbstractItemView::SingleSelection);
connect(ui->btnOpenFile,SIGNAL(clicked()),this,SLOT(onOpenFile()));
connect(ui->btnExit,SIGNAL(clicked()),this,SLOT(onExit()));
char * fn = new char[40];
strcpy(fn,"/sdcard/recepti/recepti.bet");
dict = iniparser_load(fn);
if(dict == NULL)
{
QMessageBox::information(this,"iniparser library",QString("Failed to load dictionary from file:\n%1").arg(fn));
return;
}
int n = iniparser_getnsec(dict);
//QMessageBox::information(this,QString("iniparser"),QString("%1 sections found from file: %2").arg(n).arg(fn));
if(n>0)
{
for(int i =0 ; i<n ; i++)
{
QString str(iniparser_getsecname(dict,i));
ui->listWidget->addItem(str.toUpper());
}
ui->listWidget->item(0)->setSelected(true);
}
}
int faptime_config_parse(char *path) {
if (config != NULL) {
iniparser_freedict(config);
config = NULL;
}
config = iniparser_load(path);
if (!config) {
/* This is the only real error here... */
return FT_CONFIG_ERROR;
}
char *table = faptime_config_get_table();
if (table == NULL) {
return FT_NO_TABLE;
}
struct faptime_table *ft = faptime_table_from_string(table, NULL);
free(table);
if (!ft) {
iniparser_freedict(config);
config = NULL;
return FT_BAD_TABLE;
}
faptime_set_global_table(ft);
free(ft);
ft = NULL;
return FT_CONFIG_OK;
}
int parse_ini_file(char * ini_name)
{
dictionary * ini ;
const char * s;
int i;
printf("Parse: Read configuration: %s\n", ini_name);
ini = iniparser_load(ini_name);
if (ini==NULL) {
//fprintf(stderr, "cannot parse file: %s\n", ini_name);
return -1 ;
}
s = iniparser_getstring(ini, "firmata:port", NULL);
serial_port = strdup(s);
int ret;
for(i=0; i<NUM_REL; i++) {
char *new_str;
ret = asprintf(&new_str,"%s%d","files:file",i+1);
s = iniparser_getstring(ini, new_str, NULL);
file[i] = strdup(s);
ret = asprintf(&new_str,"%s%d","firmata:rel_port_",i+1);
rel[i] = iniparser_getint(ini, new_str, -1);
ret = asprintf(&new_str,"%s%d","firmata:rel_inv_",i+1);
inv[i] = iniparser_getint(ini, new_str, -1);;
}
ledg = iniparser_getint(ini, "firmata:ledg", -1);
ledb = iniparser_getint(ini, "firmata:ledb", -1);
ledr = iniparser_getint(ini, "firmata:ledr", -1);
iniparser_freedict(ini);
return 0 ;
}
void ClistManager::ReadList()
{
m_vecLGTargetInfo.clear();
dictionary* pDictionary = NULL;
pDictionary = iniparser_load(LS_LIST_FILENAME);
if(NULL == pDictionary)
{
OUR_DEBUG((LM_ERROR, "[ClistManager::ReadList](%s)Read Ini fail.\n", LS_LIST_FILENAME));
return;
}
uint32 u4Count = (uint32)iniparser_getint(pDictionary, "List:Count", 0);
char szTempName[50] = {'\0'};
for(uint32 i = 0; i < u4Count; i++)
{
_LG_Target_Info objTarhgetInfo;
sprintf_safe(szTempName, 50, "List:LGID%d", i);
objTarhgetInfo.m_u4LGID = (uint32)iniparser_getint(pDictionary, szTempName, 0);
sprintf_safe(szTempName, 50, "List:LGIP%d", i);
char* pData = iniparser_getstring(pDictionary, szTempName, NULL);
{
sprintf_safe(objTarhgetInfo.m_szIP, 50, "%s", pData);
}
sprintf_safe(szTempName, 50, "List:LGPort%d", i);
objTarhgetInfo.m_u4Port = (uint32)iniparser_getint(pDictionary, szTempName, 0);;
m_vecLGTargetInfo.push_back(objTarhgetInfo);
}
}
void reload_config()
{
free_cfg(0);
ini = iniparser_load(DEF_CFG);
if (ini==NULL) {
write_to_log(FATAL, "cannot parse file: %s\n", DEF_CFG);
goto err;
}
if (!section_list) {
section_list = malloc(sizeof(struct sectionList));
if(!section_list) {
write_to_log(FATAL, "%s - %d - %s", __func__, __LINE__, "Unable to allocate memory");
goto err;
}
}
if (_get_sections() != 0) {
write_to_log(FATAL, "%s - %d - %s", __func__, __LINE__, "Section List could not be filled");
goto err;
}
write_to_log(INFO, "%s", "Configuration reloaded without error");
return;
err:
exit(EXIT_FAILURE);
}
void CBaseCommand::ReadIniFile(const char* pIniFileName)
{
dictionary* pDictionary = NULL;
pDictionary = iniparser_load(pIniFileName);
if(NULL == pDictionary)
{
OUR_DEBUG((LM_ERROR, "[CBaseCommand::ReadIniFile](%s)Read Ini fail.\n", pIniFileName));
return;
}
else
{
//读取Ini文件内容
m_u4LSServerID = (uint32)iniparser_getint(pDictionary, "LSServer:ServerID", NULL);
if(NULL != m_u4LSServerID)
{
OUR_DEBUG((LM_INFO, "[CBaseCommand::ReadIniFile]ServerID=%d.\n", m_u4LSServerID));
}
char* pData = iniparser_getstring(pDictionary, "LSServer:IP", NULL);
if(NULL != pData)
{
OUR_DEBUG((LM_INFO, "[CBaseCommand::ReadIniFile]IP=%s.\n", pData));
sprintf_safe(m_szLSIP, 50, "%s", pData);
}
m_u4LSPort = (uint32)iniparser_getint(pDictionary, "LSServer:Port", 0);
if(0 != m_u4LSPort)
{
OUR_DEBUG((LM_INFO, "[CBaseCommand::ReadIniFile]Port=%d.\n", m_u4LSPort));
}
iniparser_freedict(pDictionary);
}
}
char* DeviceFunctionCfg_GetField( int FunctionNumber, char* FieldName, char* DeviceCfgPath )
{
char* ret = NULL;
char* Section = NULL;
char* Newline;
dictionary* Dict = iniparser_load( DeviceCfgPath );
Section = iniparser_getsecname( Dict, FunctionNumber );
ret = iniparser_getsecstring( Dict, Section, FieldName, NULL ) ;
if( ret != NULL )
{
Newline = strstr(ret, "\\n");
while( Newline != NULL )
{
if( *( Newline-1 ) != '\\' )
{
*Newline = ' ';
*(Newline+1) = '\n';
}
Newline = strstr(ret, "\\n");
}
ret = strdup( ret );
}
iniparser_freedict( Dict );
return ret;
}
int main() {
dictionary *ini = iniparser_load("config.ini");
iniparser_dump(ini, stdout);
return 0;
}
static void parse_ips_mode_ini(void)
{
dictionary *ini = NULL;
int ret = 0;
ini = iniparser_load("./slave.ini");
if (ini == NULL) {
fprintf(stderr,"can not open %s","slave.ini");
return;
}
ret = iniparser_getint(ini, "ips_mode:dma_use_chain", -1);
if(ret != -1) {
test_ips_mode.dma_use_chain = ret;
}
ret = iniparser_getint(ini, "ips_mode:dma_use_nlwr", -1);
if(ret != -1) {
test_ips_mode.dma_use_nlwr = ret;
}
ret = iniparser_getint(ini, "ips_mode:tx_use_wptr", -1);
if(ret != -1) {
test_ips_mode.tx.use_wptr = ret;
}
ret = iniparser_getint(ini, "ips_mode:tx_use_rptr", -1);
if(ret != -1) {
test_ips_mode.tx.use_rptr = ret;
}
ret = iniparser_getint(ini, "ips_mode:rx_use_wptr", -1);
if(ret != -1) {
test_ips_mode.rx.use_wptr = ret;
}
ret = iniparser_getint(ini, "ips_mode:rx_use_rptr", -1);
if(ret != -1) {
test_ips_mode.rx.use_rptr = ret;
}
}
/* Parse Configuration File */
dictionary* load_conf(void)
{
char *path = concat_str(get_execdir(), "/conf/hawkd.ini", NULL);
dictionary *file = iniparser_load(path);
free(path);
return file;
}
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));
}
void camera_control_restore_system_settings(CameraControl* cc, const char* file) {
int NOT_FOUND = -1;
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) {
dictionary* ini = iniparser_load(file);
AutoAEC = iniparser_getint(ini, "PSEye:AutoAEC", NOT_FOUND);
AutoAGC = iniparser_getint(ini, "PSEye:AutoAGC", NOT_FOUND);
Gain = iniparser_getint(ini, "PSEye:Gain", NOT_FOUND);
Exposure = iniparser_getint(ini, "PSEye:Exposure", NOT_FOUND);
Contrast = iniparser_getint(ini, "PSEye:Contrast", NOT_FOUND);
Brightness = iniparser_getint(ini, "PSEye:Brightness", NOT_FOUND);
iniparser_freedict(ini);
if (AutoAEC != NOT_FOUND)
v4l2_set_control(fd, V4L2_CID_EXPOSURE_AUTO, AutoAEC);
if (AutoAGC != NOT_FOUND)
v4l2_set_control(fd, V4L2_CID_AUTOGAIN, AutoAGC);
if (Gain != NOT_FOUND)
v4l2_set_control(fd, V4L2_CID_GAIN, Gain);
if (Exposure != NOT_FOUND)
v4l2_set_control(fd, V4L2_CID_EXPOSURE, Exposure);
if (Contrast != NOT_FOUND)
v4l2_set_control(fd, V4L2_CID_CONTRAST, Contrast);
if (Brightness != NOT_FOUND)
v4l2_set_control(fd, V4L2_CID_BRIGHTNESS, Brightness);
}
}
bstring get_token_from_config_file()
{
bstring config_file = locate_config_file();
dictionary *config;
struct stat statbuf;
int rc = stat((char *) config_file->data, &statbuf);
if (rc < 0 || statbuf.st_size == 0)
{
bdestroy(config_file);
return 0;
}
else
{
config = iniparser_load(bdata(config_file));
}
char *token = iniparser_getstring(config, "authentication:token", 0);
bdestroy(config_file);
bstring ret = 0;
if (token)
{
ret = bfromcstr(token);
}
iniparser_freedict(config);
return ret;
}
/**
* Creates the ini file for the odom and initializes the odom values to initial values
*/
void Odometry_Boot(Sensor * sensor,SensorVariable * start)
{
/* MAKE THESE GLOBAL*/
LOG.ODOMETRY("BOOTING THE ODOMETERY SENSOR");
if(fileExists("config/odometry.ini"))
{
dictionary* config = iniparser_load("config/odometry.ini");
Odometry_leftWheelMeterPerTick = iniparser_getdouble(config,"WheelEncoderConstant:MeterPerTickLeft",0);
Odometry_rightWheelMeterPerTick = iniparser_getdouble(config,"WheelEncoderConstant:MeterPerTickRight",0);
Odometry_trackInMeters = iniparser_getdouble(config,"DistanceBetweenWheels:track",0);
Odometry_cvarL = iniparser_getdouble(config,"Variance:LeftWheel",.000049871);
Odometry_cvarR = iniparser_getdouble(config,"Variance:RightWheel",.000073805);
iniparser_freedict(config);
LOG.ODOMETRY("Odometry Ini file loaded");
}
else
{
LOG.ERR("odomentry.ini was not found");
}
matrix Variance = Matrix_Create(2,2);
Variance = Matrix_SetValue(Variance,1,1,.01);
Variance = Matrix_SetValue(Variance,2,2,.01);
sensor->state->Variance=Variance;
sensor->state->State= Matrix_Create(3,1);
sensor->H = Matrix_Create(2,6);
sensor->H = Matrix_SetValue(sensor->H,1,4,PSOUpdateRateInS);
sensor->H = Matrix_SetValue(sensor->H,1,5,Odometry_trackInMeters*PSOUpdateRateInS/2.0);
sensor->H = Matrix_SetValue(sensor->H,2,4,PSOUpdateRateInS);
sensor->H = Matrix_SetValue(sensor->H,2,5,-Odometry_trackInMeters*PSOUpdateRateInS/2.0);
Odometry_rightWheelTicks=Microprocessor->getRightWheelTicks();
Odometry_leftWheelTicks=Microprocessor->getLeftWheelTicks();
}
int main()
{
char ini_name[80]="/root/test.ini";
char entry_name[80]="";
int exists_flag;
int radars;
int r;
ini= iniparser_load(ini_name);
printf("Testing INI reading\n");
// if (ini==NULL) {
// fprintf(stderr, "cannot parse file: %s\n", ini_name);
// return -1 ;
// }
exists_flag=iniparser_find_entry(ini,"site_settings:number_of_radars");
if(exists_flag) {
radars=iniparser_getint(ini,"site_settings:number_of_radars",0);
printf(" Number of radars:%d\n",radars);
} else {
printf("Entry does not exist: %s\n","site_settings:number_of_radars");
}
for(r=1;r<=radars;r++) {
sprintf(entry_name,"radar_%d",r);
exists_flag=iniparser_find_entry(ini,entry_name);
if(exists_flag) {
printf(" radar %d section exists\n",r);
sprintf(entry_name,"radar_%d:stid",r);
printf(" Station ID: %d\n",iniparser_getint(ini,entry_name,-1));
}
}
// iniparser_dump(ini, stderr);
iniparser_freedict(ini);
return 0;
}
void verlet(const char* filename){
dictionary* ini;
ini = iniparser_load(filename);
iniparser_dump(ini, stdout);
FILE *file;
file = fopen(LOGFILE, "a");
iniparser_dump(ini, file);
fclose(file);
ReportMessage("\n");
t_key key = key_init(ini);
t_pSys pSys = pSys_init (ini);
t_opts opts = opts_init (ini);
t_pair p = t_pair_init(ini);
t_dump dump = dump_init(ini);
t_fix fix = fix_init(ini);
t_compute compute = compute_init(ini, &key);
init (&key, &pSys, &opts, &p, &compute);
if(key.dump) dump_run(&key, &pSys, &opts, &dump); // Make initial snapshot.
while(opts.thisIter < opts.targIters){ // Repeat until iterational limit.
verlet_iter (&key, &pSys, &opts, &p, &fix, &compute);
if(key.dump) dump_run(&key, &pSys, &opts, &dump);
resetStep(&pSys);
}
}
void parse_config() {
conf = iniparser_load("opensunny.ini");
//dictionary_dump(conf, stderr);
populate_inverter_list(conf, inverters, &inverter_count, MAX_INVERTERS);
}
NTSTATUS gp_inifile_init_context(TALLOC_CTX *mem_ctx,
uint32_t flags,
const char *unix_path,
const char *suffix,
struct gp_inifile_context **ctx_ret)
{
struct gp_inifile_context *ctx = NULL;
NTSTATUS status;
dictionary *dict = NULL;
char *tmp_filename = NULL;
const char *ini_filename = NULL;
if (!unix_path || !ctx_ret) {
return NT_STATUS_INVALID_PARAMETER;
}
ctx = TALLOC_ZERO_P(mem_ctx, struct gp_inifile_context);
NT_STATUS_HAVE_NO_MEMORY(ctx);
talloc_set_destructor(ctx, gp_inifile_free_context);
status = gp_find_file(mem_ctx, flags, unix_path, suffix,
&ini_filename);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
status = convert_file_from_ucs2(mem_ctx, ini_filename,
&tmp_filename);
if (!NT_STATUS_IS_OK(status)) {
goto failed;
}
dict = iniparser_load(tmp_filename);
if (!dict) {
status = NT_STATUS_NO_SUCH_FILE;
goto failed;
}
ctx->generated_filename = tmp_filename;
ctx->dict = dict;
ctx->mem_ctx = mem_ctx;
*ctx_ret = ctx;
return NT_STATUS_OK;
failed:
DEBUG(1,("gp_inifile_init_context failed: %s\n",
nt_errstr(status)));
TALLOC_FREE(ctx);
return status;
}
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 ;
}
static int ini_load(struct config *c, const char *name)
{
dictionary *ini = iniparser_load(name);
if (!ini) {
loge("iniparser_load %s failed!\n", name);
return -1;
}
c->priv = (void *)ini;
return 0;
}
