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;
}
