static int handle_wcs_data(const uint8_t *tlv_msg, int length) { struct wifi_sc *wsc = NULL; GKeyFile *keyfile = NULL; int ret = -EINVAL; wsc = decode_from_tlv(tlv_msg, length); if (!wsc) return -EINVAL; if (!wsc->ssid) goto out; keyfile = g_key_file_new(); if (!keyfile) { ret = -ENOMEM; goto out; } g_key_file_set_string(keyfile, NEARD_SERVICE_GROUP, SERVICE_KEY_TYPE, "wifi"); g_key_file_set_string(keyfile, NEARD_SERVICE_GROUP, SERVICE_KEY_SSID, wsc->ssid); g_key_file_set_boolean(keyfile, NEARD_SERVICE_GROUP, SERVICE_KEY_HIDDEN, TRUE); if (wsc->passphrase) g_key_file_set_string(keyfile, NEARD_SERVICE_GROUP, SERVICE_KEY_PASSPHRASE, wsc->passphrase); ret = connman_config_provision_mutable_service(keyfile); out: g_key_file_unref(keyfile); free_wifi_sc(wsc); return ret; }
/** User pressed OK. Any changes should be stored in config. */ void sat_pref_layout_ok(GKeyFile * cfg) { if (dirty) { /* we have new settings */ if (cfg != NULL) { g_key_file_set_string(cfg, MOD_CFG_GLOBAL_SECTION, MOD_CFG_GRID, gtk_entry_get_text(GTK_ENTRY(gridstr))); } else { sat_cfg_set_str(SAT_CFG_STR_MODULE_GRID, gtk_entry_get_text(GTK_ENTRY(gridstr))); sat_cfg_set_bool(SAT_CFG_BOOL_MAIN_WIN_POS, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (mwin))); sat_cfg_set_bool(SAT_CFG_BOOL_MOD_WIN_POS, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (mod))); sat_cfg_set_bool(SAT_CFG_BOOL_MOD_STATE, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (state))); } } else if (reset) { /* we have to reset the values to global or default settings */ if (cfg == NULL) { /* layout */ sat_cfg_reset_str(SAT_CFG_STR_MODULE_GRID); /* window placement */ sat_cfg_reset_bool(SAT_CFG_BOOL_MAIN_WIN_POS); sat_cfg_reset_bool(SAT_CFG_BOOL_MOD_WIN_POS); sat_cfg_reset_bool(SAT_CFG_BOOL_MOD_STATE); } else { g_key_file_remove_key((GKeyFile *) (cfg), MOD_CFG_GLOBAL_SECTION, MOD_CFG_GRID, NULL); } } dirty = FALSE; reset = FALSE; }
static gboolean save_state (time_t mtime, gchar **converted) { gchar *filename; GKeyFile *keyfile; gchar *str; GError *error; gboolean result; /* Make sure the state directory exists */ if (g_mkdir_with_parents (g_get_user_data_dir (), 0755)) { g_printerr ("Failed to create directory %s: %s\n", g_get_user_data_dir (), g_strerror (errno)); return FALSE; } filename = g_build_filename (g_get_user_data_dir (), "mateconf-gsettings-data-convert", NULL); keyfile = g_key_file_new (); str = g_strdup_printf ("%ld", mtime); g_key_file_set_string (keyfile, "State", "timestamp", str); g_free (str); g_key_file_set_string_list (keyfile, "State", "converted", (const gchar * const *)converted, g_strv_length (converted)); str = g_key_file_to_data (keyfile, NULL, NULL); g_key_file_free (keyfile); error = NULL; if (!g_file_set_contents (filename, str, -1, &error)) { g_printerr ("%s\n", error->message); g_error_free (error); result = FALSE; } else result = TRUE; g_free (filename); g_free (str); return result; }
/** Save all persistent program state to disk. This function finds the * name of the "new" state file associated with a specific book guid. * It saves some top level data, then iterates through the list of * open windows calling a helper function to save each window. * * @note The name of the state file is based on the name of the data * file, not the path name of the data file. If there are multiple * data files with the same name, the state files will be suffixed * with a number. E.G. test_account, test_account_2, test_account_3, * etc. * * @param session The QofSession whose state should be saved. * * @param unused */ static void gnc_save_all_state (gpointer session, gpointer unused) { QofBook *book; gchar guid_string[GUID_ENCODING_LENGTH+1]; const GncGUID *guid; GKeyFile *keyfile = NULL; keyfile = gnc_state_get_current (); if (keyfile) { /* Remove existing Window and Page groups from the keyfile * They will be regenerated. */ gsize num_groups, curr; gchar **groups = g_key_file_get_groups (keyfile, &num_groups); for (curr=0; curr < num_groups; curr++) { if (g_str_has_prefix (groups[curr], "Window ") || g_str_has_prefix (groups[curr], "Page ")) { DEBUG ("Removing state group %s", groups[curr]); g_key_file_remove_group (keyfile, groups[curr], NULL); } } g_strfreev (groups); } /* Store the book's GncGUID in the top level group */ book = qof_session_get_book(session); guid = qof_entity_get_guid(QOF_INSTANCE(book)); guid_to_string_buff(guid, guid_string); g_key_file_set_string(keyfile, STATE_FILE_TOP, STATE_FILE_BOOK_GUID, guid_string); gnc_main_window_save_all_windows(keyfile); #ifdef DEBUG /* Debugging: dump a copy to the trace log */ { gchar *file_data; gsize file_length; file_data = g_key_file_to_data(keyfile, &file_length, NULL); DEBUG("=== File Data Written===\n%s\n=== File End ===\n", file_data); g_free(file_data); } #endif LEAVE(""); }
static void hlfs_get_inode_info_setup(Fixture *fixture, const void *data) { const char *test_dir = (const char *)data; g_print("test env dir is %s\n", test_dir); char *fs_dir = g_build_filename(test_dir, "testfs", NULL); // g_assert(g_mkdir(fs_dir, 0700) == 0); char *uri = g_malloc0(128); g_assert(uri != NULL); snprintf(uri, 128, "%s%s", "local://", fs_dir); // char *uri = g_build_path(tmp, fs_dir, NULL); g_print("uri is %s\n", uri); pid_t status; const char cmd[256]; memset((char *) cmd, 0, 256); sprintf((char *) cmd, "%s %s %s %s %d %s %d %s %d", "../mkfs.hlfs", "-u", uri, "-b", 8192, "-s", 67108864, "-m", 1024); g_message("cmd is [%s]", cmd); status = system(cmd); #if 0 GKeyFile *sb_keyfile = g_key_file_new(); g_key_file_set_string(sb_keyfile, "METADATA", "uri", uri); g_key_file_set_integer(sb_keyfile, "METADATA", "block_size", 8196); g_key_file_set_integer(sb_keyfile, "METADATA", "segment_size", 67108864); g_key_file_set_integer(sb_keyfile, "METADATA", "max_fs_size", 671088640); gchar *content = g_key_file_to_data(sb_keyfile, NULL, NULL); char *sb_file_path = g_build_filename(fs_dir, "superblock", NULL); g_print("sb file path is %s\n", sb_file_path); GError *error = NULL; if (TRUE != g_file_set_contents(sb_file_path, content, strlen(content) + 1, &error)) { g_print("error msg is %s", error->message); error = NULL; } #endif fixture->uri = uri; g_print("fixture->uri is %s\n", fixture->uri); fixture->ctrl = init_hlfs(fixture->uri); g_assert(fixture->ctrl != NULL); int ret = hlfs_open(fixture->ctrl, 1); g_assert(ret == 0); take_snapshot(fixture, data); test_hlfs_find_inode_before_time(fixture, data); // g_key_file_free(sb_keyfile); // g_free(sb_file_path); g_free(fs_dir); return ; }
void goa_utils_keyfile_set_string (GoaAccount *account, const gchar *key, const gchar *value) { GError *error; GKeyFile *key_file; gchar *contents; gchar *group; gchar *path; gsize length; contents = NULL; path = g_strdup_printf ("%s/goa-1.0/accounts.conf", g_get_user_config_dir ()); group = g_strdup_printf ("Account %s", goa_account_get_id (account)); key_file = g_key_file_new (); error = NULL; if (!g_key_file_load_from_file (key_file, path, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error)) { g_warning ("Error loading keyfile %s: %s (%s, %d)", path, error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); goto out; } g_key_file_set_string (key_file, group, key, value); contents = g_key_file_to_data (key_file, &length, NULL); error = NULL; if (!g_file_set_contents (path, contents, length, &error)) { g_prefix_error (&error, "Error writing key-value-file %s: ", path); g_warning ("%s (%s, %d)", error->message, g_quark_to_string (error->domain), error->code); g_error_free (error); goto out; } out: g_free (contents); g_key_file_free (key_file); g_free (group); g_free (path); }
void mc_config_set_string (const mc_config_t * mc_config, const gchar * group, const gchar * param, const gchar * value) { gchar *buffer; if (!mc_config || !group || !param || !value) return; buffer = mc_config_normalize_before_save (value); g_key_file_set_string (mc_config->handle, group, param, buffer); g_free (buffer); }
static void on_save_preferences (Viewer *viewer, GKeyFile *keyfile, void *user_data) { RendererCamThumb *self = user_data; GPtrArray *keys = gu_hash_table_get_keys(self->cam_handlers); for (int k = 0; k < g_ptr_array_size(keys); k++) { char *key = g_ptr_array_index(keys, k); cam_renderer_t *cr = g_hash_table_lookup(self->cam_handlers, key); char str[80]; sprintf (str, "%d %d", cr->render_place, cr->expanded); g_key_file_set_string (keyfile, RENDERER_NAME, key, str); } }
static gboolean add_remote_to_keyfile (GKeyFile *new_keyfile, const char *key, const char *url, GPtrArray *branches, GError **error) { gboolean ret = FALSE; char **iter; g_key_file_set_string (new_keyfile, key, "url", url); for (iter = opt_set; iter && *iter; iter++) { const char *keyvalue = *iter; gs_free char *subkey = NULL; gs_free char *subvalue = NULL; if (!parse_keyvalue (keyvalue, &subkey, &subvalue, error)) goto out; g_key_file_set_string (new_keyfile, key, subkey, subvalue); } if (branches->len > 0) g_key_file_set_string_list (new_keyfile, key, "branches", (const char *const *)branches->pdata, branches->len); if (opt_no_gpg_verify) g_key_file_set_boolean (new_keyfile, key, "gpg-verify", FALSE); ret = TRUE; out: return ret; }
/** * Sets a key in the key store file. */ bool keystore_store_key(const char *nick, const char *key) { const char *password; char *encrypted; char *wrapped; bool ok = false; GKeyFile *keyfile = getConfigFile(); // Remove old key delete_nick(keyfile, nick); // Add new key password = get_keystore_password(); if (password) { // Encrypt the password encrypted = fish_encrypt(password, strlen(password), key); if (!encrypted) goto end; // Prepend "+OK " wrapped = g_strconcat("+OK ", encrypted, NULL); g_free(encrypted); // Store encrypted in file g_key_file_set_string(keyfile, nick, "key", wrapped); free(wrapped); } else { // Store unencrypted in file g_key_file_set_string(keyfile, nick, "key", key); } // Save key store file ok = save_keystore(keyfile); end: g_key_file_free(keyfile); return ok; }
/* create basic conffile with sensible defaults */ static void create_conf_file(void) { GKeyFile *settingsfile; gchar *keyfile; mkdir(CONFIG_FILE_DIR, 0755); settingsfile = g_key_file_new(); g_key_file_set_string(settingsfile, MODE_SETTING_ENTRY, MODE_SETTING_KEY, MODE_DEVELOPER ); keyfile = g_key_file_to_data (settingsfile, NULL, NULL); if(g_file_set_contents(FS_MOUNT_CONFIG_FILE, keyfile, -1, NULL) == 0) log_debug("Conffile creation failed. Continuing without configuration!\n"); g_key_file_free(settingsfile); }
static void policy_allowed_bearers(const char *allowed_bearers) { struct passwd *pwd; uid_t uid; char *pathname; GKeyFile *keyfile; LOG("update to '%s'", allowed_bearers); uid = getuid(); pwd = getpwuid(uid); g_assert(pwd); keyfile = g_key_file_new(); g_key_file_set_string(keyfile, "policy_foo", "uid", pwd->pw_name); g_key_file_set_string(keyfile, "policy_foo", "AllowedBearers", allowed_bearers); pathname = g_strdup_printf("%s/foo.policy", POLICYDIR); policy_save(keyfile, pathname); g_free(pathname); g_key_file_unref(keyfile); }
void cairo_dock_add_remove_element_to_key (const gchar *cConfFilePath, const gchar *cGroupName, const gchar *cKeyName, gchar *cElementName, gboolean bAdd) { GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath); if (pKeyFile == NULL) return ; gchar *cElementList = g_key_file_get_string (pKeyFile, cGroupName, cKeyName, NULL), *cNewElementList = NULL; if (cElementList != NULL && *cElementList == '\0') { g_free (cElementList); cElementList= NULL; } if (bAdd) { //g_print ("on rajoute %s\n", cElementName); if (cElementList != NULL) cNewElementList = g_strdup_printf ("%s;%s", cElementList, cElementName); else cNewElementList = g_strdup (cElementName); } else { //g_print ("on enleve %s\n", cElementName); gchar *str = g_strstr_len (cElementList, strlen (cElementList), cElementName); g_return_if_fail (str != NULL); if (str == cElementList) { if (str[strlen (cElementName)] == '\0') cNewElementList = g_strdup (""); else cNewElementList = g_strdup (str + strlen (cElementName) + 1); } else { *(str-1) = '\0'; if (str[strlen (cElementName)] == '\0') cNewElementList = g_strdup (cElementList); else cNewElementList = g_strdup_printf ("%s;%s", cElementList, str + strlen (cElementName) + 1); } } g_key_file_set_string (pKeyFile, cGroupName, cKeyName, cNewElementList); cairo_dock_write_keys_to_file (pKeyFile, cConfFilePath); g_free (cElementList); g_free (cNewElementList); g_key_file_free (pKeyFile); }
/** * anjuta_session_set_string: * @session: an #AnjutaSession object * @section: Section. * @key: Key name. * @value: Key value * * Set a string @value to @key in given @section. */ void anjuta_session_set_string (AnjutaSession *session, const gchar *section, const gchar *key, const gchar *value) { g_return_if_fail (ANJUTA_IS_SESSION (session)); g_return_if_fail (section != NULL); g_return_if_fail (key != NULL); if (!value) { g_key_file_remove_key (session->priv->key_file, section, key, NULL); return; } g_key_file_set_string (session->priv->key_file, section, key, value); }
/** * builder: the gtk builder object * dialog: The dialog to extract the data from * * Gets the unlocking settings and stores them in output_data * **/ static void gather_unlock_options (GtkBuilder *builder, GtkDialog *dialog) { GcrUnlockOptionsWidget *unlock; const gchar *choice; unlock = g_object_get_data (G_OBJECT (dialog), "unlock-options-widget"); choice = gcr_unlock_options_widget_get_choice (unlock); if (choice) { g_key_file_set_integer (output_data, "unlock-options", "ttl", gcr_unlock_options_widget_get_ttl (unlock)); g_key_file_set_string (output_data, "unlock-options", "choice", choice); } }
void remmina_pref_set_value (const gchar *key, const gchar *value) { GKeyFile *gkeyfile; gchar *content; gsize length; gkeyfile = g_key_file_new (); g_key_file_load_from_file (gkeyfile, remmina_pref_file, G_KEY_FILE_NONE, NULL); g_key_file_set_string (gkeyfile, "remmina_pref", key, value); content = g_key_file_to_data (gkeyfile, &length, NULL); g_file_set_contents (remmina_pref_file, content, length, NULL); g_key_file_free (gkeyfile); g_free (content); }
/* * @param config : the key to be set * @param setting : The value to be set */ set_config_result_t set_network_setting(const char *config, const char *setting) { GKeyFile *settingsfile; gboolean test = FALSE; gchar *keyfile; if(!strcmp(config, NETWORK_IP_KEY) || !strcmp(config, NETWORK_GATEWAY_KEY)) if(validate_ip(setting) != 0) return SET_CONFIG_ERROR; settingsfile = g_key_file_new(); test = g_key_file_load_from_file(settingsfile, FS_MOUNT_CONFIG_FILE, G_KEY_FILE_NONE, NULL); if(!strcmp(config, NETWORK_IP_KEY) || !strcmp(config, NETWORK_INTERFACE_KEY) || !strcmp(config, NETWORK_GATEWAY_KEY)) { set_config_result_t ret = SET_CONFIG_ERROR; if (test) { if(config_value_changed(settingsfile, NETWORK_ENTRY, config, setting)) { g_key_file_free(settingsfile); return SET_CONFIG_UNCHANGED; } } else { log_debug("No conffile. Creating.\n"); create_conf_file(); } g_key_file_set_string(settingsfile, NETWORK_ENTRY, config, setting); keyfile = g_key_file_to_data (settingsfile, NULL, NULL); /* free the settingsfile before writing things out to be sure the contents will be correctly written to file afterwards. Just a precaution. */ g_key_file_free(settingsfile); if (g_file_set_contents(FS_MOUNT_CONFIG_FILE, keyfile, -1, NULL)) ret = SET_CONFIG_UPDATED; free(keyfile); return ret; } else { g_key_file_free(settingsfile); return SET_CONFIG_ERROR; } }
static void save_config( GKeyFile *file ) { GKeyFile *config = pgm_main_window_get_config(); g_key_file_set_boolean( config, PGM_SQL_EDITOR_CONFIG_GROUP, "AutoIndent", gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( auto_indent ) ) ); g_key_file_set_boolean( config, PGM_SQL_EDITOR_CONFIG_GROUP, "IndentOnTab", gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( indent_on_tab ) ) ); g_key_file_set_boolean( config, PGM_SQL_EDITOR_CONFIG_GROUP, "ShowLineNumbers", gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( show_line_numbers ) ) ); g_key_file_set_boolean( config, PGM_SQL_EDITOR_CONFIG_GROUP, "SmartHomeEnd", gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( smart_home_end ) ) ); g_key_file_set_boolean( config, PGM_SQL_EDITOR_CONFIG_GROUP, "InsertSpacesInsteadOfTab", gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( insert_spaces_instead_of_tabs ) ) ); g_key_file_set_boolean( config, PGM_SQL_EDITOR_CONFIG_GROUP, "HighlightCurrentLine", gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( highlight_current_line ) ) ); g_key_file_set_integer( config, PGM_SQL_EDITOR_CONFIG_GROUP, "IndentWidth", gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( indent_width_editor ) ) ); g_key_file_set_integer( config, PGM_SQL_EDITOR_CONFIG_GROUP, "TabWidth", gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( tab_width_editor ) ) ); g_key_file_set_string( config, PGM_SQL_EDITOR_CONFIG_GROUP, "Font", gtk_font_button_get_font_name( GTK_FONT_BUTTON( font_editor ) ) ); g_key_file_set_integer( config, PGM_SQL_EDITOR_CONFIG_GROUP, "DrawSpaces", gtk_combo_box_get_active( GTK_COMBO_BOX( draw_spaces_editor ) ) ); pgm_sql_editor_reload_config(); }
void save_settings(Preferences *pref) { gchar *path; gchar *dir; GKeyFile* key; GError *err = NULL; gchar *data; gsize data_len = 0; GtkWidget *dialog; path = get_config_path(); dir = g_dirname(path); key = g_key_file_new(); g_key_file_load_from_file(key, path, G_KEY_FILE_KEEP_COMMENTS|G_KEY_FILE_KEEP_TRANSLATIONS, NULL); g_key_file_set_integer(key, "core", "backend", pref->backend); g_key_file_set_string(key, "core", "download_dir", pref->download_dir); g_key_file_set_integer(key, "core", "max_concurrent_downloads", pref->max_concurrent_downloads); g_key_file_set_boolean(key, "core", "use_schedule", pref->use_schedule); g_key_file_set_integer(key, "core", "start_time_hour", pref->start_time_hour); g_key_file_set_integer(key, "core", "start_time_minute", pref->start_time_minute); g_key_file_set_integer(key, "core", "end_time_hour", pref->end_time_hour); g_key_file_set_integer(key, "core", "end_time_minute", pref->end_time_minute); data = g_key_file_to_data(key, &data_len, &err); if (err) { dialog = gtk_message_dialog_new (GTK_WINDOW(g_GAria2), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Error: %s", err->message); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_error_free(err); } if (!g_file_test(dir, G_FILE_TEST_EXISTS)) { g_mkdir_with_parents(dir, 0700); } g_file_set_contents(path, data, data_len, NULL); g_free(data); g_free(path); g_free(dir); g_key_file_free(key); }
static gboolean _accounts_rename(const char * const account_name, const char * const new_name) { if (g_key_file_has_group(accounts, new_name)) { return FALSE; } if (!g_key_file_has_group(accounts, account_name)) { return FALSE; } g_key_file_set_boolean(accounts, new_name, "enabled", g_key_file_get_boolean(accounts, account_name, "enabled", NULL)); g_key_file_set_integer(accounts, new_name, "priority.online", g_key_file_get_integer(accounts, account_name, "priority.online", NULL)); g_key_file_set_integer(accounts, new_name, "priority.chat", g_key_file_get_integer(accounts, account_name, "priority.chat", NULL)); g_key_file_set_integer(accounts, new_name, "priority.away", g_key_file_get_integer(accounts, account_name, "priority.away", NULL)); g_key_file_set_integer(accounts, new_name, "priority.xa", g_key_file_get_integer(accounts, account_name, "priority.xa", NULL)); g_key_file_set_integer(accounts, new_name, "priority.dnd", g_key_file_get_integer(accounts, account_name, "priority.dnd", NULL)); // copy other string properties int i; for (i = 0; i < ARRAY_SIZE(string_keys); i++) { char *value = g_key_file_get_string(accounts, account_name, string_keys[i], NULL); if (value != NULL) { g_key_file_set_string(accounts, new_name, string_keys[i], value); g_free(value); } } g_key_file_remove_group(accounts, account_name, NULL); _save_accounts(); autocomplete_remove(all_ac, account_name); autocomplete_add(all_ac, new_name); if (g_key_file_get_boolean(accounts, new_name, "enabled", NULL)) { autocomplete_remove(enabled_ac, account_name); autocomplete_add(enabled_ac, new_name); } return TRUE; }
char *config_get_daemonctlfile(void) { GError *error = NULL; char *value = NULL; char *key = "daemonctlfile"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = "/tmp/" APPNAME ".ctl"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
char *config_get_ttyconsoledev(void) { GError *error = NULL; char *value = NULL; char *key = "ttyconsoledev"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = "/dev/ttyUSB0"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
char *config_get_ignoredtalkgroups(void) { GError *error = NULL; char *value = NULL; char *key = "ignoredtalkgroups"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = "*"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
char *config_get_remotedbtableprefix(void) { GError *error = NULL; char *value = NULL; char *key = "remotedbtableprefix"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = APPNAME "-"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
char *config_get_callsignbookdbtablename(void) { GError *error = NULL; char *value = NULL; char *key = "callsignbookdbtablename"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = "dmrshark-csb"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
char *config_get_aprsposdescription(void) { GError *error = NULL; char *value = NULL; char *key = "aprsposdescription"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = "dmrshark"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
void accounts_set_last_activity(const char *const account_name) { if (accounts_account_exists(account_name)) { GDateTime *nowdt = g_date_time_new_now_utc(); GTimeVal nowtv; gboolean res = g_date_time_to_timeval(nowdt, &nowtv); g_date_time_unref(nowdt); if (res) { char *timestr = g_time_val_to_iso8601(&nowtv); g_key_file_set_string(accounts, account_name, "last.activity", timestr); free(timestr); _save_accounts(); } } }
static int l2tp_save(struct vpn_provider *provider, GKeyFile *keyfile) { const char *option; bool l2tp_option, pppd_option; int i; for (i = 0; i < (int)ARRAY_SIZE(pppd_options); i++) { l2tp_option = pppd_option = false; if (strncmp(pppd_options[i].cm_opt, "L2TP.", 5) == 0) l2tp_option = true; if (strncmp(pppd_options[i].cm_opt, "PPPD.", 5) == 0) pppd_option = true; if (l2tp_option || pppd_option) { option = vpn_provider_get_string(provider, pppd_options[i].cm_opt); if (!option) { /* * Check if the option prefix is L2TP as the * PPPD options were using L2TP prefix earlier. */ char *l2tp_str; if (!pppd_option) continue; l2tp_str = g_strdup_printf("L2TP.%s", &pppd_options[i].cm_opt[5]); option = vpn_provider_get_string(provider, l2tp_str); g_free(l2tp_str); if (!option) continue; } g_key_file_set_string(keyfile, vpn_provider_get_save_group(provider), pppd_options[i].cm_opt, option); } } return 0; }
char *config_get_netdevicename(void) { GError *error = NULL; char *value = NULL; char *key = "netdevicename"; char *defaultvalue = NULL; pthread_mutex_lock(&config_mutex); defaultvalue = "any"; value = g_key_file_get_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, &error); if (error || value == NULL) { value = strdup(defaultvalue); if (value) g_key_file_set_string(keyfile, CONFIG_MAIN_SECTION_NAME, key, value); } pthread_mutex_unlock(&config_mutex); return value; }
static void _dentry_ui_finish(gpointer pdata, gboolean cancelled) { FmFilePropertiesDEntryData *data = pdata; gsize len; char *text; if (data == NULL) return; if (!cancelled) { text = g_object_get_qdata(data->icon, fm_qdata_id); if (text) { g_key_file_set_string(data->kf, GRP_NAME, "Icon", text); /* disable default handler for icon change since we'll do it below */ g_object_set_qdata(data->icon, fm_qdata_id, NULL); data->changed = TRUE; } } if (!cancelled && data->changed) { text = g_key_file_to_data(data->kf, &len, NULL); g_file_replace_contents(data->file, text, len, NULL, FALSE, 0, NULL, NULL, NULL); /* FIXME: handle errors */ g_free(text); } g_object_unref(data->file); g_key_file_free(data->kf); /* disable own handler on data->name */ g_signal_handlers_disconnect_by_func(data->name, _dentry_name_changed, data); /* restore the field so properties dialog will not do own processing */ gtk_entry_set_text(data->name, data->saved_name); if (data->hidden) { /* disable own handler on data->hidden */ g_signal_handlers_disconnect_by_func(data->hidden, _dentry_hidden_toggled, data); /* disable default handler returning previous value */ gtk_toggle_button_set_active(data->hidden, data->was_hidden); } g_free(data->saved_name); g_free(data->lang); g_slice_free(FmFilePropertiesDEntryData, data); }