/** \brief User pressed OK. Any changes should be stored in config.
*/
void
sat_pref_single_sat_ok (GKeyFile *cfg)
{
if (dirty) {
if (cfg != NULL) {
g_key_file_set_integer (cfg,
MOD_CFG_SINGLE_SAT_SECTION,
MOD_CFG_SINGLE_SAT_FIELDS,
flags);
}
else {
sat_cfg_set_int (SAT_CFG_INT_SINGLE_SAT_FIELDS, flags);
}
}
else if (reset) {
if (cfg != NULL) {
/* local mode; remove key */
g_key_file_remove_key (cfg,
MOD_CFG_SINGLE_SAT_SECTION,
MOD_CFG_SINGLE_SAT_FIELDS,
NULL);
}
else {
/* global mode; reset value */
sat_cfg_reset_int (SAT_CFG_INT_SINGLE_SAT_FIELDS);
}
}
dirty = FALSE;
reset = FALSE;
}
/** Store a str configuration value. */
void sat_cfg_set_str(sat_cfg_str_e param, const gchar *value)
{
if (param < SAT_CFG_STR_NUM)
{
if (config == NULL)
{
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Module not initialised\n"),
__func__);
}
else
{
if (value)
{
g_key_file_set_string (config,
sat_cfg_str[param].group,
sat_cfg_str[param].key,
value);
}
else
{
/* remove key from config */
g_key_file_remove_key (config,
sat_cfg_str[param].group,
sat_cfg_str[param].key,
NULL);
}
}
}
else
{
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Unknown STR param index (%d)\n"),
__func__, param);
}
}
void sat_cfg_reset_str (sat_cfg_str_e param)
{
if (param < SAT_CFG_STR_NUM) {
if (config == NULL) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Module not initialised\n"),
__FUNCTION__);
}
else {
g_key_file_remove_key (config,
sat_cfg_str[param].group,
sat_cfg_str[param].key,
NULL);
}
}
else {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s: Unknown STR param index (%d)\n"),
__FUNCTION__, param);
}
}
void
prefs_clear_roster_contact_char(void)
{
g_key_file_remove_key(prefs, PREF_GROUP_UI, "roster.contact.char", NULL);
_save_prefs();
}
void
prefs_clear_roster_room_private_char(void)
{
g_key_file_remove_key(prefs, PREF_GROUP_UI, "roster.rooms.pruvate.char", NULL);
_save_prefs();
}
void
prefs_clear_roster_resource_char(void)
{
g_key_file_remove_key(prefs, PREF_GROUP_UI, "roster.resource.char", NULL);
_save_prefs();
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS, NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.5.0 autoaway.time to autoaway.awaytime
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL)) {
gint time = g_key_file_get_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
g_key_file_set_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.awaytime", time);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
}
// move pre 0.5.0 autoaway.message to autoaway.awaymessage
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL)) {
char *message = g_key_file_get_string(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
g_key_file_set_string(prefs, PREF_GROUP_PRESENCE, "autoaway.awaymessage", message);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
prefs_free_string(message);
}
// migrate pre 0.5.0 time settings
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
char *val = NULL;
if (time) {
val = time;
} else {
val = "off";
}
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.console", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.chat", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.muc", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.mucconfig", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.private", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.xmlconsole", val);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "time", NULL);
prefs_free_string(time);
}
// move pre 0.5.0 notify settings
if (g_key_file_has_key(prefs, PREF_GROUP_NOTIFICATIONS, "room", NULL)) {
char *value = g_key_file_get_string(prefs, PREF_GROUP_NOTIFICATIONS, "room", NULL);
if (g_strcmp0(value, "on") == 0) {
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room", TRUE);
} else if (g_strcmp0(value, "off") == 0) {
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room", FALSE);
} else if (g_strcmp0(value, "mention") == 0) {
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room", FALSE);
g_key_file_set_boolean(prefs, PREF_GROUP_NOTIFICATIONS, "room.mention", TRUE);
}
prefs_free_string(value);
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
room_trigger_ac = autocomplete_new();
gsize len = 0;
gchar **triggers = g_key_file_get_string_list(prefs, PREF_GROUP_NOTIFICATIONS, "room.trigger.list", &len, NULL);
int i = 0;
for (i = 0; i < len; i++) {
autocomplete_add(room_trigger_ac, triggers[i]);
}
g_strfreev(triggers);
}
static gchar *_cairo_dock_generate_desktop_file_for_launcher (const gchar *cDesktopURI, const gchar *cDockName, double fOrder, GError **erreur)
{
g_return_val_if_fail (cDesktopURI != NULL, NULL);
GError *tmp_erreur = NULL;
gchar *cFilePath = (*cDesktopURI == '/' ? g_strdup (cDesktopURI) : g_filename_from_uri (cDesktopURI, NULL, &tmp_erreur));
if (tmp_erreur != NULL)
{
g_propagate_error (erreur, tmp_erreur);
return NULL;
}
//\___________________ On supprime a la main les '%20' qui foutent le boxon (rare).
cairo_dock_remove_html_spaces (cFilePath);
//\___________________ On ouvre le patron.
GKeyFile *pKeyFile = cairo_dock_open_key_file (cFilePath);
if (pKeyFile == NULL)
return NULL;
//\___________________ On renseigne nos champs.
g_key_file_set_double (pKeyFile, "Desktop Entry", "Order", fOrder);
g_key_file_set_string (pKeyFile, "Desktop Entry", "Container", cDockName);
//\___________________ On elimine les indesirables.
g_key_file_remove_key (pKeyFile, "Desktop Entry", "X-Ubuntu-Gettext-Domain", NULL);
gchar *cCommand = g_key_file_get_string (pKeyFile, "Desktop Entry", "Exec", &tmp_erreur);
if (tmp_erreur != NULL)
{
g_propagate_error (erreur, tmp_erreur);
g_key_file_free (pKeyFile);
return NULL;
}
gchar *str = strchr (cCommand, '%');
if (str != NULL)
{
*str = '\0';
g_key_file_set_string (pKeyFile, "Desktop Entry", "Exec", cCommand);
}
g_free (cCommand);
gchar *cIconName = g_key_file_get_string (pKeyFile, "Desktop Entry", "Icon", &tmp_erreur);
if (tmp_erreur != NULL)
{
g_propagate_error (erreur, tmp_erreur);
g_key_file_free (pKeyFile);
return NULL;
}
if (*cIconName != '/' && (g_str_has_suffix (cIconName, ".svg") || g_str_has_suffix (cIconName, ".png") || g_str_has_suffix (cIconName, ".xpm")))
{
cIconName[strlen(cIconName) - 4] = '\0';
g_key_file_set_string (pKeyFile, "Desktop Entry", "Icon", cIconName);
}
g_free (cIconName);
//\___________________ On lui choisit un nom de fichier tel qu'il n'y ait pas de collision.
gchar *cBaseName = g_path_get_basename (cFilePath);
gchar *cNewDesktopFileName = cairo_dock_generate_desktop_filename (cBaseName, g_cCurrentLaunchersPath);
g_free (cBaseName);
//\___________________ On ecrit tout ca dans un fichier base sur le template.
gchar *cNewDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, cNewDesktopFileName);
cairo_dock_flush_conf_file_full (pKeyFile, cNewDesktopFilePath, CAIRO_DOCK_SHARE_DATA_DIR, FALSE, CAIRO_DOCK_LAUNCHER_CONF_FILE);
g_free (cNewDesktopFilePath);
g_key_file_free (pKeyFile);
g_free (cFilePath);
return cNewDesktopFileName;
}
gboolean
ot_admin_builtin_upgrade (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
g_autoptr(GOptionContext) context = NULL;
glnx_unref_object OstreeSysroot *sysroot = NULL;
glnx_unref_object OstreeSysrootUpgrader *upgrader = NULL;
g_autoptr(GKeyFile) origin = NULL;
glnx_unref_object OstreeAsyncProgress *progress = NULL;
gboolean changed;
OstreeSysrootUpgraderPullFlags upgraderpullflags = 0;
context = g_option_context_new ("Construct new tree from current origin and deploy it, if it changed");
if (!ostree_admin_option_context_parse (context, options, &argc, &argv,
OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER,
&sysroot, cancellable, error))
goto out;
if (!ostree_sysroot_load (sysroot, cancellable, error))
goto out;
upgrader = ostree_sysroot_upgrader_new_for_os (sysroot, opt_osname,
cancellable, error);
if (!upgrader)
goto out;
origin = ostree_sysroot_upgrader_dup_origin (upgrader);
if (origin != NULL)
{
gboolean origin_changed = FALSE;
if (opt_override_commit != NULL)
{
/* Override the commit to pull and deploy. */
g_key_file_set_string (origin, "origin",
"override-commit",
opt_override_commit);
origin_changed = TRUE;
}
else
{
/* Strip any override-commit from the origin file so
* we always upgrade to the latest available commit. */
origin_changed = g_key_file_remove_key (origin, "origin",
"override-commit", NULL);
}
/* Should we consider requiring --discard-hotfix here? */
origin_changed |= g_key_file_remove_key (origin, "origin", "unlocked", NULL);
if (origin_changed)
{
/* XXX GCancellable parameter is not used. */
if (!ostree_sysroot_upgrader_set_origin (upgrader, origin, NULL, error))
goto out;
}
}
{ g_auto(GLnxConsoleRef) console = { 0, };
glnx_console_lock (&console);
if (console.is_tty)
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);
if (opt_allow_downgrade)
upgraderpullflags |= OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER;
if (!ostree_sysroot_upgrader_pull (upgrader, 0, upgraderpullflags,
progress, &changed,
cancellable, error))
goto out;
if (progress)
ostree_async_progress_finish (progress);
}
if (!changed)
{
g_print ("No update available.\n");
}
else
{
if (!ostree_sysroot_upgrader_deploy (upgrader, cancellable, error))
goto out;
if (opt_reboot)
{
if (!ot_admin_execve_reboot (sysroot, error))
goto out;
}
}
ret = TRUE;
out:
return ret;
}
/* appends app to type in Added Associations */
void mime_type_append_action( const char* type, const char* desktop_id )
{ //sfm 0.7.7+ added
// http://www.freedesktop.org/wiki/Specifications/mime-actions-spec
GKeyFile* file;
gsize len = 0;
char* data = NULL;
char** apps;
gsize n_apps, i;
char* str;
if ( !( type && type[0] != '\0' && desktop_id && desktop_id[0] != '\0' ) )
return;
char* dir = g_build_filename( g_get_user_data_dir(), "applications", NULL );
char* path = g_build_filename( dir, "mimeapps.list", NULL );
g_mkdir_with_parents( dir, 0700 );
g_free( dir );
// Load old file content, if available
file = g_key_file_new();
g_key_file_load_from_file( file, path, 0, NULL );
// append app to [Added Associations]
char* new_action = NULL;
gboolean is_present = FALSE;
apps = g_key_file_get_string_list( file, "Added Associations", type, &n_apps,
NULL );
if ( apps )
{
for ( i = 0; i < n_apps; ++i )
{
g_strstrip( apps[i] );
if ( apps[i][0] != '\0' )
{
if ( !strcmp( apps[i], desktop_id ) )
{
is_present = TRUE;
break;
}
str = new_action;
new_action = g_strdup_printf( "%s%s;", str ? str : "", apps[i] );
g_free( str );
}
}
g_strfreev( apps );
}
// update key file - added
if ( !is_present )
{
str = new_action;
new_action = g_strdup_printf( "%s%s;", str ? str : "", desktop_id );
g_free( str );
g_key_file_set_string( file, "Added Associations", type, new_action );
}
g_free( new_action );
// remove app from [Removed Associations]
char* removed = NULL;
apps = g_key_file_get_string_list( file, "Removed Associations", type, &n_apps,
NULL );
if ( apps )
{
for ( i = 0; i < n_apps; ++i )
{
g_strstrip( apps[i] );
if ( apps[i][0] != '\0' && strcmp( apps[i], desktop_id ) )
{
str = removed;
removed = g_strdup_printf( "%s%s;", str ? str : "", apps[i] );
g_free( str );
}
}
g_strfreev( apps );
}
// update key file - removed
if ( removed )
g_key_file_set_string( file, "Removed Associations", type, removed );
else
g_key_file_remove_key( file, "Removed Associations", type, NULL );
g_free( removed );
// save
data = g_key_file_to_data( file, &len, NULL );
g_key_file_free( file );
save_to_file( path, data, len );
g_free( path );
g_free( data );
}
/*
* Set a column in the map provider table to a new value and mirror the changes
* in the key file. If value is NULL, restore the default value.
*/
void
ph_config_set_map_provider(GtkTreeIter *iter,
guint row,
gint column,
const GValue *value)
{
gchar *name;
gchar *group;
const gchar *key;
g_return_if_fail(ph_config != NULL);
g_return_if_fail(iter != NULL);
g_return_if_fail(column >= 0 && column < PH_MAP_PROVIDER_COLUMN_COUNT);
if (ph_config->map_providers == NULL)
(void) ph_config_get_map_providers();
g_return_if_fail(ph_config->map_providers != NULL);
gtk_tree_model_get(GTK_TREE_MODEL(ph_config->map_providers), iter,
PH_MAP_PROVIDER_COLUMN_NAME, &name, -1);
group = ph_config_get_map_provider_group(name);
key = ph_config_get_map_provider_key(column);
if (value == NULL && row < G_N_ELEMENTS(ph_config_default_map_providers)) {
/* restore default value for built-in provider */
ph_map_provider_to_list_single(&ph_config_default_map_providers[row],
ph_config->map_providers, iter, column);
(void) g_key_file_remove_key(ph_config->key_file, group, key, NULL);
}
else {
GValue target = { 0 };
GType target_type;
target_type = gtk_tree_model_get_column_type(
GTK_TREE_MODEL(ph_config->map_providers), column);
g_value_init(&target, target_type);
if (value == NULL) {
/* restore default value for another provider */
switch (column) {
case PH_MAP_PROVIDER_COLUMN_URL:
g_value_set_static_string(&target, "");
break;
case PH_MAP_PROVIDER_COLUMN_TILE_SIZE:
g_value_set_uint(&target, 256);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_MIN:
g_value_set_uint(&target, 0);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_MAX:
g_value_set_uint(&target, 18);
break;
case PH_MAP_PROVIDER_COLUMN_ZOOM_DETAIL:
g_value_set_uint(&target, 14);
break;
default:
g_warn_if_reached();
}
}
else
/* actually set to a new value */
g_value_transform(value, &target);
gtk_list_store_set_value(ph_config->map_providers, iter,
column, &target);
ph_config_set_value(group, key, &target);
g_value_unset(&target);
}
g_free(name);
g_free(group);
}
int main (int argc, char *argv[])
{
int retval = -1;
int lockfd;
int autologin = -1;
int pause = -1;
int setupterm = -1;
int active = -1;
int nwatch = -1;
int vtnr = -1;
int rtimedir = -1;
gint nseats;
gint seatx;
gchar *cf = NULL;
gchar *sname = NULL;
gchar *username = NULL;
gchar *session_type = NULL;
gchar *pam_defserv = NULL;
gchar *pam_serv = NULL;
gchar *watchx = NULL;
gchar *rtimemode = NULL;
GKeyFile *kf;
GError *error = NULL;
GOptionContext *opts;
GOptionEntry main_entries[] = {
{ "config-file", 'c',
0, G_OPTION_ARG_FILENAME, &cf,
"configuration file name",
NULL },
{ "seat", 's',
0, G_OPTION_ARG_STRING, &sname,
"seat id",
NULL },
{ "username", 'u',
0, G_OPTION_ARG_STRING, &username,
"default user name",
NULL },
{ "autologin", 'a',
0, G_OPTION_ARG_INT, &autologin,
"autologin enable/disable",
NULL },
{ "pause", 'p',
0, G_OPTION_ARG_INT, &pause,
"pause session enable/disable",
NULL },
{ "setupterm", 't',
0, G_OPTION_ARG_INT, &setupterm,
"setup terminal enable/disable",
NULL },
{ "sessiontype", 'd',
0, G_OPTION_ARG_STRING, &session_type,
"session type: can be one of 'unspecified', 'tty', 'x11', 'wayland' \
or 'mir'",
NULL },
{ "active", 'e',
0, G_OPTION_ARG_INT, &active,
"seat activation enable/disable",
NULL },
{ "pamdefserv", 'f',
0, G_OPTION_ARG_STRING, &pam_defserv,
"pam service file for default user",
NULL },
{ "pamserv", 'g',
0, G_OPTION_ARG_STRING, &pam_serv,
"pam service",
NULL },
{ "nwatch", 'h',
0, G_OPTION_ARG_INT, &nwatch,
"number of seat-ready watch items",
NULL },
{ "watchx", 'i',
0, G_OPTION_ARG_STRING, &watchx,
"seat-ready watch item",
NULL },
{ "vtnr", 'j',
0, G_OPTION_ARG_INT, &vtnr,
"virtual terminal number for seat",
NULL },
{ "rtimedir", 'k',
0, G_OPTION_ARG_INT, &rtimedir,
"setup XDG_RUNTIME_DIR for the user - enable/disable",
NULL },
{ "rtimemode", 'm',
0, G_OPTION_ARG_STRING, &rtimemode,
"access mode for the XDG_RUNTIME_DIR",
NULL },
{ NULL }
};
opts = g_option_context_new ("<add|change|remove> [command]");
g_option_context_add_main_entries (opts, main_entries, NULL);
g_option_context_parse (opts, &argc, &argv, NULL);
g_option_context_free (opts);
if (argc < 2) {
printf ("%s [options] <add|change|remove> [command]\n", argv[0]);
return -1;
}
if (!cf)
cf = g_build_filename (TLM_SYSCONF_DIR, "tlm.conf", NULL);
lockfd = open (cf, O_RDWR);
if (lockfd < 0)
g_critical ("open(%s): %s", cf, strerror (errno));
if (lockf (lockfd, F_LOCK, 0))
g_critical ("lockf(): %s", strerror (errno));
kf = g_key_file_new ();
if (!g_key_file_load_from_file (kf, cf,
G_KEY_FILE_KEEP_COMMENTS, &error)) {
g_warning ("failed to load config file: %s", error->message);
goto err_exit;
}
nseats = g_key_file_get_integer (kf,
TLM_CONFIG_GENERAL,
TLM_CONFIG_GENERAL_NSEATS,
NULL);
if (g_strcmp0 (argv[1], "add") == 0) {
seatx = nseats;
nseats++;
sname = g_strdup_printf ("seat%d", seatx);
puts (sname);
}
else if (g_strcmp0 (argv[1], "change") == 0) {
if (!sname) {
g_warning ("no seat specified");
goto err_exit;
}
if (!g_key_file_has_group (kf, sname)) {
g_warning ("given seat doesn't exist");
goto err_exit;
}
}
else if (g_strcmp0 (argv[1], "remove") == 0) {
if (!sname) {
g_warning ("no seat specified");
goto err_exit;
}
if (!g_key_file_has_group (kf, sname)) {
g_warning ("given seat doesn't exist");
goto err_exit;
}
g_key_file_remove_key (kf,
sname,
TLM_CONFIG_GENERAL_SESSION_CMD,
NULL);
autologin = 0;
pause = 1;
}
if (argc >= 3) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_GENERAL_SESSION_CMD,
argv[2]);
}
if (username) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_GENERAL_DEFAULT_USER,
username);
}
if (autologin >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_GENERAL_AUTO_LOGIN,
autologin);
}
if (pause >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_GENERAL_PAUSE_SESSION,
pause);
}
if (setupterm >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_GENERAL_SETUP_TERMINAL,
setupterm);
}
if (pam_serv) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_GENERAL_PAM_SERVICE,
pam_serv);
}
if (pam_defserv) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_GENERAL_DEFAULT_PAM_SERVICE,
pam_defserv);
}
if (active >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_SEAT_ACTIVE,
active);
}
if (session_type) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_GENERAL_SESSION_TYPE,
session_type);
}
if (nwatch >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_SEAT_NWATCH,
nwatch);
}
if (watchx) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_SEAT_WATCHX,
watchx);
}
if (vtnr >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_SEAT_VTNR,
vtnr);
}
if (rtimedir >= 0) {
g_key_file_set_integer (kf,
sname,
TLM_CONFIG_GENERAL_SETUP_RUNTIME_DIR,
rtimedir);
}
if (rtimemode) {
g_key_file_set_string (kf,
sname,
TLM_CONFIG_GENERAL_RUNTIME_MODE,
rtimemode);
}
g_key_file_set_integer (kf,
TLM_CONFIG_GENERAL,
TLM_CONFIG_GENERAL_NSEATS,
nseats);
if (!g_key_file_save_to_file (kf, cf, &error))
g_warning ("failed to save config file: %s", error->message);
retval = 0;
err_exit:
g_free (sname);
g_free (cf);
g_free (session_type);
g_free (pam_defserv);
g_free (pam_serv);
g_free (watchx);
g_free (rtimemode);
g_key_file_free (kf);
if (!lockf (lockfd, F_ULOCK, 0)) {}
close (lockfd);
return retval;
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS,
NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.4.7 otr.warn to enc.warn
err = NULL;
gboolean otr_warn = g_key_file_get_boolean(prefs, PREF_GROUP_UI, "otr.warn", &err);
if (err == NULL) {
g_key_file_set_boolean(prefs, PREF_GROUP_UI, _get_key(PREF_ENC_WARN), otr_warn);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "otr.warn", NULL);
} else {
g_error_free(err);
}
// migrate pre 0.4.7 time settings format
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
if (g_strcmp0(time, "minutes") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "%H:%M");
} else if (g_strcmp0(time, "seconds") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "%H:%M:%S");
} else if (g_strcmp0(time, "off") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time", "");
}
prefs_free_string(time);
}
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time.statusbar", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time.statusbar", NULL);
if (g_strcmp0(time, "minutes") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "%H:%M");
} else if (g_strcmp0(time, "seconds") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "%H:%M:%S");
} else if (g_strcmp0(time, "off") == 0) {
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.statusbar", "");
}
prefs_free_string(time);
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
}
static void
process_one_file (const char *filename,
GError **err)
{
char *new_filename;
GKeyFile *kf = NULL;
GError *rebuild_error;
GSList *tmp;
kf = g_key_file_new ();
if (!g_key_file_load_from_file (kf, filename,
G_KEY_FILE_KEEP_COMMENTS|
G_KEY_FILE_KEEP_TRANSLATIONS,
err)) {
g_key_file_free (kf);
return;
}
if (!desktop_file_fixup (kf, filename)) {
g_key_file_free (kf);
g_set_error (err, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE,
_("Failed to fix the content of the desktop file"));
return;
}
/* Mark file as having been processed by us, so automated
* tools can check that desktop files went through our
* munging
*/
g_key_file_set_string (kf, GROUP_DESKTOP_ENTRY,
"X-Desktop-File-Install-Version", VERSION);
tmp = edit_actions;
while (tmp != NULL)
{
DfuEditAction *action = tmp->data;
switch (action->type)
{
case DFU_SET_KEY:
g_key_file_set_string (kf, GROUP_DESKTOP_ENTRY,
action->key, action->action_value);
dfu_key_file_drop_locale_strings (kf, GROUP_DESKTOP_ENTRY,
action->key);
break;
case DFU_REMOVE_KEY:
g_key_file_remove_key (kf, GROUP_DESKTOP_ENTRY,
action->key, NULL);
dfu_key_file_drop_locale_strings (kf, GROUP_DESKTOP_ENTRY,
action->key);
break;
case DFU_ADD_TO_LIST:
dfu_key_file_merge_list (kf, GROUP_DESKTOP_ENTRY,
action->key, action->action_value);
break;
case DFU_REMOVE_FROM_LIST:
dfu_key_file_remove_list (kf, GROUP_DESKTOP_ENTRY,
action->key, action->action_value);
break;
case DFU_COPY_KEY:
dfu_key_file_copy_key (kf, GROUP_DESKTOP_ENTRY, action->key,
GROUP_DESKTOP_ENTRY, action->action_value);
break;
default:
g_assert_not_reached ();
}
tmp = tmp->next;
}
if (edit_mode)
{
new_filename = g_strdup (filename);
}
else
{
char *basename = g_path_get_basename (filename);
if (vendor_name && !g_str_has_prefix (basename, vendor_name))
{
char *new_base;
new_base = g_strconcat (vendor_name, "-", basename, NULL);
new_filename = g_build_filename (target_dir, new_base, NULL);
g_free (new_base);
}
else
{
new_filename = g_build_filename (target_dir, basename, NULL);
}
g_free (basename);
}
if (!dfu_key_file_to_path (kf, new_filename, err)) {
g_key_file_free (kf);
g_free (new_filename);
return;
}
g_key_file_free (kf);
/* Load and validate the file we just wrote */
if (!desktop_file_validate (new_filename, FALSE, TRUE, TRUE))
{
g_set_error (err, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE,
_("Failed to validate the created desktop file"));
if (!files_are_the_same (filename, new_filename))
g_unlink (new_filename);
g_free (new_filename);
return;
}
if (!edit_mode)
{
if (g_chmod (new_filename, permissions) < 0)
{
g_set_error (err, G_FILE_ERROR,
g_file_error_from_errno (errno),
_("Failed to set permissions %o on \"%s\": %s"),
permissions, new_filename, g_strerror (errno));
if (!files_are_the_same (filename, new_filename))
g_unlink (new_filename);
g_free (new_filename);
return;
}
if (delete_original &&
!files_are_the_same (filename, new_filename))
{
if (g_unlink (filename) < 0)
g_printerr (_("Error removing original file \"%s\": %s\n"),
filename, g_strerror (errno));
}
}
if (rebuild_mime_info_cache)
{
rebuild_error = NULL;
rebuild_cache (target_dir, &rebuild_error);
if (rebuild_error != NULL)
g_propagate_error (err, rebuild_error);
}
g_free (new_filename);
}
/**
* fm_folder_config_remove_key
* @fc: a configuration descriptor
* @key: a key to search
*
* Removes the key and associated data from the cache.
*
* Since: 1.2.0
*/
void fm_folder_config_remove_key(FmFolderConfig *fc, const char *key)
{
fc->changed = TRUE;
g_key_file_remove_key(fc->kf, fc->group, key, NULL);
}
void
prefs_load(void)
{
GError *err;
prefs_loc = _get_preferences_file();
if (g_file_test(prefs_loc, G_FILE_TEST_EXISTS)) {
g_chmod(prefs_loc, S_IRUSR | S_IWUSR);
}
prefs = g_key_file_new();
g_key_file_load_from_file(prefs, prefs_loc, G_KEY_FILE_KEEP_COMMENTS,
NULL);
err = NULL;
log_maxsize = g_key_file_get_integer(prefs, PREF_GROUP_LOGGING, "maxsize", &err);
if (err) {
log_maxsize = 0;
g_error_free(err);
}
// move pre 0.4.8 autoaway.time to autoaway.awaytime
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL)) {
gint time = g_key_file_get_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
g_key_file_set_integer(prefs, PREF_GROUP_PRESENCE, "autoaway.awaytime", time);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.time", NULL);
}
// move pre 0.4.8 autoaway.message to autoaway.awaymessage
if (g_key_file_has_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL)) {
char *message = g_key_file_get_string(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
g_key_file_set_string(prefs, PREF_GROUP_PRESENCE, "autoaway.awaymessage", message);
g_key_file_remove_key(prefs, PREF_GROUP_PRESENCE, "autoaway.message", NULL);
prefs_free_string(message);
}
// migrate pre 0.4.8 time settings
if (g_key_file_has_key(prefs, PREF_GROUP_UI, "time", NULL)) {
char *time = g_key_file_get_string(prefs, PREF_GROUP_UI, "time", NULL);
char *val = NULL;
if (time) {
val = time;
} else {
val = "off";
}
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.console", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.chat", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.muc", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.mucconfig", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.private", val);
g_key_file_set_string(prefs, PREF_GROUP_UI, "time.xmlconsole", val);
g_key_file_remove_key(prefs, PREF_GROUP_UI, "time", NULL);
prefs_free_string(time);
}
_save_prefs();
boolean_choice_ac = autocomplete_new();
autocomplete_add(boolean_choice_ac, "on");
autocomplete_add(boolean_choice_ac, "off");
}
gboolean load_config(const gchar *filename, RaucConfig **config, GError **error)
{
GError *ierror = NULL;
g_autoptr(RaucConfig) c = g_new0(RaucConfig, 1);
gboolean res = FALSE;
g_autoptr(GKeyFile) key_file = NULL;
gchar **groups;
gsize group_count;
GList *slotlist = NULL;
GHashTable *slots = NULL;
GList *l;
gchar *bootloader;
const gchar **pointer;
gboolean dtbvariant;
gchar *variant_data;
key_file = g_key_file_new();
res = g_key_file_load_from_file(key_file, filename, G_KEY_FILE_NONE, &ierror);
if (!res) {
g_propagate_error(error, ierror);
goto free;
}
/* parse [system] section */
c->system_compatible = key_file_consume_string(key_file, "system", "compatible", &ierror);
if (!c->system_compatible) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
bootloader = key_file_consume_string(key_file, "system", "bootloader", NULL);
if (!bootloader) {
g_set_error_literal(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_BOOTLOADER,
"No bootloader selected in system config");
res = FALSE;
goto free;
}
pointer = &supported_bootloaders[0];
while (*pointer) {
if (g_strcmp0(bootloader, *pointer) == 0) {
c->system_bootloader = bootloader;
break;
}
pointer++;
}
if (!c->system_bootloader) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_BOOTLOADER,
"Unsupported bootloader '%s' selected in system config", bootloader);
res = FALSE;
goto free;
}
if (g_strcmp0(c->system_bootloader, "barebox") == 0) {
c->system_bb_statename = key_file_consume_string(key_file, "system", "barebox-statename", NULL);
}
c->max_bundle_download_size = g_key_file_get_uint64(key_file, "system", "max-bundle-download-size", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
g_debug("No value for key \"max-bundle-download-size\" in [system] defined "
"- using default value of %d bytes.", DEFAULT_MAX_BUNDLE_DOWNLOAD_SIZE);
c->max_bundle_download_size = DEFAULT_MAX_BUNDLE_DOWNLOAD_SIZE;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
if (c->max_bundle_download_size == 0) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_MAX_BUNDLE_DOWNLOAD_SIZE,
"Invalid value (%" G_GUINT64_FORMAT ") for key \"max-bundle-download-size\" in system config", c->max_bundle_download_size);
res = FALSE;
goto free;
}
g_key_file_remove_key(key_file, "system", "max-bundle-download-size", NULL);
c->mount_prefix = key_file_consume_string(key_file, "system", "mountprefix", NULL);
if (!c->mount_prefix) {
g_debug("No mount prefix provided, using /mnt/rauc/ as default");
c->mount_prefix = g_strdup("/mnt/rauc/");
}
if (g_strcmp0(c->system_bootloader, "grub") == 0) {
c->grubenv_path = resolve_path(filename,
key_file_consume_string(key_file, "system", "grubenv", NULL));
if (!c->grubenv_path) {
g_debug("No grubenv path provided, using /boot/grub/grubenv as default");
c->grubenv_path = g_strdup("/boot/grub/grubenv");
}
}
c->activate_installed = g_key_file_get_boolean(key_file, "system", "activate-installed", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
c->activate_installed = TRUE;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_key(key_file, "system", "activate-installed", NULL);
c->system_variant_type = R_CONFIG_SYS_VARIANT_NONE;
/* parse 'variant-dtb' key */
dtbvariant = g_key_file_get_boolean(key_file, "system", "variant-dtb", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
dtbvariant = FALSE;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_key(key_file, "system", "variant-dtb", NULL);
if (dtbvariant)
c->system_variant_type = R_CONFIG_SYS_VARIANT_DTB;
/* parse 'variant-file' key */
variant_data = key_file_consume_string(key_file, "system", "variant-file", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
variant_data = NULL;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
if (variant_data) {
if (c->system_variant_type != R_CONFIG_SYS_VARIANT_NONE) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_INVALID_FORMAT,
"Only one of the keys 'variant-file', variant-dtb','variant-name' is allowed");
res = FALSE;
goto free;
}
c->system_variant_type = R_CONFIG_SYS_VARIANT_FILE;
c->system_variant = variant_data;
}
/* parse 'variant-name' key */
variant_data = key_file_consume_string(key_file, "system", "variant-name", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
variant_data = NULL;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
if (variant_data) {
if (c->system_variant_type != R_CONFIG_SYS_VARIANT_NONE) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_INVALID_FORMAT,
"Only one of the keys 'variant-file', variant-dtb','variant-name' is allowed");
res = FALSE;
goto free;
}
c->system_variant_type = R_CONFIG_SYS_VARIANT_NAME;
c->system_variant = variant_data;
}
c->statusfile_path = resolve_path(filename,
key_file_consume_string(key_file, "system", "statusfile", NULL));
if (!check_remaining_keys(key_file, "system", &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_group(key_file, "system", NULL);
/* parse [keyring] section */
c->keyring_path = resolve_path(filename,
key_file_consume_string(key_file, "keyring", "path", NULL));
c->use_bundle_signing_time = g_key_file_get_boolean(key_file, "keyring", "use-bundle-signing-time", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND) ||
g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND)) {
c->use_bundle_signing_time = FALSE;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_key(key_file, "keyring", "use-bundle-signing-time", NULL);
if (!check_remaining_keys(key_file, "keyring", &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_group(key_file, "keyring", NULL);
/* parse [casync] section */
c->store_path = key_file_consume_string(key_file, "casync", "storepath", NULL);
if (!check_remaining_keys(key_file, "casync", &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_group(key_file, "casync", NULL);
/* parse [autoinstall] section */
c->autoinstall_path = resolve_path(filename,
key_file_consume_string(key_file, "autoinstall", "path", NULL));
if (!check_remaining_keys(key_file, "autoinstall", &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_group(key_file, "autoinstall", NULL);
/* parse [handlers] section */
c->systeminfo_handler = resolve_path(filename,
key_file_consume_string(key_file, "handlers", "system-info", NULL));
c->preinstall_handler = resolve_path(filename,
key_file_consume_string(key_file, "handlers", "pre-install", NULL));
c->postinstall_handler = resolve_path(filename,
key_file_consume_string(key_file, "handlers", "post-install", NULL));
if (!check_remaining_keys(key_file, "handlers", &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_group(key_file, "handlers", NULL);
/* parse [slot.*.#] sections */
slots = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, r_free_slot);
groups = g_key_file_get_groups(key_file, &group_count);
for (gsize i = 0; i < group_count; i++) {
RaucSlot *slot = g_new0(RaucSlot, 1);
gchar **groupsplit;
groupsplit = g_strsplit(groups[i], ".", -1);
/* We treat sections starting with "slot." as slots */
if (g_str_equal(groupsplit[0], RAUC_SLOT_PREFIX)) {
gchar* value;
/* Assure slot strings consist of 3 parts, delimited by dots */
if (g_strv_length(groupsplit) != 3) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_INVALID_FORMAT,
"Invalid slot name format: %s", groups[i]);
res = FALSE;
goto free;
}
value = g_strconcat(groupsplit[1], ".", groupsplit[2], NULL);
if (!value) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_INVALID_FORMAT,
"Invalid slot name");
res = FALSE;
goto free;
}
slot->name = g_intern_string(value);
g_free(value);
slot->description = key_file_consume_string(key_file, groups[i], "description", NULL);
if (!slot->description)
slot->description = g_strdup("");
slot->sclass = g_intern_string(groupsplit[1]);
value = resolve_path(filename,
key_file_consume_string(key_file, groups[i], "device", &ierror));
if (!value) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
slot->device = value;
value = key_file_consume_string(key_file, groups[i], "type", NULL);
if (!value)
value = g_strdup("raw");
slot->type = value;
value = key_file_consume_string(key_file, groups[i], "bootname", NULL);
slot->bootname = value;
slot->readonly = g_key_file_get_boolean(key_file, groups[i], "readonly", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
slot->readonly = FALSE;
g_clear_error(&ierror);
} else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_key(key_file, groups[i], "readonly", NULL);
slot->force_install_same = g_key_file_get_boolean(key_file, groups[i], "force-install-same", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
g_clear_error(&ierror);
/* try also deprecatet flag ignore-checksum */
slot->force_install_same = g_key_file_get_boolean(key_file, groups[i], "ignore-checksum", &ierror);
if (g_error_matches(ierror, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND)) {
slot->force_install_same = FALSE;
g_clear_error(&ierror);
}
else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
}
else if (ierror) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_key(key_file, groups[i], "force-install-same", NULL);
g_key_file_remove_key(key_file, groups[i], "ignore-checksum", NULL);
slot->extra_mount_opts = key_file_consume_string(key_file, groups[i], "extra-mount-opts", NULL);
g_hash_table_insert(slots, (gchar*)slot->name, slot);
}
g_strfreev(groupsplit);
}
/* Add parent pointers */
slotlist = g_hash_table_get_keys(slots);
for (l = slotlist; l != NULL; l = l->next) {
RaucSlot *s;
g_autofree gchar* group_name = NULL;
gchar* value;
group_name = g_strconcat(RAUC_SLOT_PREFIX ".", l->data, NULL);
value = key_file_consume_string(key_file, group_name, "parent", NULL);
if (!value) {
g_key_file_remove_group(key_file, group_name, NULL);
continue;
}
s = g_hash_table_lookup(slots, value);
if (!s) {
g_set_error(
error,
R_CONFIG_ERROR,
R_CONFIG_ERROR_PARENT,
"Parent slot '%s' not found!", value);
res = FALSE;
goto free;
}
((RaucSlot*)g_hash_table_lookup(slots, l->data))->parent = s;
if (!check_remaining_keys(key_file, group_name, &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_key_file_remove_group(key_file, group_name, NULL);
}
g_list_free(slotlist);
c->slots = slots;
if (!check_remaining_groups(key_file, &ierror)) {
g_propagate_error(error, ierror);
res = FALSE;
goto free;
}
g_strfreev(groups);
res = TRUE;
free:
if (res)
*config = g_steal_pointer(&c);
else
*config = NULL;
return res;
}
static void
process_one_file (const char *filename,
GError **err)
{
char *new_filename;
char *dirname;
char *basename;
GKeyFile *kf = NULL;
GError *rebuild_error;
GSList *tmp;
kf = g_key_file_new ();
if (!g_key_file_load_from_file (kf, filename,
G_KEY_FILE_KEEP_COMMENTS|
G_KEY_FILE_KEEP_TRANSLATIONS,
err)) {
g_key_file_free (kf);
return;
}
if (!desktop_file_fixup (kf, filename)) {
g_key_file_free (kf);
g_set_error (err, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE,
_("Failed to fix the content of the desktop file"));
return;
}
if (copy_name_to_generic_name)
dfu_key_file_copy_key (kf, GROUP_DESKTOP_ENTRY, "Name",
GROUP_DESKTOP_ENTRY, "GenericName");
if (copy_generic_name_to_name)
dfu_key_file_copy_key (kf, GROUP_DESKTOP_ENTRY, "GenericName",
GROUP_DESKTOP_ENTRY, "Name");
/* Mark file as having been processed by us, so automated
* tools can check that desktop files went through our
* munging
*/
g_key_file_set_string (kf, GROUP_DESKTOP_ENTRY,
"X-Desktop-File-Install-Version", VERSION);
#define PROCESS_LIST(key, added, removed) \
/* Add to the list */ \
tmp = added; \
while (tmp != NULL) \
{ \
dfu_key_file_merge_list (kf, GROUP_DESKTOP_ENTRY, \
key, tmp->data); \
tmp = tmp->next; \
} \
\
/* Remove from the list */ \
tmp = removed; \
while (tmp != NULL) \
{ \
dfu_key_file_remove_list (kf, GROUP_DESKTOP_ENTRY, \
key, tmp->data); \
tmp = tmp->next; \
}
/* Add/remove categories */
PROCESS_LIST ("Categories", added_categories, removed_categories);
/* Add/remove onlyshowin */
PROCESS_LIST ("OnlyShowIn", added_only_show_in, removed_only_show_in);
/* Remove keys */
tmp = removed_keys;
while (tmp != NULL)
{
g_key_file_remove_key (kf, GROUP_DESKTOP_ENTRY, tmp->data, NULL);
tmp = tmp->next;
}
/* Add/remove mime-types */
PROCESS_LIST ("MimeType", added_mime_types, removed_mime_types);
dirname = g_path_get_dirname (filename);
basename = g_path_get_basename (filename);
if (vendor_name && !g_str_has_prefix (basename, vendor_name))
{
char *new_base;
new_base = g_strconcat (vendor_name, "-", basename, NULL);
new_filename = g_build_filename (target_dir, new_base, NULL);
g_free (new_base);
}
else
{
new_filename = g_build_filename (target_dir, basename, NULL);
}
g_free (dirname);
g_free (basename);
if (!dfu_key_file_to_file (kf, new_filename, err)) {
g_key_file_free (kf);
g_free (new_filename);
return;
}
g_key_file_free (kf);
/* Load and validate the file we just wrote */
if (!desktop_file_validate (new_filename, FALSE, TRUE))
{
g_set_error (err, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_PARSE,
_("Failed to validate the created desktop file"));
g_unlink (new_filename);
g_free (new_filename);
return;
}
if (g_chmod (new_filename, permissions) < 0)
{
g_set_error (err, G_FILE_ERROR,
g_file_error_from_errno (errno),
_("Failed to set permissions %o on \"%s\": %s"),
permissions, new_filename, g_strerror (errno));
g_unlink (new_filename);
g_free (new_filename);
return;
}
if (delete_original &&
!files_are_the_same (filename, new_filename))
{
if (g_unlink (filename) < 0)
g_printerr (_("Error removing original file \"%s\": %s\n"),
filename, g_strerror (errno));
}
if (rebuild_mime_info_cache)
{
rebuild_error = NULL;
rebuild_cache (target_dir, &rebuild_error);
if (rebuild_error != NULL)
g_propagate_error (err, rebuild_error);
}
g_free (new_filename);
}
gboolean
ot_admin_builtin_upgrade (int argc, char **argv, OstreeCommandInvocation *invocation, GCancellable *cancellable, GError **error)
{
g_autoptr(GOptionContext) context = g_option_context_new ("");
g_autoptr(OstreeSysroot) sysroot = NULL;
if (!ostree_admin_option_context_parse (context, options, &argc, &argv,
OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER,
invocation, &sysroot, cancellable, error))
return FALSE;
if (opt_pull_only && opt_deploy_only)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Cannot simultaneously specify --pull-only and --deploy-only");
return FALSE;
}
else if (opt_pull_only && opt_reboot)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Cannot simultaneously specify --pull-only and --reboot");
return FALSE;
}
g_autoptr(OstreeSysrootUpgrader) upgrader =
ostree_sysroot_upgrader_new_for_os (sysroot, opt_osname,
cancellable, error);
if (!upgrader)
return FALSE;
g_autoptr(GKeyFile) origin = ostree_sysroot_upgrader_dup_origin (upgrader);
if (origin != NULL)
{
gboolean origin_changed = FALSE;
if (opt_override_commit != NULL)
{
/* Override the commit to pull and deploy. */
g_key_file_set_string (origin, "origin",
"override-commit",
opt_override_commit);
origin_changed = TRUE;
}
else
{
/* Strip any override-commit from the origin file so
* we always upgrade to the latest available commit. */
origin_changed = g_key_file_remove_key (origin, "origin",
"override-commit", NULL);
}
/* Should we consider requiring --discard-hotfix here? */
origin_changed |= g_key_file_remove_key (origin, "origin", "unlocked", NULL);
if (origin_changed)
{
/* XXX GCancellable parameter is not used. */
if (!ostree_sysroot_upgrader_set_origin (upgrader, origin, NULL, error))
return FALSE;
}
}
gboolean changed;
OstreeSysrootUpgraderPullFlags upgraderpullflags = 0;
if (opt_deploy_only)
upgraderpullflags |= OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC;
{ g_auto(GLnxConsoleRef) console = { 0, };
glnx_console_lock (&console);
g_autoptr(OstreeAsyncProgress) progress = NULL;
if (console.is_tty)
progress = ostree_async_progress_new_and_connect (ostree_repo_pull_default_console_progress_changed, &console);
if (opt_allow_downgrade)
upgraderpullflags |= OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER;
if (!ostree_sysroot_upgrader_pull (upgrader, 0, upgraderpullflags,
progress, &changed,
cancellable, error))
{
/* In the pull-only case, we do a cleanup here to ensure that if
* multiple commits were pulled, we garbage collect any old
* partially-pulled intermediate commits before pulling more. This is
* really a best practice in general, but for maximum compatiblity, we
* only do cleanup if a user specifies the new --pull-only option.
* Otherwise, we would break the case of trying to deploy a commit that
* isn't directly referenced.
*/
if (opt_pull_only)
(void) ostree_sysroot_cleanup (sysroot, NULL, NULL);
return FALSE;
}
if (progress)
ostree_async_progress_finish (progress);
}
if (!changed)
{
g_print ("No update available.\n");
}
else
{
if (!opt_pull_only)
{
if (!ostree_sysroot_upgrader_deploy (upgrader, cancellable, error))
return FALSE;
}
if (opt_reboot)
{
if (!ot_admin_execve_reboot (sysroot, error))
return FALSE;
}
}
return TRUE;
}
static GKeyFile *
_eventd_config_process_config_file(GHashTable *config_files, const gchar *id, GKeyFile *config_file)
{
gchar *parent_id;
switch ( libeventd_config_key_file_get_string(config_file, "Event", "Extends", &parent_id) )
{
case 1:
return config_file;
case -1:
return NULL;
case 0:
break;
}
GError *error = NULL;
if ( ! g_key_file_remove_key(config_file, "Event", "Extends", &error) )
{
g_warning("Couldn't clean event file '%s': %s", id, error->message);
g_clear_error(&error);
goto fail;
}
GKeyFile *parent;
parent = g_hash_table_lookup(config_files, parent_id);
if ( parent == NULL )
{
g_warning("Event file '%s' has no parent file '%s'", id, parent_id);
goto fail;
}
if ( ( parent = _eventd_config_process_config_file(config_files, parent_id, parent) ) == NULL )
goto fail;
GString *merged_data;
gchar *data;
data = g_key_file_to_data(parent, NULL, NULL);
merged_data = g_string_new(data);
g_free(data);
data = g_key_file_to_data(config_file, NULL, NULL);
g_string_append(merged_data, data);
g_free(data);
GKeyFile *new_config_file;
new_config_file = g_key_file_new();
if ( g_key_file_load_from_data(new_config_file, merged_data->str, -1, G_KEY_FILE_NONE, &error) )
g_hash_table_insert(config_files, g_strdup(id), new_config_file);
else
{
g_warning("Couldn't merge '%s' and '%s': %s", id, parent_id, error->message);
g_clear_error(&error);
g_key_file_free(new_config_file);
new_config_file = NULL;
}
g_string_free(merged_data, TRUE);
g_free(parent_id);
return new_config_file;
fail:
g_free(parent_id);
return NULL;
}
static gboolean
package_diff_transaction_execute (RpmostreedTransaction *transaction,
GCancellable *cancellable,
GError **error)
{
PackageDiffTransaction *self;
OstreeSysroot *sysroot;
glnx_unref_object OstreeSysrootUpgrader *upgrader = NULL;
glnx_unref_object OstreeAsyncProgress *progress = NULL;
glnx_unref_object OstreeRepo *repo = NULL;
g_autoptr(GKeyFile) origin = NULL;
g_autofree gchar *origin_description = NULL;
OstreeSysrootUpgraderPullFlags upgrader_flags = 0;
gboolean upgrading = FALSE;
gboolean changed = FALSE;
gboolean ret = FALSE;
self = (PackageDiffTransaction *) transaction;
sysroot = rpmostreed_transaction_get_sysroot (transaction);
upgrader = ostree_sysroot_upgrader_new_for_os (sysroot,
self->osname,
cancellable,
error);
if (upgrader == NULL)
goto out;
if (!ostree_sysroot_get_repo (sysroot, &repo, cancellable, error))
goto out;
origin = ostree_sysroot_upgrader_dup_origin (upgrader);
/* Determine if we're upgrading before we set the refspec. */
upgrading = (self->refspec == NULL && self->revision == NULL);
if (self->refspec != NULL)
{
if (!change_upgrader_refspec (sysroot, upgrader,
self->refspec, cancellable,
NULL, NULL, error))
goto out;
}
else if (origin != NULL)
{
self->refspec = g_key_file_get_string (origin, "origin", "refspec", NULL);
if (self->refspec == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Could not find refspec for booted deployment");
}
}
else
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Booted deployment has no origin");
goto out;
}
progress = ostree_async_progress_new ();
rpmostreed_transaction_connect_download_progress (transaction, progress);
rpmostreed_transaction_connect_signature_progress (transaction, repo);
if (self->revision != NULL)
{
g_autofree char *checksum = NULL;
g_autofree char *version = NULL;
upgrader_flags |= OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER;
if (!rpmostreed_parse_revision (self->revision,
&checksum,
&version,
error))
goto out;
if (version != NULL)
{
rpmostreed_transaction_emit_message_printf (transaction,
"Resolving version '%s'",
version);
if (!rpmostreed_repo_lookup_version (repo,
self->refspec,
version,
progress,
cancellable,
&checksum,
error))
goto out;
}
g_key_file_set_string (origin, "origin", "override-commit", checksum);
if (!ostree_sysroot_upgrader_set_origin (upgrader, origin,
cancellable, error))
goto out;
}
else if (upgrading)
{
if (g_key_file_remove_key (origin, "origin", "override-commit", NULL))
{
if (!ostree_sysroot_upgrader_set_origin (upgrader, origin,
cancellable, error))
goto out;
}
}
origin_description = ostree_sysroot_upgrader_get_origin_description (upgrader);
if (origin_description != NULL)
rpmostreed_transaction_emit_message_printf (transaction,
"Updating from: %s",
origin_description);
if (!ostree_sysroot_upgrader_pull_one_dir (upgrader,
"/usr/share/rpm",
0, upgrader_flags,
progress,
&changed,
cancellable,
error))
goto out;
rpmostree_transaction_emit_progress_end (RPMOSTREE_TRANSACTION (transaction));
if (!changed)
{
if (upgrading)
rpmostreed_transaction_emit_message_printf (transaction,
"No upgrade available.");
else
rpmostreed_transaction_emit_message_printf (transaction,
"No change.");
}
ret = TRUE;
out:
return ret;
}
/** \brief User pressed OK. Any changes should be stored in config.
*/
void
sat_pref_refresh_ok (GKeyFile *cfg)
{
if (dirty) {
if (cfg != NULL) {
g_key_file_set_integer (cfg,
MOD_CFG_GLOBAL_SECTION,
MOD_CFG_TIMEOUT_KEY,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dataspin)));
g_key_file_set_integer (cfg,
MOD_CFG_LIST_SECTION,
MOD_CFG_LIST_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (listspin)));
g_key_file_set_integer (cfg,
MOD_CFG_MAP_SECTION,
MOD_CFG_MAP_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (mapspin)));
g_key_file_set_integer (cfg,
MOD_CFG_POLAR_SECTION,
MOD_CFG_POLAR_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (polarspin)));
g_key_file_set_integer (cfg,
MOD_CFG_SINGLE_SAT_SECTION,
MOD_CFG_SINGLE_SAT_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (singlespin)));
}
else {
sat_cfg_set_int (SAT_CFG_INT_MODULE_TIMEOUT,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dataspin)));
sat_cfg_set_int (SAT_CFG_INT_LIST_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (listspin)));
sat_cfg_set_int (SAT_CFG_INT_MAP_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (mapspin)));
sat_cfg_set_int (SAT_CFG_INT_POLAR_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (polarspin)));
sat_cfg_set_int (SAT_CFG_INT_SINGLE_SAT_REFRESH,
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (singlespin)));
}
}
else if (reset) {
/* we have to reset the values to global or default settings */
if (cfg == NULL) {
/* reset values in sat-cfg */
sat_cfg_reset_int (SAT_CFG_INT_MODULE_TIMEOUT);
sat_cfg_reset_int (SAT_CFG_INT_LIST_REFRESH);
sat_cfg_reset_int (SAT_CFG_INT_MAP_REFRESH);
sat_cfg_reset_int (SAT_CFG_INT_POLAR_REFRESH);
sat_cfg_reset_int (SAT_CFG_INT_SINGLE_SAT_REFRESH);
}
else {
/* remove keys */
g_key_file_remove_key ((GKeyFile *)(cfg),
MOD_CFG_GLOBAL_SECTION,
MOD_CFG_TIMEOUT_KEY,
NULL);
g_key_file_remove_key ((GKeyFile *)(cfg),
MOD_CFG_LIST_SECTION,
MOD_CFG_LIST_REFRESH,
NULL);
g_key_file_remove_key ((GKeyFile *)(cfg),
MOD_CFG_MAP_SECTION,
MOD_CFG_MAP_REFRESH,
NULL);
g_key_file_remove_key ((GKeyFile *)(cfg),
MOD_CFG_POLAR_SECTION,
MOD_CFG_POLAR_REFRESH,
NULL);
g_key_file_remove_key ((GKeyFile *)(cfg),
MOD_CFG_SINGLE_SAT_SECTION,
MOD_CFG_SINGLE_SAT_REFRESH,
NULL);
}
}
dirty = FALSE;
reset = FALSE;
}
static void
add_config_file (GoaDaemon *daemon,
const gchar *path,
GHashTable *group_name_to_key_file_data,
GList **key_files_to_free)
{
GKeyFile *key_file;
GError *error;
key_file = g_key_file_new ();
error = NULL;
if (!g_key_file_load_from_file (key_file,
path,
G_KEY_FILE_NONE,
&error))
{
if (!(error->domain == G_FILE_ERROR && error->code == G_FILE_ERROR_NOENT))
{
g_warning ("Error loading %s: %s (%s, %d)",
path,
error->message, g_quark_to_string (error->domain), error->code);
}
g_error_free (error);
g_key_file_free (key_file);
}
else
{
gchar **groups;
const char *guid;
gsize num_groups;
guint n;
guid = g_dbus_connection_get_guid (daemon->connection);
groups = g_key_file_get_groups (key_file, &num_groups);
for (n = 0; n < num_groups; n++)
{
if (g_str_has_prefix (groups[n], "Account "))
{
gboolean is_temporary;
char *session_id;
is_temporary = g_key_file_get_boolean (key_file,
groups[n],
"IsTemporary",
NULL);
if (is_temporary)
{
session_id = g_key_file_get_string (key_file,
groups[n],
"SessionId",
NULL);
/* discard temporary accounts from older sessions */
if (session_id != NULL &&
g_strcmp0 (session_id, guid) != 0)
{
g_debug ("ignoring account \"%s\" in file %s because it's stale",
groups[n], path);
g_free (groups[n]);
g_free (session_id);
continue;
}
g_free (session_id);
}
else
{
g_key_file_remove_key (key_file, groups[n], "SessionId", NULL);
}
g_hash_table_insert (group_name_to_key_file_data,
groups[n], /* steals string */
key_file_data_new (key_file, path));
}
else
{
g_warning ("Unexpected group \"%s\" in file %s", groups[n], path);
g_free (groups[n]);
}
}
g_free (groups);
*key_files_to_free = g_list_prepend (*key_files_to_free, key_file);
}
}
static void
write_setting_value (NMSetting *setting,
const char *key,
const GValue *value,
GParamFlags flag,
gpointer user_data)
{
GKeyFile *file = (GKeyFile *) user_data;
const char *setting_name;
GType type = G_VALUE_TYPE (value);
KeyWriter *writer = &key_writers[0];
GParamSpec *pspec;
/* Setting name gets picked up from the keyfile's section name instead */
if (!strcmp (key, NM_SETTING_NAME))
return;
/* Don't write the NMSettingConnection object's 'read-only' property */
if ( NM_IS_SETTING_CONNECTION (setting)
&& !strcmp (key, NM_SETTING_CONNECTION_READ_ONLY))
return;
setting_name = nm_setting_get_name (setting);
/* If the value is the default value, remove the item from the keyfile */
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), key);
if (pspec) {
if (g_param_value_defaults (pspec, (GValue *) value)) {
g_key_file_remove_key (file, setting_name, key, NULL);
return;
}
}
/* Look through the list of handlers for non-standard format key values */
while (writer->setting_name) {
if (!strcmp (writer->setting_name, setting_name) && !strcmp (writer->key, key)) {
(*writer->writer) (file, setting, key, value);
return;
}
writer++;
}
if (type == G_TYPE_STRING) {
const char *str;
str = g_value_get_string (value);
if (str)
g_key_file_set_string (file, setting_name, key, str);
} else if (type == G_TYPE_UINT)
g_key_file_set_integer (file, setting_name, key, (int) g_value_get_uint (value));
else if (type == G_TYPE_INT)
g_key_file_set_integer (file, setting_name, key, g_value_get_int (value));
else if (type == G_TYPE_UINT64) {
char *numstr;
numstr = g_strdup_printf ("%" G_GUINT64_FORMAT, g_value_get_uint64 (value));
g_key_file_set_value (file, setting_name, key, numstr);
g_free (numstr);
} else if (type == G_TYPE_BOOLEAN) {
g_key_file_set_boolean (file, setting_name, key, g_value_get_boolean (value));
} else if (type == G_TYPE_CHAR) {
g_key_file_set_integer (file, setting_name, key, (int) g_value_get_char (value));
} else if (type == DBUS_TYPE_G_UCHAR_ARRAY) {
GByteArray *array;
array = (GByteArray *) g_value_get_boxed (value);
if (array && array->len > 0) {
int *tmp_array;
int i;
tmp_array = g_new (gint, array->len);
for (i = 0; i < array->len; i++)
tmp_array[i] = (int) array->data[i];
g_key_file_set_integer_list (file, setting_name, key, tmp_array, array->len);
g_free (tmp_array);
}
} else if (type == DBUS_TYPE_G_LIST_OF_STRING) {
GSList *list;
GSList *iter;
list = (GSList *) g_value_get_boxed (value);
if (list) {
char **array;
int i = 0;
array = g_new (char *, g_slist_length (list));
for (iter = list; iter; iter = iter->next)
array[i++] = iter->data;
g_key_file_set_string_list (file, setting_name, key, (const gchar **const) array, i);
g_free (array);
}
} else if (type == DBUS_TYPE_G_MAP_OF_STRING) {
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));
}
