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 ;
}
void INI::save(FILE* file)
{
if (! file)
return;
iniparser_dump_ini(this->ini, file);
}
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;
}
static int ini_dump(dictionary *ini, char *stb_ini_file_path)
{
char *tmp_file = "/var/change.ini";
FILE *fp;
char cmd[256] = { 0 };
int size;
fp = fopen(tmp_file, "w");
if (NULL == fp) {
cfg_error("fopen file %s failed\n", tmp_file);
return -1;
}
iniparser_dump_ini(ini, fp);
iniparser_freedict(ini);
fseek(fp, SEEK_SET, SEEK_END);
size = ftell(fp);
fclose(fp);
if (size > 10) {
sync();
sprintf(cmd, "mv %s %s", tmp_file, stb_ini_file_path);
system (cmd);
cfg_notice("%s\n", cmd);
sync();
n_module_stop(N_MOD_BROWS, 9);
n_module_stop(N_MOD_MPLAYER, 9);
} else {
cfg_notice("%s error size=%d\n", cmd, size);
unlink(tmp_file);
sync();
}
return FV_OK;
}
/*
*enum debug_business_enum{
* DBG_BUSINESS_NORMAL = 0,
* DBG_BUSINESS_ALLOC,
* DBG_BUSINESS_CONTAINER,
* MAX_DEBUG_BUSINESS_NUM
*};
*/
void debugger_set_businesses(debugger_t *debugger)
{
dictionary *d = debugger->d;;
int bussiness_num,i;
#define MAX_STRING_LEN 50
char switch_str[MAX_STRING_LEN];
char level_str[MAX_STRING_LEN];
int sw,lv;
bussiness_num = iniparser_getint(d, (char *)"businesses:business_num",0);
if(bussiness_num == 0){
iniparser_setstr(d, (char *)"businesses", NULL);
iniparser_setstr(d, (char *)"businesses:business_num", "3");
for(i = 0; i < MAX_DEBUG_BUSINESS_NUM; i++){
snprintf(switch_str,MAX_STRING_LEN,"businesses:business%d_switch",i);
snprintf(level_str,MAX_STRING_LEN,"businesses:business%d_level",i);
iniparser_setstr(d, switch_str,"1");
iniparser_setstr(d, level_str,"9");
debugger_set_business(debugger,i,1,9);
}
FILE *f = fopen(debugger->ini_file_name, "w");
iniparser_dump_ini(d, f);
fclose(f);
}else{
for(i = 0; i < bussiness_num; i++){
snprintf(switch_str,MAX_STRING_LEN,"businesses:business%d_switch",i);
snprintf(level_str,MAX_STRING_LEN,"businesses:business%d_level",i);
printf("debugger_set_businesses,bussiness_num=%d\n",bussiness_num);
sw = iniparser_getint(d, switch_str,1);
lv = iniparser_getint(d, level_str,9);
debugger_set_business(debugger,i,sw,lv);
}
}
#undef MAX_BUSINESSES_SETTING_LEN
}
/**
@brief Dumps the loaded config to stdout
@return int Returns FT_CONFIG_OK if there was a config file (even if it was
empty). If no config has been loaded, function returns FT_NO_CONFIG.
*/
int faptime_config_dump(void) {
if (config == NULL) {
return FT_NO_CONFIG;
}
iniparser_dump_ini(config, stdout);
return FT_CONFIG_OK;
}
void iniparser_save_ini(dictionary * d, const char * file) {
FILE *pFile;
pFile = fopen(file, "w");
if (pFile != NULL) {
iniparser_dump_ini(d, pFile);
fclose(pFile);
}
}
void
ccsIniSave (IniDictionary *dictionary,
const char *fileName)
{
if (!ccsCreateDirFor (fileName))
return;
iniparser_dump_ini (dictionary, fileName);
}
//save ini file
void Save_INI_File(dictionary *iniDictIn, char *fName)
{
//dump dict content to the file
FILE *fp;
fp = fopen(fName,"w+");
if(fp)
{
iniparser_dump_ini(iniDictIn, fp);
fclose(fp);
}
}
void update_config(char *token, char *username)
{
bstring file = locate_config_file();
bstring tmp = bstrcpy(file);
bcatcstr(tmp, ".tmp_XXXXXX");
int fd = mkstemp((char *) tmp->data);
if (fd < 0)
{
perror("mkstemp");
exit(1);
}
FILE *fp = fdopen(fd, "w");
if (fp == 0)
{
perror("fdopen");
exit(1);
}
dictionary *config;
struct stat statbuf;
int rc = stat((char *) file->data, &statbuf);
if (rc < 0 || statbuf.st_size == 0)
{
/* create a new empty dictionary */
config = dictionary_new(0);
dictionary_set(config, "authentication", 0);
}
else
{
config = iniparser_load(bdata(file));
}
iniparser_set(config, "authentication:token", token);
if (username)
iniparser_set(config, "authentication:user_id", username);
iniparser_dump_ini(config, fp);
iniparser_freedict(config);
fclose(fp);
if (rename(bdata(tmp), bdata(file)) < 0)
{
fprintf(stderr, "Error rename %s to %s: %s\n",
bdata(tmp), bdata(file), strerror(errno));
exit(1);
}
bdestroy(tmp);
bdestroy(file);
}
void save_conf()
{
unlink(DEF_CFG);
FILE *conf_f = fopen(DEF_CFG, "w");
if (!conf_f) {
LOG(URGENT, "Unable to open the config file");
return;
}
iniparser_dump_ini(ini, conf_f);
fclose(conf_f);
}
void InitParser::save(const string& file_name) const
{
// Check file presence
FILE * fp = NULL;
fp = fopen(file_name.c_str(),"wt");
if (fp) {
iniparser_dump_ini(dico, fp);
} else {
cerr << "ERROR : Can't open file " << file_name << endl;
// exit(-1);
}
if (fp) fclose(fp);
}
/******************* FUNCTION *********************/
void CMRCmdOptions::dumpUsedConfigFile ( void )
{
//trivial
if (dumpUsedDic == NULL || dumpConfigFile.empty())
return;
//dump only on master
if (cmrIsMPIMaster())
{
info("Dump used config file in '%s'.",dumpConfigFile.c_str());
overrideByConfigFile();
if (dumpConfigFile == "-")
{
iniparser_dump_ini(dumpUsedDic,stdout);
} else {
FILE * fp = fopen(dumpConfigFile.c_str(),"w");
assume(fp != NULL,"Fail to open file : '%s'",dumpConfigFile.c_str());
iniparser_dump_ini(dumpUsedDic,fp);
fclose(fp);
}
}
}
void network_print_init(debugger_t *debugger)
{
#define MAX_NETWORK_INIT_BUF_LEN 20
int sd;
struct sockaddr_in *raddr;
debug_network_prive_t *net_priv = &debugger->priv.net;
dictionary *d = debugger->d;;
char *ip;
uint32_t default_dbg_port = 10276;
char buf[MAX_NETWORK_INIT_BUF_LEN];
char default_dbg_ip[] = "127.0.0.1";
net_priv->port = iniparser_getint(d, (char *)"network:debug_port",default_dbg_port);
ip = iniparser_getstr(d, (char *)"network:debug_ip");
if(ip == NULL){
/*
*memcpy(debug_ip,get_ipaddr(),strlen(get_ipaddr()));
*/
dbg_str(DBG_ERROR,"iniparser_getstr err");
memcpy(net_priv->ip_str,default_dbg_ip,strlen(default_dbg_ip));
iniparser_setstr(d, (char *)"network", NULL);
debug_string_itoa(default_dbg_port,buf,10);
iniparser_setstr(d, (char *)"network:debug_port",buf);
iniparser_setstr(d, (char *)"network:debug_ip", net_priv->ip_str);
FILE *f = fopen(debugger->ini_file_name, "w");
iniparser_dump_ini(d, f);
fclose(f);
}
else
memcpy(net_priv->ip_str,ip,strlen(ip));
sd = socket(AF_INET,SOCK_DGRAM,0);
if(sd <0){
printf("create socket\n");
exit(1);
}
int val=1;
if(setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,&val,sizeof(val))<0){
printf("setsocgketopt error\n");
exit(1);
}
pthread_mutex_init(&debugger->priv.net.send_dgram_lock,NULL);
debugger->priv.net.sd = sd;
raddr = &debugger->priv.net.raddr;
raddr->sin_family = AF_INET;
raddr->sin_port = htons(net_priv->port);
inet_pton(AF_INET,net_priv->ip_str,&raddr->sin_addr);
#undef MAX_NETWORK_INIT_BUF_LEN
}
void InitParser::save(const string& file_name) const
{
// Check file presence
FILE * fp = NULL;
fp = fopen(file_name.c_str(),"wt");
if (fp) {
iniparser_dump_ini(dico, fp);
} else {
//~ cerr << "ERROR : Can't open file " << file_name << endl;
Log.write("Init_parser : can't open config file "+ file_name, cLog::eLOG_TYPE_ERROR);
// exit(-1);
}
if (fp) fclose(fp);
}
int flib_ini_save(flib_ini *ini, const char *filename) {
int result = INI_ERROR_OTHER;
if(!log_badargs_if2(ini==NULL, filename==NULL)) {
FILE *file = fopen(filename, "wb");
if(!file) {
flib_log_e("Error opening file \"%s\" for writing.", filename);
} else {
iniparser_dump_ini(ini->inidict, file);
if(fclose(file)) {
flib_log_e("Write error on ini file \"%s\"", filename);
} else {
result = 0;
}
}
}
return result;
}
bool AmConfigBase::save_config()
{
bool ret = false;
if (mDictionary && mConfigFile) {
FILE *filePointer = fopen(mConfigFile, "w+");
if (NULL == filePointer) {
ERROR("%s\n", strerror(errno));
} else {
iniparser_dump_ini(mDictionary, filePointer);
fclose(filePointer);
ret = true;
}
} else {
ERROR("Please load config file before save it!");
}
return ret;
}
void SaveConfigFile()
{
#if !defined(_WIN32) && !defined(__APPLE__)
// Get home dir
char buf[1024];
struct stat s;
homeDir = getenv("HOME");
snprintf(buf, 1024, "%s/%s", homeDir, DOT_DIR);
// Make dot dir if not existent
if (stat(buf, &s) == -1 || !S_ISDIR(s.st_mode))
mkdir(buf, 0755);
#else
homeDir = 0;
#endif
const char* configFile = FindConfigFile("vbam.ini");
if (configFile == NULL)
{
configFile = FindConfigFile("vbam.cfg");
}
if (configFile != NULL)
{
FILE *f = fopen(configFile, "w");
// Needs mixed case version of the option name to add new options into the ini
//for (int i = 0; i < (sizeof(argOptions) / sizeof(option)); i++)
//{
// std::string pref = "preferences:";
// pref.append(argOptions[i].name);
// if (!iniparser_find_entry(preferences, pref.c_str()))
// {
// iniparser_set(preferences, pref.c_str(), NULL);
// }
//}
iniparser_dump_ini(preferences, f);
fclose(f);
}
}
void ttscpVoiceDialog::accept()
{
QByteArray ba;
tts.stopf();
//tts.stop();
dictionary * ini = iniparser_load("qenix.ini"); //Must deallocate manualy
if (ini==NULL)
{
iniparser_freedict(ini);
fprintf(stderr, "cannot parse file [%s]", "qenix.ini");
return;
}
iniparser_dump(ini, stderr);
tts.setInit_f(spinF->value());
ba = QByteArray::number(spinF->value());
iniparser_setstr(ini, "ttscp:init_f", ba.data());
tts.setInit_i(spinI->value());
ba = QByteArray::number(spinI->value());
iniparser_setstr(ini, "ttscp:init_i", ba.data());
tts.setInit_t(spinT->value());
ba = QByteArray::number(spinT->value());
iniparser_setstr(ini, "ttscp:init_t", ba.data());
//msgbox(QString(t));
FILE *fw;
fw = fopen("qenix.ini", "wb+");
iniparser_dump_ini(ini, fw);
fclose(fw);
iniparser_freedict(ini);
done(Accepted);
}
/*init socket*/
void log_print_init(debugger_t *debugger)
{
debug_log_prive_t *log_priv = &debugger->priv.log;
FILE *fp;
dictionary *d = debugger->d;;
char *file_name;
char default_log_name[] = "dbg_log.txt";
printf("debug log init\n");
file_name = iniparser_getstr(d, (char *)"log:log_file_name");
if(file_name){
memcpy(log_priv->log_file_name,file_name,strlen(file_name));
}else{
memcpy(log_priv->log_file_name,default_log_name,strlen(default_log_name));
iniparser_setstr(d, (char *)"Log", NULL);
iniparser_setstr(d, (char *)"Log:log_file_name",log_priv->log_file_name);
FILE *f = fopen(debugger->ini_file_name, "w");
iniparser_dump_ini(d, f);
fclose(f);
}
fp = fopen(log_priv->log_file_name,"ab+");
if(fp == NULL)
{
perror("log file fopen()");
exit(1);
}
log_priv->fp = fp;
/*
*pthread_mutex_init(&log_priv->log_file_lock,NULL);
*/
printf("run at here.\n");
sync_lock_init(&log_priv->log_file_lock,debugger->lock_type);
printf("debug log init end\n");
}
extern bool ini_conf_save(p_conf conf)
{
dictionary *dict;
FILE *fp;
char buf[PATH_MAX];
int i;
if (conf == NULL) {
return false;
}
conf->confver = XREADER_VERSION_NUM;
dict = dictionary_new(0);
if (dict == NULL)
return false;
fp = fopen(conf_filename, "w");
if (fp == NULL) {
return false;
}
if (iniparser_setstring(dict, "Global", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "UI", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Text", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Image", NULL) != 0)
goto error;
if (iniparser_setstring(dict, "Music", NULL) != 0)
goto error;
iniparser_setstring(dict, "Global:path", conf->path);
iniparser_setstring(dict, "UI:forecolor",
hexToString(buf, sizeof(buf), conf->forecolor));
iniparser_setstring(dict, "Image:giftranscolor",
hexToString(buf, sizeof(buf), conf->giftranscolor));
iniparser_setstring(dict, "UI:bgcolor",
hexToString(buf, sizeof(buf), conf->bgcolor));
iniparser_setstring(dict, "UI:have_bg",
booleanToString(buf, sizeof(buf), conf->have_bg));
iniparser_setstring(dict, "UI:titlecolor",
hexToString(buf, sizeof(buf), conf->titlecolor));
iniparser_setstring(dict, "UI:menutextcolor",
hexToString(buf, sizeof(buf), conf->menutextcolor));
iniparser_setstring(dict, "UI:menubcolor",
hexToString(buf, sizeof(buf), conf->menubcolor));
iniparser_setstring(dict, "UI:selicolor",
hexToString(buf, sizeof(buf), conf->selicolor));
iniparser_setstring(dict, "UI:selbcolor",
hexToString(buf, sizeof(buf), conf->selbcolor));
iniparser_setstring(dict, "UI:msgbcolor",
hexToString(buf, sizeof(buf), conf->msgbcolor));
iniparser_setstring(dict, "UI:usedyncolor",
booleanToString(buf, sizeof(buf), conf->usedyncolor));
iniparser_setstring(dict, "Text:rowspace",
dwordToString(buf, sizeof(buf), conf->rowspace));
iniparser_setstring(dict, "Text:infobar",
infobarToString(buf, sizeof(buf), conf->infobar));
iniparser_setstring(dict, "Text:infobar_style",
intToString(buf, sizeof(buf), conf->infobar_style));
iniparser_setstring(dict, "Text:rlastrow",
booleanToString(buf, sizeof(buf), conf->rlastrow));
iniparser_setstring(dict, "Text:autobm",
booleanToString(buf, sizeof(buf), conf->autobm));
iniparser_setstring(dict, "Text:vertread",
vertreadToString(buf, sizeof(buf), conf->vertread));
iniparser_setstring(dict, "Text:encode",
encodeToString(buf, sizeof(buf), conf->encode));
iniparser_setstring(dict, "Image:fit",
fitToString(buf, sizeof(buf), conf->fit));
iniparser_setstring(dict, "Image:imginfobar",
booleanToString(buf, sizeof(buf), conf->imginfobar));
iniparser_setstring(dict, "Text:scrollbar",
booleanToString(buf, sizeof(buf), conf->scrollbar));
iniparser_setstring(dict, "Image:scale",
dwordToString(buf, sizeof(buf), conf->scale));
iniparser_setstring(dict, "Image:rotate",
rotateToString(buf, sizeof(buf), conf->rotate));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->txtkey[i]));
SPRINTF_S(key, "Image:imgkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->imgkey[i]));
}
iniparser_setstring(dict, "Global:shortpath", conf->shortpath);
iniparser_setstring(dict, "Global:confver",
hexToString(buf, sizeof(buf), conf->confver));
iniparser_setstring(dict, "Image:bicubic",
booleanToString(buf, sizeof(buf), conf->bicubic));
iniparser_setstring(dict, "Text:wordspace",
dwordToString(buf, sizeof(buf), conf->wordspace));
iniparser_setstring(dict, "Text:borderspace",
dwordToString(buf, sizeof(buf), conf->borderspace));
iniparser_setstring(dict, "Global:lastfile", conf->lastfile);
iniparser_setstring(dict, "Music:mp3encode",
encodeToString(buf, sizeof(buf), conf->mp3encode));
iniparser_setstring(dict, "Music:lyricencode",
encodeToString(buf, sizeof(buf), conf->lyricencode));
iniparser_setstring(dict, "Music:mp3cycle",
cycleToString(buf, sizeof(buf), conf->mp3cycle));
iniparser_setstring(dict, "Global:isreading",
booleanToString(buf, sizeof(buf), conf->isreading));
iniparser_setstring(dict, "UI:bgarch", conf->bgarch);
iniparser_setstring(dict, "UI:bgfile", conf->bgfile);
iniparser_setstring(dict, "UI:bgwhere",
intToString(buf, sizeof(buf), conf->bgwhere));
iniparser_setstring(dict, "Image:slideinterval",
dwordToString(buf, sizeof(buf), conf->slideinterval));
iniparser_setstring(dict, "Music:hprmctrl",
booleanToString(buf, sizeof(buf), conf->hprmctrl));
iniparser_setstring(dict, "UI:grayscale",
intToString(buf, sizeof(buf), conf->grayscale));
iniparser_setstring(dict, "Global:showhidden",
booleanToString(buf, sizeof(buf), conf->showhidden));
iniparser_setstring(dict, "Global:showunknown",
booleanToString(buf, sizeof(buf), conf->showunknown));
iniparser_setstring(dict, "Global:showfinfo",
booleanToString(buf, sizeof(buf), conf->showfinfo));
iniparser_setstring(dict, "Global:allowdelete",
booleanToString(buf, sizeof(buf), conf->allowdelete));
iniparser_setstring(dict, "Global:arrange",
arrangeToString(buf, sizeof(buf), conf->arrange));
iniparser_setstring(dict, "Global:enableusb",
booleanToString(buf, sizeof(buf), conf->enableusb));
iniparser_setstring(dict, "Image:viewpos",
viewposToString(buf, sizeof(buf), conf->viewpos));
iniparser_setstring(dict, "Image:imgmvspd",
dwordToString(buf, sizeof(buf), conf->imgmvspd));
iniparser_setstring(dict, "Image:imgpaging",
imgpagingToString(buf, sizeof(buf), conf->imgpaging));
iniparser_setstring(dict, "Image:imgpaging_spd",
dwordToString(buf, sizeof(buf), conf->imgpaging_spd));
iniparser_setstring(dict, "Image:imgpaging_interval",
dwordToString(buf, sizeof(buf),
conf->imgpaging_interval));
iniparser_setstring(dict, "Image:imgpaging_duration",
dwordToString(buf, sizeof(buf),
conf->imgpaging_duration));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Global:flkey1_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->flkey[i]));
}
iniparser_setstring(dict, "UI:fontsize",
intToString(buf, sizeof(buf), conf->fontsize));
iniparser_setstring(dict, "Text:reordertxt",
booleanToString(buf, sizeof(buf), conf->reordertxt));
iniparser_setstring(dict, "Text:pagetonext",
booleanToString(buf, sizeof(buf), conf->pagetonext));
iniparser_setstring(dict, "Text:autopage",
intToString(buf, sizeof(buf), conf->autopage));
iniparser_setstring(dict, "Text:prev_autopage",
intToString(buf, sizeof(buf), conf->prev_autopage));
iniparser_setstring(dict, "Text:autopagetype",
intToString(buf, sizeof(buf), conf->autopagetype));
iniparser_setstring(dict, "Text:autolinedelay",
intToString(buf, sizeof(buf), conf->autolinedelay));
iniparser_setstring(dict, "Image:thumb",
thumbToString(buf, sizeof(buf), conf->thumb));
iniparser_setstring(dict, "Text:bookfontsize",
intToString(buf, sizeof(buf), conf->bookfontsize));
iniparser_setstring(dict, "Text:enable_analog",
booleanToString(buf, sizeof(buf), conf->enable_analog));
iniparser_setstring(dict, "Image:img_enable_analog",
booleanToString(buf, sizeof(buf),
conf->img_enable_analog));
for (i = 0; i < 20; ++i) {
char key[20];
SPRINTF_S(key, "Text:txtkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->txtkey2[i]));
SPRINTF_S(key, "Image:imgkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->imgkey2[i]));
SPRINTF_S(key, "Global:flkey2_%02d", i);
iniparser_setstring(dict, key,
hexToString(buf, sizeof(buf), conf->flkey2[i]));
}
iniparser_setstring(dict, "Image:imgpagereserve",
dwordToString(buf, sizeof(buf), conf->imgpagereserve));
iniparser_setstring(dict, "Music:lyricex",
dwordToString(buf, sizeof(buf), conf->lyricex));
iniparser_setstring(dict, "Music:autoplay",
booleanToString(buf, sizeof(buf), conf->autoplay));
iniparser_setstring(dict, "Text:usettf",
booleanToString(buf, sizeof(buf), conf->usettf));
iniparser_setstring(dict, "Text:cttfarch", conf->cttfarch);
iniparser_setstring(dict, "Text:cttfpath", conf->cttfpath);
iniparser_setstring(dict, "Text:ettfarch", conf->ettfarch);
iniparser_setstring(dict, "Text:ettfpath", conf->ettfpath);
for (i = 0; i < 3; ++i) {
char key[20];
SPRINTF_S(key, "Global:freqs_%d", i);
iniparser_setstring(dict, key,
intToString(buf, sizeof(buf), conf->freqs[i]));
}
iniparser_setstring(dict, "Image:imgbrightness",
intToString(buf, sizeof(buf), conf->imgbrightness));
iniparser_setstring(dict, "Global:dis_scrsave",
booleanToString(buf, sizeof(buf), conf->dis_scrsave));
iniparser_setstring(dict, "Global:autosleep",
intToString(buf, sizeof(buf), conf->autosleep));
iniparser_setstring(dict, "Image:load_exif",
booleanToString(buf, sizeof(buf), conf->load_exif));
iniparser_setstring(dict, "Global:launchtype",
intToString(buf, sizeof(buf), conf->launchtype));
iniparser_setstring(dict, "Text:infobar_use_ttf_mode",
booleanToString(buf, sizeof(buf),
conf->infobar_use_ttf_mode));
iniparser_setstring(dict, "Text:infobar_fontsize",
dwordToString(buf, sizeof(buf),
conf->infobar_fontsize));
iniparser_setstring(dict, "Image:no_repeat",
booleanToString(buf, sizeof(buf), conf->img_no_repeat));
iniparser_setstring(dict, "Global:hide_flash",
booleanToString(buf, sizeof(buf), conf->hide_flash));
iniparser_setstring(dict, "Text:tabstop",
dwordToString(buf, sizeof(buf), conf->tabstop));
iniparser_setstring(dict, "Music:apetagorder",
booleanToString(buf, sizeof(buf), conf->apetagorder));
iniparser_setstring(dict, "UI:language", conf->language);
iniparser_setstring(dict, "UI:filelistwidth",
intToString(buf, sizeof(buf), conf->filelistwidth));
iniparser_setstring(dict, "Text:ttf_load_to_memory",
booleanToString(buf, sizeof(buf),
conf->ttf_load_to_memory));
iniparser_setstring(dict, "Global:save_password",
booleanToString(buf, sizeof(buf), conf->save_password));
iniparser_setstring(dict, "Text:scrollbar_width",
intToString(buf, sizeof(buf), conf->scrollbar_width));
iniparser_setstring(dict, "Text:hide_last_row",
booleanToString(buf, sizeof(buf), conf->hide_last_row));
iniparser_setstring(dict, "Text:infobar_show_timer",
booleanToString(buf, sizeof(buf),
conf->infobar_show_timer));
iniparser_setstring(dict, "Text:englishtruncate",
booleanToString(buf, sizeof(buf),
conf->englishtruncate));
iniparser_setstring(dict, "Image:image_scroll_chgn_speed",
booleanToString(buf, sizeof(buf),
conf->image_scroll_chgn_speed));
iniparser_setstring(dict, "Text:ttf_haste_up",
booleanToString(buf, sizeof(buf), conf->ttf_haste_up));
iniparser_setstring(dict, "Text:linenum_style",
booleanToString(buf, sizeof(buf), conf->linenum_style));
iniparser_setstring(dict, "Text:infobar_align",
alignToString(buf, sizeof(buf), conf->infobar_align));
iniparser_setstring(dict, "Music:musicdrv_opts", conf->musicdrv_opts);
iniparser_setstring(dict, "Image:magnetic_scrolling",
booleanToString(buf, sizeof(buf),
conf->magnetic_scrolling));
iniparser_setstring(dict, "Image:use_image_queue",
booleanToString(buf, sizeof(buf),
conf->use_image_queue));
iniparser_setstring(dict, "Image:max_cache_img",
dwordToString(buf, sizeof(buf), conf->max_cache_img));
iniparser_setstring(dict, "Music:show_encoder_msg",
booleanToString(buf, sizeof(buf),
conf->show_encoder_msg));
iniparser_dump_ini(dict, fp);
fclose(fp);
dictionary_del(dict);
return true;
error:
if (fp != NULL)
fclose(fp);
return false;
}
int main(int argc, char * argv[], char * envp[]) {
int n = 0;
dictionary *ini = NULL, *ini_tmp = NULL;
FILE * in = NULL ;
if (argc < 2) {
fprintf(stderr, "ssparser action args\n");
return -1;
}
if(!strcmp(argv[1], "merge")) {
if (argc < 4) {
fprintf(stderr, "ssparser merge file1 file2 ...\n");
return -1;
}
n = 2;
ini = iniparser_load_from_file(argv[n]);
if(NULL == ini) {
fprintf(stderr, "load %s error\n", argv[n]);
return -1;
}
for (n = n+1;n < argc; n++) {
ini_tmp = iniparser_load_from_file(argv[n]);
if(NULL == ini_tmp) {
fprintf(stderr, "load %s error\n", argv[n]);
return -1;
}
dictionary_merge(ini, ini_tmp);
iniparser_freedict(ini_tmp);
}
if ((in=fopen(argv[2], "w"))==NULL) {
fprintf(stderr, "iniparser: cannot open %s\n", argv[2]);
iniparser_freedict(ini);
return -1;
}
iniparser_dump_sh(ini, in);
fclose(in);
in = NULL;
iniparser_freedict(ini);
} else if(!strcmp(argv[1], "convert")) {
if(argc != 4) {
fprintf(stderr, "ssparser convert file_in json|sh|ini|update\n");
return -1;
}
ini = iniparser_load_from_file(argv[2]);
if(NULL == ini) {
fprintf(stderr, "cannot read file:%s\n", argv[2]);
return -1;
}
if(!strcmp(argv[3], "sh")) {
iniparser_dump_sh(ini, stdout);
} else if(!strcmp(argv[3], "ini")) {
iniparser_dump_ini(ini, stdout);
} else if(!strcmp(argv[3], "json")) {
iniparser_dump_json(ini, stdout);
} else if(!strcmp(argv[3], "update")) {
char** env;
for (env = envp; *env != 0; env++) {
char* this_env = xstrdup(*env);
char *v = strstr(this_env, "=");
if(v != NULL) {
*v = '\0';
v += 1;
iniparser_find_set(ini, this_env, v);
}
if(this_env != NULL) {
free(this_env);
}
}
if ((in=fopen(argv[2], "w"))==NULL) {
fprintf(stderr, "iniparser: cannot open %s\n", argv[2]);
iniparser_freedict(ini);
return -1;
}
iniparser_dump_sh(ini, in);
fclose(in);
in = NULL;
} else {
fprintf(stderr, "output format:%s not found\n", argv[3]);
}
iniparser_freedict(ini);
} else {
fprintf(stderr, "ssparser merge|convert file1 ...");
}
return 0 ;
}
static void ini_dump(struct config *c, FILE *f)
{
dictionary *ini = (dictionary *)c->priv;
iniparser_dump_ini(ini, f);
}
int main(int argc, const char *argv[]) {
const char* argument;
long int initial_timestamp;
float initial_lat, initial_lng, initial_alt;
float burst_alt, ascent_rate, drag_coeff, rmswinderror;
int descent_mode;
int scenario_idx, n_scenarios;
int alarm_time;
char* endptr; // used to check for errors on strtod calls
wind_file_cache_t* file_cache;
dictionary* scenario = NULL;
// configure command-line options parsing
void *options = gopt_sort(&argc, argv, gopt_start(
gopt_option('h', 0, gopt_shorts('h', '?'), gopt_longs("help")),
gopt_option('z', 0, gopt_shorts(0), gopt_longs("version")),
gopt_option('v', GOPT_REPEAT, gopt_shorts('v'), gopt_longs("verbose")),
gopt_option('o', GOPT_ARG, gopt_shorts('o'), gopt_longs("output")),
gopt_option('k', GOPT_ARG, gopt_shorts('k'), gopt_longs("kml")),
gopt_option('t', GOPT_ARG, gopt_shorts('t'), gopt_longs("start_time")),
gopt_option('i', GOPT_ARG, gopt_shorts('i'), gopt_longs("data_dir")),
gopt_option('d', 0, gopt_shorts('d'), gopt_longs("descending")),
gopt_option('e', GOPT_ARG, gopt_shorts('e'), gopt_longs("wind_error")),
gopt_option('a', GOPT_ARG, gopt_shorts('a'), gopt_longs("alarm"))
));
if (gopt(options, 'h')) {
// Help!
// Print usage information
printf("Usage: %s [options] [scenario files]\n", argv[0]);
printf("Options:\n\n");
printf(" -h --help Display this information.\n");
printf(" --version Display version information.\n");
printf(" -v --verbose Display more information while running,\n");
printf(" Use -vv, -vvv etc. for even more verbose output.\n");
printf(" -t --start_time <int> Start time of model, defaults to current time.\n");
printf(" Should be a UNIX standard format timestamp.\n");
printf(" -o --output <file> Output file for CSV data, defaults to stdout. Overrides scenario.\n");
printf(" -k --kml <file> Output KML file.\n");
printf(" -d --descending We are in the descent phase of the flight, i.e. after\n");
printf(" burst or cutdown. burst_alt and ascent_rate ignored.\n");
printf(" -i --data_dir <dir> Input directory for wind data, defaults to current dir.\n\n");
printf(" -e --wind_error <err> RMS windspeed error (m/s).\n");
printf(" -a --alarm <seconds> Use alarm() to kill pred incase it hangs.\n");
printf("The scenario file is an INI-like file giving the launch scenario. If it is\n");
printf("omitted, the scenario is read from standard input.\n");
exit(0);
}
if (gopt(options, 'z')) {
// Version information
printf("Landing Prediction version: %s\nCopyright (c) CU Spaceflight 2009\n", VERSION);
exit(0);
}
if (gopt_arg(options, 'a', &argument) && strcmp(argument, "-")) {
alarm_time = strtol(argument, &endptr, 0);
if (endptr == argument) {
fprintf(stderr, "ERROR: %s: invalid alarm length\n", argument);
exit(1);
}
alarm(alarm_time);
}
verbosity = gopt(options, 'v');
if (gopt(options, 'd'))
descent_mode = DESCENT_MODE_DESCENDING;
else
descent_mode = DESCENT_MODE_NORMAL;
if (gopt_arg(options, 'k', &argument) && strcmp(argument, "-")) {
kml_file = fopen(argument, "wb");
if (!kml_file) {
fprintf(stderr, "ERROR: %s: could not open KML file for output\n", argument);
exit(1);
}
}
else
kml_file = NULL;
if (gopt_arg(options, 't', &argument) && strcmp(argument, "-")) {
initial_timestamp = strtol(argument, &endptr, 0);
if (endptr == argument) {
fprintf(stderr, "ERROR: %s: invalid start timestamp\n", argument);
exit(1);
}
} else {
initial_timestamp = time(NULL);
}
if (!(gopt_arg(options, 'i', &data_dir) && strcmp(data_dir, "-")))
data_dir = "./";
// populate wind data file cache
file_cache = wind_file_cache_new(data_dir);
// read in flight parameters
n_scenarios = argc - 1;
if(n_scenarios == 0) {
// we'll parse from std in
n_scenarios = 1;
}
for(scenario_idx = 0; scenario_idx < n_scenarios; ++scenario_idx) {
char* scenario_output = NULL;
if(argc > scenario_idx+1) {
scenario = iniparser_load(argv[scenario_idx+1]);
} else {
scenario = iniparser_loadfile(stdin);
}
if(!scenario) {
fprintf(stderr, "ERROR: could not parse scanario file.\n");
exit(1);
}
if(verbosity > 1) {
fprintf(stderr, "INFO: Parsed scenario file:\n");
iniparser_dump_ini(scenario, stderr);
}
scenario_output = iniparser_getstring(scenario, "output:filename", NULL);
if (gopt_arg(options, 'o', &argument) && strcmp(argument, "-")) {
if(verbosity > 0) {
fprintf(stderr, "INFO: Writing output to file specified on command line: %s\n", argument);
}
output = fopen(argument, "wb");
if (!output) {
fprintf(stderr, "ERROR: %s: could not open CSV file for output\n", argument);
exit(1);
}
} else if (scenario_output != NULL) {
if(verbosity > 0) {
fprintf(stderr, "INFO: Writing output to file specified in scenario: %s\n", scenario_output);
}
output = fopen(scenario_output, "wb");
if (!output) {
fprintf(stderr, "ERROR: %s: could not open CSV file for output\n", scenario_output);
exit(1);
}
} else {
if(verbosity > 0) {
fprintf(stderr, "INFO: Writing output to stdout.\n");
}
output = stdout;
}
// write KML header
if (kml_file)
start_kml();
// The observant amongst you will notice that there are default values for
// *all* keys. This information should not be spread around too well.
// Unfortunately, this means we lack some error checking.
initial_lat = iniparser_getdouble(scenario, "launch-site:latitude", 0.0);
initial_lng = iniparser_getdouble(scenario, "launch-site:longitude", 0.0);
initial_alt = iniparser_getdouble(scenario, "launch-site:altitude", 0.0);
ascent_rate = iniparser_getdouble(scenario, "altitude-model:ascent-rate", 1.0);
// The 1.1045 comes from a magic constant buried in
// ~cuspaceflight/public_html/predict/index.php.
drag_coeff = iniparser_getdouble(scenario, "altitude-model:descent-rate", 1.0) * 1.1045;
burst_alt = iniparser_getdouble(scenario, "altitude-model:burst-altitude", 1.0);
rmswinderror = iniparser_getdouble(scenario, "atmosphere:wind-error", 0.0);
if(gopt_arg(options, 'e', &argument) && strcmp(argument, "-")) {
rmswinderror = strtod(argument, &endptr);
if (endptr == argument) {
fprintf(stderr, "ERROR: %s: invalid RMS wind speed error\n", argument);
exit(1);
}
}
{
int year, month, day, hour, minute, second;
year = iniparser_getint(scenario, "launch-time:year", -1);
month = iniparser_getint(scenario, "launch-time:month", -1);
day = iniparser_getint(scenario, "launch-time:day", -1);
hour = iniparser_getint(scenario, "launch-time:hour", -1);
minute = iniparser_getint(scenario, "launch-time:minute", -1);
second = iniparser_getint(scenario, "launch-time:second", -1);
if((year >= 0) && (month >= 0) && (day >= 0) && (hour >= 0)
&& (minute >= 0) && (second >= 0))
{
struct tm timeval = { 0 };
time_t scenario_launch_time = -1;
if(verbosity > 0) {
fprintf(stderr, "INFO: Using launch time from scenario: "
"%i/%i/%i %i:%i:%i\n",
year, month, day, hour, minute, second);
}
timeval.tm_sec = second;
timeval.tm_min = minute;
timeval.tm_hour = hour;
timeval.tm_mday = day; /* 1 - 31 */
timeval.tm_mon = month - 1; /* 0 - 11 */
timeval.tm_year = year - 1900; /* f**k you Millenium Bug! */
#ifndef _BSD_SOURCE
# warning This version of mktime does not allow explicit setting of timezone.
#else
timeval.tm_zone = "UTC";
#endif
scenario_launch_time = mktime(&timeval);
if(scenario_launch_time <= 0) {
fprintf(stderr, "ERROR: Launch time in scenario is invalid\n");
exit(1);
} else {
initial_timestamp = scenario_launch_time;
}
}
}
if(verbosity > 0) {
fprintf(stderr, "INFO: Scenario loaded:\n");
fprintf(stderr, " - Initial latitude : %lf deg N\n", initial_lat);
fprintf(stderr, " - Initial longitude : %lf deg E\n", initial_lng);
fprintf(stderr, " - Initial altitude : %lf m above sea level\n", initial_alt);
fprintf(stderr, " - Initial timestamp : %li\n", initial_timestamp);
fprintf(stderr, " - Drag coeff. : %lf\n", drag_coeff);
if(!descent_mode) {
fprintf(stderr, " - Ascent rate : %lf m/s\n", ascent_rate);
fprintf(stderr, " - Burst alt. : %lf m\n", burst_alt);
}
fprintf(stderr, " - Windspeed err. : %f m/s\n", rmswinderror);
}
{
// do the actual stuff!!
altitude_model_t* alt_model = altitude_model_new(descent_mode, burst_alt,
ascent_rate, drag_coeff);
if(!alt_model) {
fprintf(stderr, "ERROR: error initialising altitude profile\n");
exit(1);
}
if (!run_model(file_cache, alt_model,
initial_lat, initial_lng, initial_alt, initial_timestamp,
rmswinderror)) {
fprintf(stderr, "ERROR: error during model run!\n");
exit(1);
}
altitude_model_free(alt_model);
}
// release the scenario
iniparser_freedict(scenario);
// write footer to KML and close output files
if (kml_file) {
finish_kml();
fclose(kml_file);
}
if (output != stdout) {
fclose(output);
}
}
// release gopt data,
gopt_free(options);
// release the file cache resources.
wind_file_cache_free(file_cache);
return 0;
}
/* ...
*/
void CBaIniParse::TwistedIni() {
IBaIniParser *pNewHdl = 0;
dictionary *pOrgHdl = 0;
std::string tmp;
CPPUNIT_ASSERT(!IBaIniParserCreate("You/Shall/Not/Path"));
CPPUNIT_ASSERT(!iniparser_load("You/Shall/Not/Path"));
CPPUNIT_ASSERT(!IBaIniParserCreate(ERRORINI));
CPPUNIT_ASSERT(!iniparser_load(ERRORINI));
CPPUNIT_ASSERT(!iniparser_load(OFKEYINI));
CPPUNIT_ASSERT(!IBaIniParserCreate(OFKEYINI));
CPPUNIT_ASSERT(!IBaIniParserCreate(OFVALINI));
CPPUNIT_ASSERT(!iniparser_load(OFVALINI));
pNewHdl = IBaIniParserCreate(TWISTEDINI);
pOrgHdl = iniparser_load(TWISTEDINI);
CPPUNIT_ASSERT(pNewHdl);
CPPUNIT_ASSERT(pOrgHdl);
pNewHdl->Dump(stdout);
std::cout << "a==============================================================\n\n";
iniparser_dump(pOrgHdl, stdout);
std::cout << "a==============================================================\n\n";
pNewHdl->DumpIni(stdout);
std::cout << "a==============================================================\n\n";
iniparser_dump_ini(pOrgHdl, stdout);
CPPUNIT_ASSERT_EQUAL(
(bool) iniparser_find_entry(pOrgHdl, "open["),
pNewHdl->Exists("open["));
// Multi-lines
tmp = pNewHdl->GetString("multi:multi line key", "");
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == "multi line value");
tmp = pNewHdl->GetString("multi:visible", "");
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == "1");
tmp = pNewHdl->GetString("multi:a", "");
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == "beginend");
tmp = pNewHdl->GetString("multi:c", "");
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == "begin end");
CPPUNIT_ASSERT(IBaIniParserDestroy(pNewHdl));
iniparser_freedict(pOrgHdl);
pNewHdl = 0;
pOrgHdl = 0;
pNewHdl = IBaIniParserCreate(0);
pOrgHdl = dictionary_new(10);
CPPUNIT_ASSERT(pNewHdl);
CPPUNIT_ASSERT(pOrgHdl);
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set(0, 0), !iniparser_set(pOrgHdl, 0, 0));
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section", 0),
!iniparser_set(pOrgHdl, "section", 0));
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section:key", "value"),
!iniparser_set(pOrgHdl, "section:key", "value"));
tmp = pNewHdl->GetString("section:key", 0);
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == iniparser_getstring(pOrgHdl, "section:key", 0));
/* reset the key's value*/
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section:key", 0),
!iniparser_set(pOrgHdl, "section:key", 0));
tmp = iniparser_getstring(pOrgHdl, "section:key", "dummy") ?
iniparser_getstring(pOrgHdl, "section:key", "dummy") : "";
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == pNewHdl->GetString("section:key", "dummy"));
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section:key", "value"),
!iniparser_set(pOrgHdl, "section:key", "value"));
tmp = pNewHdl->GetString("section:key", 0);
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == iniparser_getstring(pOrgHdl, "section:key", 0));
iniparser_unset(pOrgHdl, "section:key");
pNewHdl->Reset("section:key");
tmp = pNewHdl->GetString("section:key", "dummy");
CPPUNIT_ASSERT_MESSAGE(tmp, tmp == iniparser_getstring(pOrgHdl, "section:key", "dummy"));
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section:key", 0), !iniparser_set(pOrgHdl, "section:key", 0));
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section:key1", 0), !iniparser_set(pOrgHdl, "section:key1", 0));
CPPUNIT_ASSERT_EQUAL(pNewHdl->Set("section:key2", 0), !iniparser_set(pOrgHdl, "section:key2", 0));
}
int
parse_ini_file(char *key, char *def, char *val, char *res)
{
FILE *fd;
dictionary *d;
int ini_update = 0;
char section[256] = {0};
switch( check_inifile() ) {
case 0:
return 0;
case 1:
return 1;
case 2:
ini_cur = ini_default;
d = iniparser_load(ini_default);
if (d) {
fd = fopen(ini_name, "w");
if (fd) {
iniparser_dump_ini(d, fd);
fclose(fd);
iniparser_freedict(d);
ini_cur = ini_name;
ini_update = 1;
break;
}
} else {
fprintf(stderr, "cannot parse file: %s\n",ini_cur);
}
return 0;
break;
case 3:
ini_cur = ini_name;
break;
case 4:
ini_cur = "/mnt/sd/mcaboot.ini";
break;
default:
break;
}
d = iniparser_load(ini_cur);
if (!d) {
fprintf(stderr, "cannot parse file: %s\n", ini_cur);
return -1;
}
if (key && val) {
char *s = iniparser_getstring(d, key, NULL);
if (s) {
if (strcmp(s, val)) {
iniparser_set(d, key, val);
ini_update = 1;
}
} else {
iniparser_get_section_string(key, section);
iniparser_set(d, section, NULL);
iniparser_set(d, key, val);
ini_update = 1;
}
}
if (key && res) {
char *s = iniparser_getstring(d, key, def);
strcpy(res, s);
}
if (ini_update) {
fd = fopen(ini_name, "w");
if (fd) {
iniparser_dump_ini(d, fd);
fflush(fd);
fclose(fd);
}
}
iniparser_freedict(d);
return 0;
}
