static void pk_backend_refresh_cache_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar *tmp_dir_name, *db_err, *path = NULL;
gint ret;
gboolean force;
GSList *file_list = NULL, *l;
GFile *db_file = NULL;
GFileInfo *file_info = NULL;
GError *err = NULL;
sqlite3_stmt *stmt = NULL;
PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_CHANGELOG);
/* Create temporary directory */
tmp_dir_name = g_dir_make_tmp("PackageKit.XXXXXX", &err);
if (!tmp_dir_name) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_INTERNAL_ERROR, "%s", err->message);
g_error_free(err);
return;
}
g_variant_get(params, "(b)", &force);
/* Force the complete cache refresh if the read configuration file is newer than the metadata cache */
if (!force) {
path = g_build_filename(LOCALSTATEDIR, "cache", "PackageKit", "metadata", "metadata.db", NULL);
db_file = g_file_new_for_path(path);
file_info = g_file_query_info(db_file, "time::modified-usec", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, NULL, &err);
if (err) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "%s: %s", path, err->message);
g_error_free(err);
goto out;
}
ret = sqlite3_prepare_v2(job_data->db,
"SELECT value FROM cache_info WHERE key LIKE 'last_modification'",
-1,
&stmt,
NULL);
if ((ret != SQLITE_OK) || ((ret = sqlite3_step(stmt)) != SQLITE_ROW)) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "%s: %s", path, sqlite3_errstr(ret));
goto out;
}
if ((guint32) sqlite3_column_int(stmt, 0) > g_file_info_get_attribute_uint32(file_info, "time::modified-usec"))
force = TRUE;
}
if (force) { /* It should empty all tables */
if (sqlite3_exec(job_data->db, "DELETE FROM repos", NULL, 0, &db_err) != SQLITE_OK) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_INTERNAL_ERROR, "%s", db_err);
sqlite3_free(db_err);
goto out;
}
}
for (l = repos; l; l = g_slist_next(l)) /* Get list of files that should be downloaded */
file_list = g_slist_concat(file_list, katja_pkgtools_collect_cache_info(l->data, tmp_dir_name));
/* Download repository */
pk_backend_job_set_status(job, PK_STATUS_ENUM_DOWNLOAD_REPOSITORY);
for (l = file_list; l; l = g_slist_next(l))
katja_get_file(&job_data->curl, ((gchar **)l->data)[0], ((gchar **)l->data)[1]);
g_slist_free_full(file_list, (GDestroyNotify)g_strfreev);
/* Refresh cache */
pk_backend_job_set_status(job, PK_STATUS_ENUM_REFRESH_CACHE);
for (l = repos; l; l = g_slist_next(l))
katja_pkgtools_generate_cache(l->data, job, tmp_dir_name);
out:
sqlite3_finalize(stmt);
if (file_info)
g_object_unref(file_info);
if (db_file)
g_object_unref(db_file);
g_free(path);
pk_directory_remove_contents(tmp_dir_name);
g_rmdir(tmp_dir_name);
g_free(tmp_dir_name);
}
static void
download_track (RBMtpThread *thread, RBMtpThreadTask *task)
{
LIBMTP_file_t *fileinfo;
LIBMTP_error_t *stack;
GError *error = NULL;
GFile *dir;
RBMtpDownloadCallback cb = (RBMtpDownloadCallback) task->callback;
/* first, check there's enough space to copy it */
fileinfo = LIBMTP_Get_Filemetadata (thread->device, task->track_id);
if (fileinfo == NULL) {
stack = LIBMTP_Get_Errorstack (thread->device);
rb_debug ("unable to get track metadata for %u: %s", task->track_id, stack->error_text);
error = g_error_new (RB_MTP_THREAD_ERROR,
RB_MTP_THREAD_ERROR_GET_TRACK,
_("Unable to copy file from MTP device: %s"),
stack->error_text);
LIBMTP_Clear_Errorstack (thread->device);
cb (task->track_id, NULL, error, task->user_data);
g_error_free (error);
return;
}
if (task->filename[0] == '\0') {
dir = g_file_new_for_path (g_get_tmp_dir ());
} else {
GFile *file = g_file_new_for_path (task->filename);
dir = g_file_get_parent (file);
g_object_unref (file);
}
rb_debug ("checking for %" G_GINT64_FORMAT " bytes available", fileinfo->filesize);
if (rb_check_dir_has_space (dir, fileinfo->filesize) == FALSE) {
char *dpath = g_file_get_path (dir);
rb_debug ("not enough space in %s", dpath);
error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_NO_SPACE,
_("Not enough space in %s"), dpath);
g_free (dpath);
}
LIBMTP_destroy_file_t (fileinfo);
g_object_unref (dir);
if (error != NULL) {
rb_debug ("bailing out due to error: %s", error->message);
cb (task->track_id, NULL, error, task->user_data);
g_error_free (error);
return;
}
if (task->filename[0] == '\0') {
/* download to a temporary file */
int fd;
GError *tmperror = NULL;
g_free (task->filename);
fd = g_file_open_tmp ("rb-mtp-temp-XXXXXX", &task->filename, &tmperror);
if (fd == -1) {
rb_debug ("unable to open temporary file: %s", tmperror->message);
error = g_error_new (RB_MTP_THREAD_ERROR,
RB_MTP_THREAD_ERROR_TEMPFILE,
_("Unable to open temporary file: %s"),
tmperror->message);
g_error_free (tmperror);
cb (task->track_id, NULL, error, task->user_data);
g_error_free (error);
return;
} else {
rb_debug ("downloading track %u to file descriptor %d", task->track_id, fd);
if (LIBMTP_Get_Track_To_File_Descriptor (thread->device, task->track_id, fd, NULL, NULL)) {
stack = LIBMTP_Get_Errorstack (thread->device);
rb_debug ("unable to retrieve track %u: %s", task->track_id, stack->error_text);
error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK,
_("Unable to copy file from MTP device: %s"),
stack->error_text);
LIBMTP_Clear_Errorstack (thread->device);
cb (task->track_id, NULL, error, task->user_data);
g_error_free (error);
close (fd);
remove (task->filename);
return;
}
rb_debug ("done downloading track");
close (fd);
}
} else {
if (LIBMTP_Get_Track_To_File (thread->device, task->track_id, task->filename, NULL, NULL)) {
stack = LIBMTP_Get_Errorstack (thread->device);
error = g_error_new (RB_MTP_THREAD_ERROR, RB_MTP_THREAD_ERROR_GET_TRACK,
_("Unable to copy file from MTP device: %s"),
stack->error_text);
LIBMTP_Clear_Errorstack (thread->device);
cb (task->track_id, NULL, error, task->user_data);
g_error_free (error);
return;
}
}
cb (task->track_id, task->filename, NULL, task->user_data);
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
CdUtilPrivate *priv;
gboolean ret = TRUE;
gboolean verbose = FALSE;
guint retval = 1;
g_autoptr(GError) error = NULL;
g_autofree gchar *cmd_descriptions = NULL;
g_autofree gchar *locale = NULL;
g_autoptr(GFile) file = NULL;
const GOptionEntry options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
/* TRANSLATORS: command line option */
_("Show extra debugging information"), NULL },
{ "locale", '\0', 0, G_OPTION_ARG_STRING, &locale,
/* TRANSLATORS: command line option */
_("The locale to use when setting localized text"), NULL },
{ NULL}
};
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
cmsSetLogErrorHandler (cd_util_lcms_error_cb);
/* create helper object */
priv = g_new0 (CdUtilPrivate, 1);
priv->rewrite_file = TRUE;
priv->client = cd_client_new ();
/* add commands */
priv->cmd_array = g_ptr_array_new_with_free_func ((GDestroyNotify) cd_util_item_free);
cd_util_add (priv->cmd_array,
"extract-vcgt",
/* TRANSLATORS: command description */
_("Generate the VCGT calibration of a given size"),
cd_util_extract_vcgt);
cd_util_add (priv->cmd_array,
"md-clear",
/* TRANSLATORS: command description */
_("Clear any metadata in the profile"),
cd_util_clear_metadata);
cd_util_add (priv->cmd_array,
"md-init",
/* TRANSLATORS: command description */
_("Initialize any metadata for the profile"),
cd_util_init_metadata);
cd_util_add (priv->cmd_array,
"md-add",
/* TRANSLATORS: command description */
_("Add a metadata item to the profile"),
cd_util_add_metadata);
cd_util_add (priv->cmd_array,
"md-remove",
/* TRANSLATORS: command description */
_("Remove a metadata item from the profile"),
cd_util_remove_metadata);
cd_util_add (priv->cmd_array,
"set-copyright",
/* TRANSLATORS: command description */
_("Sets the copyright string"),
cd_util_set_copyright);
cd_util_add (priv->cmd_array,
"set-description",
/* TRANSLATORS: command description */
_("Sets the description string"),
cd_util_set_description);
cd_util_add (priv->cmd_array,
"set-manufacturer",
/* TRANSLATORS: command description */
_("Sets the manufacturer string"),
cd_util_set_manufacturer);
cd_util_add (priv->cmd_array,
"set-model",
/* TRANSLATORS: command description */
_("Sets the model string"),
cd_util_set_model);
cd_util_add (priv->cmd_array,
"md-fix",
/* TRANSLATORS: command description */
_("Automatically fix metadata in the profile"),
cd_util_set_fix_metadata);
cd_util_add (priv->cmd_array,
"set-version",
/* TRANSLATORS: command description */
_("Set the ICC profile version"),
cd_util_set_version);
cd_util_add (priv->cmd_array,
"export-tag-data",
/* TRANSLATORS: command description */
_("Export the tag data"),
cd_util_export_tag_data);
/* sort by command name */
g_ptr_array_sort (priv->cmd_array,
(GCompareFunc) cd_sort_command_name_cb);
/* get a list of the commands */
priv->context = g_option_context_new (NULL);
cmd_descriptions = cd_util_get_descriptions (priv->cmd_array);
g_option_context_set_summary (priv->context, cmd_descriptions);
/* TRANSLATORS: program name */
g_set_application_name (_("Color Management"));
g_option_context_add_main_entries (priv->context, options, NULL);
ret = g_option_context_parse (priv->context, &argc, &argv, &error);
if (!ret) {
/* TRANSLATORS: the user didn't read the man page */
g_print ("%s: %s\n", _("Failed to parse arguments"),
error->message);
goto out;
}
/* use explicit locale */
priv->locale = g_strdup (locale);
/* set verbose? */
if (verbose) {
g_setenv ("COLORD_VERBOSE", "1", FALSE);
} else {
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
cd_util_ignore_cb, NULL);
}
/* the first option is always the filename */
if (argc < 2) {
g_print ("%s\n", "Filename must be the first argument");
goto out;
}
/* open file */
file = g_file_new_for_path (argv[1]);
priv->icc = cd_icc_new ();
ret = cd_icc_load_file (priv->icc,
file,
CD_ICC_LOAD_FLAGS_ALL,
NULL,
&error);
if (!ret) {
g_print ("%s\n", error->message);
goto out;
}
/* run the specified command */
ret = cd_util_run (priv, argv[2], (gchar**) &argv[2], &error);
if (!ret) {
g_print ("%s\n", error->message);
goto out;
}
/* save file */
if (priv->rewrite_file) {
ret = cd_icc_save_file (priv->icc,
file,
CD_ICC_SAVE_FLAGS_NONE,
NULL,
&error);
if (!ret) {
g_print ("%s\n", error->message);
goto out;
}
}
/* success */
retval = 0;
out:
if (priv != NULL) {
if (priv->cmd_array != NULL)
g_ptr_array_unref (priv->cmd_array);
g_option_context_free (priv->context);
if (priv->icc != NULL)
g_object_unref (priv->icc);
g_object_unref (priv->client);
g_free (priv->locale);
g_free (priv);
}
return retval;
}
static GtkWidget *
panel_place_menu_item_create_menu (PanelPlaceMenuItem *place_item)
{
GtkWidget *places_menu;
GtkWidget *item;
char *gsettings_name = NULL;
char *name;
char *uri;
GFile *file;
places_menu = panel_create_menu ();
file = g_file_new_for_path (g_get_home_dir ());
uri = g_file_get_uri (file);
name = panel_util_get_label_for_uri (uri);
g_object_unref (file);
panel_menu_items_append_place_item (PANEL_ICON_HOME, NULL,
name,
_("Open your personal folder"),
places_menu,
G_CALLBACK (activate_home_uri),
uri);
g_free (name);
g_free (uri);
if (!place_item->priv->caja_prefs_settings ||
!g_settings_get_boolean (place_item->priv->caja_prefs_settings,
CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY)) {
file = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP));
uri = g_file_get_uri (file);
g_object_unref (file);
panel_menu_items_append_place_item (
PANEL_ICON_DESKTOP, NULL,
/* Translators: Desktop is used here as in
* "Desktop Folder" (this is not the Desktop
* environment). */
C_("Desktop Folder", "Desktop"),
_("Open the contents of your desktop in a folder"),
places_menu,
G_CALLBACK (activate_desktop_uri),
/* FIXME: if the dir changes, we'd need to update the drag data since the uri is not the same */
uri);
g_free (uri);
}
panel_place_menu_item_append_gtk_bookmarks (places_menu, g_settings_get_uint (place_item->priv->menubar_settings, PANEL_MENU_BAR_MAX_ITEMS_OR_SUBMENU));
add_menu_separator (places_menu);
if (place_item->priv->caja_desktop_settings != NULL)
gsettings_name = g_settings_get_string (place_item->priv->caja_desktop_settings,
CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY);
if (PANEL_GLIB_STR_EMPTY (gsettings_name))
gsettings_name = g_strdup (_("Computer"));
panel_menu_items_append_place_item (
PANEL_ICON_COMPUTER, NULL,
gsettings_name,
_("Browse all local and remote disks and folders accessible from this computer"),
places_menu,
G_CALLBACK (activate_uri),
"computer://");
if (gsettings_name)
g_free (gsettings_name);
panel_place_menu_item_append_local_gio (place_item, places_menu);
add_menu_separator (places_menu);
panel_menu_items_append_place_item (
PANEL_ICON_NETWORK, NULL,
_("Network"),
_("Browse bookmarked and local network locations"),
places_menu,
G_CALLBACK (activate_uri),
"network://");
panel_place_menu_item_append_remote_gio (place_item, places_menu);
if (panel_is_program_in_path ("caja-connect-server") ||
panel_is_program_in_path ("nautilus-connect-server") ||
panel_is_program_in_path ("nemo-connect-server")) {
item = panel_menu_items_create_action_item (PANEL_ACTION_CONNECT_SERVER);
if (item != NULL)
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu),
item);
}
add_menu_separator (places_menu);
if (panel_is_program_in_path ("mate-search-tool"))
panel_menu_items_append_from_desktop (places_menu,
"mate-search-tool.desktop",
NULL,
FALSE);
else
panel_menu_items_append_from_desktop (places_menu,
"gnome-search-tool.desktop",
NULL,
FALSE);
panel_recent_append_documents_menu (places_menu,
place_item->priv->recent_manager);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
GtkWidget *toplevel = gtk_widget_get_toplevel (places_menu);
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
return places_menu;
}
/* Setting '/theme' changed either at widget or at xfconf property */
static void _xfdashboard_settings_widget_changed_theme(XfdashboardSettings *self, GtkTreeSelection *inSelection)
{
XfdashboardSettingsPrivate *priv;
GtkTreeModel *model;
GtkTreeIter iter;
gchar *themeDisplayName;
gchar *themeComment;
gchar *themeAuthor;
gchar *themeVersion;
gchar *themeScreenshot;
gchar *themeFilename;
gchar *themeName;
g_return_if_fail(XFDASHBOARD_IS_SETTINGS(self));
g_return_if_fail(GTK_IS_TREE_SELECTION(inSelection));
priv=self->priv;
themeDisplayName=NULL;
themeComment=NULL;
themeAuthor=NULL;
themeVersion=NULL;
themeScreenshot=NULL;
themeFilename=NULL;
themeName=NULL;
/* Get selected entry from widget */
if(gtk_tree_selection_get_selected(inSelection, &model, &iter))
{
/* Get data from model */
gtk_tree_model_get(model,
&iter,
COLUMN_THEME_NAME, &themeName,
COLUMN_THEME_FILE, &themeFilename,
COLUMN_THEME_DISPLAY_NAME, &themeDisplayName,
COLUMN_THEME_DESCRIPTION, &themeComment,
COLUMN_THEME_AUTHORS, &themeAuthor,
COLUMN_THEME_VERSION, &themeVersion,
COLUMN_THEME_SCREENSHOTS, &themeScreenshot,
-1);
}
/* Set text in labels */
if(themeDisplayName)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeName), themeDisplayName);
gtk_widget_show(priv->widgetThemeName);
gtk_widget_show(priv->widgetThemeNameLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeName);
gtk_widget_hide(priv->widgetThemeNameLabel);
}
if(themeComment)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeDescription), themeComment);
gtk_widget_show(priv->widgetThemeDescription);
gtk_widget_show(priv->widgetThemeDescriptionLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeDescription);
gtk_widget_hide(priv->widgetThemeDescriptionLabel);
}
if(themeAuthor)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeAuthor), themeAuthor);
gtk_widget_show(priv->widgetThemeAuthor);
gtk_widget_show(priv->widgetThemeAuthorLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeAuthor);
gtk_widget_hide(priv->widgetThemeAuthorLabel);
}
if(themeVersion)
{
gtk_label_set_text(GTK_LABEL(priv->widgetThemeVersion), themeVersion);
gtk_widget_show(priv->widgetThemeVersion);
gtk_widget_show(priv->widgetThemeVersionLabel);
}
else
{
gtk_widget_hide(priv->widgetThemeVersion);
gtk_widget_hide(priv->widgetThemeVersionLabel);
}
/* Set screenshot */
if(themeScreenshot)
{
gchar *screenshotFile;
GdkPixbuf *screenshotImage;
screenshotFile=NULL;
screenshotImage=NULL;
/* Get screenshot file but resolve relative path if needed */
if(!g_path_is_absolute(themeScreenshot))
{
GFile *file;
GFile *parentPath;
gchar *themePath;
file=NULL;
parentPath=NULL;
themePath=NULL;
/* Resolve relative path relative to theme path */
file=g_file_new_for_path(themeFilename);
if(file) parentPath=g_file_get_parent(file);
if(parentPath) themePath=g_file_get_path(parentPath);
if(themePath) screenshotFile=g_build_filename(themePath, themeScreenshot, NULL);
/* Release allocated resources */
if(themePath) g_free(themePath);
if(parentPath) g_object_unref(parentPath);
if(file) g_object_unref(file);
}
else
{
/* Path is absolute so just create a copy */
screenshotFile=g_strdup(themeScreenshot);
}
/* If screenshot file exists set up and show image
* otherwise hide image.
*/
if(screenshotFile &&
g_file_test(screenshotFile, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
{
GError *error;
gint width;
gint height;
error=NULL;
/* Check if screenshot fits into widget without scaling or
* scale it to maximum size but preserve aspect ratio.
*/
if(gdk_pixbuf_get_file_info(screenshotFile, &width, &height))
{
if(width<MAX_SCREENSHOT_WIDTH)
{
screenshotImage=gdk_pixbuf_new_from_file(screenshotFile,
&error);
}
else
{
screenshotImage=gdk_pixbuf_new_from_file_at_scale(screenshotFile,
MAX_SCREENSHOT_WIDTH,
-1,
TRUE,
&error);
}
if(error)
{
g_warning("Could not load screenshot: %s",
error ? error->message : _("Unknown error"));
/* Release allocated resources */
if(error) g_error_free(error);
if(screenshotImage)
{
g_object_unref(screenshotImage);
screenshotImage=NULL;
}
}
}
}
if(screenshotImage)
{
gtk_image_set_from_pixbuf(GTK_IMAGE(priv->widgetThemeScreenshot), screenshotImage);
gtk_widget_show(priv->widgetThemeScreenshot);
}
else
{
gtk_widget_hide(priv->widgetThemeScreenshot);
}
/* Release allocated resources */
if(screenshotImage) g_object_unref(screenshotImage);
if(screenshotFile) g_free(screenshotFile);
}
else
{
gtk_widget_hide(priv->widgetThemeScreenshot);
}
/* Set value at xfconf property if it must be changed */
if(themeName)
{
gchar *currentTheme;
currentTheme=xfconf_channel_get_string(priv->xfconfChannel, "/theme", DEFAULT_THEME);
if(g_strcmp0(currentTheme, themeName))
{
xfconf_channel_set_string(priv->xfconfChannel, "/theme", themeName);
}
g_free(currentTheme);
}
/* Release allocated resources */
if(themeDisplayName) g_free(themeDisplayName);
if(themeComment) g_free(themeComment);
if(themeAuthor) g_free(themeAuthor);
if(themeVersion) g_free(themeVersion);
if(themeScreenshot) g_free(themeScreenshot);
if(themeFilename) g_free(themeFilename);
if(themeName) g_free(themeName);
}
gboolean
ostree_option_context_parse (GOptionContext *context,
const GOptionEntry *main_entries,
int *argc,
char ***argv,
OstreeBuiltinFlags flags,
OstreeRepo **out_repo,
GCancellable *cancellable,
GError **error)
{
glnx_unref_object OstreeRepo *repo = NULL;
gboolean success = FALSE;
/* Entries are listed in --help output in the order added. We add the
* main entries ourselves so that we can add the --repo entry first. */
if (!(flags & OSTREE_BUILTIN_FLAG_NO_REPO))
g_option_context_add_main_entries (context, repo_entry, NULL);
if (main_entries != NULL)
g_option_context_add_main_entries (context, main_entries, NULL);
g_option_context_add_main_entries (context, global_entries, NULL);
if (!g_option_context_parse (context, argc, argv, error))
return FALSE;
if (opt_version)
{
g_print ("%s\n %s\n", PACKAGE_STRING, OSTREE_FEATURES);
exit (EXIT_SUCCESS);
}
if (opt_verbose)
g_log_set_handler (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, message_handler, NULL);
if (opt_repo == NULL && !(flags & OSTREE_BUILTIN_FLAG_NO_REPO))
{
GError *local_error = NULL;
repo = ostree_repo_new_default ();
if (!ostree_repo_open (repo, cancellable, &local_error))
{
if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_autofree char *help = NULL;
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Command requires a --repo argument");
g_error_free (local_error);
help = g_option_context_get_help (context, FALSE, NULL);
g_printerr ("%s", help);
}
else
{
g_propagate_error (error, local_error);
}
goto out;
}
}
else if (opt_repo != NULL)
{
g_autoptr(GFile) repo_file = g_file_new_for_path (opt_repo);
repo = ostree_repo_new (repo_file);
if (!(flags & OSTREE_BUILTIN_FLAG_NO_CHECK))
{
if (!ostree_repo_open (repo, cancellable, error))
goto out;
}
}
if (out_repo)
*out_repo = g_steal_pointer (&repo);
success = TRUE;
out:
return success;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[2];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
GError *error = NULL;
INIT_I18N ();
gegl_init (NULL, NULL);
run_mode = param[0].data.d_int32;
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0)
{
const gchar *filename = param[1].data.d_string;
TIFF *tif;
tif = tiff_open (filename, "r", &error);
if (tif)
{
TiffSelectedPages pages;
pages.target = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
gimp_get_data (LOAD_PROC, &pages.target);
pages.n_pages = pages.o_pages = TIFFNumberOfDirectories (tif);
if (pages.n_pages == 0)
{
g_set_error (&error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("TIFF '%s' does not contain any directories"),
gimp_filename_to_utf8 (filename));
status = GIMP_PDB_EXECUTION_ERROR;
}
else
{
gboolean run_it = FALSE;
gint i;
if (run_mode != GIMP_RUN_INTERACTIVE)
{
pages.pages = g_new (gint, pages.n_pages);
for (i = 0; i < pages.n_pages; i++)
pages.pages[i] = i;
run_it = TRUE;
}
else
{
gimp_ui_init (PLUG_IN_BINARY, FALSE);
}
if (pages.n_pages == 1)
{
pages.pages = g_new0 (gint, pages.n_pages);
pages.target = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
run_it = TRUE;
}
if ((! run_it) && (run_mode == GIMP_RUN_INTERACTIVE))
run_it = load_dialog (tif, LOAD_PROC, &pages);
if (run_it)
{
gint32 image;
gboolean resolution_loaded = FALSE;
gimp_set_data (LOAD_PROC,
&pages.target, sizeof (pages.target));
image = load_image (param[1].data.d_string, tif, &pages,
&resolution_loaded,
&error);
g_free (pages.pages);
if (image > 0)
{
GFile *file;
GimpMetadata *metadata;
file = g_file_new_for_path (param[1].data.d_string);
metadata = gimp_image_metadata_load_prepare (image,
"image/tiff",
file, NULL);
if (metadata)
{
GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL;
if (resolution_loaded)
flags &= ~GIMP_METADATA_LOAD_RESOLUTION;
gimp_image_metadata_load_finish (image, "image/tiff",
metadata, flags,
run_mode == GIMP_RUN_INTERACTIVE);
g_object_unref (metadata);
}
g_object_unref (file);
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else
{
status = GIMP_PDB_CANCEL;
}
}
TIFFClose (tif);
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else if ((strcmp (name, SAVE_PROC) == 0) ||
(strcmp (name, SAVE2_PROC) == 0))
{
/* Plug-in is either file_tiff_save or file_tiff_save2 */
GimpMetadata *metadata;
GimpMetadataSaveFlags metadata_flags;
GimpParasite *parasite;
gint32 image = param[1].data.d_int32;
gint32 drawable = param[2].data.d_int32;
gint32 orig_image = image;
GimpExportReturn export = GIMP_EXPORT_CANCEL;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image, &drawable, "TIFF",
GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_GRAY |
GIMP_EXPORT_CAN_HANDLE_INDEXED |
GIMP_EXPORT_CAN_HANDLE_ALPHA);
if (export == GIMP_EXPORT_CANCEL)
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
int
rpmostree_compose_builtin_tree (int argc,
char **argv,
GCancellable *cancellable,
GError **error)
{
int exit_status = EXIT_FAILURE;
GError *temp_error = NULL;
GOptionContext *context = g_option_context_new ("TREEFILE - Run yum and commit the result to an OSTree repository");
RpmOstreeTreeComposeContext selfdata = { NULL, };
RpmOstreeTreeComposeContext *self = &selfdata;
JsonNode *treefile_rootval = NULL;
JsonObject *treefile = NULL;
gs_free char *cachekey = NULL;
gs_free char *new_inputhash = NULL;
gs_unref_object GFile *previous_root = NULL;
gs_free char *previous_checksum = NULL;
gs_unref_object GFile *yumroot = NULL;
gs_unref_object GFile *yumroot_varcache = NULL;
gs_unref_object OstreeRepo *repo = NULL;
gs_unref_ptrarray GPtrArray *bootstrap_packages = NULL;
gs_unref_ptrarray GPtrArray *packages = NULL;
gs_unref_object GFile *treefile_path = NULL;
gs_unref_object GFile *treefile_dirpath = NULL;
gs_unref_object GFile *repo_path = NULL;
gs_unref_object JsonParser *treefile_parser = NULL;
gs_unref_variant_builder GVariantBuilder *metadata_builder =
g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
g_autoptr(RpmOstreeContext) corectx = NULL;
g_autoptr(GHashTable) varsubsts = NULL;
gboolean workdir_is_tmp = FALSE;
self->treefile_context_dirs = g_ptr_array_new_with_free_func ((GDestroyNotify)g_object_unref);
if (!rpmostree_option_context_parse (context,
option_entries,
&argc, &argv,
RPM_OSTREE_BUILTIN_FLAG_LOCAL_CMD,
cancellable,
NULL,
error))
goto out;
if (argc < 2)
{
rpmostree_usage_error (context, "TREEFILE must be specified", error);
goto out;
}
if (!opt_repo)
{
rpmostree_usage_error (context, "--repo must be specified", error);
goto out;
}
if (getuid () != 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"compose tree must presently be run as uid 0 (root)");
goto out;
}
repo_path = g_file_new_for_path (opt_repo);
repo = self->repo = ostree_repo_new (repo_path);
if (!ostree_repo_open (repo, cancellable, error))
goto out;
treefile_path = g_file_new_for_path (argv[1]);
if (opt_workdir)
{
self->workdir = g_file_new_for_path (opt_workdir);
}
else
{
gs_free char *tmpd = NULL;
if (!rpmostree_mkdtemp ("/var/tmp/rpm-ostree.XXXXXX", &tmpd, NULL, error))
goto out;
self->workdir = g_file_new_for_path (tmpd);
workdir_is_tmp = TRUE;
if (opt_workdir_tmpfs)
{
if (mount ("tmpfs", tmpd, "tmpfs", 0, (const void*)"mode=755") != 0)
{
_rpmostree_set_prefix_error_from_errno (error, errno,
"mount(tmpfs): ");
goto out;
}
}
}
if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (self->workdir),
FALSE, &self->workdir_dfd, error))
goto out;
if (opt_cachedir)
{
if (!glnx_opendirat (AT_FDCWD, opt_cachedir, TRUE, &self->cachedir_dfd, error))
{
g_prefix_error (error, "Opening cachedir '%s': ", opt_cachedir);
goto out;
}
}
else
{
self->cachedir_dfd = fcntl (self->workdir_dfd, F_DUPFD_CLOEXEC, 3);
if (self->cachedir_dfd < 0)
{
glnx_set_error_from_errno (error);
goto out;
}
}
if (opt_metadata_strings)
{
if (!parse_keyvalue_strings (opt_metadata_strings,
metadata_builder, error))
goto out;
}
if (fchdir (self->workdir_dfd) != 0)
{
glnx_set_error_from_errno (error);
goto out;
}
corectx = rpmostree_context_new_unprivileged (self->cachedir_dfd, cancellable, error);
if (!corectx)
goto out;
varsubsts = rpmostree_context_get_varsubsts (corectx);
treefile_parser = json_parser_new ();
if (!json_parser_load_from_file (treefile_parser,
gs_file_get_path_cached (treefile_path),
error))
goto out;
treefile_rootval = json_parser_get_root (treefile_parser);
if (!JSON_NODE_HOLDS_OBJECT (treefile_rootval))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Treefile root is not an object");
goto out;
}
treefile = json_node_get_object (treefile_rootval);
if (!process_includes (self, treefile_path, 0, treefile,
cancellable, error))
goto out;
if (opt_print_only)
{
gs_unref_object JsonGenerator *generator = json_generator_new ();
gs_unref_object GOutputStream *stdout = g_unix_output_stream_new (1, FALSE);
json_generator_set_pretty (generator, TRUE);
json_generator_set_root (generator, treefile_rootval);
(void) json_generator_to_stream (generator, stdout, NULL, NULL);
exit_status = EXIT_SUCCESS;
goto out;
}
{ const char *input_ref = _rpmostree_jsonutil_object_require_string_member (treefile, "ref", error);
if (!input_ref)
goto out;
self->ref = _rpmostree_varsubst_string (input_ref, varsubsts, error);
if (!self->ref)
goto out;
}
if (!ostree_repo_read_commit (repo, self->ref, &previous_root, &previous_checksum,
cancellable, &temp_error))
{
if (g_error_matches (temp_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_clear_error (&temp_error);
g_print ("No previous commit for %s\n", self->ref);
}
else
{
g_propagate_error (error, temp_error);
goto out;
}
}
else
g_print ("Previous commit: %s\n", previous_checksum);
self->previous_checksum = previous_checksum;
yumroot = g_file_get_child (self->workdir, "rootfs.tmp");
if (!glnx_shutil_rm_rf_at (self->workdir_dfd, "rootfs.tmp", cancellable, error))
goto out;
if (json_object_has_member (treefile, "automatic_version_prefix") &&
!compose_strv_contains_prefix (opt_metadata_strings, "version="))
{
gs_unref_variant GVariant *variant = NULL;
gs_free char *last_version = NULL;
gs_free char *next_version = NULL;
const char *ver_prefix;
ver_prefix = _rpmostree_jsonutil_object_require_string_member (treefile,
"automatic_version_prefix",
error);
if (!ver_prefix)
goto out;
if (previous_checksum)
{
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT,
previous_checksum, &variant, error))
goto out;
last_version = checksum_version (variant);
}
next_version = _rpmostree_util_next_version (ver_prefix, last_version);
g_variant_builder_add (metadata_builder, "{sv}", "version",
g_variant_new_string (next_version));
}
bootstrap_packages = g_ptr_array_new ();
packages = g_ptr_array_new ();
if (json_object_has_member (treefile, "bootstrap_packages"))
{
if (!_rpmostree_jsonutil_append_string_array_to (treefile, "bootstrap_packages", packages, error))
goto out;
}
if (!_rpmostree_jsonutil_append_string_array_to (treefile, "packages", packages, error))
goto out;
g_ptr_array_add (packages, NULL);
{ gs_unref_object JsonGenerator *generator = json_generator_new ();
char *treefile_buf = NULL;
gsize len;
json_generator_set_root (generator, treefile_rootval);
json_generator_set_pretty (generator, TRUE);
treefile_buf = json_generator_to_data (generator, &len);
self->serialized_treefile = g_bytes_new_take (treefile_buf, len);
}
treefile_dirpath = g_file_get_parent (treefile_path);
if (TRUE)
{
gboolean generate_from_previous = TRUE;
if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treefile,
"preserve-passwd",
&generate_from_previous,
error))
goto out;
if (generate_from_previous)
{
if (!rpmostree_generate_passwd_from_previous (repo, yumroot,
treefile_dirpath,
previous_root, treefile,
cancellable, error))
goto out;
}
}
{ gboolean unmodified = FALSE;
if (!install_packages_in_root (self, corectx, treefile, yumroot,
(char**)packages->pdata,
opt_force_nocache ? NULL : &unmodified,
&new_inputhash,
cancellable, error))
goto out;
if (unmodified)
{
g_print ("No apparent changes since previous commit; use --force-nocache to override\n");
exit_status = EXIT_SUCCESS;
goto out;
}
else if (opt_dry_run)
{
g_print ("--dry-run complete, exiting\n");
exit_status = EXIT_SUCCESS;
goto out;
}
}
if (g_strcmp0 (g_getenv ("RPM_OSTREE_BREAK"), "post-yum") == 0)
goto out;
if (!rpmostree_treefile_postprocessing (yumroot, self->treefile_context_dirs->pdata[0],
self->serialized_treefile, treefile,
cancellable, error))
goto out;
if (!rpmostree_prepare_rootfs_for_commit (yumroot, treefile, cancellable, error))
goto out;
if (!rpmostree_copy_additional_files (yumroot, self->treefile_context_dirs->pdata[0], treefile, cancellable, error))
goto out;
if (!rpmostree_check_passwd (repo, yumroot, treefile_dirpath, treefile,
previous_checksum,
cancellable, error))
goto out;
if (!rpmostree_check_groups (repo, yumroot, treefile_dirpath, treefile,
previous_checksum,
cancellable, error))
goto out;
{
const char *gpgkey;
gboolean selinux = TRUE;
gs_unref_variant GVariant *metadata = NULL;
g_variant_builder_add (metadata_builder, "{sv}",
"rpmostree.inputhash",
g_variant_new_string (new_inputhash));
metadata = g_variant_ref_sink (g_variant_builder_end (metadata_builder));
if (!_rpmostree_jsonutil_object_get_optional_string_member (treefile, "gpg_key", &gpgkey, error))
goto out;
if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treefile,
"selinux",
&selinux,
error))
goto out;
{ g_autofree char *new_revision = NULL;
glnx_fd_close int rootfs_fd = -1;
if (!glnx_opendirat (AT_FDCWD, gs_file_get_path_cached (yumroot), TRUE,
&rootfs_fd, error))
goto out;
g_print ("Committing...\n");
if (!rpmostree_commit (rootfs_fd, repo, self->ref, metadata, gpgkey, selinux, NULL,
&new_revision,
cancellable, error))
goto out;
g_print ("%s => %s\n", self->ref, new_revision);
}
}
if (opt_touch_if_changed)
{
gs_fd_close int fd = open (opt_touch_if_changed, O_CREAT|O_WRONLY|O_NOCTTY, 0644);
if (fd == -1)
{
gs_set_error_from_errno (error, errno);
g_prefix_error (error, "Updating '%s': ", opt_touch_if_changed);
goto out;
}
if (futimens (fd, NULL) == -1)
{
gs_set_error_from_errno (error, errno);
goto out;
}
}
exit_status = EXIT_SUCCESS;
out:
/* Explicitly close this one now as it may have references to files
* we delete below.
*/
g_clear_object (&corectx);
/* Move back out of the workding directory to ensure unmount works */
(void )chdir ("/");
if (self->workdir_dfd != -1)
(void) close (self->workdir_dfd);
if (workdir_is_tmp)
{
if (opt_workdir_tmpfs)
if (umount (gs_file_get_path_cached (self->workdir)) != 0)
{
fprintf (stderr, "warning: umount failed: %m\n");
}
(void) gs_shutil_rm_rf (self->workdir, NULL, NULL);
}
if (self)
{
g_clear_object (&self->workdir);
g_clear_pointer (&self->serialized_treefile, g_bytes_unref);
g_ptr_array_unref (self->treefile_context_dirs);
}
return exit_status;
}
static char *
get_prefix_for_entry (GMenuTreeEntry *entry)
{
char *prefix = NULL, *file_prefix = NULL;
const char *id;
GFile *file;
char *name;
int i = 0;
id = gmenu_tree_entry_get_desktop_file_id (entry);
file = g_file_new_for_path (gmenu_tree_entry_get_desktop_file_path (entry));
name = g_file_get_basename (file);
if (!name)
{
g_object_unref (file);
return NULL;
}
for (i = 0; vendor_prefixes[i]; i++)
{
if (g_str_has_prefix (name, vendor_prefixes[i]))
{
file_prefix = g_strdup (vendor_prefixes[i]);
break;
}
}
while (strcmp (name, id) != 0)
{
char *t;
char *pname;
GFile *parent = g_file_get_parent (file);
if (!parent)
{
g_warn_if_reached ();
break;
}
pname = g_file_get_basename (parent);
if (!pname)
{
g_object_unref (parent);
break;
}
if (!g_strstr_len (id, -1, pname))
{
/* handle <LegacyDir prefix="..."> */
char *t;
size_t name_len = strlen (name);
size_t id_len = strlen (id);
char *t_id = g_strdup (id);
t_id[id_len - name_len] = '\0';
t = g_strdup(t_id);
g_free (prefix);
g_free (t_id);
g_free (name);
name = g_strdup (id);
prefix = t;
g_object_unref (file);
file = parent;
g_free (pname);
g_free (file_prefix);
file_prefix = NULL;
break;
}
t = g_strconcat (pname, "-", name, NULL);
g_free (name);
name = t;
t = g_strconcat (pname, "-", prefix, NULL);
g_free (prefix);
prefix = t;
g_object_unref (file);
file = parent;
g_free (pname);
}
if (file)
g_object_unref (file);
if (strcmp (name, id) == 0)
{
g_free (name);
if (file_prefix && !prefix)
return file_prefix;
if (file_prefix)
{
char *t = g_strconcat (prefix, "-", file_prefix, NULL);
g_free (prefix);
g_free (file_prefix);
prefix = t;
}
return prefix;
}
g_free (name);
g_free (prefix);
g_free (file_prefix);
g_return_val_if_reached (NULL);
}
XfdesktopSpecialFileIcon *
xfdesktop_special_file_icon_new(XfdesktopSpecialFileIconType type,
GdkScreen *screen)
{
XfdesktopSpecialFileIcon *special_file_icon;
GFile *file = NULL;
switch(type) {
case XFDESKTOP_SPECIAL_FILE_ICON_FILESYSTEM:
file = g_file_new_for_uri("file:///");
break;
case XFDESKTOP_SPECIAL_FILE_ICON_HOME:
file = g_file_new_for_path(xfce_get_homedir());
break;
case XFDESKTOP_SPECIAL_FILE_ICON_TRASH:
file = g_file_new_for_uri("trash:///");
break;
default:
g_return_val_if_reached(NULL);
}
special_file_icon = g_object_new(XFDESKTOP_TYPE_SPECIAL_FILE_ICON, NULL);
special_file_icon->priv->type = type;
special_file_icon->priv->gscreen = screen;
special_file_icon->priv->file = file;
special_file_icon->priv->file_info = g_file_query_info(file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if(!special_file_icon->priv->file_info) {
g_object_unref(special_file_icon);
return NULL;
}
/* query file system information from GIO */
special_file_icon->priv->filesystem_info = g_file_query_filesystem_info(special_file_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* update the trash full state */
if(type == XFDESKTOP_SPECIAL_FILE_ICON_TRASH)
xfdesktop_special_file_icon_update_trash_count(special_file_icon);
g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),
"changed",
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
special_file_icon);
special_file_icon->priv->monitor = g_file_monitor(special_file_icon->priv->file,
G_FILE_MONITOR_NONE,
NULL, NULL);
if(special_file_icon->priv->monitor) {
g_signal_connect(special_file_icon->priv->monitor,
"changed",
G_CALLBACK(xfdesktop_special_file_icon_changed),
special_file_icon);
}
return special_file_icon;
}
static gboolean
install_packages_in_root (RpmOstreeTreeComposeContext *self,
RpmOstreeContext *ctx,
JsonObject *treedata,
GFile *yumroot,
char **packages,
gboolean *out_unmodified,
char **out_new_inputhash,
GCancellable *cancellable,
GError **error)
{
gboolean ret = FALSE;
guint progress_sigid;
GFile *contextdir = self->treefile_context_dirs->pdata[0];
g_autoptr(RpmOstreeInstall) hifinstall = { 0, };
HifContext *hifctx;
gs_free char *ret_new_inputhash = NULL;
g_autoptr(GKeyFile) treespec = g_key_file_new ();
JsonArray *enable_repos = NULL;
JsonArray *add_files = NULL;
/* TODO - uncomment this once we have SELinux working */
#if 0
g_autofree char *cache_repo_pathstr = glnx_fdrel_abspath (self->cachedir_dfd, "repo");
g_autoptr(GFile) cache_repo_path = g_file_new_for_path (cache_repo_pathstr);
glnx_unref_object OstreeRepo *ostreerepo = ostree_repo_new (cache_repo_path);
if (!g_file_test (cache_repo_pathstr, G_FILE_TEST_EXISTS))
{
if (!ostree_repo_create (ostreerepo, OSTREE_REPO_MODE_BARE_USER, cancellable, error))
goto out;
}
#endif
hifctx = rpmostree_context_get_hif (ctx);
if (opt_proxy)
hif_context_set_http_proxy (hifctx, opt_proxy);
hif_context_set_repo_dir (hifctx, gs_file_get_path_cached (contextdir));
g_key_file_set_string (treespec, "tree", "ref", self->ref);
g_key_file_set_string_list (treespec, "tree", "packages", (const char *const*)packages, g_strv_length (packages));
/* Some awful code to translate between JSON and GKeyFile */
if (json_object_has_member (treedata, "install-langs"))
{
JsonArray *a = json_object_get_array_member (treedata, "install-langs");
if (!set_keyfile_string_array_from_json (treespec, "tree", "install-langs", a, error))
goto out;
}
/* Bind the json \"repos\" member to the hif state, which looks at the
* enabled= member of the repos file. By default we forcibly enable
* only repos which are specified, ignoring the enabled= flag.
*/
if (!json_object_has_member (treedata, "repos"))
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Treefile is missing required \"repos\" member");
goto out;
}
enable_repos = json_object_get_array_member (treedata, "repos");
if (!set_keyfile_string_array_from_json (treespec, "tree", "repos", enable_repos, error))
goto out;
{ gboolean docs = TRUE;
if (!_rpmostree_jsonutil_object_get_optional_boolean_member (treedata,
"documentation",
&docs,
error))
goto out;
if (!docs)
g_key_file_set_boolean (treespec, "tree", "documentation", FALSE);
}
{ g_autoptr(GError) tmp_error = NULL;
g_autoptr(RpmOstreeTreespec) treespec_value = rpmostree_treespec_new_from_keyfile (treespec, &tmp_error);
g_assert_no_error (tmp_error);
if (!rpmostree_context_setup (ctx, gs_file_get_path_cached (yumroot), "/", treespec_value,
cancellable, error))
goto out;
}
/* --- Downloading metadata --- */
if (!rpmostree_context_download_metadata (ctx, cancellable, error))
goto out;
if (!rpmostree_context_prepare_install (ctx, &hifinstall, cancellable, error))
goto out;
if (json_object_has_member (treedata, "add-files"))
add_files = json_object_get_array_member (treedata, "add-files");
/* FIXME - just do a depsolve here before we compute download requirements */
if (!compute_checksum_from_treefile_and_goal (self, hif_context_get_goal (hifctx),
contextdir, add_files,
&ret_new_inputhash, error))
goto out;
/* Only look for previous checksum if caller has passed *out_unmodified */
if (self->previous_checksum && out_unmodified != NULL)
{
gs_unref_variant GVariant *commit_v = NULL;
gs_unref_variant GVariant *commit_metadata = NULL;
const char *previous_inputhash = NULL;
if (!ostree_repo_load_variant (self->repo, OSTREE_OBJECT_TYPE_COMMIT,
self->previous_checksum,
&commit_v, error))
goto out;
commit_metadata = g_variant_get_child_value (commit_v, 0);
if (g_variant_lookup (commit_metadata, "rpmostree.inputhash", "&s", &previous_inputhash))
{
if (strcmp (previous_inputhash, ret_new_inputhash) == 0)
{
*out_unmodified = TRUE;
ret = TRUE;
goto out;
}
}
else
g_print ("Previous commit found, but without rpmostree.inputhash metadata key\n");
}
if (opt_dry_run)
{
ret = TRUE;
goto out;
}
/* --- Downloading packages --- */
if (!rpmostree_context_download (ctx, hifinstall, cancellable, error))
goto out;
{ g_auto(GLnxConsoleRef) console = { 0, };
gs_unref_object HifState *hifstate = hif_state_new ();
progress_sigid = g_signal_connect (hifstate, "percentage-changed",
G_CALLBACK (on_hifstate_percentage_changed),
"Installing packages:");
glnx_console_lock (&console);
if (!hif_transaction_commit (hif_context_get_transaction (hifctx),
hif_context_get_goal (hifctx),
hifstate,
error))
goto out;
g_signal_handler_disconnect (hifstate, progress_sigid);
}
ret = TRUE;
if (out_unmodified)
*out_unmodified = FALSE;
gs_transfer_out_value (out_new_inputhash, &ret_new_inputhash);
out:
return ret;
}
static void
migrate_history ()
{
GFileInputStream *input;
GMarkupParseContext *context;
GError *error = NULL;
GFile *file;
char *filename;
char buffer[1024];
HistoryParseData parse_data;
gchar *temporary_file = g_build_filename (ephy_dot_dir (), "ephy-history.db", NULL);
/* Do nothing if the history file already exists. Safer than wiping
* it out. */
if (g_file_test (temporary_file, G_FILE_TEST_EXISTS)) {
g_warning ("Did not migrate Epiphany's history, the ephy-history.db file already exists");
g_free (temporary_file);
return;
}
history_service = ephy_history_service_new (temporary_file);
g_free (temporary_file);
memset (&parse_data, 0, sizeof (HistoryParseData));
parse_data.location = NULL;
parse_data.title = NULL;
parse_data.visits = NULL;
filename = g_build_filename (ephy_dot_dir (),
"ephy-history.xml",
NULL);
file = g_file_new_for_path (filename);
g_free (filename);
input = g_file_read (file, NULL, &error);
g_object_unref (file);
if (error) {
if (error->code != G_IO_ERROR_NOT_FOUND)
g_warning ("Could not load Epiphany history data, migration aborted: %s", error->message);
g_error_free (error);
return;
}
context = g_markup_parse_context_new (&history_parse_funcs, 0, &parse_data, NULL);
while (TRUE) {
gssize count = g_input_stream_read (G_INPUT_STREAM (input), buffer, sizeof (buffer), NULL, &error);
if (count <= 0)
break;
if (!g_markup_parse_context_parse (context, buffer, count, &error))
break;
}
g_markup_parse_context_free (context);
g_input_stream_close (G_INPUT_STREAM (input), NULL, NULL);
g_object_unref (input);
if (parse_data.visits) {
ephy_history_service_add_visits (history_service, parse_data.visits, NULL, (EphyHistoryJobCallback)visit_cb, NULL);
ephy_history_page_visit_list_free (parse_data.visits);
while (!all_done)
g_main_context_iteration (NULL, FALSE);
}
g_object_unref (history_service);
}
/*
* Function to use anywhere in the application to send a message to the LogList
*/
void Log_Print (Log_Error_Type error_type, gchar const *format, ...)
{
va_list args;
gchar *string;
GtkTreeIter iter;
static gboolean first_time = TRUE;
static gchar *file_path = NULL;
GFile *file;
GFileOutputStream *file_ostream;
GError *error = NULL;
va_start (args, format);
string = g_strdup_vprintf(format, args);
va_end (args);
// If the log window is displayed then messages are displayed, else
// the messages are stored in a temporary list.
if (LogList && logListModel)
{
gint n_items;
gchar *time = Log_Format_Date();
/* Remove lines that exceed the limit. */
n_items = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (logListModel),
NULL);
if (n_items > LOG_MAX_LINES - 1
&& gtk_tree_model_get_iter_first(GTK_TREE_MODEL(logListModel), &iter))
{
gtk_list_store_remove(GTK_LIST_STORE(logListModel), &iter);
}
gtk_list_store_insert_with_values (logListModel, &iter, G_MAXINT,
LOG_PIXBUF,
Log_Get_Stock_Id_From_Error_Type (error_type),
LOG_TIME_TEXT, time, LOG_TEXT,
string, LOG_ROW_BACKGROUND, NULL,
LOG_ROW_FOREGROUND, NULL, -1);
Log_List_Set_Row_Visible(GTK_TREE_MODEL(logListModel), &iter);
g_free(time);
}else
{
Log_Data *LogData = g_malloc0(sizeof(Log_Data));
LogData->time = Log_Format_Date();
LogData->error_type = error_type;
LogData->string = g_strdup(string);
LogPrintTmpList = g_list_append(LogPrintTmpList,LogData);
//g_print("%s",string);
}
// Store also the messages in the log file.
if (!file_path)
{
gchar *cache_path = g_build_filename (g_get_user_cache_dir (),
PACKAGE_TARNAME, NULL);
if (!g_file_test (cache_path, G_FILE_TEST_IS_DIR))
{
gint result = g_mkdir_with_parents (cache_path, S_IRWXU);
if (result == -1)
{
g_printerr ("%s", "Unable to create cache directory");
g_free (cache_path);
g_free (string);
return;
}
}
file_path = g_build_filename (cache_path, LOG_FILE, NULL);
g_free (cache_path);
}
file = g_file_new_for_path (file_path);
/* On startup, the log is cleared. The log is then appended to for the
* remainder of the application lifetime. */
if (first_time)
{
file_ostream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE,
NULL, &error);
}
else
{
file_ostream = g_file_append_to (file, G_FILE_CREATE_NONE, NULL,
&error);
}
if (file_ostream)
{
gchar *time;
GString *data;
gsize bytes_written;
time = Log_Format_Date ();
data = g_string_new (time);
g_free (time);
data = g_string_append_c (data, ' ');
data = g_string_append (data, string);
g_free (string);
data = g_string_append_c (data, '\n');
if (!g_output_stream_write_all (G_OUTPUT_STREAM (file_ostream),
data->str, data->len, &bytes_written,
NULL, &error))
{
g_debug ("Only %" G_GSIZE_FORMAT " bytes out of %" G_GSIZE_FORMAT
"bytes of data were written", bytes_written, data->len);
/* To avoid recursion of Log_Print. */
g_warning ("Error writing to the log file '%s' ('%s')", file_path,
error->message);
g_error_free (error);
g_string_free (data, TRUE);
g_object_unref (file_ostream);
g_object_unref (file);
return;
}
first_time = FALSE;
g_string_free (data, TRUE);
}
else
{
g_warning ("Error opening output stream of file '%s' ('%s')",
file_path, error->message);
g_error_free (error);
}
g_object_unref (file_ostream);
g_object_unref (file);
}
/**
* seahorse_util_uris_package
* @package: Package uri
* @uris: null-terminated array of uris to package
*
* Package uris into an archive. The uris must be local.
*
* Returns: Success or failure
*/
gboolean
seahorse_util_uris_package (const gchar* package, const char** uris)
{
GError* err = NULL;
gchar *out = NULL;
gint status;
gboolean r;
GString *str;
gchar *cmd;
gchar *t;
gchar *x;
GFile *file, *fpackage;
fpackage = g_file_new_for_uri (package);
t = g_file_get_path (fpackage);
x = g_shell_quote (t);
g_free (t);
/* create execution */
str = g_string_new ("");
g_string_printf (str, "file-roller --add-to=%s", x);
g_free(x);
while(*uris) {
x = g_uri_parse_scheme (*uris);
if (x)
file = g_file_new_for_uri (*uris);
else
file = g_file_new_for_path (*uris);
g_free (x);
t = g_file_get_path (file);
g_object_unref (file);
g_return_val_if_fail (t != NULL, FALSE);
x = g_shell_quote(t);
g_free(t);
g_string_append_printf (str, " %s", x);
g_free(x);
uris++;
}
/* Execute the command */
cmd = g_string_free (str, FALSE);
r = g_spawn_command_line_sync (cmd, &out, NULL, &status, &err);
g_free (cmd);
if (out) {
g_print (out, NULL);
g_free (out);
}
if (!r) {
seahorse_util_handle_error (err, _("Couldn't run file-roller"));
return FALSE;
}
if(!(WIFEXITED(status) && WEXITSTATUS(status) == 0)) {
seahorse_util_show_error(NULL, _("Couldn't package files"),
_("The file-roller process did not complete successfully"));
return FALSE;
}
t = g_file_get_path (fpackage);
if (t != NULL) {
g_chmod (t, S_IRUSR | S_IWUSR);
g_free (t);
}
return TRUE;
}
int
main (int argc, char **argv)
{
GtkWidget *w1;
gchar *path;
g_type_init ();
gtk_init (&argc, &argv);
toplevel = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (toplevel), 12);
grid = gtk_grid_new ();
w1 = gtk_label_new ("File:");
gtk_widget_set_halign (w1, GTK_ALIGN_START);
gtk_grid_attach (GTK_GRID (grid),
w1, 0, 0, 1, 1);
file_l = gtk_button_new ();
path = g_build_filename (g_get_current_dir (), "apple-red.png", NULL);
file = g_file_new_for_path (path);
gtk_button_set_label (GTK_BUTTON (file_l), path);
g_free (path);
gtk_widget_set_halign (file_l, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (grid), file_l,
w1, GTK_POS_RIGHT, 3, 1);
g_signal_connect (file_l, "clicked",
G_CALLBACK (button_clicked), NULL);
radio_file = gtk_radio_button_new_with_label (NULL, "Use GFile");
radio_content = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio_file),
"Use content type");
gtk_grid_attach (GTK_GRID (grid), radio_file,
0, 1, 1, 1);
gtk_grid_attach_next_to (GTK_GRID (grid), radio_content,
radio_file, GTK_POS_BOTTOM, 1, 1);
open = gtk_button_new_with_label ("Trigger App Chooser dialog");
gtk_grid_attach_next_to (GTK_GRID (grid), open,
radio_content, GTK_POS_BOTTOM, 1, 1);
recommended = gtk_check_button_new_with_label ("Show recommended");
gtk_grid_attach_next_to (GTK_GRID (grid), recommended,
open, GTK_POS_BOTTOM, 1, 1);
g_object_set (recommended, "active", TRUE, NULL);
fallback = gtk_check_button_new_with_label ("Show fallback");
gtk_grid_attach_next_to (GTK_GRID (grid), fallback,
recommended, GTK_POS_RIGHT, 1, 1);
other = gtk_check_button_new_with_label ("Show other");
gtk_grid_attach_next_to (GTK_GRID (grid), other,
fallback, GTK_POS_RIGHT, 1, 1);
all = gtk_check_button_new_with_label ("Show all");
gtk_grid_attach_next_to (GTK_GRID (grid), all,
other, GTK_POS_RIGHT, 1, 1);
def = gtk_check_button_new_with_label ("Show default");
gtk_grid_attach_next_to (GTK_GRID (grid), def,
all, GTK_POS_RIGHT, 1, 1);
g_object_set (recommended, "active", TRUE, NULL);
prepare_dialog ();
g_signal_connect (open, "clicked",
G_CALLBACK (display_dialog), NULL);
gtk_container_add (GTK_CONTAINER (toplevel), grid);
gtk_widget_show_all (toplevel);
g_signal_connect (toplevel, "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return EXIT_SUCCESS;
}
gboolean
wavpack_tag_write_file_tag (const ET_File *ETFile,
GError **error)
{
WavpackStreamReader writer = { wavpack_read_bytes, wavpack_get_pos,
wavpack_set_pos_abs, wavpack_set_pos_rel,
wavpack_push_back_byte, wavpack_get_length,
wavpack_can_seek, wavpack_write_bytes };
GFile *file;
EtWavpackWriteState state;
const gchar *filename;
const File_Tag *FileTag;
WavpackContext *wpc;
gchar message[80];
gchar *buffer;
g_return_val_if_fail (ETFile != NULL && ETFile->FileTag != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
filename = ((File_Name *)((GList *)ETFile->FileNameCur)->data)->value;
FileTag = (File_Tag *)ETFile->FileTag->data;
file = g_file_new_for_path (filename);
state.error = NULL;
state.iostream = g_file_open_readwrite (file, NULL, &state.error);
g_object_unref (file);
if (!state.iostream)
{
g_propagate_error (error, state.error);
return FALSE;
}
state.istream = G_FILE_INPUT_STREAM (g_io_stream_get_input_stream (G_IO_STREAM (state.iostream)));
state.ostream = G_FILE_OUTPUT_STREAM (g_io_stream_get_output_stream (G_IO_STREAM (state.iostream)));
state.seekable = G_SEEKABLE (state.iostream);
/* NULL for the WavPack correction file. */
wpc = WavpackOpenFileInputEx (&writer, &state, NULL, message,
OPEN_EDIT_TAGS, 0);
if (wpc == NULL)
{
if (state.error)
{
g_propagate_error (error, state.error);
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s",
message);
}
g_object_unref (state.iostream);
return FALSE;
}
/* Title. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "title", FileTag->title))
{
goto err;
}
/* Artist. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "artist", FileTag->artist))
{
goto err;
}
/* Album artist. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "album artist",
FileTag->album_artist))
{
goto err;
}
/* Album. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "album", FileTag->album))
{
goto err;
}
/* Discnumber. */
if (FileTag->disc_number && FileTag->disc_total)
{
buffer = g_strdup_printf ("%s/%s", FileTag->disc_number,
FileTag->disc_total);
if (!et_wavpack_append_or_delete_tag_item (wpc, "part", buffer))
{
g_free (buffer);
goto err;
}
else
{
g_free (buffer);
}
}
else
{
if (!et_wavpack_append_or_delete_tag_item (wpc, "part",
FileTag->disc_number))
{
goto err;
}
}
/* Year. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "year", FileTag->year))
{
goto err;
}
/* Tracknumber + tracktotal. */
if (FileTag->track_total)
{
buffer = g_strdup_printf ("%s/%s", FileTag->track,
FileTag->track_total);
if (!et_wavpack_append_or_delete_tag_item (wpc, "track", buffer))
{
g_free (buffer);
goto err;
}
else
{
g_free (buffer);
}
}
else
{
if (!et_wavpack_append_or_delete_tag_item (wpc, "track",
FileTag->track))
{
goto err;
}
}
/* Genre. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "genre", FileTag->genre))
{
goto err;
}
/* Comment. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "comment", FileTag->comment))
{
goto err;
}
/* Composer. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "composer",
FileTag->composer))
{
goto err;
}
/* Original artist. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "original artist",
FileTag->orig_artist))
{
goto err;
}
/* Copyright. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "copyright",
FileTag->copyright))
{
goto err;
}
/* URL. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "copyright url",
FileTag->url))
{
goto err;
}
/* Encoded by. */
if (!et_wavpack_append_or_delete_tag_item (wpc, "encoded by",
FileTag->encoded_by))
{
goto err;
}
if (WavpackWriteTag (wpc) == 0)
{
goto err;
}
WavpackCloseFile (wpc);
g_object_unref (state.iostream);
return TRUE;
err:
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "%s",
WavpackGetErrorMessage (wpc));
WavpackCloseFile (wpc);
return FALSE;
}
static void
run (const gchar *name,
gint nparams,
const GimpParam *param,
gint *nreturn_vals,
GimpParam **return_vals)
{
static GimpParam values[4];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
gint32 image_ID;
GError *error = NULL;
run_mode = param[0].data.d_int32;
INIT_I18N ();
gegl_init (NULL, NULL);
*nreturn_vals = 1;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
if (strcmp (name, LOAD_PROC) == 0 ||
strcmp (name, LOAD_MERGED_PROC) == 0)
{
gboolean resolution_loaded = FALSE;
gboolean interactive;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
interactive = TRUE;
break;
default:
interactive = FALSE;
break;
}
image_ID = load_image (param[1].data.d_string,
strcmp (name, LOAD_MERGED_PROC) == 0,
&resolution_loaded, &error);
if (image_ID != -1)
{
GFile *file = g_file_new_for_path (param[1].data.d_string);
GimpMetadata *metadata;
metadata = gimp_image_metadata_load_prepare (image_ID, "image/x-psd",
file, NULL);
if (metadata)
{
GimpMetadataLoadFlags flags = GIMP_METADATA_LOAD_ALL;
if (resolution_loaded)
flags &= ~GIMP_METADATA_LOAD_RESOLUTION;
gimp_image_metadata_load_finish (image_ID, "image/x-psd",
metadata, flags,
interactive);
g_object_unref (metadata);
}
g_object_unref (file);
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
else if (strcmp (name, LOAD_THUMB_PROC) == 0)
{
if (nparams < 2)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
const gchar *filename = param[0].data.d_string;
gint width = 0;
gint height = 0;
image_ID = load_thumbnail_image (filename, &width, &height, &error);
if (image_ID != -1)
{
*nreturn_vals = 4;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
values[2].type = GIMP_PDB_INT32;
values[2].data.d_int32 = width;
values[3].type = GIMP_PDB_INT32;
values[3].data.d_int32 = height;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
}
else if (strcmp (name, SAVE_PROC) == 0)
{
gint32 drawable_id;
GimpMetadata *metadata;
GimpMetadataSaveFlags metadata_flags;
GimpExportReturn export = GIMP_EXPORT_IGNORE;
IFDBG(2) g_debug ("\n---------------- %s ----------------\n",
param[3].data.d_string);
image_ID = param[1].data.d_int32;
drawable_id = param[2].data.d_int32;
switch (run_mode)
{
case GIMP_RUN_INTERACTIVE:
case GIMP_RUN_WITH_LAST_VALS:
gimp_ui_init (PLUG_IN_BINARY, FALSE);
export = gimp_export_image (&image_ID, &drawable_id, "PSD",
GIMP_EXPORT_CAN_HANDLE_RGB |
GIMP_EXPORT_CAN_HANDLE_GRAY |
GIMP_EXPORT_CAN_HANDLE_INDEXED |
GIMP_EXPORT_CAN_HANDLE_ALPHA |
GIMP_EXPORT_CAN_HANDLE_LAYERS |
GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS);
if (export == GIMP_EXPORT_CANCEL)
{
values[0].data.d_status = GIMP_PDB_CANCEL;
return;
}
break;
default:
break;
}
static void
cleaner_task_handler (GTask *task, gpointer source_object,
gpointer task_data, GCancellable *cancellable)
{
HevFileboxCleaner *self = HEV_FILEBOX_CLEANER (source_object);
HevFileboxCleanerPrivate *priv = HEV_FILEBOX_CLEANER_GET_PRIVATE (self);
gchar *fp_path = NULL, *fm_path = NULL;
GFile *file = NULL;
GFileEnumerator *file_enumerator = NULL;
GFileInfo *file_info = NULL;
g_debug ("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
fp_path = g_key_file_get_string (priv->config, "Module", "FilePoolPath", NULL);
fm_path = g_key_file_get_string (priv->config, "Module", "FileMetaPath", NULL);
/* enumerate file pool */
file = g_file_new_for_path (fp_path);
file_enumerator = g_file_enumerate_children (file,
G_FILE_ATTRIBUTE_STANDARD_NAME","G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
while (file_info = g_file_enumerator_next_file (file_enumerator, NULL, NULL)) {
if (G_FILE_TYPE_REGULAR == g_file_info_get_file_type (file_info)) {
gchar *meta_path = NULL;
GKeyFile *meta = NULL;
meta_path = g_build_filename (fm_path, g_file_info_get_name (file_info), NULL);
meta = g_key_file_new ();
if (g_key_file_load_from_file (meta, meta_path, G_KEY_FILE_NONE, NULL)) {
gint64 exp = 0;
GDateTime *now_date = NULL, *exp_date = NULL;
exp = g_key_file_get_int64 (meta, "Meta", "ExpDate", NULL);
now_date = g_date_time_new_now_utc ();
exp_date = g_date_time_new_from_unix_utc (exp);
/* compare date */
if (1 == g_date_time_compare (now_date, exp_date)) {
gchar *file_path = NULL;
file_path = g_build_filename (fp_path,
g_file_info_get_name (file_info), NULL);
/* delete file and it's meta */
g_unlink ((const gchar *) file_path);
g_unlink ((const gchar *) meta_path);
g_free (file_path);
}
g_date_time_unref (now_date);
g_date_time_unref (exp_date);
}
g_key_file_unref (meta);
g_free (meta_path);
}
g_object_unref (file_info);
}
g_object_unref (file_enumerator);
g_object_unref (file);
g_free (fp_path);
g_free (fm_path);
g_task_return_boolean (task, TRUE);
}
gboolean
ostree_admin_option_context_parse (GOptionContext *context,
const GOptionEntry *main_entries,
int *argc,
char ***argv,
OstreeAdminBuiltinFlags flags,
OstreeSysroot **out_sysroot,
GCancellable *cancellable,
GError **error)
{
g_autoptr(GFile) sysroot_path = NULL;
glnx_unref_object OstreeSysroot *sysroot = NULL;
gboolean success = FALSE;
/* Entries are listed in --help output in the order added. We add the
* main entries ourselves so that we can add the --sysroot entry first. */
g_option_context_add_main_entries (context, global_admin_entries, NULL);
if (!ostree_option_context_parse (context, main_entries, argc, argv, OSTREE_BUILTIN_FLAG_NO_REPO, NULL, cancellable, error))
goto out;
if (opt_sysroot != NULL)
sysroot_path = g_file_new_for_path (opt_sysroot);
sysroot = ostree_sysroot_new (sysroot_path);
if (flags & OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER)
{
GFile *path = ostree_sysroot_get_path (sysroot);
/* If sysroot path is "/" then user must be root. */
if (!g_file_has_parent (path, NULL) && getuid () != 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
"You must be root to perform this command");
goto out;
}
}
if (opt_print_current_dir)
{
g_autoptr(GPtrArray) deployments = NULL;
OstreeDeployment *first_deployment;
g_autoptr(GFile) deployment_file = NULL;
g_autofree char *deployment_path = NULL;
if (!ostree_sysroot_load (sysroot, cancellable, error))
goto out;
deployments = ostree_sysroot_get_deployments (sysroot);
if (deployments->len == 0)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Unable to find a deployment in sysroot");
goto out;
}
first_deployment = deployments->pdata[0];
deployment_file = ostree_sysroot_get_deployment_directory (sysroot, first_deployment);
deployment_path = g_file_get_path (deployment_file);
g_print ("%s\n", deployment_path);
exit (EXIT_SUCCESS);
}
if ((flags & OSTREE_ADMIN_BUILTIN_FLAG_UNLOCKED) == 0)
{
/* Released when sysroot is finalized, or on process exit */
if (!ot_admin_sysroot_lock (sysroot, error))
goto out;
}
if (out_sysroot)
*out_sysroot = g_steal_pointer (&sysroot);
success = TRUE;
out:
return success;
}
int
main(int argc, char *argv[])
{
EventdCoreContext *context;
gchar *runtime_dir = NULL;
gchar *control_socket = NULL;
gchar **binds = NULL;
gboolean take_over_socket = FALSE;
gboolean enable_relay = TRUE;
gboolean enable_sd_modules = TRUE;
gchar *config_dir = NULL;
gboolean daemonize = FALSE;
gboolean print_paths = FALSE;
gboolean print_version = FALSE;
EventdReturnCode retval = EVENTD_RETURN_CODE_OK;
GError *error = NULL;
GOptionContext *option_context = NULL;
#ifdef EVENTD_DEBUG
g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
#endif /* EVENTD_DEBUG */
setlocale(LC_ALL, "");
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, EVENTD_LOCALEDIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
#endif /* ENABLE_NLS */
if ( ! g_get_filename_charsets(NULL) )
{
g_warning(PACKAGE_NAME " does not support non-UTF-8 filename encoding");
return EVENTD_RETURN_CODE_FILESYSTEM_ENCODING_ERROR;
}
if ( G_UNLIKELY(! g_module_supported()) )
{
g_warning("No loadable module support");
return EVENTD_RETURN_CODE_NO_MODULE_SUPPORT_ERROR;
}
#ifdef EVENTD_DEBUG
setvbuf(stdout, NULL, _IOLBF, 0);
const gchar *debug_log_filename = g_getenv("EVENTD_DEBUG_LOG_FILENAME");
GDataOutputStream *debug_stream = NULL;
if ( debug_log_filename != NULL )
{
GFile *debug_log;
debug_log = g_file_new_for_path(debug_log_filename);
GError *error = NULL;
GFileOutputStream *debug_log_stream;
debug_log_stream = g_file_append_to(debug_log, G_FILE_CREATE_NONE, NULL, &error);
if ( debug_log_stream == NULL )
{
g_warning("Couldn't open debug log file: %s", error->message);
g_clear_error(&error);
}
else
{
debug_stream = g_data_output_stream_new(G_OUTPUT_STREAM(debug_log_stream));
g_object_unref(debug_log_stream);
g_log_set_default_handler(_eventd_core_debug_log_handler, debug_stream);
}
g_object_unref(debug_log);
}
#endif /* EVENTD_DEBUG */
context = g_new0(EventdCoreContext, 1);
context->interface.get_sockets = eventd_core_get_sockets;
context->interface.push_event = eventd_core_push_event;
#ifdef G_OS_UNIX
context->system_mode = ( g_getenv("XDG_RUNTIME_DIR") == NULL );
if ( context->system_mode )
g_setenv("XDG_RUNTIME_DIR", "/run", TRUE);
#endif /* G_OS_UNIX */
GOptionEntry entries[] =
{
{ "private-socket", 'i', 0, G_OPTION_ARG_FILENAME, &control_socket, "Socket to listen for internal control", "<socket>" },
{ "listen", 'l', 0, G_OPTION_ARG_STRING_ARRAY, &binds, "Add a socket to listen to", "<socket>" },
{ "take-over", 't', GIO_UNIX_OPTION_FLAG, G_OPTION_ARG_NONE, &take_over_socket, "Take over socket", NULL },
{ "no-relay", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &enable_relay, "Disable the relay feature", NULL },
{ "no-service-discovery", 0, G_OPTION_FLAG_REVERSE, G_OPTION_ARG_NONE, &enable_sd_modules, "Disable the service discovery feature", NULL },
{ "config-dir", 'c', 0, G_OPTION_ARG_FILENAME, &config_dir, "Additionnal configuration directory", "<directory>" },
{ "daemonize", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, &daemonize, NULL, NULL },
{ "paths", 'P', 0, G_OPTION_ARG_NONE, &print_paths, "Print search paths", NULL },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &print_version, "Print version", NULL },
{ .long_name = NULL }
};
static void
picture_scaled (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
BgPicturesSource *bg_source = BG_PICTURES_SOURCE (user_data);
CcBackgroundItem *item;
GError *error = NULL;
GdkPixbuf *pixbuf;
const char *source_url;
GtkTreeIter iter;
GtkListStore *store;
store = bg_source_get_liststore (BG_SOURCE (bg_source));
item = g_object_get_data (source_object, "item");
pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error);
if (pixbuf == NULL)
{
g_warning ("Failed to load image: %s", error->message);
g_error_free (error);
g_object_unref (item);
return;
}
/* insert the item into the liststore */
gtk_list_store_insert_with_values (store, &iter, 0,
0, pixbuf,
1, item,
-1);
source_url = cc_background_item_get_source_url (item);
if (source_url != NULL)
{
g_hash_table_insert (bg_source->priv->known_items,
bg_pictures_source_get_unique_filename (source_url), GINT_TO_POINTER (TRUE));
}
else
{
char *cache_path;
GFile *file, *parent, *dir;
cache_path = bg_pictures_source_get_cache_path ();
dir = g_file_new_for_path (cache_path);
g_free (cache_path);
file = g_file_new_for_uri (cc_background_item_get_uri (item));
parent = g_file_get_parent (file);
if (g_file_equal (parent, dir))
{
char *basename;
basename = g_file_get_basename (file);
g_hash_table_insert (bg_source->priv->known_items,
basename, GINT_TO_POINTER (TRUE));
}
g_object_unref (file);
g_object_unref (parent);
}
g_object_unref (pixbuf);
}
int
main (int argc, char *argv[])
{
GError *error;
GOptionContext *context;
GFile *file;
setlocale (LC_ALL, "");
g_type_init ();
error = NULL;
context = g_option_context_new ("- list files at <location>");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
g_option_context_free (context);
if (error != NULL)
{
g_printerr ("Error parsing commandline options: %s\n", error->message);
g_printerr ("\n");
g_printerr (_("Try \"%s --help\" for more information."),
g_get_prgname ());
g_printerr ("\n");
g_error_free(error);
return 1;
}
if (attributes != NULL)
{
/* asking for attributes implies -l; otherwise it won't get shown */
show_long = TRUE;
}
attributes = g_strconcat (G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_SIZE ","
G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN,
attributes != NULL ? "," : "",
attributes,
NULL);
if (show_completions != NULL)
{
print_completions (show_completions);
return 0;
}
if (argc > 1)
{
int i;
for (i = 1; i < argc; i++) {
file = g_file_new_for_commandline_arg (argv[i]);
list (file);
g_object_unref (file);
}
}
else
{
char *cwd;
cwd = g_get_current_dir ();
file = g_file_new_for_path (cwd);
g_free (cwd);
list (file);
g_object_unref (file);
}
g_free (attributes);
return 0;
}
static void
panel_place_menu_item_init (PanelPlaceMenuItem *menuitem)
{
GFile *bookmark;
char *bookmarks_filename;
GError *error;
menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem);
if (mate_gsettings_schema_exists (CAJA_DESKTOP_SCHEMA)) {
menuitem->priv->caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA);
g_signal_connect (menuitem->priv->caja_desktop_settings,
"changed::" CAJA_DESKTOP_HOME_ICON_NAME_KEY,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
g_signal_connect (menuitem->priv->caja_desktop_settings,
"changed::" CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
}
else
menuitem->priv->caja_desktop_settings = NULL;
if (mate_gsettings_schema_exists (CAJA_PREFS_SCHEMA)) {
menuitem->priv->caja_prefs_settings = g_settings_new (CAJA_PREFS_SCHEMA);
g_signal_connect (menuitem->priv->caja_prefs_settings,
"changed::" CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
}
else
menuitem->priv->caja_prefs_settings = NULL;
menuitem->priv->menubar_settings = g_settings_new (PANEL_MENU_BAR_SCHEMA);
g_signal_connect (menuitem->priv->menubar_settings,
"changed::" PANEL_MENU_BAR_MAX_ITEMS_OR_SUBMENU,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
menuitem->priv->recent_manager = gtk_recent_manager_get_default ();
bookmarks_filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
bookmark = g_file_new_for_path (bookmarks_filename);
error = NULL;
menuitem->priv->bookmarks_monitor = g_file_monitor_file
(bookmark,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (error) {
g_warning ("Failed to add file monitor for %s: %s\n",
bookmarks_filename, error->message);
g_error_free (error);
} else {
g_signal_connect (G_OBJECT (menuitem->priv->bookmarks_monitor),
"changed",
(GCallback) panel_place_menu_item_gtk_bookmarks_changed,
menuitem);
}
g_object_unref (bookmark);
g_free (bookmarks_filename);
menuitem->priv->volume_monitor = g_volume_monitor_get ();
menuitem->priv->drive_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-changed",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_connected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-connected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_disconnected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-disconnected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->volume_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-added",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-changed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-removed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->mount_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-added",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-changed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-removed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
}
int main (int argc, char** argv) {
GFile *db_dir, *db_file;
notmuch_status_t status;
notmuch_database_t *db = NULL;
notmuch_query_t *query = NULL;
notmuch_messages_t *messages = NULL;
notmuch_message_t *message = NULL;
GMainLoop *loop = NULL;
const char *query_string = "date:2014-02-01..";
if (argc != 2)
{
g_warning ("Usage: %s EVOLUTION_MAILDIR", argv[0]);
return 1;
}
db_dir = g_file_new_for_path (argv[1]);
db_file = g_file_get_child (db_dir, ".notmuch");
if (!g_file_query_exists (db_dir, NULL))
{
g_object_unref (db_dir);
g_object_unref (db_file);
g_error ("directory %s does not exists");
return 2;
}
if (!g_file_query_exists (db_file, NULL))
status = notmuch_database_create (argv[1], &db);
else
status = notmuch_database_open (argv[1], NOTMUCH_DATABASE_MODE_READ_WRITE, &db);
if (status)
{
g_error ("Could not open database: %d", status);
g_object_unref (db_dir);
g_object_unref (db_file);
notmuch_database_destroy (db);
return 3;
}
scan_directory (db, db_dir);
//loop = g_main_loop_new (NULL, FALSE);
//g_main_loop_run (loop);
query = notmuch_query_create (db, query_string);
if (!query) {
g_error ("Could not create query from string = \"%s\"", query_string);
notmuch_database_destroy (db);
g_object_unref (db_file);
g_object_unref (db_dir);
return 4;
}
g_message ("Query results -\n\n");
for (messages = notmuch_query_search_messages (query);
notmuch_messages_valid (messages);
notmuch_messages_move_to_next (messages)) {
message = notmuch_messages_get (messages);
g_message ("Message file: %s", notmuch_message_get_filename (message));
g_message ("Message ID: %s", notmuch_message_get_message_id (message));
g_message ("Message Sender: %s", notmuch_message_get_header (message, "from"));
g_message ("Message Recipients: %s", notmuch_message_get_header (message, "to"));
g_message ("Message Subject: %s", notmuch_message_get_header (message, "subject"));
g_message ("Message date: %s\n", notmuch_message_get_header (message, "date"));
notmuch_message_destroy (message);
}
notmuch_query_destroy (query);
notmuch_database_destroy (db);
g_object_unref (db_file);
g_object_unref (db_dir);
return 0;
}
static void
fr_command_jar_add (FrCommand *comm,
const char *from_file,
GList *file_list,
const char *base_dir,
gboolean update,
gboolean follow_links)
{
FrProcess *proc = comm->process;
GList *zip_list = NULL, *jardata_list = NULL, *jar_list = NULL;
GList *scan;
char *tmp_dir;
for (scan = file_list; scan; scan = scan->next) {
char *filename = scan->data;
char *path = g_build_filename (base_dir, filename, NULL);
char *package = NULL;
if (_g_filename_has_extension (filename, ".java"))
package = get_package_name_from_java_file (path);
else if (_g_filename_has_extension (filename, ".class"))
package = get_package_name_from_class_file (path);
if ((package == NULL) || (strlen (package) == 0))
zip_list = g_list_append (zip_list, g_strdup (filename));
else {
JarData *newdata = g_new0 (JarData, 1);
newdata->package_minus_one_level = _g_path_remove_level (package);
newdata->link_name = g_strdup (_g_path_get_basename (package));
newdata->rel_path = _g_path_remove_level (filename);
newdata->filename = g_strdup (_g_path_get_basename (filename));
jardata_list = g_list_append (jardata_list, newdata);
}
g_free (package);
g_free (path);
}
tmp_dir = _g_path_get_temp_work_dir (NULL);
for (scan = jardata_list; scan ; scan = scan->next) {
JarData *jdata = scan->data;
char *pack_path;
GFile *directory;
char *old_link;
char *link_name;
int retval;
pack_path = g_build_filename (tmp_dir, jdata->package_minus_one_level, NULL);
directory = g_file_new_for_path (pack_path);
if (! _g_file_make_directory_tree (directory, 0755, NULL)) {
g_object_unref (directory);
g_free (pack_path);
continue;
}
old_link = g_build_filename (base_dir, jdata->rel_path, NULL);
link_name = g_build_filename (pack_path, jdata->link_name, NULL);
retval = symlink (old_link, link_name);
if ((retval != -1) || (errno == EEXIST))
jar_list = g_list_append (jar_list,
g_build_filename (jdata->package_minus_one_level,
jdata->link_name,
jdata->filename,
NULL));
g_free (link_name);
g_free (old_link);
g_object_unref (directory);
g_free (pack_path);
}
if (zip_list != NULL)
FR_COMMAND_CLASS (fr_command_jar_parent_class)->add (comm, NULL, zip_list, base_dir, update, follow_links);
if (jar_list != NULL)
FR_COMMAND_CLASS (fr_command_jar_parent_class)->add (comm, NULL, jar_list, tmp_dir, update, follow_links);
fr_process_begin_command (proc, "rm");
fr_process_set_working_dir (proc, "/");
fr_process_add_arg (proc, "-r");
fr_process_add_arg (proc, "-f");
fr_process_add_arg (proc, tmp_dir);
fr_process_end_command (proc);
fr_process_set_sticky (proc, TRUE);
for (scan = jardata_list; scan ; scan = scan->next) {
JarData *jdata = scan->data;
g_free (jdata->filename);
g_free (jdata->package_minus_one_level);
g_free (jdata->link_name);
g_free (jdata->rel_path);
}
_g_string_list_free (jardata_list);
_g_string_list_free (jar_list);
_g_string_list_free (zip_list);
g_free (tmp_dir);
}
static GtkWidget *
panel_place_menu_item_create_menu (PanelPlaceMenuItem *place_item)
{
GtkWidget *places_menu;
GtkWidget *item;
char *gconf_name;
char *name;
char *uri;
GFile *file;
places_menu = panel_create_menu ();
file = g_file_new_for_path (g_get_home_dir ());
uri = g_file_get_uri (file);
name = panel_util_get_label_for_uri (uri);
g_object_unref (file);
item = panel_menu_item_uri_new (uri, PANEL_ICON_HOME, NULL,
name,
_("Open your personal folder"),
G_CALLBACK (activate_home_uri));
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item);
g_free (name);
g_free (uri);
if (!gconf_client_get_bool (panel_gconf_get_client (),
DESKTOP_IS_HOME_DIR_KEY,
NULL)) {
file = g_file_new_for_path (g_get_user_special_dir (G_USER_DIRECTORY_DESKTOP));
uri = g_file_get_uri (file);
g_object_unref (file);
item = panel_menu_item_uri_new (
/* FIXME: if the dir changes, we'd need to update the drag data since the uri is not the same */
uri, PANEL_ICON_DESKTOP, NULL,
/* Translators: Desktop is used here as in
* "Desktop Folder" (this is not the Desktop
* environment). */
C_("Desktop Folder", "Desktop"),
_("Open the contents of your desktop in a folder"),
G_CALLBACK (activate_desktop_uri));
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item);
g_free (uri);
}
panel_place_menu_item_append_gtk_bookmarks (places_menu);
add_menu_separator (places_menu);
gconf_name = gconf_client_get_string (panel_gconf_get_client (),
COMPUTER_NAME_KEY,
NULL);
if (gconf_name == NULL) {
gconf_name = g_strdup (_("Computer"));
}
item = panel_menu_item_uri_new ("computer://",
PANEL_ICON_COMPUTER, NULL,
gconf_name,
_("Browse all local and remote disks and folders accessible from this computer"),
G_CALLBACK (activate_uri));
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item);
g_free (gconf_name);
panel_place_menu_item_append_local_gio (place_item, places_menu);
add_menu_separator (places_menu);
item = panel_menu_item_uri_new ("network://",
PANEL_ICON_NETWORK, NULL,
_("Network"),
_("Browse bookmarked and local network locations"),
G_CALLBACK (activate_uri));
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item);
panel_place_menu_item_append_remote_gio (place_item, places_menu);
if (panel_is_program_in_path ("nautilus-connect-server")) {
item = panel_menu_items_create_action_item (PANEL_ACTION_CONNECT_SERVER);
if (item != NULL)
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu),
item);
}
add_menu_separator (places_menu);
item = panel_menu_item_desktop_new ("gnome-search-tool.desktop",
NULL,
FALSE);
if (item)
gtk_menu_shell_append (GTK_MENU_SHELL (places_menu), item);
panel_recent_append_documents_menu (places_menu,
place_item->priv->recent_manager);
return places_menu;
}
static void
picture_scaled (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
BgPicturesSource *bg_source;
CcBackgroundItem *item;
GError *error = NULL;
GdkPixbuf *pixbuf;
const char *source_url;
const char *software;
GtkTreeIter iter;
GtkListStore *store;
pixbuf = gdk_pixbuf_new_from_stream_finish (res, &error);
if (pixbuf == NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
g_warning ("Failed to load image: %s", error->message);
g_error_free (error);
return;
}
/* since we were not cancelled, we can now cast user_data
* back to BgPicturesSource.
*/
bg_source = BG_PICTURES_SOURCE (user_data);
store = bg_source_get_liststore (BG_SOURCE (bg_source));
item = g_object_get_data (source_object, "item");
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
1,
(GtkTreeIterCompareFunc)sort_func,
bg_source,
NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
1,
GTK_SORT_ASCENDING);
/* Ignore screenshots */
software = gdk_pixbuf_get_option (pixbuf, "tEXt::Software");
if (software != NULL &&
g_str_equal (software, "gnome-screenshot"))
{
g_debug ("Ignored URL '%s' as it's a screenshot from gnome-screenshot",
cc_background_item_get_uri (item));
g_object_unref (pixbuf);
g_object_unref (item);
return;
}
cc_background_item_load (item, NULL);
/* insert the item into the liststore */
gtk_list_store_insert_with_values (store, &iter, 0,
0, pixbuf,
1, item,
-1);
source_url = cc_background_item_get_source_url (item);
if (source_url != NULL)
{
g_hash_table_insert (bg_source->priv->known_items,
bg_pictures_source_get_unique_filename (source_url), GINT_TO_POINTER (TRUE));
}
else
{
char *cache_path;
GFile *file, *parent, *dir;
cache_path = bg_pictures_source_get_cache_path ();
dir = g_file_new_for_path (cache_path);
g_free (cache_path);
file = g_file_new_for_uri (cc_background_item_get_uri (item));
parent = g_file_get_parent (file);
if (g_file_equal (parent, dir))
{
char *basename;
basename = g_file_get_basename (file);
g_hash_table_insert (bg_source->priv->known_items,
basename, GINT_TO_POINTER (TRUE));
}
g_object_unref (file);
g_object_unref (parent);
}
g_object_unref (pixbuf);
}
static void
panel_place_menu_item_init (PanelPlaceMenuItem *menuitem)
{
GFile *bookmark;
char *bookmarks_filename;
GError *error;
menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem);
gconf_client_add_dir (panel_gconf_get_client (),
DESKTOP_IS_HOME_DIR_DIR,
GCONF_CLIENT_PRELOAD_NONE,
NULL);
gconf_client_add_dir (panel_gconf_get_client (),
NAMES_DIR,
GCONF_CLIENT_PRELOAD_NONE,
NULL);
panel_gconf_notify_add_while_alive (HOME_NAME_KEY,
(GConfClientNotifyFunc) panel_place_menu_item_key_changed,
G_OBJECT (menuitem));
panel_gconf_notify_add_while_alive (DESKTOP_IS_HOME_DIR_KEY,
(GConfClientNotifyFunc) panel_place_menu_item_key_changed,
G_OBJECT (menuitem));
panel_gconf_notify_add_while_alive (COMPUTER_NAME_KEY,
(GConfClientNotifyFunc) panel_place_menu_item_key_changed,
G_OBJECT (menuitem));
menuitem->priv->recent_manager = gtk_recent_manager_get_default ();
bookmarks_filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
bookmark = g_file_new_for_path (bookmarks_filename);
error = NULL;
menuitem->priv->bookmarks_monitor = g_file_monitor_file
(bookmark,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (error) {
g_warning ("Failed to add file monitor for %s: %s\n",
bookmarks_filename, error->message);
g_error_free (error);
} else {
g_signal_connect (G_OBJECT (menuitem->priv->bookmarks_monitor),
"changed",
(GCallback) panel_place_menu_item_gtk_bookmarks_changed,
menuitem);
}
g_object_unref (bookmark);
g_free (bookmarks_filename);
menuitem->priv->volume_monitor = g_volume_monitor_get ();
menuitem->priv->drive_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-changed",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_connected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-connected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_disconnected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-disconnected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->volume_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-added",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-changed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-removed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->mount_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-added",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-changed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-removed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
}
static void
load_desktop_file (GFile *file,
GAsyncResult *result,
GAsyncResult *init_result)
{
HDImagesetBackground *background = HD_IMAGESET_BACKGROUND (g_async_result_get_source_object (init_result));
HDImagesetBackgroundPrivate *priv = background->priv;
char *file_contents = NULL;
gsize file_size;
char *etag;
GKeyFile *key_file = NULL;
guint i;
GError *error = NULL;
char *type = NULL;
g_file_load_contents_finish (file,
result,
&file_contents,
&file_size,
&etag,
&error);
if (error)
{
g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result),
error);
g_error_free (error);
goto complete;
}
key_file = g_key_file_new ();
g_key_file_load_from_data (key_file,
file_contents,
file_size,
G_KEY_FILE_NONE,
&error);
if (error)
{
g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result),
error);
g_error_free (error);
goto complete;
}
type = g_key_file_get_string (key_file,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TYPE,
&error);
if (error)
{
g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result),
error);
g_error_free (error);
goto complete;
}
else if (g_strcmp0 (type, KEY_FILE_BACKGROUND_VALUE_TYPE) != 0)
{
g_simple_async_result_set_error (G_SIMPLE_ASYNC_RESULT (init_result),
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Not a valid imageset .desktop file. Type needs to be Background Image");
}
priv->name = g_key_file_get_string (key_file,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_NAME,
&error);
if (error)
{
g_simple_async_result_set_from_error (G_SIMPLE_ASYNC_RESULT (init_result),
error);
g_error_free (error);
goto complete;
}
int max_value = HD_DESKTOP_VIEWS;
if(hd_backgrounds_is_portrait_wallpaper_enabled (hd_backgrounds_get ()))
max_value += HD_DESKTOP_VIEWS;
for (i = 0; i < max_value; i++)
{
gchar *key, *value;
GFile *image_file;
if (i >= HD_DESKTOP_VIEWS)
key = g_strdup_printf ("X-Portrait-File%u", i + 1 - HD_DESKTOP_VIEWS);
else
key = g_strdup_printf ("X-File%u", i + 1);
value = g_key_file_get_string (key_file,
G_KEY_FILE_DESKTOP_GROUP,
key,
&error);
g_free (key);
if (error)
{
g_error_free (error);
error = NULL;
g_free (value);
continue;
}
g_strstrip (value);
if (g_path_is_absolute (value))
image_file = g_file_new_for_path (value);
else
{
GFile *desktop_parent = g_file_get_parent (file);
image_file = g_file_get_child (desktop_parent,
value);
g_object_unref (desktop_parent);
}
g_free (value);
if (g_file_query_exists (image_file,
NULL))
{
hd_object_vector_push_back (priv->image_files,
image_file);
g_object_unref (image_file);
}
else
{
char *path = g_file_get_path (image_file);
g_simple_async_result_set_error (G_SIMPLE_ASYNC_RESULT (init_result),
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
"Could not find file %s",
path);
g_object_unref (image_file);
g_free (path);
goto complete;
}
}
g_simple_async_result_set_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (init_result),
TRUE);
complete:
g_free (file_contents);
g_free (type);
if (key_file)
g_key_file_free (key_file);
g_simple_async_result_complete (G_SIMPLE_ASYNC_RESULT (init_result));
}
static void pk_backend_get_updates_thread(PkBackendJob *job, GVariant *params, gpointer user_data) {
gchar *pkg_id, *full_name, *desc, **pkg_tokens;
const gchar *pkg_metadata_filename;
GFile *pkg_metadata_dir;
GFileEnumerator *pkg_metadata_enumerator;
GFileInfo *pkg_metadata_file_info;
GError *err = NULL;
sqlite3_stmt *stmt;
PkBackendKatjaJobData *job_data = pk_backend_job_get_user_data(job);
pk_backend_job_set_status(job, PK_STATUS_ENUM_QUERY);
if ((sqlite3_prepare_v2(job_data->db,
"SELECT p1.full_name, p1.name, p1.ver, p1.arch, r.repo, p1.summary, p1.ext "
"FROM pkglist AS p1 NATURAL JOIN repos AS r "
"WHERE p1.name LIKE @name AND p1.repo_order = "
"(SELECT MIN(p2.repo_order) FROM pkglist AS p2 WHERE p2.name = p1.name GROUP BY p2.name)",
-1,
&stmt,
NULL) != SQLITE_OK)) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_CANNOT_GET_FILELIST, "%s", sqlite3_errmsg(job_data->db));
goto out;
}
/* Read the package metadata directory and comprare all installed packages with ones in the cache */
pkg_metadata_dir = g_file_new_for_path("/var/log/packages");
pkg_metadata_enumerator = g_file_enumerate_children(pkg_metadata_dir, "standard::name",
G_FILE_QUERY_INFO_NONE,
NULL,
&err);
g_object_unref(pkg_metadata_dir);
if (err) {
pk_backend_job_error_code(job, PK_ERROR_ENUM_NO_CACHE, "/var/log/packages: %s", err->message);
g_error_free(err);
goto out;
}
while ((pkg_metadata_file_info = g_file_enumerator_next_file(pkg_metadata_enumerator, NULL, NULL))) {
pkg_metadata_filename = g_file_info_get_name(pkg_metadata_file_info);
pkg_tokens = katja_cut_pkg(pkg_metadata_filename);
/* Select the package from the database */
sqlite3_bind_text(stmt, 1, pkg_tokens[0], -1, SQLITE_TRANSIENT);
/* If there are more packages with the same name, remember the one from the repository with the lowest order */
if ((sqlite3_step(stmt) == SQLITE_ROW) ||
g_slist_find_custom(repos, ((gchar *) sqlite3_column_text(stmt, 4)), katja_cmp_repo)) {
full_name = g_strdup((gchar *) sqlite3_column_text(stmt, 0));
if (!g_strcmp0((gchar *) sqlite3_column_text(stmt, 6), "obsolete")) { /* Remove if obsolete */
pkg_id = pk_package_id_build(pkg_tokens[PK_PACKAGE_ID_NAME],
pkg_tokens[PK_PACKAGE_ID_VERSION],
pkg_tokens[PK_PACKAGE_ID_ARCH],
"obsolete");
/* TODO:
* 1: Use the repository name instead of "obsolete" above and check in pk_backend_update_packages()
if the package is obsolete or not
* 2: Get description from /var/log/packages, not from the database */
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));
pk_backend_job_package(job, PK_INFO_ENUM_REMOVING, pkg_id, desc);
g_free(desc);
g_free(pkg_id);
} else if (g_strcmp0(pkg_metadata_filename, full_name)) { /* Update available */
pkg_id = pk_package_id_build((gchar *) sqlite3_column_text(stmt, 1),
(gchar *) sqlite3_column_text(stmt, 2),
(gchar *) sqlite3_column_text(stmt, 3),
(gchar *) sqlite3_column_text(stmt, 4));
desc = g_strdup((gchar *) sqlite3_column_text(stmt, 5));
pk_backend_job_package(job, PK_INFO_ENUM_NORMAL, pkg_id, desc);
g_free(desc);
g_free(pkg_id);
}
g_free(full_name);
}
sqlite3_clear_bindings(stmt);
sqlite3_reset(stmt);
g_strfreev(pkg_tokens);
g_object_unref(pkg_metadata_file_info);
}
g_object_unref(pkg_metadata_enumerator);
out:
sqlite3_finalize(stmt);
}
