void panel_layout_apply_default_from_gkeyfile (GdkScreen *screen) { int screen_n; gchar *layout_file = NULL; GKeyFile *keyfile = NULL; gchar **groups = NULL; GError *error = NULL; int i; screen_n = gdk_screen_get_number (screen); layout_file = panel_layout_filename(); if (layout_file) { keyfile = g_key_file_new (); if (g_key_file_load_from_file (keyfile, layout_file, G_KEY_FILE_NONE, &error)) { groups = g_key_file_get_groups (keyfile, NULL); for (i = 0; groups[i] != NULL; i++) { if (g_strcmp0 (groups[i], "Toplevel") == 0 || g_str_has_prefix (groups[i], "Toplevel ")) panel_layout_append_group_helper ( keyfile, groups[i], screen_n, "Toplevel", PANEL_TOPLEVEL_ID_LIST_KEY, PANEL_TOPLEVEL_SCHEMA, PANEL_TOPLEVEL_PATH, PANEL_TOPLEVEL_DEFAULT_PREFIX, panel_layout_toplevel_keys, G_N_ELEMENTS (panel_layout_toplevel_keys), "toplevel"); else if (g_strcmp0 (groups[i], "Object") == 0 || g_str_has_prefix (groups[i], "Object ")) panel_layout_append_group_helper ( keyfile, groups[i], -1, "Object", PANEL_OBJECT_ID_LIST_KEY, PANEL_OBJECT_SCHEMA, PANEL_OBJECT_PATH, PANEL_OBJECT_DEFAULT_PREFIX, panel_layout_object_keys, G_N_ELEMENTS (panel_layout_object_keys), "object"); else g_warning ("Unknown group in default layout: '%s'", groups[i]); } } else { g_warning ("Error while parsing default layout from '%s': %s\n", layout_file, error->message); g_error_free (error); } } else { g_warning ("Cant find a default layout file!"); /* FIXME implement a fallback panel */ } if (groups) g_strfreev (groups); if (keyfile) g_key_file_free (keyfile); if (layout_file) g_free (layout_file); }
NMConnection * nm_keyfile_plugin_connection_from_file (const char *filename, GError **error) { GKeyFile *key_file; struct stat statbuf; gboolean bad_owner, bad_permissions; NMConnection *connection = NULL; NMSettingConnection *s_con; NMSetting *setting; gchar **groups; gsize length; int i; gboolean vpn_secrets = FALSE; const char *ctype; GError *verify_error = NULL; if (stat (filename, &statbuf) != 0 || !S_ISREG (statbuf.st_mode)) { g_set_error_literal (error, KEYFILE_PLUGIN_ERROR, 0, "File did not exist or was not a regular file"); return NULL; } bad_owner = getuid () != statbuf.st_uid; bad_permissions = statbuf.st_mode & 0077; if (bad_owner || bad_permissions) { g_set_error (error, KEYFILE_PLUGIN_ERROR, 0, "File permissions (%o) or owner (%d) were insecure", statbuf.st_mode, statbuf.st_uid); return NULL; } key_file = g_key_file_new (); if (!g_key_file_load_from_file (key_file, filename, G_KEY_FILE_NONE, error)) goto out; connection = nm_connection_new (); groups = g_key_file_get_groups (key_file, &length); for (i = 0; i < length; i++) { /* Only read out secrets when needed */ if (!strcmp (groups[i], VPN_SECRETS_GROUP)) { vpn_secrets = TRUE; continue; } setting = read_setting (key_file, filename, groups[i]); if (setting) nm_connection_add_setting (connection, setting); } /* Make sure that we have the base device type setting even if * the keyfile didn't include it, which can happen when the base * device type setting is all default values (like ethernet). */ s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION); if (s_con) { ctype = nm_setting_connection_get_connection_type (s_con); setting = nm_connection_get_setting_by_name (connection, ctype); if (ctype) { if (!setting && !strcmp (ctype, NM_SETTING_WIRED_SETTING_NAME)) nm_connection_add_setting (connection, nm_setting_wired_new ()); } } /* Handle vpn secrets after the 'vpn' setting was read */ if (vpn_secrets) { NMSettingVPN *s_vpn; s_vpn = (NMSettingVPN *) nm_connection_get_setting (connection, NM_TYPE_SETTING_VPN); if (s_vpn) read_vpn_secrets (key_file, s_vpn); } g_strfreev (groups); /* Verify the connection */ if (!nm_connection_verify (connection, &verify_error)) { g_set_error (error, KEYFILE_PLUGIN_ERROR, 0, "invalid or missing connection property '%s'", (verify_error && verify_error->message) ? verify_error->message : "(unknown)"); g_clear_error (&verify_error); g_object_unref (connection); connection = NULL; } out: g_key_file_free (key_file); return connection; }
void pk_backend_initialize(GKeyFile *conf, PkBackend *backend) { gchar *path, *val, *blacklist, **groups; gint ret; gushort i; gsize groups_len; GFile *katja_conf_file; GFileInfo *file_info; GKeyFile *katja_conf; GError *err = NULL; gpointer repo = NULL; sqlite3 *db; sqlite3_stmt *stmt; g_debug("backend: initialize"); curl_global_init(CURL_GLOBAL_DEFAULT); /* Open the database. We will need it to save the time the configuration file was last modified. */ path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL); if (sqlite3_open(path, &db) != SQLITE_OK) g_error("%s: %s", path, sqlite3_errmsg(db)); g_free(path); /* Read the configuration file */ katja_conf = g_key_file_new(); path = g_build_filename(SYSCONFDIR, "PackageKit", "Katja.conf", NULL); g_key_file_load_from_file(katja_conf, path, G_KEY_FILE_NONE, &err); if (err) { g_error("%s: %s", path, err->message); g_error_free(err); } katja_conf_file = g_file_new_for_path(path); if (!(file_info = g_file_query_info(katja_conf_file, "time::modified-usec", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &err))) { g_error("%s", err->message); g_error_free(err); } if ((ret = sqlite3_prepare_v2(db, "UPDATE cache_info SET value = ? WHERE key LIKE 'last_modification'", -1, &stmt, NULL)) == SQLITE_OK) { ret = sqlite3_bind_int(stmt, 1, g_file_info_get_attribute_uint32(file_info, "time::modified-usec")); if (ret == SQLITE_OK) ret = sqlite3_step(stmt); sqlite3_finalize(stmt); } if ((ret != SQLITE_OK) && (ret != SQLITE_DONE)) g_error("%s: %s", path, sqlite3_errstr(ret)); else if (!sqlite3_changes(db)) g_error("Failed to update database: %s", path); g_object_unref(file_info); g_object_unref(katja_conf_file); sqlite3_close_v2(db); g_free(path); /* Initialize an object for each well-formed repository */ groups = g_key_file_get_groups(katja_conf, &groups_len); for (i = 0; i < groups_len; i++) { blacklist = g_key_file_get_string(katja_conf, groups[i], "Blacklist", NULL); if (g_key_file_has_key(katja_conf, groups[i], "Priority", NULL)) { repo = katja_slackpkg_new(groups[i], g_key_file_get_string(katja_conf, groups[i], "Mirror", NULL), i + 1, blacklist, g_key_file_get_string_list(katja_conf, groups[i], "Priority", NULL, NULL)); if (repo) repos = g_slist_append(repos, repo); } else if (g_key_file_has_key(katja_conf, groups[i], "IndexFile", NULL)) { val = g_key_file_get_string(katja_conf, groups[i], "IndexFile", NULL); repo = katja_dl_new(groups[i], g_key_file_get_string(katja_conf, groups[i], "Mirror", NULL), i + 1, blacklist, val); g_free(val); if (repo) repos = g_slist_append(repos, repo); else g_free(groups[i]); } g_free(blacklist); } g_free(groups); g_key_file_free(katja_conf); }
static void read_config_file (const char *filename, gboolean enoent_error) { GKeyFile *key_file = g_key_file_new(); GError *key_file_error = NULL; gchar **groups; gsize groups_count = 0; guint group_index; if (!g_key_file_load_from_file(key_file,filename, 0, &key_file_error)) { if (key_file_error) { if (key_file_error->domain != G_FILE_ERROR || key_file_error->code != G_FILE_ERROR_NOENT || enoent_error) { g_warning ("error opening config file '%s': %s\n", filename, key_file_error->message); } g_error_free(key_file_error); } g_key_file_free(key_file); return; } groups = g_key_file_get_groups (key_file, &groups_count); for (group_index = 0; group_index < groups_count; group_index++) { gsize keys_count = 0; const gchar *group = groups[group_index]; GError *keys_error = NULL; gchar **keys; keys = g_key_file_get_keys(key_file, group, &keys_count, &keys_error); if (keys) { guint key_index; for (key_index = 0; key_index < keys_count; key_index++) { const gchar *key = keys[key_index]; GError *key_error = NULL; gchar *value = g_key_file_get_value(key_file, group, key, &key_error); if (value != NULL) { g_hash_table_insert (config_hash, g_strdup_printf ("%s/%s", group, key), value); } if (key_error) { g_warning ("error getting key '%s/%s' in config file '%s'\n", group, key, filename); g_error_free(key_error); } } g_strfreev(keys); } if (keys_error) { g_warning ("error getting keys in group '%s' of config file '%s'\n", filename, group); g_error_free(keys_error); } } g_strfreev(groups); g_key_file_free(key_file); }
/** * as_distro_details_construct: * * Construct a new #AsDistroDetails instance. * * Returns: (transfer full): a new #AsDistroDetails instance. **/ AsDistroDetails* as_distro_details_construct (GType object_type) { AsDistroDetails * self = NULL; GFile* f = NULL; gchar *line; GError *error = NULL; self = (AsDistroDetails*) g_object_new (object_type, NULL); as_distro_details_set_distro_id (self, "unknown"); as_distro_details_set_distro_name (self, ""); as_distro_details_set_distro_version (self, ""); /* load configuration */ self->priv->keyf = g_key_file_new (); g_key_file_load_from_file (self->priv->keyf, AS_CONFIG_NAME, G_KEY_FILE_NONE, NULL); /* get details about the distribution we are running on */ f = g_file_new_for_path ("/etc/os-release"); if (g_file_query_exists (f, NULL)) { GDataInputStream *dis; GFileInputStream* fis; fis = g_file_read (f, NULL, &error); if (error != NULL) goto out; dis = g_data_input_stream_new ((GInputStream*) fis); g_object_unref (fis); while ((line = g_data_input_stream_read_line (dis, NULL, NULL, &error)) != NULL) { gchar **data; gchar *dvalue; if (error != NULL) { g_object_unref (dis); goto out; } data = g_strsplit (line, "=", 2); if (g_strv_length (data) != 2) { g_strfreev (data); g_free (line); continue; } dvalue = data[1]; if (g_str_has_prefix (dvalue, "\"")) { gchar *tmpstr; tmpstr = g_strndup (dvalue + 1, strlen(dvalue) - 2); g_free (dvalue); dvalue = tmpstr; } if (g_strcmp0 (data[0], "ID") == 0) as_distro_details_set_distro_id (self, dvalue); else if (g_strcmp0 (data[0], "NAME") == 0) as_distro_details_set_distro_name (self, dvalue); else if (g_strcmp0 (data[0], "VERSION_ID") == 0) as_distro_details_set_distro_version (self, dvalue); g_free (line); } } out: if (error != NULL) g_error_free (error); g_object_unref (f); return self; }
static gboolean dlg_add_folder_load_options (DialogData *data, const char *name) { GFile *options_dir; GFile *options_file; char *file_path; GKeyFile *key_file; GError *error = NULL; char *base_dir = NULL; char *filename = NULL; char *include_files = NULL; char *exclude_files = NULL; char *exclude_folders = NULL; gboolean update; gboolean recursive; gboolean no_symlinks; options_dir = get_user_config_subdirectory (ADD_FOLDER_OPTIONS_DIR, TRUE); options_file = g_file_get_child (options_dir, name); file_path = g_file_get_path (options_file); key_file = g_key_file_new (); if (! g_key_file_load_from_file (key_file, file_path, G_KEY_FILE_KEEP_COMMENTS, &error)) { if (error->code != G_IO_ERROR_NOT_FOUND) g_warning ("Could not load options file: %s\n", error->message); g_clear_error (&error); g_object_unref (options_file); g_object_unref (options_dir); g_key_file_free (key_file); return FALSE; } base_dir = g_key_file_get_string (key_file, "Options", "base_dir", NULL); filename = g_key_file_get_string (key_file, "Options", "filename", NULL); include_files = g_key_file_get_string (key_file, "Options", "include_files", NULL); exclude_files = g_key_file_get_string (key_file, "Options", "exclude_files", NULL); exclude_folders = g_key_file_get_string (key_file, "Options", "exclude_folders", NULL); update = g_key_file_get_boolean (key_file, "Options", "update", NULL); recursive = g_key_file_get_boolean (key_file, "Options", "recursive", NULL); no_symlinks = g_key_file_get_boolean (key_file, "Options", "no_symlinks", NULL); sync_widgets_with_options (data, base_dir, filename, include_files, exclude_files, exclude_folders, update, recursive, no_symlinks); dlg_add_folder_save_last_used_options (data, file_path); g_free (base_dir); g_free (filename); g_free (include_files); g_free (exclude_files); g_free (exclude_folders); g_key_file_free (key_file); g_free (file_path); g_object_unref (options_file); g_object_unref (options_dir); return TRUE; }
static gboolean read_persistent_state(GAPersistentState *pstate, const gchar *path, gboolean frozen) { GKeyFile *keyfile = NULL; GError *gerr = NULL; struct stat st; gboolean ret = true; g_assert(pstate); if (stat(path, &st) == -1) { /* it's okay if state file doesn't exist, but any other error * indicates a permissions issue or some other misconfiguration * that we likely won't be able to recover from. */ if (errno != ENOENT) { g_critical("unable to access state file at path %s: %s", path, strerror(errno)); ret = false; goto out; } /* file doesn't exist. initialize state to default values and * attempt to save now. (we could wait till later when we have * modified state we need to commit, but if there's a problem, * such as a missing parent directory, we want to catch it now) * * there is a potential scenario where someone either managed to * update the agent from a version that didn't use a key store * while qemu-ga thought the filesystem was frozen, or * deleted the key store prior to issuing a fsfreeze, prior * to restarting the agent. in this case we go ahead and defer * initial creation till we actually have modified state to * write, otherwise fail to recover from freeze. */ set_persistent_state_defaults(pstate); if (!frozen) { ret = write_persistent_state(pstate, path); if (!ret) { g_critical("unable to create state file at path %s", path); ret = false; goto out; } } ret = true; goto out; } keyfile = g_key_file_new(); g_key_file_load_from_file(keyfile, path, 0, &gerr); if (gerr) { g_critical("error loading persistent state from path: %s, %s", path, gerr->message); ret = false; goto out; } persistent_state_from_keyfile(pstate, keyfile); out: if (keyfile) { g_key_file_free(keyfile); } if (gerr) { g_error_free(gerr); } return ret; }
void plugin_load(void) { GtkWidget *mainwin; GtkWidget *statusbar; GtkWidget *plugin_box; GdkPixbuf *on_pixbuf; GdkPixbuf *off_pixbuf; gchar *rcpath; gboolean startup; syl_init_gettext("autoforward", "lib/locale"); debug_print(gettext("Auto mail forward Plug-in")); debug_print(dgettext("autoforward", "Auto mail forward Plug-in")); syl_plugin_add_menuitem("/Tools", _("Autoforward Settings [autoforward]"), exec_autoforward_menu_cb, NULL); g_signal_connect(syl_app_get(), "add-msg", G_CALLBACK(exec_autoforward_cb), NULL); mainwin = syl_plugin_main_window_get(); statusbar = syl_plugin_main_window_get_statusbar(); plugin_box = gtk_hbox_new(FALSE, 0); on_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)online); g_plugin_on=gtk_image_new_from_pixbuf(on_pixbuf); off_pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)offline); g_plugin_off=gtk_image_new_from_pixbuf(off_pixbuf); gtk_box_pack_start(GTK_BOX(plugin_box), g_plugin_on, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(plugin_box), g_plugin_off, FALSE, FALSE, 0); g_tooltip = gtk_tooltips_new(); g_onoff_switch = gtk_button_new(); gtk_button_set_relief(GTK_BUTTON(g_onoff_switch), GTK_RELIEF_NONE); GTK_WIDGET_UNSET_FLAGS(g_onoff_switch, GTK_CAN_FOCUS); gtk_widget_set_size_request(g_onoff_switch, 20, 20); gtk_container_add(GTK_CONTAINER(g_onoff_switch), plugin_box); g_signal_connect(G_OBJECT(g_onoff_switch), "clicked", G_CALLBACK(exec_autoforward_onoff_cb), mainwin); gtk_box_pack_start(GTK_BOX(statusbar), g_onoff_switch, FALSE, FALSE, 0); gtk_widget_show_all(g_onoff_switch); gtk_widget_hide(g_plugin_on); info.name = g_strdup(_(PLUGIN_NAME)); info.description = g_strdup(_(PLUGIN_DESC)); rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL); g_keyfile = g_key_file_new(); if (g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL)){ startup=g_key_file_get_boolean (g_keyfile, "forward", "startup", NULL); debug_print("startup:%s", startup ? "true" : "false"); if (startup){ g_enable=TRUE; gtk_widget_hide(g_plugin_off); gtk_widget_show(g_plugin_on); gtk_tooltips_set_tip(g_tooltip, g_onoff_switch, _("Autoforward is enabled. Click the icon to disable plugin."), NULL); } g_free(rcpath); } }
/** * main: **/ int main (int argc, char *argv[]) { gboolean ret = TRUE; gboolean disable_timer = FALSE; gboolean version = FALSE; gboolean timed_exit = FALSE; gboolean immediate_exit = FALSE; gboolean keep_environment = FALSE; gchar *backend_name = NULL; gchar *conf_filename = NULL; PkEngine *engine = NULL; GKeyFile *conf = NULL; GError *error = NULL; GOptionContext *context; guint timer_id = 0; const GOptionEntry options[] = { { "backend", '\0', 0, G_OPTION_ARG_STRING, &backend_name, /* TRANSLATORS: a backend is the system package tool, e.g. yum, apt */ _("Packaging backend to use, e.g. dummy"), NULL }, { "disable-timer", '\0', 0, G_OPTION_ARG_NONE, &disable_timer, /* TRANSLATORS: if we should not monitor how long we are inactive for */ _("Disable the idle timer"), NULL }, { "version", '\0', 0, G_OPTION_ARG_NONE, &version, /* TRANSLATORS: show version */ _("Show version and exit"), NULL }, { "timed-exit", '\0', 0, G_OPTION_ARG_NONE, &timed_exit, /* TRANSLATORS: exit after we've started up, used for user profiling */ _("Exit after a small delay"), NULL }, { "immediate-exit", '\0', 0, G_OPTION_ARG_NONE, &immediate_exit, /* TRANSLATORS: exit straight away, used for automatic profiling */ _("Exit after the engine has loaded"), NULL }, { "keep-environment", '\0', 0, G_OPTION_ARG_NONE, &keep_environment, /* TRANSLATORS: don't unset environment variables, used for debugging */ _("Don't clear environment on startup"), NULL }, { NULL } }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); openlog ("PackageKit", LOG_NDELAY, LOG_USER); #if (GLIB_MAJOR_VERSION == 2 && GLIB_MINOR_VERSION < 35) g_type_init (); #endif /* TRANSLATORS: describing the service that is running */ context = g_option_context_new (_("PackageKit service")); g_option_context_add_main_entries (context, options, NULL); g_option_context_add_group (context, pk_debug_get_option_group ()); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); if (version) { g_print ("Version %s\n", VERSION); goto exit_program; } /* we don't actually need to do this, except it rules out the * 'it works from the command line but not service activation' bugs */ #ifdef HAVE_CLEARENV if (!keep_environment) clearenv (); #endif /* get values from the config file */ conf = g_key_file_new (); conf_filename = pk_main_get_config_filename (); ret = g_key_file_load_from_file (conf, conf_filename, G_KEY_FILE_NONE, &error); if (!ret) { g_print ("Failed to load config file: %s", error->message); g_error_free (error); goto out; } g_key_file_set_boolean (conf, "Daemon", "KeepEnvironment", keep_environment); /* log the startup */ syslog (LOG_DAEMON | LOG_DEBUG, "daemon start"); /* after how long do we timeout? */ exit_idle_time = g_key_file_get_integer (conf, "Daemon", "ShutdownTimeout", NULL); g_debug ("daemon shutdown set to %i seconds", exit_idle_time); /* override the backend name */ if (backend_name != NULL) { g_key_file_set_string (conf, "Daemon", "DefaultBackend", backend_name); } /* resolve 'auto' to an actual name */ backend_name = g_key_file_get_string (conf, "Daemon", "DefaultBackend", NULL); if (g_strcmp0 (backend_name, "auto") == 0) { ret = pk_main_set_auto_backend (conf, &error); if (!ret) { g_print ("Failed to resolve auto: %s", error->message); g_error_free (error); goto out; } } loop = g_main_loop_new (NULL, FALSE); /* create a new engine object */ engine = pk_engine_new (conf); g_signal_connect (engine, "quit", G_CALLBACK (pk_main_quit_cb), loop); /* do stuff on ctrl-c */ g_unix_signal_add_full (G_PRIORITY_DEFAULT, SIGINT, pk_main_sigint_cb, loop, NULL); /* load the backend */ ret = pk_engine_load_backend (engine, &error); if (!ret) { /* TRANSLATORS: cannot load the backend the user specified */ g_print ("Failed to load the backend: %s", error->message); g_error_free (error); goto out; } /* Only timeout and close the mainloop if we have specified it * on the command line */ if (timed_exit) g_timeout_add_seconds (20, (GSourceFunc) timed_exit_cb, loop); /* only poll when we are alive */ if (exit_idle_time != 0 && !disable_timer) { timer_id = g_timeout_add_seconds (5, (GSourceFunc) pk_main_timeout_check_cb, engine); g_source_set_name_by_id (timer_id, "[PkMain] main poll"); } /* immediatly exit */ if (immediate_exit) g_timeout_add (50, (GSourceFunc) timed_exit_cb, loop); /* run until quit */ g_main_loop_run (loop); out: /* log the shutdown */ syslog (LOG_DAEMON | LOG_DEBUG, "daemon quit"); closelog (); if (timer_id > 0) g_source_remove (timer_id); if (loop != NULL) g_main_loop_unref (loop); g_key_file_unref (conf); if (engine != NULL) g_object_unref (engine); g_free (backend_name); g_free (conf_filename); exit_program: return 0; }
static void exec_autoforward_menu_cb(void) { /* show modal dialog */ GtkWidget *window; GtkWidget *vbox; GtkWidget *confirm_area; GtkWidget *ok_btn; GtkWidget *cancel_btn; GtkWidget *hbox; GtkWidget *label; GtkWidget *radio1; GtkWidget *radio2; GtkWidget *frame; GtkWidget *vbox_cond; GtkTreeIter iter; GtkTreeViewColumn *column; GtkWidget *view; GtkWidget *sw; GtkWidget *bbox; gchar *rcpath; gchar *to; gsize sz=0; GError *errval; gchar **folders; int nindex; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_container_set_border_width(GTK_CONTAINER(window), 8); /*gtk_widget_set_size_request(window, 200, 100);*/ gtk_window_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_policy(GTK_WINDOW(window), FALSE, TRUE, FALSE); gtk_widget_realize(window); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(window), vbox); confirm_area = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(confirm_area), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(confirm_area), 6); ok_btn = gtk_button_new_from_stock(GTK_STOCK_OK); GTK_WIDGET_SET_FLAGS(ok_btn, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(confirm_area), ok_btn, FALSE, FALSE, 0); gtk_widget_show(ok_btn); cancel_btn = gtk_button_new_from_stock(GTK_STOCK_CANCEL); GTK_WIDGET_SET_FLAGS(cancel_btn, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(confirm_area), cancel_btn, FALSE, FALSE, 0); gtk_widget_show(cancel_btn); gtk_widget_show(confirm_area); gtk_box_pack_end(GTK_BOX(vbox), confirm_area, FALSE, FALSE, 0); gtk_widget_grab_default(ok_btn); gtk_window_set_title(GTK_WINDOW(window), _("Autoforward Settings [autoforward]")); g_signal_connect(G_OBJECT(ok_btn), "clicked", G_CALLBACK(prefs_ok_cb), window); g_signal_connect(G_OBJECT(cancel_btn), "clicked", G_CALLBACK(prefs_cancel_cb), window); /* email settings */ hbox = gtk_hbox_new(FALSE, 6); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new(_("Forward to(E-mail):")); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); g_address = gtk_entry_new(); gtk_widget_show(g_address); gtk_box_pack_start(GTK_BOX(hbox), g_address, FALSE, TRUE, 0); /* email settings */ g_startup = gtk_check_button_new_with_label(_("Enable plugin on startup")); gtk_widget_show(g_startup); gtk_box_pack_start(GTK_BOX(vbox), g_startup, FALSE, FALSE, 0); #if 0 g_unreadonly = gtk_check_button_new_with_label(_("Forward unread mail only")); gtk_widget_show(g_unreadonly); gtk_box_pack_start(GTK_BOX(vbox), g_unreadonly, FALSE, FALSE, 0); #endif /* all */ radio1 = gtk_radio_button_new_with_label(NULL, _("Forward all mail")); /* folder filtered */ radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1), _("Forward mail in folder")); frame = gtk_frame_new(_("Forward condition:")); gtk_widget_show(frame); gtk_container_add(GTK_CONTAINER(vbox), frame); vbox_cond = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox_cond); gtk_container_add(GTK_CONTAINER(frame), vbox_cond); gtk_box_pack_start(GTK_BOX(vbox_cond), radio1, FALSE, FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox_cond), radio2, FALSE, FALSE, 6); /* treeview */ g_folders = gtk_list_store_new(1, G_TYPE_STRING); column = gtk_tree_view_column_new_with_attributes (_("Forward mail in following folder:"), gtk_cell_renderer_text_new (), "text", 0, NULL); view=gtk_tree_view_new_with_model(GTK_TREE_MODEL(g_folders)); gtk_tree_view_append_column (GTK_TREE_VIEW (view), column); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), view); gtk_box_pack_start (GTK_BOX(vbox_cond), sw, TRUE, TRUE, 2); /* add and delete */ bbox = gtk_hbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(bbox), 6); g_add_btn = gtk_button_new_from_stock(GTK_STOCK_ADD); g_delete_btn = gtk_button_new_from_stock(GTK_STOCK_DELETE); gtk_box_pack_start(GTK_BOX(bbox), g_add_btn, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bbox), g_delete_btn, FALSE, FALSE, 0); gtk_widget_show_all(bbox); gtk_box_pack_end(GTK_BOX(vbox_cond), bbox, FALSE, FALSE, 6); gtk_widget_show_all(vbox_cond); g_signal_connect (g_add_btn, "clicked", G_CALLBACK (add_mail_folder_cb), view); g_signal_connect (g_delete_btn, "clicked", G_CALLBACK (delete_mail_folder_cb), view); g_signal_connect(GTK_BUTTON(radio1), "clicked", G_CALLBACK(forward_mail_all_cb), view); g_signal_connect(GTK_BUTTON(radio2), "clicked", G_CALLBACK(forward_mail_folder_cb), view); /* load settings */ rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL); g_keyfile = g_key_file_new(); if (g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL)){ g_startup_flg = g_key_file_get_boolean (g_keyfile, "forward", "startup", NULL); debug_print("startup:%s\n", g_startup_flg ? "true" : "false"); if (g_startup_flg){ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_startup), TRUE); } #if 0 g_unreadonly_flg = g_key_file_get_boolean (g_keyfile, "forward", "unreadonly", NULL); debug_print("unreadonly:%s\n", g_unreadonly_flg ? "true" : "false"); if (g_unreadonly_flg){ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_unreadonly), TRUE); } #endif to=g_key_file_get_string (g_keyfile, "forward", "to", NULL); gtk_entry_set_text(GTK_ENTRY(g_address), to); g_forward_flg=g_key_file_get_boolean (g_keyfile, "forward", "all", NULL); if (g_forward_flg){ gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE); }else{ g_print("activate view and radio2\n"); gtk_widget_set_sensitive(GTK_WIDGET(view), TRUE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), TRUE); } /**/ folders = g_key_file_get_string_list(g_keyfile, "forward", "folder", &sz, &errval); if (folders!=NULL){ nindex=0; for (nindex = 0; nindex < sz; nindex++){ gtk_list_store_append(g_folders, &iter); gtk_list_store_set(g_folders, &iter, 0, folders[nindex], -1); } } }else{ /* default settings */ g_startup_flg = FALSE; g_forward_flg = TRUE; gtk_widget_set_sensitive(GTK_WIDGET(view), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(g_add_btn), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(g_delete_btn), FALSE); } g_free(rcpath); gtk_widget_show(window); }
void exec_autoforward_cb(GObject *obj, FolderItem *item, const gchar *file, guint num) { PrefsCommon *prefs_common; PrefsAccount *ac; gchar *rcpath; GSList* to_list=NULL; gchar *to; GError *errval; gboolean forward_all; gsize gz=0; gchar **folders; gboolean bmatch; int nindex; if (g_enable!=TRUE){ return; } if (item->stype != F_NORMAL && item->stype != F_INBOX){ return; } prefs_common = prefs_common_get(); if (prefs_common->online_mode != TRUE){ return; } ac = (PrefsAccount*)account_get_default(); g_return_if_fail(ac != NULL); /* check item->path for filter */ g_print("[DEBUG] %s:%s name:%s\n", G_STRLOC, G_STRFUNC, item->name); g_print("[DEBUG] %s:%s path:%s\n", G_STRLOC, G_STRFUNC, item->path); #if 0 MsgInfo *msginfo = folder_item_get_msginfo(item, num); debug_print("[DEBUG] flags:%08x UNREAD:%08x NEW:%08x MARKED:%08x ", msginfo->flags, MSG_UNREAD, MSG_NEW, MSG_MARKED); debug_print("[DEBUG] perm_flags:%08x \n", msginfo->flags.perm_flags); debug_print("[DEBUG] tmp_flags:%08x \n", msginfo->flags.tmp_flags); if ( g_unreadonly_flg != FALSE){ debug_print("[DEBUG] unreadonly flag:%s\n", g_unreadonly_flg ? "true" : "false"); if (MSG_IS_UNREAD(msginfo->flags)){ debug_print("[DEBUG] MSG_IS_UNREAD:true"); } else { return; } } #endif rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL); g_keyfile = g_key_file_new(); g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL); to=g_key_file_get_string (g_keyfile, "forward", "to", NULL); debug_print("[DEBUG] to:%s", to); to_list = address_list_append(to_list, to); forward_all = g_key_file_get_boolean (g_keyfile, "forward", "all", &errval); if (forward_all != TRUE){ if (errval) { switch (errval->code){ case G_KEY_FILE_ERROR_INVALID_VALUE: case G_KEY_FILE_ERROR_KEY_NOT_FOUND: forward_all=TRUE; break; default: break; } } } bmatch = FALSE; if (forward_all != TRUE){ folders = g_key_file_get_string_list(g_keyfile, "forward", "folder", &gz, NULL); if (gz != 0) { /* match or not */ nindex = 0; for (nindex = 0; nindex < gz; nindex++){ if (g_strcmp0(folders[nindex], item->path) == 0){ bmatch = TRUE; debug_print("[DEBUG] %s %s => match\n", folders[nindex], item->path); } } } else { bmatch = FALSE; } }else{ bmatch = TRUE; } g_free(rcpath); g_return_if_fail(to_list != NULL); g_print("[DEBUG] item->path:%s\n", item->path); g_print("[DEBUG] bmatch:%d\n", bmatch); g_return_if_fail(bmatch == TRUE); syl_plugin_send_message_set_forward_flags(ac->address); syl_plugin_send_message(file, ac, to_list); }
static void prefs_ok_cb(GtkWidget *widget, gpointer data) { gchar *rcpath; const gchar *address; gboolean startup; gboolean unreadonly; GtkTreeModel *model; gint nfolder; gchar **folders; GtkTreeIter iter; gboolean valid; int nindex; gchar *folder; gsize sz; gchar *buf; rcpath = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "autoforwardrc", NULL); g_keyfile = g_key_file_new(); g_key_file_load_from_file(g_keyfile, rcpath, G_KEY_FILE_KEEP_COMMENTS, NULL); address = gtk_entry_get_text(GTK_ENTRY(g_address)); if (address!=NULL){ g_key_file_set_string (g_keyfile, "forward", "to", address); } startup = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_startup)); g_key_file_set_boolean (g_keyfile, "forward", "startup", startup); debug_print("startup:%s\n", startup ? "true" : "false"); unreadonly = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g_unreadonly)); g_key_file_set_boolean (g_keyfile, "forward", "unreadonly", unreadonly); debug_print("unread only:%s\n", g_unreadonly_flg ? "true" : "false"); g_key_file_set_boolean (g_keyfile, "forward", "all", g_forward_flg); debug_print("forward all:%s\n", g_forward_flg ? "true" : "false"); /**/ model = GTK_TREE_MODEL(g_folders); nfolder = gtk_tree_model_iter_n_children(model, NULL); if (nfolder > 0){ folders = malloc(sizeof(gchar*)*nfolder); nindex = 0; for (valid = gtk_tree_model_get_iter_first(model, &iter); valid; valid = gtk_tree_model_iter_next(model, &iter)) { gtk_tree_model_get(model, &iter, 0, &folder, -1); folders[nindex] = folder; g_print("%d:%s\n", nindex, folder); nindex++; } g_key_file_set_string_list(g_keyfile, "forward", "folder", (const gchar * const*)folders, nfolder); }else{ g_key_file_remove_key(g_keyfile, "forward", "folder", NULL); } buf=g_key_file_to_data(g_keyfile, &sz, NULL); g_file_set_contents(rcpath, buf, sz, NULL); g_free(rcpath); gtk_widget_destroy(GTK_WIDGET(data)); }
int main (int argc, char *argv[]) { #ifndef WIN32 // Do not run as root. if (getuid () == 0) { cout << "Bibledit-Xiphos has not been designed to run with root privileges." << endl; return 1; } #endif // The necessary g* initializers, in the proper order. g_thread_init(NULL); g_type_init (); gtk_init (&argc, &argv); gchar * iconfile = g_build_filename (PACKAGE_DATA_DIR, "bibledit-xiphos.xpm", NULL); gtk_window_set_default_icon_from_file(iconfile, NULL); g_free (iconfile); // Initialize variables. event_id_rescan_bus = 0; last_message_id = "0"; quit = false; // Read settings. GKeyFile *keyfile = g_key_file_new(); gchar * key_file_name = registry_file_name (); g_key_file_load_from_file(keyfile, key_file_name, G_KEY_FILE_NONE, NULL); g_free (key_file_name); GtkBuilder *gtkbuilder; gtkbuilder = gtk_builder_new (); gchar * filename = g_build_filename (PACKAGE_DATA_DIR, "gtkbuilder.xml", NULL); gtk_builder_add_from_file (gtkbuilder, filename, NULL); g_free (filename); window = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "window")); g_signal_connect ((gpointer) window, "delete_event", G_CALLBACK (quit_program), NULL); gtk_widget_show_all (window); entry_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_url")); gchar * url = g_key_file_get_string (keyfile, "settings", "bibledit-web-url", NULL); if (!url) { url = strdup ("http://localhost/bibledit"); } gtk_entry_set_text (GTK_ENTRY (entry_url), url); g_free (url); g_signal_connect((gpointer) entry_url, "changed", G_CALLBACK(on_entry_url_changed), NULL); button_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_url")); g_signal_connect((gpointer) button_url, "clicked", G_CALLBACK(on_button_url_clicked), NULL); label_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_url")); entry_user = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_user")); gchar * user = g_key_file_get_string (keyfile, "settings", "bibledit-web-user", NULL); if (!user) { user = strdup (""); } gtk_entry_set_text (GTK_ENTRY (entry_user), user); g_free (user); g_signal_connect((gpointer) entry_user, "changed", G_CALLBACK(on_entry_user_changed), NULL); label_xiphos_process = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_xiphos_process")); label_id = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_id")); label_command = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_command")); label_body = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_body")); label_xiphos = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_xiphos")); button_hide = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_hide")); g_signal_connect((gpointer) button_hide, "clicked", G_CALLBACK(on_button_hide_clicked), NULL); g_key_file_free (keyfile); // We use asynchronous transport, so that we can send several messages simultanously. session = soup_session_async_new_with_options (SOUP_SESSION_USER_AGENT, "bibledit-xiphos/1.0", NULL); start_xiphos_web_listener (); // Obtain a connection to the Session Bus. GError *error = NULL; sigcon = dbus_g_bus_get(DBUS_BUS_SESSION, &error); if(sigcon) { con = dbus_g_connection_get_connection(sigcon); } else { printf ("%s\n", error->message); fflush (stdout); g_error_free(error); return 1; } // Request our name on the DBus. if (con) { DBusError *dbuserror = NULL; int retval = dbus_bus_request_name(con, "org.bibledit.xiphos", 0, dbuserror); if (retval != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) { if (dbus_error_is_set(dbuserror)) { printf ("%s\n", dbuserror->message); fflush (stdout); dbus_error_free(dbuserror); } } } // Connect to a couple of signals that indicate applications have started or have exited. // Then a rescan of the bus can show whether the programs that we're interested in run. proxy = NULL; if (sigcon) proxy = dbus_g_proxy_new_for_name(sigcon, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus"); if (proxy) { dbus_g_proxy_add_signal(proxy, "NameAcquired", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy, "NameAcquired", G_CALLBACK (on_name_acquired), NULL, NULL); dbus_g_proxy_add_signal(proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy, "NameOwnerChanged", G_CALLBACK (on_name_owner_changed), NULL, NULL); dbus_g_proxy_add_signal(proxy, "NameLost", G_TYPE_STRING, G_TYPE_INVALID); dbus_g_proxy_connect_signal(proxy, "NameLost", G_CALLBACK (on_name_lost), NULL, NULL); } // Signal trapping for doing a clean exit. signal(SIGINT, sigproc); signal(SIGQUIT, sigquit); // Main loop. gtk_main(); // Destroy any pending timeout. destroy_source(event_id_rescan_bus); // Abort the session including the listeners soup_session_abort (session); // The connection obtained through dbus_g_connection_get_connection does not have its reference count incremented. // Therefore it should not be unreferenced. // dbus_connection_unref(con); // Destroy the proxy. if (proxy) { g_object_unref(proxy); } // Well done. return 0; }
static void mame_gui_prefs_init (MameGuiPrefs *pr) { gboolean load_result; gint *int_array; gsize columnsize; guint i; GMAMEUI_DEBUG ("Creating GUI prefs object"); pr->priv = g_new0 (MameGuiPrefsPrivate, 1); int_array = g_new0 (gint, NUMBER_COLUMN); /* Used for loading integer lists from prefs file */ pr->priv->cols_shown = g_value_array_new (NUMBER_COLUMN); pr->priv->cols_width = g_value_array_new (NUMBER_COLUMN); pr->priv->executable_paths = g_value_array_new (4); /* FIXME TODO MAX_EXECUTABLES */ pr->priv->rom_paths = g_value_array_new (4); /* FIXME TODO - define max number */ pr->priv->sample_paths = g_value_array_new (4); /* FIXME TODO - define max number */ /* The gmameui.ini pref file should be stored in the following locations: ~/.config/gmameui (on Linux) */ pr->priv->filename = g_build_filename (get_gmameui_config_dir (), "gmameui.ini", NULL); pr->priv->prefs_ini_file = g_key_file_new (); GError *error = NULL; load_result = g_key_file_load_from_file (pr->priv->prefs_ini_file, pr->priv->filename, G_KEY_FILE_KEEP_COMMENTS, &error); if (!load_result) { GMAMEUI_DEBUG ("Error loading %s - %s", pr->priv->filename, error->message); g_error_free (error); error = NULL; } /* UI preferences */ pr->priv->ui_width = mame_gui_prefs_get_int_property_from_key_file (pr, "ui-width"); pr->priv->ui_height = mame_gui_prefs_get_int_property_from_key_file (pr, "ui-height"); pr->priv->show_toolbar = mame_gui_prefs_get_bool_property_from_key_file (pr, "show-toolbar"); pr->priv->show_statusbar = mame_gui_prefs_get_bool_property_from_key_file (pr, "show-statusbar"); pr->priv->show_filterlist = mame_gui_prefs_get_bool_property_from_key_file (pr, "show-filterlist"); pr->priv->show_screenshot = mame_gui_prefs_get_bool_property_from_key_file (pr, "show-screenshot"); pr->priv->current_rom_filter = mame_gui_prefs_get_int_property_from_key_file (pr, "current-rom-filter"); pr->priv->current_mode = mame_gui_prefs_get_int_property_from_key_file (pr, "current-mode"); pr->priv->previous_mode = mame_gui_prefs_get_int_property_from_key_file (pr, "previous-mode"); int_array = g_key_file_get_integer_list (pr->priv->prefs_ini_file, "Preferences", "cols-shown", &columnsize, &error); for (i = 0; i < NUMBER_COLUMN; ++i) { GValue val = { 0, }; g_value_init (&val, G_TYPE_INT); g_value_set_int (&val, int_array != NULL ? int_array[i] : 1); /* If not available, default to shown */ GMAMEUI_DEBUG ("Value for cols-shown at %d is %d", i, g_value_get_int (&val)); g_value_array_append (pr->priv->cols_shown, &val); } if (error) { GMAMEUI_DEBUG ("Error retrieving cols-shown: %s", error->message); g_error_free (error); error = NULL; } int_array = g_key_file_get_integer_list (pr->priv->prefs_ini_file, "Preferences", "cols-width", &columnsize, &error); for (i = 0; i < NUMBER_COLUMN; ++i) { GValue val = { 0, }; /* FIXME TODO 0 means auto sized columns */ g_value_init (&val, G_TYPE_INT); g_value_set_int (&val, int_array != NULL ? int_array[i] : 0); /* If not available, default to 0 */ GMAMEUI_DEBUG ("Value for cols-width at %d is %d", i, g_value_get_int (&val)); g_value_array_append (pr->priv->cols_width, &val); } if (error) { GMAMEUI_DEBUG ("Error retrieving cols-width: %s", error->message); g_error_free (error); error = NULL; } pr->priv->sort_col = mame_gui_prefs_get_int_property_from_key_file (pr, "sort-col"); pr->priv->sort_col_direction = mame_gui_prefs_get_int_property_from_key_file (pr, "sort-col-direction"); pr->priv->xpos_filters = mame_gui_prefs_get_int_property_from_key_file (pr, "xpos-filters"); pr->priv->xpos_gamelist = mame_gui_prefs_get_int_property_from_key_file (pr, "xpos-gamelist"); /* Startup preferences */ pr->priv->GameCheck = mame_gui_prefs_get_bool_property_from_key_file (pr, "gamecheck"); pr->priv->VersionCheck = mame_gui_prefs_get_bool_property_from_key_file (pr, "versioncheck"); pr->priv->use_xmame_options = mame_gui_prefs_get_bool_property_from_key_file (pr, "usexmameoptions"); pr->priv->prefercustomicons = mame_gui_prefs_get_bool_property_from_key_file (pr, "prefercustomicons"); pr->priv->gui_joy = mame_gui_prefs_get_bool_property_from_key_file (pr, "usejoyingui"); pr->priv->joystick_name = mame_gui_prefs_get_string_property_from_key_file (pr, "joystick-name"); if (!pr->priv->joystick_name) pr->priv->joystick_name = g_strdup (get_joy_dev ()); /* Miscellaneous preferences */ pr->priv->theprefix = mame_gui_prefs_get_bool_property_from_key_file (pr, "theprefix"); pr->priv->current_rom_name = mame_gui_prefs_get_string_property_from_key_file (pr, "current-rom"); pr->priv->current_executable_name = mame_gui_prefs_get_string_property_from_key_file (pr, "current-executable"); /* Load the executable paths */ pr->priv->executable_paths = mame_gui_prefs_get_stringlist_property_from_key_file (pr, "Preferences", "executable-paths"); /* Load the ROM paths */ pr->priv->rom_paths = mame_gui_prefs_get_stringlist_property_from_key_file (pr, "Preferences", "rom-paths"); /* Load the Samples paths */ pr->priv->sample_paths = mame_gui_prefs_get_stringlist_property_from_key_file (pr, "Preferences", "sample-paths"); /* Directory preferences */ GMAMEUI_DEBUG ("Reading directories preferences from file"); for (i = 0; i < NUM_DIRS; i++) { pr->priv->directories[i] = mame_gui_prefs_get_string_property_from_key_file (pr, directory_prefs[i].name); /* If no values set, set default values */ if (!pr->priv->directories[i]) pr->priv->directories[i] = g_strdup (directory_prefs[i].default_dir); /* strdup, since we free in finalize */ GMAMEUI_DEBUG ("Setting directory %d (%s) to %s", i, directory_prefs[i].name, pr->priv->directories[i]); /* If directory does not exist under $HOME/.config/mame, create it */ if (i >= DIR_CFG) { gchar *dir; dir = g_build_filename (g_get_user_config_dir (), "mame", directory_prefs[i].default_dir, NULL); if (!g_file_test (dir, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)) { GMAMEUI_DEBUG ("Directory %s does not exist, creating it", dir); g_mkdir (dir, S_IRWXU); } g_free (dir); } } GMAMEUI_DEBUG ("Reading directories preferences from file... done"); /* Set handlers so that whenever the values are changed (from anywhere), the signal handler is invoked; the callback then saves to the g_key_file */ g_signal_connect (pr, "notify::ui-width", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::ui-height", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::show-toolbar", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::show-statusbar", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::show-filterlist", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::show-screenshot", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::current-rom-filter", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::current-mode", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::previous-mode", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::cols-shown", (GCallback) mame_gui_prefs_save_int_arr, NULL); g_signal_connect (pr, "notify::cols-width", (GCallback) mame_gui_prefs_save_int_arr, NULL); g_signal_connect (pr, "notify::sort-col", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::sort-col-direction", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::xpos-filters", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::xpos-gamelist", (GCallback) mame_gui_prefs_save_int, NULL); g_signal_connect (pr, "notify::gamecheck", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::versioncheck", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::usexmameoptions", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::prefercustomicons", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::usejoyingui", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::joystick-name", (GCallback) mame_gui_prefs_save_string, NULL); g_signal_connect (pr, "notify::theprefix", (GCallback) mame_gui_prefs_save_bool, NULL); g_signal_connect (pr, "notify::current-rom", (GCallback) mame_gui_prefs_save_string, NULL); g_signal_connect (pr, "notify::current-executable", (GCallback) mame_gui_prefs_save_string, NULL); g_signal_connect (pr, "notify::executable-paths", (GCallback) mame_gui_prefs_save_string_arr, NULL); g_signal_connect (pr, "notify::rom-paths", (GCallback) mame_gui_prefs_save_string_arr, NULL); g_signal_connect (pr, "notify::sample-paths", (GCallback) mame_gui_prefs_save_string_arr, NULL); for (i = 0; i < NUM_DIRS; i++) { gchar *signal_name; signal_name = g_strdup_printf("notify::%s", directory_prefs[i].name); GMAMEUI_DEBUG("Connecting signal %s", signal_name); g_signal_connect (pr, signal_name, (GCallback) mame_gui_prefs_save_string, NULL); g_free (signal_name); } GMAMEUI_DEBUG ("Creating GUI prefs object... done"); }
void moloch_config_load() { gboolean status; GError *error = 0; GKeyFile *keyfile; int i; keyfile = molochKeyFile = g_key_file_new(); status = g_key_file_load_from_file(keyfile, config.configFile, G_KEY_FILE_NONE, &error); if (!status || error) { printf("Couldn't load config file (%s) %s\n", config.configFile, (error?error->message:"")); exit(1); } char **includes = moloch_config_str_list(keyfile, "includes", NULL); if (includes) { moloch_config_load_includes(includes); g_strfreev(includes); //LOG("KEYFILE:\n%s", g_key_file_to_data(molochKeyFile, NULL, NULL)); } char *rotateIndex = moloch_config_str(keyfile, "rotateIndex", "daily"); if (strcmp(rotateIndex, "hourly") == 0) config.rotate = MOLOCH_ROTATE_HOURLY; else if (strcmp(rotateIndex, "hourly6") == 0) config.rotate = MOLOCH_ROTATE_HOURLY6; else if (strcmp(rotateIndex, "daily") == 0) config.rotate = MOLOCH_ROTATE_DAILY; else if (strcmp(rotateIndex, "weekly") == 0) config.rotate = MOLOCH_ROTATE_WEEKLY; else if (strcmp(rotateIndex, "monthly") == 0) config.rotate = MOLOCH_ROTATE_MONTHLY; else { printf("Unknown rotateIndex '%s'\n", rotateIndex); exit(1); } g_free(rotateIndex); config.nodeClass = moloch_config_str(keyfile, "nodeClass", NULL); gchar **tags = moloch_config_str_list(keyfile, "dontSaveTags", NULL); if (tags) { for (i = 0; tags[i]; i++) { if (!(*tags[i])) continue; int num = 1; char *colon = strchr(tags[i], ':'); if (colon) { *colon = 0; num = atoi(colon+1); if (num < 1) num = 1; if (num > 0xffff) num = 0xffff; } moloch_string_add((MolochStringHash_t *)(char*)&config.dontSaveTags, tags[i], (gpointer)(long)num, TRUE); } g_strfreev(tags); } config.plugins = moloch_config_str_list(keyfile, "plugins", NULL); config.rootPlugins = moloch_config_str_list(keyfile, "rootPlugins", NULL); config.smtpIpHeaders = moloch_config_str_list(keyfile, "smtpIpHeaders", NULL); if (config.smtpIpHeaders) { for (i = 0; config.smtpIpHeaders[i]; i++) { int len = strlen(config.smtpIpHeaders[i]); char *lower = g_ascii_strdown(config.smtpIpHeaders[i], len); g_free(config.smtpIpHeaders[i]); config.smtpIpHeaders[i] = lower; if (lower[len-1] == ':') lower[len-1] = 0; } } config.prefix = moloch_config_str(keyfile, "prefix", ""); int len = strlen(config.prefix); if (len > 0 && config.prefix[len - 1] != '_') { char *tmp = malloc(len + 2); memcpy(tmp, config.prefix, len); tmp[len] = '_'; tmp[len+1] = 0; g_free(config.prefix); config.prefix = tmp; } config.elasticsearch = moloch_config_str(keyfile, "elasticsearch", "localhost:9200"); config.interface = moloch_config_str_list(keyfile, "interface", NULL); config.pcapDir = moloch_config_str_list(keyfile, "pcapDir", NULL); config.bpf = moloch_config_str(keyfile, "bpf", NULL); config.yara = moloch_config_str(keyfile, "yara", NULL); config.emailYara = moloch_config_str(keyfile, "emailYara", NULL); config.rirFile = moloch_config_str(keyfile, "rirFile", NULL); config.ouiFile = moloch_config_str(keyfile, "ouiFile", NULL); config.geoLite2ASN = moloch_config_str(keyfile, "geoLite2ASN", "/data/moloch/etc/GeoLite2-ASN.mmdb"); config.geoLite2Country = moloch_config_str(keyfile, "geoLite2Country", "/data/moloch/etc/GeoLite2-Country.mmdb"); config.dropUser = moloch_config_str(keyfile, "dropUser", NULL); config.dropGroup = moloch_config_str(keyfile, "dropGroup", NULL); config.pluginsDir = moloch_config_str_list(keyfile, "pluginsDir", NULL); config.parsersDir = moloch_config_str_list(keyfile, "parsersDir", " /data/moloch/parsers ; ./parsers "); char *offlineRegex = moloch_config_str(keyfile, "offlineFilenameRegex", "(?i)\\.(pcap|cap)$"); config.offlineRegex = g_regex_new(offlineRegex, 0, 0, &error); if (!config.offlineRegex || error) { printf("Couldn't parse offlineRegex (%s) %s\n", offlineRegex, (error?error->message:"")); exit(1); } g_free(offlineRegex); config.pcapDirTemplate = moloch_config_str(keyfile, "pcapDirTemplate", NULL); if (config.pcapDirTemplate && config.pcapDirTemplate[0] != '/') { printf("pcapDirTemplate MUST start with a / '%s'\n", config.pcapDirTemplate); exit(1); } config.pcapDirAlgorithm = moloch_config_str(keyfile, "pcapDirAlgorithm", "round-robin"); if (strcmp(config.pcapDirAlgorithm, "round-robin") != 0 && strcmp(config.pcapDirAlgorithm, "max-free-percent") != 0 && strcmp(config.pcapDirAlgorithm, "max-free-bytes") != 0) { printf("'%s' is not a valid value for pcapDirAlgorithm. Supported algorithms are round-robin, max-free-percent, and max-free-bytes.\n", config.pcapDirAlgorithm); exit(1); } config.maxFileSizeG = moloch_config_double(keyfile, "maxFileSizeG", 4, 0.01, 1024); config.maxFileSizeB = config.maxFileSizeG*1024LL*1024LL*1024LL; config.maxFileTimeM = moloch_config_int(keyfile, "maxFileTimeM", 0, 0, 0xffff); config.timeouts[SESSION_ICMP]= moloch_config_int(keyfile, "icmpTimeout", 10, 1, 0xffff); config.timeouts[SESSION_UDP] = moloch_config_int(keyfile, "udpTimeout", 60, 1, 0xffff); config.timeouts[SESSION_TCP] = moloch_config_int(keyfile, "tcpTimeout", 60*8, 10, 0xffff); config.timeouts[SESSION_SCTP]= moloch_config_int(keyfile, "sctpTimeout", 60, 10, 0xffff); config.timeouts[SESSION_ESP] = moloch_config_int(keyfile, "espTimeout", 60*10, 10, 0xffff); config.tcpSaveTimeout = moloch_config_int(keyfile, "tcpSaveTimeout", 60*8, 10, 60*120); int maxStreams = moloch_config_int(keyfile, "maxStreams", 1500000, 1, 16777215); config.maxPackets = moloch_config_int(keyfile, "maxPackets", 10000, 1, 0xffff); config.maxPacketsInQueue = moloch_config_int(keyfile, "maxPacketsInQueue", 200000, 10000, 5000000); config.dbBulkSize = moloch_config_int(keyfile, "dbBulkSize", 200000, MOLOCH_HTTP_BUFFER_SIZE*2, 1000000); config.dbFlushTimeout = moloch_config_int(keyfile, "dbFlushTimeout", 5, 1, 60*30); config.maxESConns = moloch_config_int(keyfile, "maxESConns", 20, 5, 1000); config.maxESRequests = moloch_config_int(keyfile, "maxESRequests", 500, 10, 5000); config.logEveryXPackets = moloch_config_int(keyfile, "logEveryXPackets", 50000, 1000, 0xffffffff); config.pcapBufferSize = moloch_config_int(keyfile, "pcapBufferSize", 300000000, 100000, 0xffffffff); config.pcapWriteSize = moloch_config_int(keyfile, "pcapWriteSize", 0x40000, 0x10000, 0x800000); config.maxFreeOutputBuffers = moloch_config_int(keyfile, "maxFreeOutputBuffers", 50, 0, 0xffff); config.fragsTimeout = moloch_config_int(keyfile, "fragsTimeout", 60*8, 60, 0xffff); config.maxFrags = moloch_config_int(keyfile, "maxFrags", 10000, 100, 0xffffff); config.snapLen = moloch_config_int(keyfile, "snapLen", 16384, 1, MOLOCH_PACKET_MAX_LEN); config.maxMemPercentage = moloch_config_int(keyfile, "maxMemPercentage", 100, 5, 100); config.maxReqBody = moloch_config_int(keyfile, "maxReqBody", 256, 0, 0x7fff); config.packetThreads = moloch_config_int(keyfile, "packetThreads", 1, 1, MOLOCH_MAX_PACKET_THREADS); config.logUnknownProtocols = moloch_config_boolean(keyfile, "logUnknownProtocols", config.debug); config.logESRequests = moloch_config_boolean(keyfile, "logESRequests", config.debug); config.logFileCreation = moloch_config_boolean(keyfile, "logFileCreation", config.debug); config.logHTTPConnections = moloch_config_boolean(keyfile, "logHTTPConnections", TRUE); config.parseSMTP = moloch_config_boolean(keyfile, "parseSMTP", TRUE); config.parseSMB = moloch_config_boolean(keyfile, "parseSMB", TRUE); config.parseQSValue = moloch_config_boolean(keyfile, "parseQSValue", FALSE); config.parseCookieValue = moloch_config_boolean(keyfile, "parseCookieValue", FALSE); config.supportSha256 = moloch_config_boolean(keyfile, "supportSha256", FALSE); config.reqBodyOnlyUtf8 = moloch_config_boolean(keyfile, "reqBodyOnlyUtf8", TRUE); config.compressES = moloch_config_boolean(keyfile, "compressES", FALSE); config.antiSynDrop = moloch_config_boolean(keyfile, "antiSynDrop", TRUE); config.readTruncatedPackets = moloch_config_boolean(keyfile, "readTruncatedPackets", FALSE); config.trackESP = moloch_config_boolean(keyfile, "trackESP", FALSE); config.maxStreams[SESSION_TCP] = maxStreams/config.packetThreads*1.25; config.maxStreams[SESSION_UDP] = maxStreams/config.packetThreads/20; config.maxStreams[SESSION_SCTP] = maxStreams/config.packetThreads/20; config.maxStreams[SESSION_ICMP] = maxStreams/config.packetThreads/200; config.maxStreams[SESSION_ESP] = maxStreams/config.packetThreads/200; gchar **saveUnknownPackets = moloch_config_str_list(keyfile, "saveUnknownPackets", NULL); if (saveUnknownPackets) { for (i = 0; saveUnknownPackets[i]; i++) { char *s = saveUnknownPackets[i]; if (strcmp(s, "all") == 0) { memset(&config.etherSavePcap, 0xff, 1024); memset(&config.ipSavePcap, 0xff, 4); } else if (strcmp(s, "ip:all") == 0) { memset(&config.ipSavePcap, 0xff, 4); } else if (strcmp(s, "ether:all") == 0) { memset(&config.etherSavePcap, 0xff, 1024); } else if (strncmp(s, "ip:", 3) == 0) { int n = atoi(s+3); if (n < 0 || n > 0xff) LOGEXIT("Bad value: %s", s); BIT_SET(n, config.ipSavePcap); } else if (strncmp(s, "-ip:", 4) == 0) { int n = atoi(s+4); if (n < 0 || n > 0xff) LOGEXIT("Bad value: %s", s); BIT_CLR(n, config.ipSavePcap); } else if (strncmp(s, "ether:", 6) == 0) { int n = atoi(s+6); if (n < 0 || n > 0xffff) LOGEXIT("Bad value: %s", s); BIT_SET(n, config.etherSavePcap); } else if (strncmp(s, "-ether:", 7) == 0) { int n = atoi(s+7); if (n < 0 || n > 0xffff) LOGEXIT("Bad value: %s", s); BIT_CLR(n, config.etherSavePcap); } else { LOGEXIT("Not sure what %s is", s); } } } }
void LayoutSettings::load(const char* settingsFile) { GKeyFile* keyfile; GKeyFileFlags flags; GError* error = 0; keyfile = g_key_file_new(); if(!keyfile) return; flags = GKeyFileFlags( G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS); if( !g_key_file_load_from_file( keyfile, settingsFile, flags, &error ) ) { g_key_file_free( keyfile ); if (error) g_error_free(error); return ; } KEYS_SIZEF("Main", "launcherWidthPctScreenRelative","launcherHeighPctScreenRelative",launcherSizePctScreenRelative); KEY_INTEGER("Main","centerUiVerticalOffset",centerUiVerticalOffset); KEY_INTEGER("Main","searchPillWidth",searchPillWidth); KEY_INTEGER("Main","searchPillInnerIconRightOffset",searchPillInnerIconRightOffset); KEY_INTEGER("Main","searchPillTopOffsetFromStatusBar",searchPillTopOffsetFromStatusBar); KEYS_POINT("Main","searchPillInnerTextHorizAdjust","searchPillInnerTextVertAdjust",searchPillInnerTextAdjust); KEY_BOOLEAN("Main","openglHatesOddNumbers",openglHatesOddNumbers); KEY_BOOLEAN("Tabs","tabBarUseAbsoluteSize",tabBarUseAbsoluteSize); KEYS_SIZEF("Tabs", "tabBarWidthPctLauncherRelative","tabBarHeightPctLauncherRelative",tabBarSizePctLauncherRelative); KEY_INTEGER("Tabs","tabBarHeightAbsolute",tabBarHeightAbsolute); KEY_INTEGER("Tabs","tabBarTabFontSizePx",tabBarTabFontSizePx); KEY_BOOLEAN("Tabs","tabBarTabFontEmbolden",tabBarTabFontEmbolden); KEY_COLOR("Tabs","tabBarSelectedTabFontColor",tabBarSelectedTabFontColor); KEY_COLOR("Tabs","tabBarUnSelectedTabFontColor",tabBarUnSelectedTabFontColor); KEY_INTEGER("Tabs","tabTextVerticalPosAdjust",tabTextVerticalPosAdjust); KEY_INTEGER("DoneButton","doneButtonFontSizePx",doneButtonFontSizePx); KEY_BOOLEAN("DoneButton","doneButtonFontEmbolden",doneButtonFontEmbolden); KEY_COLOR("DoneButton","doneButtonFontColor",doneButtonFontColor); KEY_INTEGER("DoneButton","doneButtonTextVerticalPosAdjust",doneButtonTextVerticalPosAdjust); KEYS_POINT("DoneButton", "doneButtonHorizontalPositionAdjustPx", "doneButtonVerticalPositionAdjustPx", doneButtonPositionAdjust); KEYS_SIZEF("Pages","pageWidthPctLauncherRelative","pageHeightPctLauncherRelative",pageSizePctLauncherRelative); KEY_BOOLEAN("Pages","autoPageSize",autoPageSize); KEYS_SIZE("Pages","pageLeftBorderActivationSizePx","pageRightBorderActivationSizePx",pageHorizontalBorderActivationAreaSizePx); KEYS_SIZE("Pages","pageTopActivationSizePx","pageBottomActivationSizePx",pageVerticalBorderActivationAreaSizePx); KEY_INTEGER("Pages","pageTopBorderActivationTimeoutMs",pageTopBorderActivationTimeoutMs); KEY_INTEGER("Pages","pageBottomBorderActivationTimeoutMs",pageBottomBorderActivationTimeoutMs); KEY_INTEGER("Pages","pageLeftBorderActivationTimeoutMs",pageLeftBorderActivationTimeoutMs); KEY_INTEGER("Pages","pageRightBorderActivationTimeoutMs",pageRightBorderActivationTimeoutMs); KEY_BOOLEAN("QuickLaunch","quickLaunchBarUseAbsoluteSize",quickLaunchBarUseAbsoluteSize); KEYS_SIZEF("QuickLaunch","quickLaunchBarWidthPctScreenRelative","quickLaunchBarHeightPctScreenRelative",quickLaunchBarSizePctScreenRelative); KEY_INTEGER("QuickLaunch","quickLaunchBarHeightAbsolute",quickLaunchBarHeightAbsolute); KEYS_POINT("QuickLaunch","quickLaunchBarLauncherAccessButtonHorizontalOffsetPx", "quickLaunchBarLauncherAccessButtonVerticalOffsetPx", quickLaunchBarLauncherAccessButtonOffsetPx); KEYS_POINT("QuickLaunch","quickLaunchItemAreaHorizontalOffsetPx", "quickLaunchItemAreaVerticalOffsetPx", quickLaunchItemAreaOffsetPx); KEY_INTEGER("QuickLaunch","quickLaunchMaxItems",quickLaunchMaxItems); KEYS_POINT("Icons","iconVisibleLocationHorizontalOffsetPx","iconVisibleLocationVerticalOffsetPx",iconVisibleLocationOffsetPx); g_key_file_free( keyfile ); }
static NMConnection * import (NMVpnPluginUiInterface *iface, const char *path, GError **error) { NMConnection *connection; NMSettingConnection *s_con; NMSettingVPN *s_vpn; NMSettingIP4Config *s_ip4; GKeyFile *keyfile; GKeyFileFlags flags; const char *buf; gboolean bval; keyfile = g_key_file_new (); flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS; if (!g_key_file_load_from_file (keyfile, path, flags, NULL)) { g_set_error (error, NM_OPENCONNECT_IMPORT_EXPORT_ERROR, NM_OPENCONNECT_IMPORT_EXPORT_ERROR_NOT_OPENCONNECT, "does not look like a %s VPN connection (parse failed)", OPENCONNECT_PLUGIN_NAME); return NULL; } connection = nm_connection_new (); s_con = NM_SETTING_CONNECTION (nm_setting_connection_new ()); nm_connection_add_setting (connection, NM_SETTING (s_con)); s_vpn = NM_SETTING_VPN (nm_setting_vpn_new ()); g_object_set (s_vpn, NM_SETTING_VPN_SERVICE_TYPE, NM_DBUS_SERVICE_OPENCONNECT, NULL); nm_connection_add_setting (connection, NM_SETTING (s_vpn)); s_ip4 = NM_SETTING_IP4_CONFIG (nm_setting_ip4_config_new ()); nm_connection_add_setting (connection, NM_SETTING (s_ip4)); /* Host */ buf = g_key_file_get_string (keyfile, "openconnect", "Host", NULL); if (buf) { nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_GATEWAY, buf); } else { g_set_error (error, NM_OPENCONNECT_IMPORT_EXPORT_ERROR, NM_OPENCONNECT_IMPORT_EXPORT_ERROR_BAD_DATA, "does not look like a %s VPN connection (no Host)", OPENCONNECT_PLUGIN_NAME); g_object_unref (connection); return NULL; } /* Optional Settings */ /* Description */ buf = g_key_file_get_string (keyfile, "openconnect", "Description", NULL); if (buf) g_object_set (s_con, NM_SETTING_CONNECTION_ID, buf, NULL); /* CA Certificate */ buf = g_key_file_get_string (keyfile, "openconnect", "CACert", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_CACERT, buf); /* Proxy */ buf = g_key_file_get_string (keyfile, "openconnect", "Proxy", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_PROXY, buf); /* Cisco Secure Desktop */ bval = g_key_file_get_boolean (keyfile, "openconnect", "CSDEnable", NULL); if (bval) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_CSD_ENABLE, "yes"); /* Cisco Secure Desktop wrapper */ buf = g_key_file_get_string (keyfile, "openconnect", "CSDWrapper", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_CSD_WRAPPER, buf); /* User Certificate */ buf = g_key_file_get_string (keyfile, "openconnect", "UserCertificate", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_USERCERT, buf); /* Private Key */ buf = g_key_file_get_string (keyfile, "openconnect", "PrivateKey", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_PRIVKEY, buf); /* FSID */ bval = g_key_file_get_boolean (keyfile, "openconnect", "FSID", NULL); if (bval) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_PEM_PASSPHRASE_FSID, "yes"); /* Soft token mode */ buf = g_key_file_get_string (keyfile, "openconnect", "StokenSource", NULL); if (buf) nm_setting_vpn_add_data_item (s_vpn, NM_OPENCONNECT_KEY_TOKEN_MODE, buf); /* Soft token secret */ buf = g_key_file_get_string (keyfile, "openconnect", "StokenString", NULL); if (buf) nm_setting_vpn_add_secret (s_vpn, NM_OPENCONNECT_KEY_TOKEN_SECRET, buf); return connection; }
int main(int argc, char *argv[]) { struct passwd *pwent; gchar *username = NULL; gchar *jobid = NULL; gchar *format = NULL; gchar *state = NULL; GOptionEntry entries[] = { { "username", 'u', 0, G_OPTION_ARG_STRING, &username, "MyEMSL Username", "U" }, { "jobid", 'j', 0, G_OPTION_ARG_STRING, &jobid, "Job ID to query", "J" }, { "format", 'f', 0, G_OPTION_ARG_STRING, &format, "Format Output", NULL }, { NULL } }; GError *error = NULL; GOptionContext *context; struct stat statbuf; int res; char *newargv[16]; uid_t realuid = getuid(); gchar *unixuser; GKeyFile *keyfile = g_key_file_new(); g_key_file_load_from_file(keyfile, "/etc/myemsl/general.ini", G_KEY_FILE_NONE, NULL); unixuser = g_key_file_get_string(keyfile, "unix", "user", NULL); if(!unixuser) { fprintf(stderr, "Failed to get myemsl user\n"); exit(-1); } context = g_option_context_new("- MyEMSL Status"); g_option_context_add_main_entries(context, entries, NULL); if(!g_option_context_parse(context, &argc, &argv, &error)) { fprintf(stderr, "option parsing failed: %s\n", error->message); exit(-1); } pwent = getpwuid(realuid); if(!pwent) { fprintf(stderr, "Failed to get your passwd entry.\n"); exit(-1); } if(username) { if(strcmp(pwent->pw_name, "apache")) { fprintf(stderr, "Only the apache user can specify user.\n"); exit(-1); } } else { username = g_strdup(pwent->pw_name); if(!username) { fprintf(stderr, "Could not get calling user's name.\n"); exit(-1); } } if(!jobid) { fprintf(stderr, "You must specify a jobid with the --jobid option.\n"); exit(-1); } pwent = getpwnam(unixuser); if(!pwent) { fprintf(stderr, "Failed to get uid for the myemsl user.\n"); exit(-1); } res = setregid(pwent->pw_gid, pwent->pw_gid); if(res) { fprintf(stderr, "Failed to switch gid.\n"); exit(-1); } res = setreuid(pwent->pw_uid, pwent->pw_uid); if(res) { fprintf(stderr, "Failed to switch uid.\n"); exit(-1); } newargv[0] = "/usr/libexec/myemsl/ingest/status_vni"; newargv[1] = "--username"; newargv[2] = username; newargv[3] = "--jobid"; newargv[4] = jobid; newargv[5] = newargv[6] = newargv[7] = newargv[8] = NULL; if(format) { newargv[5] = "--format"; newargv[6] = format; } newargv[9] = NULL; res = execvp(newargv[0], newargv); if(res) { fprintf(stderr, "Failed to exec %s. Error: %d.\n", newargv[0], res); exit(-1); } return 0; }
void Settings::load(const char* settingsFile) { GKeyFile* keyfile; GKeyFileFlags flags; GError* error = 0; keyfile = g_key_file_new(); if(!keyfile) return; flags = GKeyFileFlags( G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS); if( !g_key_file_load_from_file( keyfile, settingsFile, flags, &error ) ) { g_key_file_free( keyfile ); if (error) g_error_free(error); return ; } // Fill in with the macros above. KEY_STRING("General","ApplicationPath", lunaAppsPath ); // apps path can now be multiple paths, separated by : (setenv PATH style) KEY_STRING("General","AppInstallBase", appInstallBase); // due to all the churn surrounding moving of apps around, this is now a conf option KEY_STRING("General","AppInstallRelative", appInstallRelative); // due to all the churn surrounding moving of apps around, this is now a conf option // KEY_STRING("General","PackageInstallBase", packageInstallBase); KEY_STRING("General","PackageInstallRelative", packageInstallRelative); KEY_STRING("General","PackageManifestsPath", packageManifestsPath); KEY_STRING("General","DownloadPathMedia",downloadPathMedia); //validate path, reset to default if necessary if (!validateDownloadPath(downloadPathMedia)) { downloadPathMedia = "/media/internal/downloads"; } KEY_STRING("General","AppInstallTemp",appInstallerTmp); KEY_STRING("General","SystemPath", lunaSystemPath ); KEY_STRING("General","AppLauncherPath", lunaAppLauncherPath ); KEY_STRING("General","SystemResourcesPath", lunaSystemResourcesPath ); KEY_STRING("General","SystemLocalePath", lunaSystemLocalePath ); KEY_STRING("General","PresetLaunchPointsPath",lunaPresetLaunchPointsPath); KEY_STRING("General","LaunchPointsPath", lunaLaunchPointsPath); KEY_STRING("General", "PreferencesPath", lunaPrefsPath); KEY_STRING("General","UiComponentsPath", lunaQmlUiComponentsPath ); KEY_STRING("General","ScreenCapturesPath", lunaScreenCapturesPath ); KEY_BOOLEAN("General", "ShowReticle", showReticle); KEY_INTEGER("General", "NotificationSoundDuration", notificationSoundDuration); KEY_BOOLEAN("General", "ShowNotificationsAtTop", showNotificationsAtTop); KEY_INTEGER( "CoreNavi", "ThrobberBrightnessInLight", ledPulseMaxBrightness); KEY_INTEGER( "CoreNavi", "ThrobberBrightnessInDark", ledPulseDarkBrightness); KEY_BOOLEAN( "CoreNavi", "EnableLightBar", lightbarEnabled); KEY_INTEGER( "CoreNavi", "CoreNaviBrightnessScaler", coreNaviScaler); KEY_INTEGER( "CoreNavi", "GestureAnimationSpeedInMs", gestureAnimationSpeed); KEY_INTEGER( "CoreNavi", "HomeDoubleClickDuration", homeDoubleClickDuration); KEY_INTEGER( "Display", "BrightnessOutdoorScale", backlightOutdoorScale); KEY_INTEGER( "Display", "BrightnessDimScale", backlightDimScale); KEY_INTEGER( "Display", "BrightnessDarkScale", backlightDarkScale); KEY_BOOLEAN( "Display", "EnableALS", enableAls); KEY_BOOLEAN( "Display", "TurnOffAccelerometerWhenDimmed", turnOffAccelWhenDimmed); KEY_BOOLEAN( "Display", "DisableLocking", disableLocking); KEY_INTEGER( "Display", "LockScreenTimeoutMs", lockScreenTimeout); KEY_INTEGER( "Memory", "CardLimit", cardLimit ); KEY_INTEGER( "General","DisplayWidth",displayWidth); KEY_INTEGER( "General","DisplayHeight",displayHeight); KEY_INTEGER( "General","GestureAreaHeight",gestureAreaHeight); KEY_INTEGER( "General","DisplayNumBuffers", displayNumBuffers); KEY_INTEGER("General", "MaxPenMoveFreq", maxPenMoveFreq); KEY_INTEGER("General", "MaxPaintLoad", maxPaintLoad); KEY_INTEGER("General", "MaxGestureChangeFreq", maxGestureChangeFreq); KEY_INTEGER("General", "MaxTouchChangeFreq", maxTouchChangeFreq); KEY_BOOLEAN( "Debug", "WatchPenEvents", debug_trackInputEvents ); KEY_BOOLEAN( "Debug", "EnableDebugModeByDefault", debug_enabled ); KEY_BOOLEAN( "Debug", "PiranhaDrawColoredOutlines", debug_piranhaDrawColoredOutlines); KEY_BOOLEAN( "Debug", "PiranhaDisplayFps", debug_piranhaDisplayFps); KEY_BOOLEAN( "Debug", "ShowGestures", debug_showGestures); KEY_BOOLEAN( "Debug", "DoVerboseCrashLogging", debug_doVerboseCrashLogging); KEY_BOOLEAN( "Debug", "LoopInCrashHandler", debug_loopInCrashHandler); KEY_INTEGER( "Debug", "AppInstallerCleaner",debug_appInstallerCleaner ); KEY_STRING( "General", "CmdResourceHandlers", lunaCmdHandlerPath ); KEY_STRING( "General", "CmdResourceHandlersActiveCopy", lunaCmdHandlerSavedPath); KEY_STRING( "Fonts", "Banner", fontBanner ); KEY_STRING( "Fonts", "ActiveBanner", fontActiveBanner ); KEY_STRING( "Fonts", "LockWindow", fontLockWindow ); KEY_STRING( "Fonts", "DockMode", fontDockMode ); KEY_STRING( "Fonts", "Quicklaunch", fontQuicklaunch ); KEY_STRING( "Fonts", "StatusBar", fontStatusBar ); KEY_STRING( "Fonts", "KeyboardKeys", fontKeyboardKeys ); KEY_STRING( "Fonts", "StatusBar", fontStatusBar ); KEY_INTEGER("TouchEvents", "TapRadiusMax", tapRadius); KEY_INTEGER("TouchEvents", "TapRadiusMin", tapRadiusMin); KEY_INTEGER("TouchEvents", "TapRadiusShrinkPerc", tapRadiusShrinkPercent); KEY_INTEGER("TouchEvents", "TapRadiusShrinkGranMs", tapRadiusShrinkGranMs); KEY_BOOLEAN("TouchEvents", "EnableForWebApps", enableTouchEventsForWebApps); tapRadiusSquared = tapRadius * tapRadius; KEY_INTEGER("TouchEvents", "DoubleClickDuration", tapDoubleClickDuration); // Clamp to sensible values if (tapDoubleClickDuration < 50) tapDoubleClickDuration = 50; else if (tapDoubleClickDuration > 2000) tapDoubleClickDuration = 2000; KEY_INTEGER("VTrackBall", "PixelsPerMoveH", h_trackball_pixels_per_move ); KEY_INTEGER("VTrackBall", "PixelsPerMoveV", v_trackball_pixels_per_move ); KEY_INTEGER("VTrackBall", "AccelRateH1", h_accel_rate1 ); KEY_INTEGER("VTrackBall", "AccelRateV1", v_accel_rate1 ); KEY_INTEGER("VTrackBall", "AccelConstH1", h_accel_const1 ); KEY_INTEGER("VTrackBall", "AccelConstV1", v_accel_const1 ); KEY_INTEGER("VTrackBall", "AccelRateH2", h_accel_rate2 ); KEY_INTEGER("VTrackBall", "AccelRateV2", v_accel_rate2 ); KEY_INTEGER("VTrackBall", "AccelConstH2", h_accel_const2 ); KEY_INTEGER("VTrackBall", "AccelConstV2", v_accel_const2 ); KEY_STRING("General", "QuickLaunchDefaultPositions", quicklaunchDefaultPositions ); #if defined(TARGET_DESKTOP) //If we don't have a home directory, we'll set it to /tmp. Otherwise, this does nothing. setenv("HOME", "/tmp", 0); const std::string homeFolder = getenv("HOME"); quicklaunchUserPositions = homeFolder + "/.user-dock-positions.json"; #endif KEY_STRING("General", "QuickLaunchUserPositions", quicklaunchUserPositions ); KEY_INTEGER( "General", "StatusBarTitleMaxWidth", statusBarTitleMaxWidth); KEY_BOOLEAN( "DockMode", "DockModePrelaunchAllApps", dockModePrelaunchAllApps); KEY_BOOLEAN( "DockMode", "DockModeCloseAppOnMinimize", dockModeCloseOnMinimize); KEY_BOOLEAN( "DockMode", "DockModeCloseAppsOnExit", dockModeCloseOnExit); KEY_INTEGER( "DockMode", "DockModeMaxApps", dockModeMaxApps); KEY_INTEGER( "DockMode", "DockModeNightBrightness", dockModeNightBrightness); KEY_INTEGER( "DockMode", "DockModeMenuHeight", dockModeMenuHeight); KEY_STRING("DockMode", "DockModeDefaultPositions", quicklaunchDefaultPositions ); #if defined(TARGET_DESKTOP) dockModeUserPositions = homeFolder + "/.user-dock-mode-launcher-positions.json"; #endif KEY_STRING("DockMode", "DockModeUserPositions", quicklaunchUserPositions ); KEY_BOOLEAN( "VirtualKeyboard", "VirtualKeyboardEnabled", virtualKeyboardEnabled); KEY_BOOLEAN( "VirtualCoreNavi", "VirtualCoreNaviEnabled", virtualCoreNaviEnabled); KEY_INTEGER( "VirtualCoreNavi", "VirtualCoreNaviHeight", virtualCoreNaviHeight); KEY_DOUBLE("Launcher", "CardSideScrollSwipeThreshold", launcherSideSwipeThreshold); KEY_BOOLEAN("Launcher", "UseOGLHardwareAntialias", launcherUsesHwAA); KEY_INTEGER("Launcher", "LauncherItemRowSpacingAdjust",launcherRowSpacingAdjust); KEY_INTEGER("Launcher", "LauncherLabelWidthAdjust",launcherLabelWidthAdjust); KEY_INTEGER("Launcher", "LauncherLabelXPadding",launcherLabelXPadding); KEY_DOUBLE("Launcher","LauncherIconReorderPositionThreshold",launcherIconReorderPositionThreshold); KEY_BOOLEAN("UI", "DisplayUiRotates", displayUiRotates); KEY_BOOLEAN("UI", "TabletUi", tabletUi); KEY_INTEGER("UI", "HomeButtonOrientationAngle", homeButtonOrientationAngle); KEY_INTEGER("UI", "PositiveSpaceTopPadding", positiveSpaceTopPadding); KEY_INTEGER("UI", "PositiveSpaceBottomPadding", positiveSpaceBottomPadding); KEY_DOUBLE("UI", "MaximumNegativeSpaceHeightRatio", maximumNegativeSpaceHeightRatio); KEY_DOUBLE("UI", "ActiveCardWindowRatio", activeCardWindowRatio); KEY_DOUBLE("UI", "NonActiveCardWindowRatio", nonActiveCardWindowRatio); KEY_DOUBLE("UI", "GhostCardFinalRatio", ghostCardFinalRatio); KEY_INTEGER("UI", "CardGroupRotFactor", cardGroupRotFactor); KEY_INTEGER("UI", "GapBetweenCardGroups", gapBetweenCardGroups); KEY_INTEGER("UI", "OverlayNotificationsHeight", overlayNotificationsHeight); KEY_INTEGER("UI", "SplashIconSize", splashIconSize); KEY_BOOLEAN("UI", "EnableSplashBackgrounds", enableSplashBackgrounds); KEY_BOOLEAN("UI", "AtlasEnabled", atlasEnabled); KEY_INTEGER("UI", "ModalWindowWidth", modalWindowWidth); KEY_INTEGER("UI", "ModalWindowHeight", modalWindowHeight); KEY_DOUBLE("UI", "CardGroupingXDistanceFactor", cardGroupingXDistanceFactor); KEY_DOUBLE("UI", "CardDimmPercentage", cardDimmPercentage); KEY_INTEGER("UI", "AtlasMemThreshold", atlasMemThreshold); KEY_BOOLEAN("Debug", "LauncherAtlasStatistics", launcherAtlasStatistics); KEY_BOOLEAN("Debug", "DumpLauncherAtlas", launcherDumpAtlas); if (forceSoftwareRendering) { atlasEnabled = false; launcherAtlasStatistics = false; } else if (atlasEnabled && atlasMemThreshold > 0 && MeasureTotalRAM() < atlasMemThreshold * 1024) { g_message("Atlas disabled because physical memory below %dMB threshold\n", atlasMemThreshold); atlasEnabled = false; } KEY_INTEGER("DownloadManager", "MaxQueueLength", maxDownloadManagerQueueLength); KEY_INTEGER("DownloadManager", "MaxConcurrent", maxDownloadManagerConcurrent); KEY_INTEGER("DownloadManager", "MaxRecvSpeed", maxDownloadManagerRecvSpeed); KEY_BOOLEAN( "Demo", "DemoMode", demoMode ); KEY_BOOLEAN( "Debug", "ShowAppStats", showAppStats ); KEY_BOOLEAN( "General", "CollectUseStats", collectUseStats ); KEY_BOOLEAN( "General" , "UsePartialKeywordMatchForAppSearch",usePartialKeywordAppSearch); KEY_BOOLEAN( "General" , "ScanCalculatesAppSizes",scanCalculatesAppSizes); KEY_INTEGER("KeepAlive", "MaxParked", maxNumParkedApps ); KEY_INTEGER("CpuShare", "UiMainLow", uiMainCpuShareLow); KEY_INTEGER("CpuShare", "UiOtherLow", uiOtherCpuShareLow); KEY_INTEGER("CpuShare", "JavaLow", javaCpuShareLow); KEY_INTEGER("CpuShare", "WebLow", webCpuShareLow); KEY_INTEGER("CpuShare", "GameLow", gameCpuShareLow); KEY_INTEGER("CpuShare", "Default", cpuShareDefault); KEY_BOOLEAN("AllowTurboMode", "General", allowTurboMode); KEY_STRING( "General", "WifiInterfaceName", wifiInterfaceName ); KEY_STRING( "General", "WanInterfaceName", wanInterfaceName ); KEY_BOOLEAN( "Memory", "CanRestartHeadlessApps", canRestartHeadlessApps ); KEY_BOOLEAN( "Debug", "PerformanceLogs", perfTesting); KEY_STRING( "General", "LogFileName", logFileName); KEY_INTEGER("General", "schemaValidationOption", schemaValidationOption); // apps to launch at boot time gchar** appsToLaunchAtBootStr = g_key_file_get_string_list(keyfile, "LaunchAtBoot", "Applications", NULL, NULL); if (appsToLaunchAtBootStr) { int index = 0; appsToLaunchAtBoot.clear(); while (appsToLaunchAtBootStr[index]) { appsToLaunchAtBoot.insert(appsToLaunchAtBootStr[index]); SETTINGS_TRACE("App to launch at boot time: %s\n", appsToLaunchAtBootStr[index]); ++index; } g_strfreev(appsToLaunchAtBootStr); } // apps to keep alive gchar** appsToKeepAliveStr = g_key_file_get_string_list(keyfile, "KeepAlive", "Applications", NULL, NULL); if (appsToKeepAliveStr) { int index = 0; appsToKeepAlive.clear(); while (appsToKeepAliveStr[index]) { appsToKeepAlive.insert(appsToKeepAliveStr[index]); SETTINGS_TRACE("App to keep alive: %s\n", appsToKeepAliveStr[index]); ++index; } g_strfreev(appsToKeepAliveStr); } // apps to keep alive forever (pinned) gchar** appsToKeepAliveForeverStr = g_key_file_get_string_list(keyfile, "KeepAliveUntilMemPressure", "Applications", NULL, NULL); if (appsToKeepAliveForeverStr) { int index = 0; appsToKeepAliveUntilMemPressure.clear(); while (appsToKeepAliveForeverStr[index]) { appsToKeepAliveUntilMemPressure.insert(appsToKeepAliveForeverStr[index]); SETTINGS_TRACE("App to keep alive until memory pressure: %s\n", appsToKeepAliveForeverStr[index]); ++index; } g_strfreev(appsToKeepAliveForeverStr); } // apps to allow under low memory conditions gchar** appsToAllowInLowMemoryStr = g_key_file_get_string_list(keyfile, "Memory", "AppsToAllowInLowMemory", NULL, NULL); if (appsToAllowInLowMemoryStr) { int index = 0; appsToAllowInLowMemory.clear(); while (appsToAllowInLowMemoryStr[index]) { appsToAllowInLowMemory.insert(appsToAllowInLowMemoryStr[index]); g_message("App to allow in Low memory: %s", appsToAllowInLowMemoryStr[index]); ++index; } g_strfreev(appsToAllowInLowMemoryStr); } // apps with accelerated compositing disabled gchar** appsToDisableAccelCompositingStr = g_key_file_get_string_list(keyfile, "AccelCompositingDisabled", "Applications", NULL, NULL); if (appsToDisableAccelCompositingStr) { int index = 0; appsToDisableAccelCompositing.clear(); while (appsToDisableAccelCompositingStr[index]) { appsToDisableAccelCompositing.insert(appsToDisableAccelCompositingStr[index]); SETTINGS_TRACE("App with accelerated compositing disabled: %s\n", appsToDisableAccelCompositingStr[index]); ++index; } g_strfreev(appsToDisableAccelCompositingStr); } // SUC apps that have special launch privs gchar** sucAppsList = g_key_file_get_string_list(keyfile, "SUCApps", "Applications", NULL, NULL); if (sucAppsList) { int index = 0; sucApps.clear(); while (sucAppsList[index]) { sucApps.insert(sucAppsList[index]); SETTINGS_TRACE("SUC App with special launch priviledge: %s\n", sucAppsList[index]); ++index; } g_strfreev(sucAppsList); } // ... g_key_file_free( keyfile ); // sanity check on the homeButtonOrientationAngle value: if(homeButtonOrientationAngle >= 360) homeButtonOrientationAngle = homeButtonOrientationAngle%360; if(homeButtonOrientationAngle < -90) homeButtonOrientationAngle += 360; if((homeButtonOrientationAngle != 0) && (homeButtonOrientationAngle != 90) && (homeButtonOrientationAngle != 180) && (homeButtonOrientationAngle != 270) && (homeButtonOrientationAngle != -90)) homeButtonOrientationAngle = 0; }
SeafileSession * seafile_session_new(const char *seafile_dir, CcnetClient *ccnet_session) { char *abs_seafile_dir; char *tmp_file_dir; char *config_file_path; struct stat st; GKeyFile *config; SeafileSession *session = NULL; if (!ccnet_session) return NULL; abs_seafile_dir = ccnet_expand_path (seafile_dir); tmp_file_dir = g_build_filename(abs_seafile_dir, "tmpfiles", NULL); config_file_path = g_build_filename (abs_seafile_dir, "seafile.conf", NULL); if (g_stat(abs_seafile_dir, &st) < 0 || !S_ISDIR(st.st_mode)) { g_warning ("Seafile data dir %s does not exist and is unable to create\n", abs_seafile_dir); goto onerror; } if (g_stat(tmp_file_dir, &st) < 0 || !S_ISDIR(st.st_mode)) { g_warning("Seafile tmp dir %s does not exist and is unable to create\n", tmp_file_dir); goto onerror; } GError *error = NULL; config = g_key_file_new (); if (!g_key_file_load_from_file (config, config_file_path, G_KEY_FILE_NONE, &error)) { g_warning ("Failed to load config file.\n"); g_key_file_free (config); goto onerror; } session = g_new0(SeafileSession, 1); session->seaf_dir = abs_seafile_dir; session->tmp_file_dir = tmp_file_dir; session->session = ccnet_session; session->config = config; if (load_database_config (session) < 0) { g_warning ("Failed to load database config.\n"); goto onerror; } session->fs_mgr = seaf_fs_manager_new (session, abs_seafile_dir); if (!session->fs_mgr) goto onerror; session->block_mgr = seaf_block_manager_new (session, abs_seafile_dir); if (!session->block_mgr) goto onerror; session->commit_mgr = seaf_commit_manager_new (session); if (!session->commit_mgr) goto onerror; session->repo_mgr = seaf_repo_manager_new (session); if (!session->repo_mgr) goto onerror; session->branch_mgr = seaf_branch_manager_new (session); if (!session->branch_mgr) goto onerror; return session; onerror: free (abs_seafile_dir); g_free (config_file_path); g_free (session); return NULL; }
static void translate_keyfile_to_json( const char * old_file, const char * new_file ) { tr_benc dict; GKeyFile * keyfile; gchar ** keys; gsize i; gsize length; static struct pref_entry { const char* oldkey; const char* newkey; } renamed[] = { { "default-download-directory", "download-dir" }, { "encrypted-connections-only", "encryption" }, { "listening-port", "peer-port" }, { "nat-traversal-enabled", "port-forwarding-enabled" }, { "open-dialog-folder", "open-dialog-dir" }, { "watch-folder", "watch-dir" }, { "watch-folder-enabled", "watch-dir-enabled" } }; keyfile = g_key_file_new( ); g_key_file_load_from_file( keyfile, old_file, 0, NULL ); length = 0; keys = g_key_file_get_keys( keyfile, "general", &length, NULL ); tr_bencInitDict( &dict, length ); for( i = 0; i < length; ++i ) { guint j; const char * key = keys[i]; gchar * val = g_key_file_get_value( keyfile, "general", key, NULL ); for( j = 0; j < G_N_ELEMENTS( renamed ); ++j ) if( !strcmp( renamed[j].oldkey, key ) ) key = renamed[j].newkey; if( !strcmp( val, "true" ) || !strcmp( val, "false" ) ) tr_bencDictAddInt( &dict, key, !strcmp( val, "true" ) ); else { char * end; long l; errno = 0; l = strtol( val, &end, 10 ); if( !errno && end && !*end ) tr_bencDictAddInt( &dict, key, l ); else tr_bencDictAddStr( &dict, key, val ); } g_free( val ); } g_key_file_free( keyfile ); tr_bencToFile( &dict, TR_FMT_JSON, new_file ); tr_bencFree( &dict ); }
void imgur_recording_store(GHashTable *fields, gchar *filename) { gchar *group = get_field (fields, "image_hash"); GKeyFile *keyfile; gchar *path; gchar *inifile; gchar *temp; gchar *thumbnail = NULL; GList *keys, *cursor; if (!group) { g_warning ("Received fields table with no image_hash"); return; } keyfile = g_key_file_new (); path = g_build_filename (g_get_user_data_dir (), "imgur", NULL); inifile = g_build_filename (path, "uploads.conf", NULL); g_key_file_load_from_file (keyfile, inifile, G_KEY_FILE_NONE, NULL); #ifndef MAEMO /* * Store the filename of the image we're uploading. * No point doing this on Maemo: the image we're * passed (from the libsharing client) doesn't * have the real filename anyway. */ g_key_file_set_string (keyfile, group, "filename", filename); #endif temp = g_strdup_printf ("%ld", time (NULL)); g_key_file_set_string (keyfile, group, "time", temp); g_free (temp); keys = cursor = g_hash_table_get_keys (fields); while (cursor) { gchar *key = (gchar*) cursor->data; gchar *value = get_field (fields, key); if (strcmp (key, "image_hash") != 0) { g_key_file_set_string (keyfile, group, key, value); } if (strcmp (key, "small_thumbnail") == 0) { thumbnail = value; } else { g_free (value); } cursor = cursor->next; } g_list_free (keys); temp = g_key_file_to_data (keyfile, NULL, NULL); g_mkdir_with_parents (path, 0700); /* ignore the result */ g_file_set_contents (inifile, temp, -1, NULL); g_free (temp); if (thumbnail) { gchar *extension = strrchr (thumbnail, '.'); if (extension) { gchar *thumbnail_target = g_strdup_printf ( "%s/%s%s", path, group, extension); download_thumbnail (thumbnail, thumbnail_target); } g_free (thumbnail); } g_free (inifile); g_key_file_free (keyfile); g_free (path); g_free (group); }
/** * pk_offline_get_results: * @error: A #GError or %NULL * * Gets the last result of the offline transaction. * * Return value: (transfer full): A #PkResults, or %NULL * * Since: 0.9.6 **/ PkResults * pk_offline_get_results (GError **error) { gboolean ret; gboolean success; guint i; g_autoptr(GError) error_local = NULL; g_autofree gchar *data = NULL; g_autoptr(GKeyFile) file = NULL; g_autoptr(PkError) pk_error = NULL; g_autoptr(PkResults) results = NULL; g_auto(GStrv) package_ids = NULL; g_return_val_if_fail (error == NULL || *error == NULL, NULL); /* does not exist */ if (!g_file_test (PK_OFFLINE_RESULTS_FILENAME, G_FILE_TEST_EXISTS)) { g_set_error_literal (error, PK_OFFLINE_ERROR, PK_OFFLINE_ERROR_NO_DATA, "no update results available"); return NULL; } /* load data */ file = g_key_file_new (); ret = g_key_file_load_from_file (file, PK_OFFLINE_RESULTS_FILENAME, G_KEY_FILE_NONE, &error_local); if (!ret) { g_set_error (error, PK_OFFLINE_ERROR, PK_OFFLINE_ERROR_FAILED, "results file invalid: %s", error_local->message); return NULL; } /* add error */ results = pk_results_new (); success = g_key_file_get_boolean (file, PK_OFFLINE_RESULTS_GROUP, "Success", NULL); if (!success) { g_autofree gchar *details = NULL; g_autofree gchar *enum_str = NULL; pk_error = pk_error_new (); enum_str = g_key_file_get_string (file, PK_OFFLINE_RESULTS_GROUP, "ErrorCode", NULL); details = g_key_file_get_string (file, PK_OFFLINE_RESULTS_GROUP, "ErrorDetails", NULL); g_object_set (pk_error, "code", pk_error_enum_from_string (enum_str), "details", details, NULL); pk_results_set_error_code (results, pk_error); pk_results_set_exit_code (results, PK_EXIT_ENUM_FAILED); } else { pk_results_set_exit_code (results, PK_EXIT_ENUM_SUCCESS); } /* add packages */ data = g_key_file_get_string (file, PK_OFFLINE_RESULTS_GROUP, "Packages", NULL); if (data != NULL) { package_ids = g_strsplit (data, ",", -1); for (i = 0; package_ids[i] != NULL; i++) { g_autoptr(PkPackage) pkg = NULL; pkg = pk_package_new (); pk_package_set_info (pkg, PK_INFO_ENUM_UPDATING); if (!pk_package_set_id (pkg, package_ids[i], error)) return NULL; pk_results_add_package (results, pkg); } } return g_object_ref (results); }
GstElement * purple_media_manager_get_pipeline(PurpleMediaManager *manager) { #ifdef USE_VV g_return_val_if_fail(PURPLE_IS_MEDIA_MANAGER(manager), NULL); if (manager->priv->pipeline == NULL) { FsElementAddedNotifier *notifier; gchar *filename; GError *err = NULL; GKeyFile *keyfile; GstBus *bus; manager->priv->pipeline = gst_pipeline_new(NULL); bus = gst_pipeline_get_bus( GST_PIPELINE(manager->priv->pipeline)); gst_bus_add_signal_watch(GST_BUS(bus)); g_signal_connect(G_OBJECT(bus), "message", G_CALLBACK(pipeline_bus_call), manager); gst_bus_set_sync_handler(bus, gst_bus_sync_signal_handler, NULL); gst_object_unref(bus); filename = g_build_filename(purple_user_dir(), "fs-element.conf", NULL); keyfile = g_key_file_new(); if (!g_key_file_load_from_file(keyfile, filename, G_KEY_FILE_NONE, &err)) { if (err->code == 4) purple_debug_info("mediamanager", "Couldn't read " "fs-element.conf: %s\n", err->message); else purple_debug_error("mediamanager", "Error reading " "fs-element.conf: %s\n", err->message); g_error_free(err); } g_free(filename); /* Hack to make alsasrc stop messing up audio timestamps */ if (!g_key_file_has_key(keyfile, "alsasrc", "slave-method", NULL)) { g_key_file_set_integer(keyfile, "alsasrc", "slave-method", 2); } notifier = fs_element_added_notifier_new(); fs_element_added_notifier_add(notifier, GST_BIN(manager->priv->pipeline)); fs_element_added_notifier_set_properties_from_keyfile( notifier, keyfile); gst_element_set_state(manager->priv->pipeline, GST_STATE_PLAYING); } return manager->priv->pipeline; #else return NULL; #endif }
void moloch_config_load() { gboolean status; GError *error = 0; GKeyFile *keyfile; int i; keyfile = molochKeyFile = g_key_file_new(); status = g_key_file_load_from_file(keyfile, config.configFile, G_KEY_FILE_NONE, &error); if (!status || error) { printf("Couldn't load config file (%s) %s\n", config.configFile, (error?error->message:"")); exit(1); } char **includes = moloch_config_str_list(keyfile, "includes", NULL); if (includes) { moloch_config_load_includes(includes); g_strfreev(includes); //LOG("KEYFILE:\n%s", g_key_file_to_data(molochKeyFile, NULL, NULL)); } char *rotateIndex = moloch_config_str(keyfile, "rotateIndex", "daily"); if (strcmp(rotateIndex, "hourly") == 0) config.rotate = MOLOCH_ROTATE_HOURLY; else if (strcmp(rotateIndex, "daily") == 0) config.rotate = MOLOCH_ROTATE_DAILY; else if (strcmp(rotateIndex, "weekly") == 0) config.rotate = MOLOCH_ROTATE_WEEKLY; else if (strcmp(rotateIndex, "monthly") == 0) config.rotate = MOLOCH_ROTATE_MONTHLY; else { printf("Unknown rotateIndex '%s'\n", rotateIndex); exit(1); } g_free(rotateIndex); config.nodeClass = moloch_config_str(keyfile, "nodeClass", NULL); gchar **tags = moloch_config_str_list(keyfile, "dontSaveTags", NULL); if (tags) { for (i = 0; tags[i]; i++) { if (!(*tags[i])) continue; int num = 1; char *colon = strchr(tags[i], ':'); if (colon) { *colon = 0; num = atoi(colon+1); if (num < 1) num = 1; if (num > 0xffff) num = 0xffff; } moloch_string_add((MolochStringHash_t *)(char*)&config.dontSaveTags, tags[i], (gpointer)(long)num, TRUE); } g_strfreev(tags); } char *bpfsStrs[MOLOCH_FILTER_MAX] = {"dontSaveBPFs", "minPacketsSaveBPFs"}; int t; for (t = 0; t < MOLOCH_FILTER_MAX; t++) { config.bpfs[t] = moloch_config_str_list(keyfile, bpfsStrs[t], NULL); if (config.bpfs[t]) { for (i = 0; config.bpfs[t][i]; i++); //empty loop, counting config.bpfsNum[t] = i; config.bpfsVal[t] = malloc(config.bpfsNum[t]*sizeof(int)); GRegex *regex = g_regex_new(":\\s*(\\d+)\\s*$", 0, 0, 0); GMatchInfo *match_info; for (i = 0; config.bpfs[t][i]; i++) { g_regex_match(regex, config.bpfs[t][i], 0, &match_info); if (g_match_info_matches(match_info)) { config.bpfsVal[t][i] = atoi(g_match_info_fetch(match_info, 1)); gint pos; g_match_info_fetch_pos(match_info, 0, &pos, NULL); config.bpfs[t][i][pos] = 0; } else { config.bpfsVal[t][i] = 1; } g_match_info_free(match_info); } g_regex_unref(regex); } } config.plugins = moloch_config_str_list(keyfile, "plugins", NULL); config.rootPlugins = moloch_config_str_list(keyfile, "rootPlugins", NULL); config.smtpIpHeaders = moloch_config_str_list(keyfile, "smtpIpHeaders", NULL); if (config.smtpIpHeaders) { for (i = 0; config.smtpIpHeaders[i]; i++) { int len = strlen(config.smtpIpHeaders[i]); char *lower = g_ascii_strdown(config.smtpIpHeaders[i], len); g_free(config.smtpIpHeaders[i]); config.smtpIpHeaders[i] = lower; if (lower[len-1] == ':') lower[len-1] = 0; } } config.prefix = moloch_config_str(keyfile, "prefix", ""); int len = strlen(config.prefix); if (len > 0 && config.prefix[len - 1] != '_') { char *tmp = malloc(len + 2); memcpy(tmp, config.prefix, len); tmp[len] = '_'; tmp[len+1] = 0; g_free(config.prefix); config.prefix = tmp; } config.elasticsearch = moloch_config_str(keyfile, "elasticsearch", "localhost:9200"); config.interface = moloch_config_str_list(keyfile, "interface", NULL); config.pcapDir = moloch_config_str_list(keyfile, "pcapDir", NULL); config.bpf = moloch_config_str(keyfile, "bpf", NULL); config.yara = moloch_config_str(keyfile, "yara", NULL); config.emailYara = moloch_config_str(keyfile, "emailYara", NULL); config.geoipFile = moloch_config_str(keyfile, "geoipFile", NULL); config.rirFile = moloch_config_str(keyfile, "rirFile", NULL); config.geoipASNFile = moloch_config_str(keyfile, "geoipASNFile", NULL); config.geoip6File = moloch_config_str(keyfile, "geoip6File", NULL); config.geoipASN6File = moloch_config_str(keyfile, "geoipASN6File", NULL); config.dropUser = moloch_config_str(keyfile, "dropUser", NULL); config.dropGroup = moloch_config_str(keyfile, "dropGroup", NULL); config.pluginsDir = moloch_config_str_list(keyfile, "pluginsDir", NULL); config.parsersDir = moloch_config_str_list(keyfile, "parsersDir", " /data/moloch/parsers ; ./parsers "); char *offlineRegex = moloch_config_str(keyfile, "offlineFilenameRegex", "(?i)\\.(pcap|cap)$"); config.offlineRegex = g_regex_new(offlineRegex, 0, 0, &error); if (!config.offlineRegex || error) { printf("Couldn't parse offlineRegex (%s) %s\n", offlineRegex, (error?error->message:"")); exit(1); } g_free(offlineRegex); config.pcapDirTemplate = moloch_config_str(keyfile, "pcapDirTemplate", NULL); if (config.pcapDirTemplate && config.pcapDirTemplate[0] != '/') { printf("pcapDirTemplate MUST start with a / '%s'\n", config.pcapDirTemplate); exit(1); } config.pcapDirAlgorithm = moloch_config_str(keyfile, "pcapDirAlgorithm", "round-robin"); if (strcmp(config.pcapDirAlgorithm, "round-robin") != 0 && strcmp(config.pcapDirAlgorithm, "max-free-percent") != 0 && strcmp(config.pcapDirAlgorithm, "max-free-bytes") != 0) { printf("'%s' is not a valid value for pcapDirAlgorithm. Supported algorithms are round-robin, max-free-percent, and max-free-bytes.\n", config.pcapDirAlgorithm); exit(1); } config.maxFileSizeG = moloch_config_double(keyfile, "maxFileSizeG", 4, 0.01, 1024); config.maxFileSizeB = config.maxFileSizeG*1024LL*1024LL*1024LL; config.maxFileTimeM = moloch_config_int(keyfile, "maxFileTimeM", 0, 0, 0xffff); config.timeouts[SESSION_ICMP]= moloch_config_int(keyfile, "icmpTimeout", 10, 1, 0xffff); config.timeouts[SESSION_UDP] = moloch_config_int(keyfile, "udpTimeout", 60, 1, 0xffff); config.timeouts[SESSION_TCP] = moloch_config_int(keyfile, "tcpTimeout", 60*8, 10, 0xffff); config.tcpSaveTimeout = moloch_config_int(keyfile, "tcpSaveTimeout", 60*8, 10, 60*120); config.maxStreams = moloch_config_int(keyfile, "maxStreams", 1500000, 1, 16777215); config.maxPackets = moloch_config_int(keyfile, "maxPackets", 10000, 1, 1000000); config.maxPacketsInQueue = moloch_config_int(keyfile, "maxPacketsInQueue", 200000, 10000, 5000000); config.dbBulkSize = moloch_config_int(keyfile, "dbBulkSize", 200000, MOLOCH_HTTP_BUFFER_SIZE*2, 1000000); config.dbFlushTimeout = moloch_config_int(keyfile, "dbFlushTimeout", 5, 1, 60*30); config.maxESConns = moloch_config_int(keyfile, "maxESConns", 20, 5, 1000); config.maxESRequests = moloch_config_int(keyfile, "maxESRequests", 500, 10, 5000); config.logEveryXPackets = moloch_config_int(keyfile, "logEveryXPackets", 50000, 1000, 1000000); config.pcapBufferSize = moloch_config_int(keyfile, "pcapBufferSize", 300000000, 100000, 0xffffffff); config.pcapWriteSize = moloch_config_int(keyfile, "pcapWriteSize", 0x10000, 0x40000, 0x800000); config.maxFreeOutputBuffers = moloch_config_int(keyfile, "maxFreeOutputBuffers", 50, 0, 0xffff); config.fragsTimeout = moloch_config_int(keyfile, "fragsTimeout", 60*8, 60, 0xffff); config.maxFrags = moloch_config_int(keyfile, "maxFrags", 50000, 1000, 0xffffff); config.packetThreads = moloch_config_int(keyfile, "packetThreads", 1, 1, MOLOCH_MAX_PACKET_THREADS); config.logUnknownProtocols = moloch_config_boolean(keyfile, "logUnknownProtocols", config.debug); config.logESRequests = moloch_config_boolean(keyfile, "logESRequests", config.debug); config.logFileCreation = moloch_config_boolean(keyfile, "logFileCreation", config.debug); config.parseSMTP = moloch_config_boolean(keyfile, "parseSMTP", TRUE); config.parseSMB = moloch_config_boolean(keyfile, "parseSMB", TRUE); config.parseQSValue = moloch_config_boolean(keyfile, "parseQSValue", FALSE); config.parseCookieValue = moloch_config_boolean(keyfile, "parseCookieValue", FALSE); config.compressES = moloch_config_boolean(keyfile, "compressES", FALSE); config.antiSynDrop = moloch_config_boolean(keyfile, "antiSynDrop", TRUE); config.readTruncatedPackets = moloch_config_boolean(keyfile, "readTruncatedPackets", FALSE); }
static void configure_response_cb(GtkDialog *dialog, gint response, gpointer user_data) { if (response == GTK_RESPONSE_OK || response == GTK_RESPONSE_APPLY) { GKeyFile *config = g_key_file_new(); gchar *data; gchar *config_dir = g_path_get_dirname(sc_info->config_file); GtkComboBox *combo = GTK_COMBO_BOX(g_object_get_data(G_OBJECT(dialog), "combo")); setptr(sc_info->default_language, gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo))); #ifdef HAVE_ENCHANT_1_5 setptr(sc_info->dictionary_dir, g_strdup(gtk_entry_get_text(GTK_ENTRY( g_object_get_data(G_OBJECT(dialog), "dict_dir"))))); #endif sc_speller_reinit_enchant_dict(); sc_info->check_while_typing = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( g_object_get_data(G_OBJECT(dialog), "check_type")))); sc_info->check_on_document_open = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( g_object_get_data(G_OBJECT(dialog), "check_on_open")))); sc_info->use_msgwin = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( g_object_get_data(G_OBJECT(dialog), "check_msgwin")))); sc_info->show_toolbar_item = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( g_object_get_data(G_OBJECT(dialog), "check_toolbar")))); sc_info->show_editor_menu_item = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( g_object_get_data(G_OBJECT(dialog), "check_editor_menu")))); sc_info->show_editor_menu_item_sub_menu = (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON( g_object_get_data(G_OBJECT(dialog), "check_editor_menu_sub_menu")))); g_key_file_load_from_file(config, sc_info->config_file, G_KEY_FILE_NONE, NULL); if (sc_info->default_language != NULL) /* lang may be NULL */ g_key_file_set_string(config, "spellcheck", "language", sc_info->default_language); g_key_file_set_boolean(config, "spellcheck", "check_while_typing", sc_info->check_while_typing); g_key_file_set_boolean(config, "spellcheck", "check_on_document_open", sc_info->check_on_document_open); g_key_file_set_boolean(config, "spellcheck", "use_msgwin", sc_info->use_msgwin); g_key_file_set_boolean(config, "spellcheck", "show_toolbar_item", sc_info->show_toolbar_item); g_key_file_set_boolean(config, "spellcheck", "show_editor_menu_item", sc_info->show_editor_menu_item); g_key_file_set_boolean(config, "spellcheck", "show_editor_menu_item_sub_menu", sc_info->show_editor_menu_item_sub_menu); if (sc_info->dictionary_dir != NULL) g_key_file_set_string(config, "spellcheck", "dictionary_dir", sc_info->dictionary_dir); sc_gui_recreate_editor_menu(); sc_gui_update_toolbar(); sc_gui_update_menu(); populate_dict_combo(combo); if (! g_file_test(config_dir, G_FILE_TEST_IS_DIR) && utils_mkdir(config_dir, TRUE) != 0) { dialogs_show_msgbox(GTK_MESSAGE_ERROR, _("Plugin configuration directory could not be created.")); } else { /* write config to file */ data = g_key_file_to_data(config, NULL, NULL); utils_write_file(sc_info->config_file, data); g_free(data); } g_free(config_dir); g_key_file_free(config); } }
int main( int argc, char *argv[] ) { /* GtkWidget is the storage type for widgets */ GtkWidget *window; GtkWidget *menubar; time_t now; struct tm *tm; GThread *gth = NULL; /* thread id */ gboolean run_flag = TRUE; /* used as exit flag for threads */ int i; putenv("UBUNTU_MENUPROXY="); //init_trees(); gdk_color_parse("#FFFF00", &color_yellow); gdk_color_parse("#FFFFFF", &color_white); gdk_color_parse("#404040", &color_grey); gdk_color_parse("#00FF00", &color_green); gdk_color_parse("#007700", &color_darkgreen); gdk_color_parse("#0000FF", &color_blue); gdk_color_parse("#FF0000", &color_red); gdk_color_parse("#770000", &color_darkred); gdk_color_parse("#000000", &color_black); font = pango_font_description_from_string("Sans bold 12"); #ifdef WIN32 installation_dir = g_win32_get_package_installation_directory_of_module(NULL); #else gbr_init(NULL); installation_dir = gbr_find_prefix(NULL); #endif program_path = argv[0]; current_directory[0] = 0; if (current_directory[0] == 0) strcpy(current_directory, "."); conffile = g_build_filename(g_get_user_data_dir(), "judoproxy.ini", NULL); /* create video download dir */ video_dir = g_build_filename(g_get_home_dir(), "rpivideos", NULL); g_print("Video dir = %s\n", video_dir); g_mkdir_with_parents(video_dir, 0755); keyfile = g_key_file_new(); g_key_file_load_from_file(keyfile, conffile, 0, NULL); now = time(NULL); tm = localtime(&now); current_year = tm->tm_year+1900; srand(now); //srandom(now); my_address = now + getpid()*10000; gtk_init (&argc, &argv); main_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "JudoProxy"); gtk_widget_set_size_request(window, FRAME_WIDTH, FRAME_HEIGHT); gchar *iconfile = g_build_filename(installation_dir, "etc", "judoproxy.png", NULL); gtk_window_set_default_icon_from_file(iconfile, NULL); g_free(iconfile); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 10); main_vbox = gtk_grid_new(); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1); gtk_container_add (GTK_CONTAINER (window), main_vbox); gtk_widget_show(main_vbox); /* menubar */ menubar = get_menubar_menu(window); gtk_widget_show(menubar); gtk_grid_attach(GTK_GRID(main_vbox), menubar, 0, 0, 1, 1); gtk_widget_set_hexpand(menubar, TRUE); /* judoka info */ //name_box = gtk_label_new("?"); //gtk_box_pack_start(GTK_BOX(main_vbox), name_box, FALSE, TRUE, 0); //GtkWidget *hbox = gtk_hbox_new(FALSE, 0); //gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 0); notebook = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE); gtk_widget_set_hexpand(notebook, TRUE); //gtk_widget_set_vexpand(notebook, TRUE); gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP); /* GtkWidget *camera_table = gtk_grid_new(); gtk_grid_set_column_spacing(GTK_GRID(camera_table), 10); gtk_grid_set_row_spacing(GTK_GRID(camera_table), 10); */ for (i = 0; i < NUM_TATAMIS; i++) { gchar buf[32]; GtkWidget *data_table = gtk_grid_new(); connections[i].scrolled_window = data_table; //connections[i].scrolled_window = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(connections[i].scrolled_window), 10); snprintf(buf, sizeof(buf), "T%d [--]", i+1); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), connections[i].scrolled_window, gtk_label_new(buf)); gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("Camera")), 0, 0, 2, 1); gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("JudoTimer")), 4, 0, 2, 1); GtkWidget *reload = gtk_button_new_with_label(_("Reload")); gtk_grid_attach(GTK_GRID(data_table), reload, 0, 1, 1, 1); connections[i].in_addr = gtk_entry_new(); connections[i].out_addr = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(connections[i].in_addr), 15); gtk_entry_set_width_chars(GTK_ENTRY(connections[i].out_addr), 15); gtk_grid_attach(GTK_GRID(data_table), connections[i].in_addr, 2, 0, 2, 1); gtk_grid_attach(GTK_GRID(data_table), connections[i].out_addr, 6, 0, 2, 1); gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(" "), 0, 1, 1, 1); //gtk_container_add(GTK_CONTAINER(connections[i].scrolled_window), data_table); g_signal_connect (connections[i].out_addr, "activate", G_CALLBACK(enter_callback), gint_to_ptr(i)); g_signal_connect (connections[i].in_addr, "activate", G_CALLBACK(camera_ip_enter_callback), gint_to_ptr(i)); #ifdef WEBKIT g_signal_connect (reload, "clicked", G_CALLBACK(reload_web), gint_to_ptr(i)); #else g_signal_connect (reload, "clicked", G_CALLBACK(select_camera_video), gint_to_ptr(i)); #endif } gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0); gtk_grid_attach_next_to(GTK_GRID(main_vbox), notebook, NULL, GTK_POS_BOTTOM, 1, 1); progress_bar = gtk_progress_bar_new(); gtk_grid_attach_next_to(GTK_GRID(main_vbox), progress_bar, NULL, GTK_POS_BOTTOM, 1, 1); GtkWidget *w = GTK_WIDGET(gtk_scrolled_window_new(NULL, NULL)); #ifdef WEBKIT web_view = WEBKIT_WEB_VIEW(webkit_web_view_new()); webkit_web_view_set_transparent(web_view, TRUE); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(web_view)); gtk_widget_set_vexpand(GTK_WIDGET(web_view), TRUE); WebKitWebSettings *web_settings = webkit_web_settings_new(); //g_object_set(G_OBJECT(web_settings), "enable-java-applet", FALSE, NULL); //g_object_set(G_OBJECT(web_settings), "enable-plugins", FALSE, NULL); webkit_web_view_set_settings(web_view, web_settings); gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1); gtk_widget_grab_focus(GTK_WIDGET(web_view)); //webkit_web_view_load_uri(web_view, "http://www.hs.fi"); webkit_web_view_load_uri(web_view, "http://www.quirksmode.org/html5/tests/video.html"); g_signal_connect(web_view, "download-requested", G_CALLBACK(download_req), NULL); //g_signal_connect(web_view, "load-changed", G_CALLBACK(load_changed), NULL); #else /* HTML page */ html_page = create_html_page(); gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(html_page), NULL, GTK_POS_BOTTOM, 1, 1); /* Video display */ camera_image = gtk_image_new(); gtk_widget_set_size_request(GTK_WIDGET(camera_image), 640, 360); GtkWidget *event_box = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(event_box), camera_image); gtk_widget_set_events(event_box, gtk_widget_get_events(event_box) | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | /*GDK_POINTER_MOTION_MASK |*/ GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_MOTION_MASK); g_signal_connect(G_OBJECT(event_box), "button_press_event", G_CALLBACK(button_press_callback), camera_image); g_signal_connect(G_OBJECT(event_box), "button_release_event", G_CALLBACK(button_release_callback), camera_image); g_signal_connect(G_OBJECT(event_box), "motion-notify-event", G_CALLBACK(button_notify_callback), camera_image); gtk_widget_show(camera_image); gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(event_box)); gtk_widget_set_vexpand(GTK_WIDGET(event_box), TRUE); gtk_widget_set_hexpand(GTK_WIDGET(event_box), TRUE); gtk_widget_set_vexpand(GTK_WIDGET(camera_image), TRUE); gtk_widget_set_hexpand(GTK_WIDGET(camera_image), TRUE); gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1); #endif /* timers */ timer = g_timer_new(); gtk_widget_show_all(window); set_preferences(); change_language(NULL, NULL, gint_to_ptr(language)); open_comm_socket(); scan_interfaces(); /* Create a bg thread using glib */ gpointer proxy_ssdp_thread(gpointer args); g_snprintf(ssdp_id, sizeof(ssdp_id), "JudoProxy"); static gint run[NUM_CONNECTIONS]; for (i = 0; i < NUM_CONNECTIONS; i++) { char tname[16]; run[i] = i; sprintf(tname, "Connection%d", i); gth = g_thread_new(tname, (GThreadFunc)connection_thread, &run[i]); } gth = g_thread_new("SSDP", (GThreadFunc)proxy_ssdp_thread, (gpointer)&run_flag); gth = g_thread_new("CameraVideo", camera_video, (gpointer)&run_flag); gth = gth; // make compiler happy gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS); cursor = gdk_cursor_new(GDK_HAND2); //gdk_window_set_cursor(GTK_WIDGET(main_window)->window, cursor); //g_timeout_add(100, timeout_ask_for_data, NULL); g_timeout_add(1000, check_table, NULL); g_timeout_add(100, show_camera_video, NULL); //g_idle_add(show_camera_video, NULL); /* All GTK applications must have a gtk_main(). Control ends here * and waits for an event to occur (like a key press or * mouse event). */ gtk_main(); for (i = 0; i < NUM_CONNECTIONS; i++) run[i] = -1; run_flag = FALSE; /* flag threads to stop and exit */ //g_thread_join(gth); /* wait for thread to exit */ return 0; }
/* * init debug related GUI (watch tree view) * arguments: */ void debug_init() { /* create watch page */ wtree = wtree_init(on_watch_expanded_callback, on_watch_dragged_callback, on_watch_key_pressed_callback, on_watch_changed, on_watch_button_pressed_callback); wmodel = gtk_tree_view_get_model(GTK_TREE_VIEW(wtree)); wstore = GTK_TREE_STORE(wmodel); tab_watch = gtk_scrolled_window_new( gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(wtree)), gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(wtree)) ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_watch), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tab_watch), wtree); /* create autos page */ atree = atree_init(on_watch_expanded_callback, on_watch_button_pressed_callback); tab_autos = gtk_scrolled_window_new( gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(atree)), gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(atree)) ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_autos), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tab_autos), atree); /* create stack trace page */ stree = stree_init(editor_open_position, on_select_frame); tab_call_stack = gtk_scrolled_window_new( gtk_tree_view_get_hadjustment(GTK_TREE_VIEW(stree )), gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(stree )) ); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_call_stack), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tab_call_stack), stree); /* create debug terminal page */ terminal = vte_terminal_new(); /* create PTY */ openpty(&pty_master, &pty_slave, NULL, NULL, NULL); grantpt(pty_master); unlockpt(pty_master); vte_terminal_set_pty(VTE_TERMINAL(terminal), pty_master); GtkWidget *scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(terminal)->adjustment)); GTK_WIDGET_UNSET_FLAGS(scrollbar, GTK_CAN_FOCUS); tab_terminal = gtk_frame_new(NULL); gtk_frame_set_shadow_type (GTK_FRAME(tab_terminal), GTK_SHADOW_NONE); GtkWidget *hbox = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(tab_terminal), hbox); gtk_box_pack_start(GTK_BOX(hbox), terminal, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0); /* set the default widget size first to prevent VTE expanding too much, * sometimes causing the hscrollbar to be too big or out of view. */ gtk_widget_set_size_request(GTK_WIDGET(terminal), 10, 10); vte_terminal_set_size(VTE_TERMINAL(terminal), 30, 1); /* set terminal font. */ GKeyFile *config = g_key_file_new(); gchar *configfile = g_strconcat(geany_data->app->configdir, G_DIR_SEPARATOR_S, "geany.conf", NULL); g_key_file_load_from_file(config, configfile, G_KEY_FILE_NONE, NULL); gchar *font = utils_get_setting_string(config, "VTE", "font", "Monospace 10"); vte_terminal_set_font_from_string (VTE_TERMINAL(terminal), font); /* debug messages page */ tab_messages = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tab_messages), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(tab_messages)); vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(tab_messages)); debugger_messages_textview = gtk_text_view_new(); gtk_text_view_set_editable (GTK_TEXT_VIEW (debugger_messages_textview), FALSE); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tab_messages), debugger_messages_textview); /* create tex tags */ GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(debugger_messages_textview)); gtk_text_buffer_create_tag(buffer, "black", "foreground", "#000000", NULL); gtk_text_buffer_create_tag(buffer, "grey", "foreground", "#AAAAAA", NULL); gtk_text_buffer_create_tag(buffer, "red", "foreground", "#FF0000", NULL); gtk_text_buffer_create_tag(buffer, "green", "foreground", "#00FF00", NULL); gtk_text_buffer_create_tag(buffer, "blue", "foreground", "#0000FF", NULL); gtk_text_buffer_create_tag(buffer, "yellow", "foreground", "#FFFF00", NULL); gtk_text_buffer_create_tag(buffer, "brown", "foreground", "#BB8915", NULL); gtk_text_buffer_create_tag(buffer, "rose", "foreground", "#BA92B7", NULL); }
gboolean ot_admin_builtin_deploy (int argc, char **argv, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; const char *refspec; GOptionContext *context; glnx_unref_object OstreeSysroot *sysroot = NULL; GKeyFile *origin = NULL; glnx_unref_object OstreeRepo *repo = NULL; g_autoptr(GPtrArray) new_deployments = NULL; glnx_unref_object OstreeDeployment *new_deployment = NULL; glnx_unref_object OstreeDeployment *merge_deployment = NULL; g_autofree char *revision = NULL; __attribute__((cleanup(_ostree_kernel_args_cleanup))) OstreeKernelArgs *kargs = NULL; context = g_option_context_new ("REFSPEC - Checkout revision REFSPEC as the new default deployment"); if (!ostree_admin_option_context_parse (context, options, &argc, &argv, OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER, &sysroot, cancellable, error)) goto out; if (argc < 2) { ot_util_usage_error (context, "REF/REV must be specified", error); goto out; } refspec = argv[1]; if (!ostree_sysroot_load (sysroot, cancellable, error)) goto out; if (!ostree_sysroot_get_repo (sysroot, &repo, cancellable, error)) goto out; /* Find the currently booted deployment, if any; we will ensure it * is present in the new deployment list. */ if (!ot_admin_require_booted_deployment_or_osname (sysroot, opt_osname, cancellable, error)) { g_prefix_error (error, "Looking for booted deployment: "); goto out; } if (opt_origin_path) { origin = g_key_file_new (); if (!g_key_file_load_from_file (origin, opt_origin_path, 0, error)) goto out; } else { origin = ostree_sysroot_origin_new_from_refspec (sysroot, refspec); } if (!ostree_repo_resolve_rev (repo, refspec, FALSE, &revision, error)) goto out; merge_deployment = ostree_sysroot_get_merge_deployment (sysroot, opt_osname); /* Here we perform cleanup of any leftover data from previous * partial failures. This avoids having to call gs_shutil_rm_rf() * at random points throughout the process. * * TODO: Add /ostree/transaction file, and only do this cleanup if * we find it. */ if (!ostree_sysroot_prepare_cleanup (sysroot, cancellable, error)) { g_prefix_error (error, "Performing initial cleanup: "); goto out; } kargs = _ostree_kernel_args_new (); /* If they want the current kernel's args, they very likely don't * want the ones from the merge. */ if (opt_kernel_proc_cmdline) { if (!_ostree_kernel_args_append_proc_cmdline (kargs, cancellable, error)) goto out; } else if (merge_deployment) { OstreeBootconfigParser *bootconfig = ostree_deployment_get_bootconfig (merge_deployment); g_auto(GStrv) previous_args = g_strsplit (ostree_bootconfig_parser_get (bootconfig, "options"), " ", -1); _ostree_kernel_args_append_argv (kargs, previous_args); } if (opt_kernel_argv) { _ostree_kernel_args_replace_argv (kargs, opt_kernel_argv); } if (opt_kernel_argv_append) { _ostree_kernel_args_append_argv (kargs, opt_kernel_argv_append); } { g_auto(GStrv) kargs_strv = _ostree_kernel_args_to_strv (kargs); if (!ostree_sysroot_deploy_tree (sysroot, opt_osname, revision, origin, merge_deployment, kargs_strv, &new_deployment, cancellable, error)) goto out; } if (!ostree_sysroot_simple_write_deployment (sysroot, opt_osname, new_deployment, merge_deployment, opt_retain ? OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN : 0, cancellable, error)) goto out; ret = TRUE; out: if (origin) g_key_file_unref (origin); if (context) g_option_context_free (context); return ret; }
static gboolean ril_get_net_config(struct radio_data *rsd) { GKeyFile *keyfile; GError *err = NULL; char *config_path = RIL_CONFIG_DIR; char **alreadyset = NULL; gboolean needsconfig = FALSE; gboolean value = FALSE; gboolean found = FALSE; rsd->ratmode = PREF_NET_TYPE_GSM_WCDMA_AUTO; GDir *config_dir; const gchar *config_file; gsize length; gchar **codes = NULL; int i; /* * First we need to check should the LTE be on * or not */ keyfile = g_key_file_new(); g_key_file_set_list_separator(keyfile, ','); config_dir = g_dir_open(config_path, 0, NULL); while ((config_file = g_dir_read_name(config_dir)) != NULL) { char *path = g_strconcat(RIL_CONFIG_DIR "/", config_file, NULL); DBG("Rilconfig handling %s", path); gboolean ok = g_key_file_load_from_file(keyfile, path, 0, &err); g_free(path); if (!ok) { g_error_free(err); DBG("Rilconfig file skipped"); continue; } if (g_key_file_has_group(keyfile, LTE_FLAG)) found = TRUE; else if (g_key_file_has_group(keyfile, MCC_LIST)) { codes = g_key_file_get_string_list(keyfile, MCC_LIST, MCC_KEY, &length, NULL); if (codes) { for (i = 0; codes[i]; i++) { if (g_str_equal(codes[i], ofono_sim_get_mcc(get_sim())) == TRUE) { found = TRUE; break; } } g_strfreev(codes); } } if (found) { rsd->ratmode = PREF_NET_TYPE_LTE_GSM_WCDMA; break; } } g_key_file_free(keyfile); g_dir_close(config_dir); /* Then we need to check if it already set */ keyfile = storage_open(NULL, RIL_STORE); alreadyset = g_key_file_get_groups(keyfile, NULL); if (alreadyset[0]) value = g_key_file_get_boolean( keyfile, alreadyset[0], LTE_FLAG, NULL); else if (rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO) value = TRUE; if (!value && rsd->ratmode == PREF_NET_TYPE_LTE_GSM_WCDMA) { g_key_file_set_boolean(keyfile, LTE_FLAG, LTE_FLAG, TRUE); needsconfig = TRUE; } else if (value && rsd->ratmode == PREF_NET_TYPE_GSM_WCDMA_AUTO) { g_key_file_set_boolean(keyfile, LTE_FLAG, LTE_FLAG, FALSE); needsconfig = TRUE; } g_strfreev(alreadyset); storage_close(NULL, RIL_STORE, keyfile, TRUE); DBG("needsconfig %d, rat mode %d", needsconfig, rsd->ratmode); return needsconfig; }