int main(int argc, char ** argv)
{
char * recname;
config_t cfg;
if(argc != 2)
usage(argv[0]);
recname = argv[1];
err = open(STATEFILE,O_RDWR);
CHECK_ERR_LTZ("Open schedule file");
fd = err;
err = flock(fd, LOCK_SH);
CHECK_ERR("Lock statefile");
err = atexit(&exitfunc);
config_init(&cfg);
config_read_file(&cfg, STATEFILE);
config_setting_t *root;
root = config_root_setting(&cfg);
err = config_setting_remove(root, recname);
CHECK_CFG("Remove recording from schedule");
err = config_write_file(&cfg, STATEFILE);
CHECK_CFG("Write config file");
config_destroy(&cfg);
return 0;
}
int cfgWriteFile(config_t *config, const TCHAR *filename)
{
char uFileName[MAX_PATH];
UTF8_Encode(filename, uFileName, MAX_PATH);
return config_write_file(config, uFileName);
}
void MainDialog::saveConfig() {
// ensure the existance of user config dir
QString configDir = QFileInfo(userConfigFile_).dir().path();
QDir().mkpath(configDir);
qDebug() << userConfigFile_;
// save the config file
config_write_file(&config_, userConfigFile_.toLocal8Bit().constData());
// ask compton to reload the config
QString displayName = qgetenv("DISPLAY");
for(int i = 0; i < displayName.length(); ++i) {
if(!displayName[i].isNumber()) // replace non-numeric chars with _
displayName[i] = '_';
}
QString comptonServiceName = COMPTON_SERVICE_PREFIX + displayName;
QDBusInterface iface(comptonServiceName, COMPTON_PATH, COMPTON_INTERFACE);
if(iface.isValid()) {
iface.call("reset");
// raise ourself to the top again (we'll loosing focus after reloading compton)
activateWindow();
}
// FIXME: dbus interface of compton is not always available and reset() creates
// much flickers. Maybe we should use internal dbus method set_opts().
// Or, we can patch compton to do what we want.
}
int main(int argc, char **argv)
{
static const char *output_file = "updated.cfg";
config_t cfg;
config_setting_t *root, *setting, *movie;
config_init(&cfg);
/* Read the file. If there is an error, report it and exit. */
if(! config_read_file(&cfg, "example.cfg"))
{
fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return(EXIT_FAILURE);
}
/* Find the 'movies' setting. Add intermediate settings if they don't yet
* exist.
*/
root = config_root_setting(&cfg);
setting = config_setting_get_member(root, "inventory");
if(!setting)
setting = config_setting_add(root, "inventory", CONFIG_TYPE_GROUP);
setting = config_setting_get_member(setting, "movies");
if(!setting)
setting = config_setting_add(setting, "movies", CONFIG_TYPE_LIST);
/* Create the new movie entry. */
movie = config_setting_add(setting, NULL, CONFIG_TYPE_GROUP);
setting = config_setting_add(movie, "title", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "Buckaroo Banzai");
setting = config_setting_add(movie, "media", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "DVD");
setting = config_setting_add(movie, "price", CONFIG_TYPE_FLOAT);
config_setting_set_float(setting, 12.99);
setting = config_setting_add(movie, "qty", CONFIG_TYPE_INT);
config_setting_set_float(setting, 20);
/* Write out the updated configuration. */
if(! config_write_file(&cfg, output_file))
{
fprintf(stderr, "Error while writing file.\n");
config_destroy(&cfg);
return(EXIT_FAILURE);
}
fprintf(stderr, "Updated configuration successfully written to: %s\n",
output_file);
config_destroy(&cfg);
return(EXIT_SUCCESS);
}
int writeCfgCond(void) {
config_t cfg;
config_setting_t *tminTemp = 0;
config_setting_t *tmaxTemp = 0;
config_setting_t *tminHum = 0;
config_setting_t *tmaxHum = 0;
config_setting_t *twebOR = 0;
config_init(&cfg);
if (!config_read_file(&cfg, config_cond_path))
{
printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return -1;
}
/* lookup variables in config file */
tminTemp = config_lookup(&cfg, "minTemp");
tmaxTemp = config_lookup(&cfg, "maxTemp");
tminHum = config_lookup(&cfg, "minHum");
tmaxHum = config_lookup(&cfg, "maxHum");
twebOR = config_lookup(&cfg, "webOR");
/* get variables from config file then print the variables that changed */
if (config_setting_get_int(tminTemp) != minTemp) {
printf("\nminTemp: %i -> ", config_setting_get_int(tminTemp));
config_setting_set_int(tminTemp, minTemp);
printf("%i", config_setting_get_int(tminTemp));
}
if (config_setting_get_int(tmaxTemp) != maxTemp) {
printf("\nmaxTemp: %i -> ", config_setting_get_int(tmaxTemp));
config_setting_set_int(tmaxTemp, maxTemp);
printf("%i", config_setting_get_int(tmaxTemp));
}
if (config_setting_get_int(tminHum) != minHum) {
printf("\nminHum: %i -> ", config_setting_get_int(tminHum));
config_setting_set_int(tminHum, minHum);
printf("%i", config_setting_get_int(tminHum));
}
if (config_setting_get_int(tmaxHum) != maxHum) {
printf("\nmaxHum: %i -> ", config_setting_get_int(tmaxHum));
config_setting_set_int(tmaxHum, maxHum);
printf("%i", config_setting_get_int(tmaxHum));
}
if (config_setting_get_int(twebOR) != webOR) {
printf("\nwebOR: %i -> ", config_setting_get_int(twebOR));
config_setting_set_int(twebOR, webOR);
printf("%i", config_setting_get_int(twebOR));
}
/* write the modified config file */
config_write_file(&cfg, config_cond_path);
config_destroy(&cfg);
return 0;
}
/* These two separated here */
int write_cfg(config_t * cfg, char *filename)
{
int err = config_write_file(cfg, filename);
if (err == CONFIG_FALSE)
{
E("Failed to write CFG to %s", filename);
return -1;
}
else
return 0;
}
int store_settings(char *cfg_file,
int show_line_numbers,
int show_lang,
int show_spelling_errors,
int defualt_window_width,
int default_window_height,
int undo_level,
int show_full_path
#ifdef AUTO_TAB_TOGGLE
,
int auto_tab
#endif
){
config_t cfg;
config_setting_t *root, *setting, *group, *UI;
config_init(&cfg);
int ret=0;
root = config_root_setting(&cfg);
group = config_setting_add(root,"User_Pref", CONFIG_TYPE_GROUP);
setting = config_setting_add(group,"LineNumbers", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_line_numbers);
setting = config_setting_add(group,"Spelling", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_spelling_errors);
setting = config_setting_add(group,"ShowLang", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_lang);
#ifdef AUTO_TAB_TOGGLE
setting = config_setting_add(group,"Auto_Tab", CONFIG_TYPE_INT);
config_setting_set_int(setting, auto_tab);
#endif
setting = config_setting_add(group,"Show_Full_Path", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_full_path);
UI = config_setting_add(root,"User_Interface_Settings", CONFIG_TYPE_GROUP);
setting = config_setting_add(UI,"Default_Window_Width", CONFIG_TYPE_INT);
config_setting_set_int(setting, defualt_window_width);
setting = config_setting_add(UI,"Default_Window_Height", CONFIG_TYPE_INT);
config_setting_set_int(setting, default_window_height);
setting = config_setting_add(UI,"Undo_Level", CONFIG_TYPE_INT);
config_setting_set_int(setting, undo_level);
if (! config_write_file(&cfg,(char*)cfg_file)) ret=0;
else ret=1;
config_destroy(&cfg);
return(ret);
}
// {{{ session_delete_session()
void session_delete_session(const char* user)
{
if(strlen(user)==0)
return;
struct config_t cfg;
config_init(&cfg);
config_setting_t *us;
if(!config_read_file(&cfg, OD_SESSION_FILE))
config_write_file(&cfg, OD_SESSION_FILE);
if( !(us = config_lookup(&cfg, user)) )
return;
us = config_setting_remove(cfg.root, user);
config_write_file(&cfg, OD_SESSION_FILE);
config_destroy(&cfg);
}
// {{{ session_store_session()
int session_store_session(const char* user, const char* sessid)
{
if(strlen(user)==0 || strlen(sessid)==0)
return -1;
char var[256];
struct config_t cfg;
config_init(&cfg);
char date[255];
util_get_date(date, sizeof(date), "%Y%m%d%H%M%S");
config_setting_t *cs;
config_setting_t *us;
if(!config_read_file(&cfg, OD_SESSION_FILE))
config_write_file(&cfg, OD_SESSION_FILE);
if( !(us = config_lookup(&cfg, user)) )
{
us = config_setting_add(cfg.root, user, CONFIG_TYPE_GROUP);
cs = config_setting_add(us, "sessid", CONFIG_TYPE_STRING);
cs = config_setting_add(us, "timestamp", CONFIG_TYPE_STRING);
}
snprintf(var, sizeof(var), "%s.sessid", user);
if( !(cs = config_lookup(&cfg, var)) )
return 0;
config_setting_set_string(cs, sessid);
snprintf(var, sizeof(var), "%s.timestamp", user);
if( !(cs = config_lookup(&cfg, var)) )
return 0;
config_setting_set_string(cs, date);
config_write_file(&cfg, OD_SESSION_FILE);
config_destroy(&cfg);
return 0;
}
void patch_save()
{
config_setting_t* root_setting = config_root_setting(&patch_config);
config_setting_remove(root_setting, CFG_MOD_MATRIX_CONTROLLER);
config_setting_t* mod_matrix_patch = config_setting_add(root_setting, CFG_MOD_MATRIX_CONTROLLER, CONFIG_TYPE_GROUP);
mod_matrix_controller_save(mod_matrix_patch);
if (config_write_file(&patch_config, PATCH_FILE) != CONFIG_TRUE)
{
LOG_ERROR("Patch write error to %s", PATCH_FILE);
}
}
int main(int argc, char **argv)
{
char *file = "sample.cfg", *var = "x";
if(argc >= 2)
file = argv[1];
if(argc >= 3)
var = argv[2];
/* Initialize the configuration */
config_init(&cfg);
/* Load the file */
printf("loading [%s]...", file);
if(!config_read_file(&cfg, file))
printf("failed\n");
else
{
config_setting_t *setting = NULL;
printf("ok\n");
/* Get the variable setting from the configuration.. */
printf("increment \"%s\"...", var);
setting = config_lookup(&cfg, var);
if(!setting)
printf("failed\n");
else
{
long x = config_setting_get_int(setting);
x++;
config_setting_set_int(setting, x);
printf("ok (%s=%lu)\n", var, x);
/* Save the changes */
printf("saving [%s]...", file);
config_write_file(&cfg, file);
printf("ok\n");
printf("Done!\n");
}
}
/* Free the configuration */
config_destroy(&cfg);
return 0;
}
int config_write(config_t* cfg, const char *dir, const char *file)
{
char path[BUFSIZ];
if (config_get_default_path(cfg,path, BUFSIZ, dir, file) < 0) {
config_set_strerror(cfg,"config_create_default(): %s\n", strerror(errno));
return -1;
}
if (mkdirs(path, S_IRWXU) < 0) {
config_set_strerror(cfg,"config_create_default(): \"%s\": %s\n", path, strerror(errno));
return -1;
}
return config_write_file(cfg, path);
}
static void write_config(const config_t * config,const char * table, const char * file)
{
char * filename;
char * fullname;
filename = strconcat(table,"/",file,NULL);
fullname = strconcat(base_directory,"/",filename,NULL);
file_lock(filename);
config_write_file((config_t*)config,fullname);
file_unlock(filename);
free(filename);
free(fullname);
}
int main(int argc, char **argv)
{
static const char *output_file = "newconfig.cfg";
config_t cfg;
config_setting_t *root, *setting, *group, *array;
int i;
config_init(&cfg);
root = config_root_setting(&cfg);
/* Add some settings to the configuration. */
group = config_setting_add(root, "address", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "street", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "1 Woz Way");
setting = config_setting_add(group, "city", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "San Jose");
setting = config_setting_add(group, "state", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "CA");
setting = config_setting_add(group, "zip", CONFIG_TYPE_INT);
config_setting_set_int(setting, 95110);
array = config_setting_add(root, "numbers", CONFIG_TYPE_ARRAY);
for(i = 0; i < 10; ++i)
{
setting = config_setting_add(array, NULL, CONFIG_TYPE_INT);
config_setting_set_int(setting, 10 * i);
}
/* Write out the new configuration. */
if(! config_write_file(&cfg, output_file))
{
fprintf(stderr, "Error while writing file.\n");
config_destroy(&cfg);
return(EXIT_FAILURE);
}
fprintf(stderr, "New configuration successfully written to: %s\n",
output_file);
config_destroy(&cfg);
return(EXIT_SUCCESS);
}
int write_configurations() {
config_t cfg;
//config_setting_t *setting;
//const char *str;
config_init(&cfg);
/* Read the file. If there is an error, report it and exit. */
if (!config_write_file(&cfg, "fins.cfg")) {
PRINT_ERROR("%s:%d - %s\n", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return EXIT_FAILURE;
}
config_destroy(&cfg);
return EXIT_SUCCESS;
}
/*******************************************************************************
函数名称 : webauth_rdx_save_setting
功能描述 : 保存服务器配置
输入参数 : cli_rdx_server_conf_t * list 服务器配置列表
输出参数 : 无
返 回 值 :
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 王群
修改目的 : 新添加函数
修改日期 : 2010-08-16
*******************************************************************************/
void webauth_rdx_save_setting (webauth_rdx_server_conf_t * list)
{
webauth_rdx_server_conf_t *server_cfg = NULL;
config_t cfg;
config_setting_t *server_set = NULL;
config_setting_t *root_set = NULL;
config_init (&cfg);
root_set = config_root_setting (&cfg);
for (server_cfg = list; NULL != server_cfg; server_cfg = server_cfg->next)
{
server_set = config_setting_add (root_set, server_cfg->name, CONFIG_TYPE_GROUP);
webauth_rdx_build_server_setting (server_set, server_cfg);
}
config_write_file (&cfg, RADIUS_CFG_FILE);
config_destroy (&cfg);
return;
}
gboolean
get_verbose ()
{
gboolean verbose;
gchar *file;
config_t config;
file = g_strconcat (g_getenv ("HOME"),
"/.config/gjackctl/gjackctl.conf",
NULL);
config_init (&config);
config_read_file (&config, file);
if (config_lookup_bool (&config, "gjackctl.server.verbose", &verbose) == CONFIG_FALSE)
{
config_setting_t *group;
config_setting_t *setting;
g_print ("Verbose config option not available\n");
g_print ("Creating config setting now...\n");
group = config_lookup (&config, "gjackctl.server");
setting = config_setting_add (group, "verbose", CONFIG_TYPE_BOOL);
config_setting_set_bool (setting, FALSE);
config_write_file (&config, file);
}
if (verbose == FALSE)
{
config_destroy (&config);
return FALSE;
}
else
{
config_destroy (&config);
return TRUE;
}
}
void Settings::Save()
{
config_t cfg;
config_setting_t *root, *setting, *group;
config_init(&cfg);
root = config_root_setting(&cfg);
group = config_setting_add(root, "Graphics", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "Fullscreen", CONFIG_TYPE_INT);
config_setting_set_int(setting, FullScreen);
group = config_setting_add(root, "Audio", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "PlaySFX", CONFIG_TYPE_INT);
config_setting_set_int(setting, PlaySFX);
setting = config_setting_add(group, "PlayMusic", CONFIG_TYPE_INT);
config_setting_set_int(setting, PlayMusic);
group = config_setting_add(root, "Input", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "keyLeft", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyLeft);
setting = config_setting_add(group, "keyRight", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyRight);
setting = config_setting_add(group, "keyUp", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyUp);
setting = config_setting_add(group, "keyDown", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyDown);
setting = config_setting_add(group, "keyFire1", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyFire1);
setting = config_setting_add(group, "keyFire2", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyFire2);
setting = config_setting_add(group, "keyQuit", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyQuit);
config_write_file( &cfg, "settings.cfg" );
config_destroy(&cfg);
}
int writeCfg (void)
{
config_t cfg;
config_setting_t *tonTemp = 0;
config_setting_t *toffTemp = 0;
config_setting_t *thighTemp = 0;
config_setting_t *tonHum = 0;
config_setting_t *toffHum = 0;
config_setting_t *twebOR = 0;
config_setting_t *ttempState = 0;
config_setting_t *thumState = 0;
config_init(&cfg);
if (!config_read_file(&cfg, config_file_name))
{
printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return -1;
}
/* lookup variables in config file */
tonTemp = config_lookup(&cfg, "onTemp");
toffTemp = config_lookup(&cfg, "offTemp");
thighTemp = config_lookup(&cfg, "highTemp");
tonHum = config_lookup(&cfg, "onHum");
toffHum = config_lookup(&cfg, "offHum");
twebOR = config_lookup(&cfg, "webOR");
ttempState = config_lookup(&cfg, "tempState");
thumState = config_lookup(&cfg, "humState");
/* get variables from config file then print the variables that changed */
if (config_setting_get_int(tonTemp) != onTemp) {
printf("\nonTemp: %i -> ", config_setting_get_int(tonTemp));
config_setting_set_int(tonTemp, onTemp);
printf("%i", config_setting_get_int(tonTemp));
}
if (config_setting_get_int(toffTemp) != offTemp) {
printf("\noffTemp: %i -> ", config_setting_get_int(toffTemp));
config_setting_set_int(toffTemp, offTemp);
printf("%i", config_setting_get_int(toffTemp));
}
if (config_setting_get_int(thighTemp) != highTemp) {
printf("\nhighTemp: %i -> ", config_setting_get_int(thighTemp));
config_setting_set_int(thighTemp, highTemp);
printf("%i", config_setting_get_int(thighTemp));
}
if (config_setting_get_int(tonHum) != onHum) {
printf("\nonHum: %i -> ", config_setting_get_int(tonHum));
config_setting_set_int(tonHum, onHum);
printf("%i", config_setting_get_int(tonHum));
}
if (config_setting_get_int(toffHum) != offHum) {
printf("\noffHum: %i -> ", config_setting_get_int(toffHum));
config_setting_set_int(toffHum, offHum);
printf("%i", config_setting_get_int(toffHum));
}
if (config_setting_get_int(twebOR) != webOR) {
printf("\nwebOR: %i -> ", config_setting_get_int(twebOR));
config_setting_set_int(twebOR, webOR);
printf("%i", config_setting_get_int(twebOR));
}
if (config_setting_get_int(ttempState) != tempState) {
printf("\ntempState: %i -> ", config_setting_get_int(ttempState));
config_setting_set_int(ttempState, tempState);
printf("%i", config_setting_get_int(ttempState));
}
if (config_setting_get_int(thumState) != humState) {
printf("\nhumState: %i -> ", config_setting_get_int(thumState));
config_setting_set_int(thumState, humState);
printf("%i", config_setting_get_int(thumState));
}
/* write the modified config file */
config_write_file(&cfg, config_file_name);
config_destroy(&cfg);
return 0;
}
int writeCfgState(void) {
config_t cfg;
config_setting_t *ttempState = 0;
config_setting_t *thumState = 0;
config_setting_t *tRHeatTS = 0;
config_setting_t *tRHumTS = 0;
config_setting_t *tRHepaTS = 0;
config_setting_t *tRFanTS = 0;
config_setting_t *twfactor = 0;
config_setting_t *trelay1o = 0;
config_setting_t *trelay2o = 0;
config_setting_t *trelay3o = 0;
config_setting_t *trelay4o = 0;
config_setting_t *trelay5o = 0;
config_setting_t *trelay6o = 0;
config_setting_t *trelay7o = 0;
config_setting_t *trelay8o = 0;
config_init(&cfg);
if (!config_read_file(&cfg, config_state_path))
{
printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return -1;
}
/* lookup variables in config file */
ttempState = config_lookup(&cfg, "tempState");
thumState = config_lookup(&cfg, "humState");
trelay1o = config_lookup(&cfg, "relay1o");
trelay2o = config_lookup(&cfg, "relay2o");
trelay3o = config_lookup(&cfg, "relay3o");
trelay4o = config_lookup(&cfg, "relay4o");
trelay5o = config_lookup(&cfg, "relay5o");
trelay6o = config_lookup(&cfg, "relay6o");
trelay7o = config_lookup(&cfg, "relay7o");
trelay8o = config_lookup(&cfg, "relay8o");
tRHeatTS = config_lookup(&cfg, "RHeatTS");
tRHumTS = config_lookup(&cfg, "RHumTS");
tRHepaTS = config_lookup(&cfg, "RHepaTS");
tRFanTS = config_lookup(&cfg, "RFanTS");
twfactor = config_lookup(&cfg, "wfactor");
/* get variables from config file then print the variables that changed */
if (config_setting_get_int(ttempState) != tempState) {
printf("\ntempState: %i -> ", config_setting_get_int(ttempState));
config_setting_set_int(ttempState, tempState);
printf("%i", config_setting_get_int(ttempState));
}
if (config_setting_get_int(thumState) != humState) {
printf("\nhumState: %i -> ", config_setting_get_int(thumState));
config_setting_set_int(thumState, humState);
printf("%i", config_setting_get_int(thumState));
}
if (config_setting_get_int(trelay1o) != relay1o) {
printf("\nrelay1o: %i -> ", config_setting_get_int(trelay1o));
config_setting_set_int(trelay1o, relay1o);
printf("%i", config_setting_get_int(trelay1o));
}
if (config_setting_get_int(trelay2o) != relay2o) {
printf("\nrelay2o: %i -> ", config_setting_get_int(trelay2o));
config_setting_set_int(trelay2o, relay2o);
printf("%i", config_setting_get_int(trelay2o));
}
if (config_setting_get_int(trelay3o) != relay3o) {
printf("\nrelay3o: %i -> ", config_setting_get_int(trelay3o));
config_setting_set_int(trelay3o, relay3o);
printf("%i", config_setting_get_int(trelay3o));
}
if (config_setting_get_int(trelay4o) != relay4o) {
printf("\nrelay4o: %i -> ", config_setting_get_int(trelay4o));
config_setting_set_int(trelay4o, relay4o);
printf("%i", config_setting_get_int(trelay4o));
}
if (config_setting_get_int(trelay5o) != relay5o) {
printf("\nrelay5o: %i -> ", config_setting_get_int(trelay5o));
config_setting_set_int(trelay5o, relay5o);
printf("%i", config_setting_get_int(trelay5o));
}
if (config_setting_get_int(trelay6o) != relay6o) {
printf("\nrelay6o: %i -> ", config_setting_get_int(trelay6o));
config_setting_set_int(trelay6o, relay6o);
printf("%i", config_setting_get_int(trelay6o));
}
if (config_setting_get_int(trelay7o) != relay7o) {
printf("\nrelay7o: %i -> ", config_setting_get_int(trelay7o));
config_setting_set_int(trelay7o, relay7o);
printf("%i", config_setting_get_int(trelay7o));
}
if (config_setting_get_int(trelay8o) != relay8o) {
printf("\nrelay8o: %i -> ", config_setting_get_int(trelay8o));
config_setting_set_int(trelay8o, relay8o);
printf("%i", config_setting_get_int(trelay8o));
}
if (config_setting_get_int(tRHeatTS) != RHeatTS) {
printf("\nRHeatTS: %i -> ", config_setting_get_int(tRHeatTS));
config_setting_set_int(tRHeatTS, RHeatTS);
printf("%i", config_setting_get_int(tRHeatTS));
}
if (config_setting_get_int(tRHumTS) != RHumTS) {
printf("\nRHumTS: %i -> ", config_setting_get_int(tRHumTS));
config_setting_set_int(tRHumTS, RHumTS);
printf("%i", config_setting_get_int(tRHumTS));
}
if (config_setting_get_int(tRHepaTS) != RHepaTS) {
printf("\nRHepaTS: %i -> ", config_setting_get_int(tRHepaTS));
config_setting_set_int(tRHepaTS, RHepaTS);
printf("%i", config_setting_get_int(tRHepaTS));
}
if (config_setting_get_int(tRFanTS) != RFanTS) {
printf("\nRFanTS: %i -> ", config_setting_get_int(tRFanTS));
config_setting_set_int(tRFanTS, RFanTS);
printf("%i", config_setting_get_int(tRFanTS));
}
if (config_setting_get_float(twfactor) != wfactor) {
printf("\nwfactor: %i -> ", config_setting_get_float(twfactor));
config_setting_set_float(twfactor, wfactor);
printf("%i", config_setting_get_float(twfactor));
}
/* write the modified config file */
config_write_file(&cfg, config_state_path);
config_destroy(&cfg);
return 0;
}
int iteliec_soap_register (char *username, char *password) {
herror_t err;
SoapCtx *request;
SoapCtx *response;
config_t cfg;
config_setting_t *setting, *root;
const char *cfile;
cfile = iteliec_config_file ();
config_init (&cfg);
/* Read the file. If there is an error, report it and exit. */
if (!config_read_file (&cfg, cfile)) {
iteliec_log (ITELIEC_ERR, "Please ensure configuration file %s exists and is valid", cfile);
//printf ("\n%s:%d - %s", config_error_file (&cfg), config_error_line (&cfg), config_error_text (&cfg));
config_destroy (&cfg);
return;
}
root = config_root_setting (&cfg);
/* Init */
err = soap_client_init_args (0, NULL);
if (err != H_OK) {
err_soap (err);
return ITELIEC_ERR;
}
err = soap_ctx_new_with_method ("", "sendAuth", &request);
if (err != H_OK) {
err_soap (err);
soap_client_destroy ();
return ITELIEC_ERR;
}
/* Add login details */
soap_env_add_item (request->env, "xsd:string", "username", username);
soap_env_add_item (request->env, "xsd:string", "password", password);
/* Trade for response */
err = soap_client_invoke (request, &response, "http://api.iteliec.com/register/auth/ws/", "");
if (err != H_OK) {
err_soap (err);
soap_ctx_free (request);
soap_client_destroy ();
return ITELIEC_ERR;
}
/* Parse response */
auth_type* ret = parse_auth_response (response);
if (ret->auth == true) {
printf ("Success\n");
setting = config_setting_get_member (root, "api");
if(!setting) {
setting = config_setting_add (root, "api", CONFIG_TYPE_GROUP);
}
setting = config_setting_add (setting, "hash", CONFIG_TYPE_STRING);
config_setting_set_string (setting, ret->token);
/* Write out the updated configuration. */
if(! config_write_file(&cfg, cfile)) {
fprintf (stderr, "Error while writing file.\n");
config_destroy (&cfg);
return (ITELIEC_OK);
}
printf("\nConfiguration file updated. Server is ready to run.\n");
} else {
printf("Auth failed\n");
}
/* Destroy */
soap_ctx_free (request);
soap_ctx_free (response);
soap_client_destroy ();
config_destroy (&cfg);
return ITELIEC_OK;
}
int rsct_config_save() {
if (_ctapi_config)
return config_write_file(_ctapi_config);
return 0;
}
static int yubikey_auth_core(myConf_t *myConf, REQUEST *request)
{
int passLen = 0, session = 0, counter = 0, i = 0;
MD5_CTX ctx;
int result = 0;
char *filename = "/usr/local/etc/raddb/yubico/users";
//get password by removing the last 32 characters of the password
if (strlen(request->password->vp_strvalue) <= 32)
{
DEBUG("rlm_yubikey: Password too short.");
return RLM_MODULE_REJECT;
}
passLen = strlen(request->password->vp_strvalue) - 32;
strncpy(myConf->pass, request->password->vp_strvalue, passLen);
myConf->pass[passLen] = '\0';
strncpy(myConf->token, request->password->vp_strvalue + passLen, 32);
myConf->token[32] = '\0';
//md5 stuff
MD5Init(&ctx);
DEBUG("rlm_yubikey: length: %d, string: %s", passLen, myConf->pass);
MD5Update(&ctx, (unsigned char *)myConf->pass, passLen);
MD5Final(&ctx);
MD5toString(&ctx, myConf->md5ComputedString);
myConf->md5ComputedString[32] = '\0';
DEBUG("rlm_yubikey: MD5string of your pass: %s", myConf->md5ComputedString);
DEBUG("rlm_yubikey: Username: %s", request->username->vp_strvalue);
//read file
result = config_read_file(&(myConf->config), filename);
if (result != CONFIG_TRUE)
{
DEBUG("rlm_yubikey: Failed to parse configuration file: config_read_file (&config, filename);");
DEBUG("config_error_text()= %s and config_error_line()=%d", config_error_text(&(myConf->config)), config_error_line(&(myConf->config)));
return RLM_MODULE_FAIL;
}
//parse file
myConf->config_setting = config_lookup(&(myConf->config), USERS_PATH);
if (myConf->config_setting == NULL)
{
DEBUG("rlm_yubikey: Failed to parse configuration file: config_lookup failed to find the users node");
return RLM_MODULE_FAIL;
}
//go through the list of users
for (i = 0; i < config_setting_length(myConf->config_setting); i++)
{
DEBUG("Trying i: %d", i);
config_setting_t *tmpSetting = NULL;
tmpSetting = config_setting_get_elem(myConf->config_setting, i);
if (tmpSetting == NULL)
{
DEBUG("rlm_yubikey: Failed to parse configuration file: config_setting_get_elem(config_setting,i);");
return RLM_MODULE_FAIL;
}
if ((config_setting_get_string_elem(tmpSetting, 0) == NULL) ||
(config_setting_get_string_elem(tmpSetting, 1) == NULL) ||
(config_setting_get_string_elem(tmpSetting, 2) == NULL))
{
DEBUG("rlm_yubikey: Failed to parse configuration file while reading the username/password/aeskey triplet ");
return RLM_MODULE_FAIL;
}
//check usernames are equal
if (strcmp(request->username->vp_strvalue, config_setting_get_string_elem(tmpSetting, 0)) != 0)
{
//users do not match. No need to debug this
//Go to next iteration
continue;
}
//check passwords are equal
if (strcmp(myConf->md5ComputedString, config_setting_get_string_elem(tmpSetting, 1)) != 0)
{
//passwords do not match. We debug
DEBUG("rlm_yubikey: Password does not match for user %s", request->username->vp_strvalue);
//Go to next iteration
continue;
}
//check aes stuff - mostly copied from the ykdebug.c that comes with the low-level yubikey library
uint8_t buf[128];
const char *aeskey = config_setting_get_string_elem(tmpSetting, 2);
char *token = myConf->token;
uint8_t key[YUBIKEY_KEY_SIZE];
yubikey_token_st tok;
yubikey_modhex_decode((char*) key, token, YUBIKEY_KEY_SIZE);
DEBUG("rlm_yubikey: aeskey: %s", aeskey);
yubikey_hex_decode((char*) key, aeskey, YUBIKEY_KEY_SIZE);
/* Pack up dynamic password, decrypt it and verify checksum */
yubikey_parse((uint8_t*) token, key, &tok);
DEBUG("rlm_yubikey: Struct:");
size_t i;
char *tmp = (char*) malloc(1024);
for (i = 0; i < YUBIKEY_UID_SIZE; i++)
{
sprintf(tmp + i, "%c ", tok.uid[i] & 0xFF);
}
tmp[YUBIKEY_UID_SIZE + i] = 0;
DEBUG("rlm_yubikey: uid:%s", tmp);
free(tmp);
DEBUG("rlm_yubikey: counter: %d (0x%04x)", tok.ctr, tok.ctr);
DEBUG("rlm_yubikey: timestamp (low): %d (0x%04x)", tok.tstpl, tok.tstpl);
DEBUG("rlm_yubikey: timestamp (high): %d (0x%02x)", tok.tstph, tok.tstph);
DEBUG("rlm_yubikey: session use: %d (0x%02x)", tok.use, tok.use);
DEBUG("rlm_yubikey: random: %d (0x%02x)", tok.rnd, tok.rnd);
DEBUG("rlm_yubikey: crc: %d (0x%04x)", tok.crc, tok.crc);
DEBUG("rlm_yubikey: Derived:");
DEBUG("rlm_yubikey: cleaned counter: %d (0x%04x)",yubikey_counter(tok.ctr), yubikey_counter(tok.ctr));
yubikey_modhex_encode((char*) buf, (char*) tok.uid, YUBIKEY_UID_SIZE);
DEBUG("rlm_yubikey: modhex uid: %s", buf);
DEBUG("rlm_yubikey: triggered by caps lock: %s", yubikey_capslock(tok.ctr) ? "yes" : "no");
DEBUG("rlm_yubikey: crc: %04X", yubikey_crc16((void*) & tok, YUBIKEY_KEY_SIZE));
DEBUG("rlm_yubikey: crc check: ");
if (yubikey_crc_ok_p((uint8_t*) & tok))
{
DEBUG("rlm_yubikey: ok");
char *tmppath = KEYS_PATH;
char *path = (char*) malloc(strlen(tmppath) + 32 + 1);
strcpy(path, tmppath);
strcat(path, aeskey);
myConf->config_setting = config_lookup(&(myConf->config), path);
if (myConf->config_setting == NULL)
{
DEBUG("rlm_yubikey: Error parsing file: %s not found", path);
return RLM_MODULE_FAIL;
}
//checking counter and session and update them if necessary
counter = config_setting_get_int_elem(myConf->config_setting, 0);
session = config_setting_get_int_elem(myConf->config_setting, 1);
DEBUG("rlm_yubikey: Read counter: %d, session: %d", counter, session);
if ((tok.ctr < counter)||((tok.ctr == counter) && (tok.use <= session)))
{
DEBUG("rlm_yubikey: someone tried to login with an old generated hash");
return RLM_MODULE_REJECT;
}
//updating config file with counter and session
config_setting_set_int_elem(myConf->config_setting, 0, tok.ctr);
config_setting_set_int_elem(myConf->config_setting, 1, tok.use);
DEBUG("rlm_yubikey: Written element: %ld", config_setting_get_int_elem(myConf->config_setting, 0));
DEBUG("rlm_yubikey: Written element: %ld", config_setting_get_int_elem(myConf->config_setting, 1));
if (CONFIG_FALSE == config_write_file(&(myConf->config), filename))
{
DEBUG("rlm_yubikey: Failed to write the file.");
return RLM_MODULE_FAIL;
}
return RLM_MODULE_OK;
}
DEBUG("rlm_yubikey: fail");
}
DEBUG("rlm_yubikey: Authenticating with password %s", request->password->vp_strvalue);
return RLM_MODULE_REJECT;
}
