static void
eject_done_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
gboolean succeeded;
GError *error = NULL;
GFile *file = G_FILE (user_data);
succeeded = g_mount_eject_with_operation_finish (G_MOUNT (object), res, &error);
g_object_unref (G_MOUNT (object));
if (!succeeded)
{
print_file_error (file, error->message);
success = FALSE;
g_error_free (error);
}
g_object_unref (file);
outstanding_mounts--;
if (outstanding_mounts == 0)
g_main_loop_quit (main_loop);
}
static void _vfs_backend_mount_callback (gpointer pObject, GAsyncResult *res, gpointer *data)
//static void _vfs_backend_mount_callback (gboolean succeeded, char *error, char *detailed_error, gpointer *data)
{
cd_message ("%s (%d)", __func__, GPOINTER_TO_INT (data[1]));
CairoDockFMMountCallback pCallback = data[0];
GError *erreur = NULL;
gboolean bSuccess;
if (GPOINTER_TO_INT (data[1]) == 1)
bSuccess = (g_file_mount_mountable_finish (G_FILE (pObject), res, &erreur) != NULL);
//bSuccess = (g_volume_mount_finish (G_VOLUME (pObject), res, &erreur));
else if (GPOINTER_TO_INT (data[1]) == 0)
bSuccess = g_mount_unmount_finish (G_MOUNT (pObject), res, &erreur);
else
bSuccess = g_mount_eject_finish (G_MOUNT (pObject), res, &erreur);
if (erreur != NULL)
{
cd_warning ("Attention : %s", erreur->message);
g_error_free (erreur);
}
cd_message ("(un)mount fini -> %d", bSuccess);
pCallback (GPOINTER_TO_INT (data[1]) == 1, bSuccess, data[2], data[3], data[4]);
//g_free (data[2]);
//g_object_unref (pObject);
//g_free (data);
}
static void
unmount_mount_callback (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error;
char *primary;
gboolean unmounted;
gboolean should_eject;
GtkWidget *dialog;
should_eject = user_data != NULL;
error = NULL;
if (should_eject) {
unmounted = g_mount_eject_with_operation_finish (G_MOUNT (source_object),
res, &error);
} else {
unmounted = g_mount_unmount_with_operation_finish (G_MOUNT (source_object),
res, &error);
}
if (! unmounted) {
if (error->code != G_IO_ERROR_FAILED_HANDLED) {
if (should_eject) {
primary = g_strdup_printf (_("Unable to eject %p"), source_object);
} else {
primary = g_strdup_printf (_("Unable to unmount %p"), source_object);
}
dialog = gtk_message_dialog_new (NULL,
0,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"%s",
primary);
gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
"%s",
error->message);
gtk_widget_show (GTK_WIDGET (dialog));
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_free (primary);
}
}
if (error != NULL) {
g_error_free (error);
}
}
static void
rb_removable_media_manager_eject_cb (GObject *object,
GAsyncResult *result,
RBRemovableMediaManager *mgr)
{
GError *error = NULL;
if (G_IS_VOLUME (object)) {
GVolume *volume = G_VOLUME (object);
rb_debug ("finishing ejection of volume");
g_volume_eject_finish (volume, result, &error);
if (error == NULL) {
rb_removable_media_manager_remove_volume (mgr, volume);
}
} else if (G_IS_MOUNT (object)) {
GMount *mount = G_MOUNT (object);
rb_debug ("finishing ejection of mount");
g_mount_eject_finish (mount, result, &error);
if (error == NULL) {
rb_removable_media_manager_remove_mount (mgr, mount);
}
}
if (error != NULL) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED)) {
rb_error_dialog (NULL, _("Unable to eject"), "%s", error->message);
} else {
rb_debug ("eject failure has already been handled");
}
g_error_free (error);
}
g_object_unref (mgr);
}
static void
brasero_gio_operation_umount_finish (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
BraseroGioOperation *op = user_data;
if (!op->loop)
return;
op->result = g_mount_unmount_with_operation_finish (G_MOUNT (source),
result,
&op->error);
BRASERO_MEDIA_LOG ("Umount operation completed (result = %d)", op->result);
if (op->error) {
if (op->error->code == G_IO_ERROR_NOT_MOUNTED) {
/* That can happen sometimes */
g_error_free (op->error);
op->error = NULL;
op->result = TRUE;
}
/* Since there was an error. The "unmounted" signal won't be
* emitted by GVolumeMonitor and therefore we'd get stuck if
* we didn't get out of the loop. */
brasero_gio_operation_end (op);
}
else if (!op->result)
brasero_gio_operation_end (op);
}
static char *
shell_util_get_file_display_name_if_mount (GFile *file)
{
GFile *compare;
GVolumeMonitor *monitor;
GList *mounts, *l;
char *ret;
ret = NULL;
/* compare with all mounts */
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (l = mounts; l != NULL; l = l->next)
{
GMount *mount;
mount = G_MOUNT(l->data);
compare = g_mount_get_root (mount);
if (!ret && g_file_equal (file, compare))
ret = g_mount_get_name (mount);
g_object_unref (mount);
}
g_list_free (mounts);
g_object_unref (monitor);
return ret;
}
static const char* get_icon_for_path(const char* path)
{
GVolumeMonitor *monitor;
GList *mounts;
uint i;
GMount *mount;
GIcon *icon;
const char* name = "";
monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (monitor);
for (i = 0; i < g_list_length (mounts); i++) {
mount = G_MOUNT (g_list_nth_data(mounts, i));
if (strcmp(g_mount_get_name(mount), path))
continue;
icon = g_mount_get_icon (mount);
if (!icon)
continue;
name = g_icon_to_string (icon);
g_object_unref (icon);
}
g_list_free_full (mounts, g_object_unref);
return name;
}
static void
eject_cb (GObject *object, GAsyncResult *result, gpointer nothing)
{
GError *error = NULL;
if (G_IS_VOLUME (object)) {
GVolume *volume = G_VOLUME (object);
rb_debug ("finishing ejection of volume");
g_volume_eject_with_operation_finish (volume, result, &error);
} else if (G_IS_MOUNT (object)) {
GMount *mount = G_MOUNT (object);
rb_debug ("finishing ejection of mount");
g_mount_eject_with_operation_finish (mount, result, &error);
}
if (error != NULL) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED)) {
rb_error_dialog (NULL, _("Unable to eject"), "%s", error->message);
} else {
rb_debug ("eject failure has already been handled");
}
g_error_free (error);
}
}
static void
unmount_done_cb (GObject *object, GAsyncResult *result, gpointer psource)
{
GMount *mount;
RBMtpSource *source;
gboolean ok;
GError *error = NULL;
RBMtpSourcePrivate *priv;
mount = G_MOUNT (object);
source = RB_MTP_SOURCE (psource);
priv = MTP_SOURCE_GET_PRIVATE (source);
ok = g_mount_unmount_with_operation_finish (mount, result, &error);
if (ok) {
rb_debug ("successfully unmounted mtp device");
priv->remount_volume = g_mount_get_volume (mount);
open_device (source);
} else {
g_warning ("Unable to unmount MTP device: %s", error->message);
g_error_free (error);
}
g_object_unref (mount);
g_object_unref (source);
}
static gboolean
bookmark_location_mounted_callback (NemoBookmark *bookmark,
GFile *location,
NemoBookmarkList *bookmarks)
{
gboolean ret = FALSE;
GList *volumes = g_volume_monitor_get_mounts (bookmarks->volume_monitor);
GList *iter = volumes;
while (iter != NULL) {
GMount *mount = G_MOUNT (iter->data);
GFile *mount_location = g_mount_get_root (mount);
gchar *mount_root_uri = g_file_get_uri (mount_location);
gchar *location_uri = g_file_get_uri (location);
ret = g_str_has_prefix (location_uri, mount_root_uri);
g_free (mount_root_uri);
g_free (location_uri);
g_object_unref (mount_location);
if (ret == TRUE)
break;
iter = iter->next;
}
g_list_free_full (volumes, (GDestroyNotify) g_object_unref);
return ret;
}
static void
unmount_all_with_scheme (const char *scheme)
{
GVolumeMonitor *volume_monitor;
GList *mounts;
GList *l;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
mounts = g_volume_monitor_get_mounts (volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = G_MOUNT (l->data);
GFile *root;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, scheme)) {
unmount (root);
}
g_object_unref (root);
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
static void on_unmounted(GObject* mnt, GAsyncResult* res, gpointer input_data)
{
#define data ((EjectData*)input_data)
GError* err = NULL;
/* FIXME: with this approach, we could have racing condition.
* Someone may mount other volumes before we finishing unmounting them all. */
gboolean success = g_mount_unmount_finish(G_MOUNT(mnt), res, &err);
if(success)
{
if(data->mounts) /* we still have some volumes on this drive mounted */
unmount_before_eject(data);
else /* all unmounted, do the eject. */
do_eject(data);
}
else
{
GSimpleAsyncResult* res;
GError* error = g_udisks_error_to_gio_error(err);
g_error_free(err);
res = g_simple_async_result_new_from_error(G_OBJECT(data->drv),
data->callback,
data->user_data,
err);
finish_eject(res, data);
g_error_free(error);
}
#undef data
}
static GMount *
find_mount_for_device (GUdevDevice *device)
{
GMount *mount = NULL;
const char *device_file;
GVolumeMonitor *volmon;
GList *mounts;
GList *i;
device_file = g_udev_device_get_device_file (device);
if (device_file == NULL) {
return NULL;
}
volmon = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volmon);
g_object_unref (volmon);
for (i = mounts; i != NULL; i = i->next) {
GVolume *v;
v = g_mount_get_volume (G_MOUNT (i->data));
if (v != NULL) {
char *devname = NULL;
gboolean match;
devname = g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_object_unref (v);
if (devname == NULL)
continue;
match = g_str_equal (devname, device_file);
g_free (devname);
if (match) {
mount = G_MOUNT (i->data);
g_object_ref (G_OBJECT (mount));
break;
}
}
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
return mount;
}
static void on_content_type_finished(GObject* src_obj, GAsyncResult* res, gpointer user_data)
{
AutoRun* data = (AutoRun*)user_data;
GMount* mount = G_MOUNT(src_obj);
char** types;
char* desc = NULL;
types = g_mount_guess_content_type_finish(mount, res, NULL);
if(types)
{
GtkTreeIter it;
GList* apps = NULL, *l;
char** type;
if(types[0])
{
for(type=types;*type;++type)
{
l = g_app_info_get_all_for_type(*type);
if(l)
apps = g_list_concat(apps, l);
}
desc = g_content_type_get_description(types[0]);
}
g_strfreev(types);
if(apps)
{
int pos = 0;
GtkTreePath* tp;
for(l = apps; l; l=l->next, ++pos)
{
GAppInfo* app = G_APP_INFO(l->data);
gtk_list_store_insert_with_values(data->store, &it, pos,
0, g_app_info_get_icon(app),
1, g_app_info_get_name(app),
2, app, -1);
g_object_unref(app);
}
g_list_free(apps);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->store), &it);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(data->view), &it);
tp = gtk_tree_path_new_first();
gtk_tree_view_set_cursor(data->view, tp, NULL, FALSE);
gtk_tree_path_free(tp);
}
}
if(desc)
{
gtk_label_set_text(data->type, desc);
g_free(desc);
}
else
gtk_label_set_text(data->type, _("Removable Disk"));
}
static void
autorun_guessed_content_type_callback (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GError *error;
char **guessed_content_type;
AutorunData *data = user_data;
gboolean open_folder;
open_folder = FALSE;
error = NULL;
guessed_content_type = g_mount_guess_content_type_finish (G_MOUNT (source_object), res, &error);
g_object_set_data_full (source_object,
"caja-content-type-cache",
g_strdupv (guessed_content_type),
(GDestroyNotify)g_strfreev);
if (error != NULL)
{
g_warning ("Unabled to guess content type for mount: %s", error->message);
g_error_free (error);
}
else
{
if (guessed_content_type != NULL && g_strv_length (guessed_content_type) > 0)
{
int n;
for (n = 0; guessed_content_type[n] != NULL; n++)
{
if (do_autorun_for_content_type (data->mount, guessed_content_type[n],
data->open_window_func, data->user_data))
{
open_folder = TRUE;
}
}
g_strfreev (guessed_content_type);
}
else
{
if (g_settings_get_boolean (caja_media_preferences, CAJA_PREFERENCES_MEDIA_AUTOMOUNT_OPEN))
open_folder = TRUE;
}
}
/* only open the folder once.. */
if (open_folder && data->open_window_func != NULL)
{
data->open_window_func (data->mount, data->user_data);
}
g_object_unref (data->mount);
g_free (data);
}
static void unmount_before_eject(EjectData* data)
{
GMount* mnt = G_MOUNT(data->mounts->data);
data->mounts = g_list_delete_link(data->mounts, data->mounts);
/* pop the first GMount in the list. */
g_mount_unmount_with_operation(mnt, data->flags, data->op,
data->cancellable,
on_unmounted, data);
/* FIXME: Notify volume monitor!! */
g_object_unref(mnt);
}
static void
eject_done_cb (GObject *object,
GAsyncResult *res,
gpointer user_data)
{
gboolean succeeded;
GError *error = NULL;
succeeded = g_mount_eject_with_operation_finish (G_MOUNT (object), res, &error);
g_object_unref (G_MOUNT (object));
if (!succeeded)
g_printerr (_("Error ejecting mount: %s\n"), error->message);
outstanding_mounts--;
if (outstanding_mounts == 0)
g_main_loop_quit (main_loop);
}
static GMount *
get_mount_for_mount_path (const char *mount_path,
GCancellable *cancellable)
{
GWin32Mount *mount;
/* TODO: Set mountable volume? */
mount = _g_win32_mount_new (NULL, mount_path, NULL);
return G_MOUNT (mount);
}
static void
unmount_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GMount *mount = G_MOUNT (source_object);
UnmountData *data = user_data;
g_mount_unmount_with_operation_finish (mount, res, &data->error);
g_main_loop_quit (data->loop);
}
int32_t dt_camera_import_backup_job_run(dt_job_t *job)
{
// copy sourcefile to each found destination
dt_camera_import_backup_t *t = (dt_camera_import_backup_t *)job->param;
GVolumeMonitor *vmgr= g_volume_monitor_get();
GList *mounts=g_volume_monitor_get_mounts(vmgr);
GMount *mount=NULL;
GFile *root=NULL;
if( mounts !=NULL )
do
{
mount=G_MOUNT(mounts->data);
if( ( root=g_mount_get_root( mount ) ) != NULL )
{
// Got the mount point lets check for backup folder
gchar *backuppath=NULL;
gchar *rootpath=g_file_get_path(root);
backuppath=g_build_path(G_DIR_SEPARATOR_S,rootpath,dt_conf_get_string("plugins/capture/backup/foldername"),(char *)NULL);
g_free(rootpath);
if( g_file_test(backuppath,G_FILE_TEST_EXISTS)==TRUE)
{
// Found a backup storage, lets copy file here..
gchar *destinationfile=g_build_filename(G_DIR_SEPARATOR_S,backuppath,t->destinationfile,(char *)NULL);
if( g_mkdir_with_parents(g_path_get_dirname(destinationfile),0755) >= 0 )
{
gchar *content;
gsize size;
if( g_file_get_contents(t->sourcefile,&content,&size,NULL) == TRUE )
{
GError *err=NULL;
if( g_file_set_contents(destinationfile,content,size,&err) != TRUE)
{
fprintf(stderr,"Failed to set content of file with reason: %s\n",err->message);
g_error_free(err);
}
g_free(content);
}
}
g_free(destinationfile);
}
g_free(backuppath);
}
}
while( (mounts=g_list_next(mounts)) !=NULL);
// Release volume manager
g_object_unref(vmgr);
return 0;
}
static gchar *
get_tracker_volume_name (const gchar *uri,
const gchar *datasource)
{
gchar *source_name = NULL;
GVolumeMonitor *volume_monitor;
GList *mounts, *mount;
GFile *file;
if (uri != NULL && *uri != '\0') {
volume_monitor = g_volume_monitor_get ();
mounts = g_volume_monitor_get_mounts (volume_monitor);
file = g_file_new_for_uri (uri);
mount = mounts;
while (mount != NULL) {
GFile *m_file = g_mount_get_root (G_MOUNT (mount->data));
if (g_file_equal (m_file, file)) {
gchar *m_name = g_mount_get_name (G_MOUNT (mount->data));
g_object_unref (G_OBJECT (m_file));
source_name = g_strdup_printf (_("Removable - %s"), m_name);
g_free (m_name);
break;
}
g_object_unref (G_OBJECT (m_file));
mount = mount->next;
}
g_list_free_full (mounts, g_object_unref);
g_object_unref (G_OBJECT (file));
g_object_unref (G_OBJECT (volume_monitor));
} else {
source_name = g_strdup (_("Local files"));
}
return source_name;
}
static void on_mount_action_finished(GObject* src, GAsyncResult *res, gpointer user_data)
{
struct MountData* data = user_data;
switch(data->action)
{
case MOUNT_VOLUME:
data->ret = g_volume_mount_finish(G_VOLUME(src), res, &data->err);
break;
case MOUNT_GFILE:
data->ret = g_file_mount_enclosing_volume_finish(G_FILE(src), res, &data->err);
break;
case UMOUNT_MOUNT:
data->ret = g_mount_unmount_with_operation_finish(G_MOUNT(src), res, &data->err);
break;
case EJECT_MOUNT:
data->ret = g_mount_eject_with_operation_finish(G_MOUNT(src), res, &data->err);
break;
case EJECT_VOLUME:
data->ret = g_volume_eject_with_operation_finish(G_VOLUME(src), res, &data->err);
break;
}
g_main_loop_quit(data->loop);
}
static void
unmount_cb (GObject *object, GAsyncResult *result, gpointer nothing)
{
GMount *mount = G_MOUNT (object);
GError *error = NULL;
rb_debug ("finishing unmount of mount");
g_mount_unmount_with_operation_finish (mount, result, &error);
if (error != NULL) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED)) {
rb_error_dialog (NULL, _("Unable to unmount"), "%s", error->message);
} else {
rb_debug ("unmount failure has already been handled");
}
g_error_free (error);
}
}
static void
xfdesktop_volume_icon_unmount_finish(GObject *object,
GAsyncResult *result,
gpointer user_data)
{
XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data);
GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon));
GtkWidget *toplevel = gtk_widget_get_toplevel(icon_view);
GMount *mount = G_MOUNT(object);
GError *error = NULL;
gboolean unmount_successful;
g_return_if_fail(G_IS_MOUNT(object));
g_return_if_fail(G_IS_ASYNC_RESULT(result));
g_return_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon));
unmount_successful = g_mount_unmount_with_operation_finish(mount, result, &error);
if(!unmount_successful) {
/* ignore GIO errors handled internally */
if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) {
gchar *mount_name = g_mount_get_name(mount);
gchar *primary = g_markup_printf_escaped(_("Failed to eject \"%s\""),
mount_name);
/* display an error dialog to inform the user */
xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL,
_("Eject Failed"), GTK_STOCK_DIALOG_ERROR,
primary, error->message,
GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL);
g_free(primary);
g_free(mount_name);
}
g_error_free(error);
}
#ifdef HAVE_LIBNOTIFY
xfdesktop_notify_unmount_finish(mount, unmount_successful);
#endif
g_object_unref(icon);
}
static GMount *
get_mount_for_mount_path (const char *mount_path,
GCancellable *cancellable)
{
GUnixMountEntry *mount_entry;
GUnixMount *mount;
mount_entry = g_unix_mount_at (mount_path, NULL);
if (!mount_entry)
return NULL;
/* TODO: Set mountable volume? */
mount = _g_unix_mount_new (NULL, mount_entry, NULL);
g_unix_mount_free (mount_entry);
return G_MOUNT (mount);
}
static void
rb_removable_media_manager_unmount_cb (GObject *object,
GAsyncResult *result,
RBRemovableMediaManager *mgr)
{
GMount *mount = G_MOUNT (object);
GError *error = NULL;
rb_debug ("finishing unmount of mount");
g_mount_unmount_finish (mount, result, &error);
if (error != NULL) {
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED_HANDLED)) {
rb_error_dialog (NULL, _("Unable to unmount"), "%s", error->message);
} else {
rb_debug ("unmount failure has already been handled");
}
g_error_free (error);
} else {
rb_removable_media_manager_remove_mount (mgr, mount);
}
g_object_unref (mgr);
}
static void
nautilus_x_content_bar_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
NautilusXContentBar *bar;
bar = NAUTILUS_X_CONTENT_BAR (object);
switch (prop_id) {
case PROP_MOUNT:
nautilus_x_content_bar_set_mount (bar, G_MOUNT (g_value_get_object (value)));
break;
case PROP_X_CONTENT_TYPE:
nautilus_x_content_bar_set_x_content_type (bar, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_types_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GetContentTypesData *data;
char **types;
data = user_data;
types = g_mount_guess_content_type_finish (G_MOUNT (source_object), res, NULL);
g_object_set_data_full (source_object,
"nautilus-content-type-cache",
g_strdupv (types),
(GDestroyNotify)g_strfreev);
if (data->callback) {
data->callback ((const char **) types, data->user_data);
}
g_strfreev (types);
g_slice_free (GetContentTypesData, data);
}
/**
* rb_removable_media_manager_scan:
* @manager: the #RBRemovableMediaManager
*
* Initiates a new scan of all attached media. Newly activated plugins that use
* the create-source-volume or create-source-mount signals should call this if
* the 'scanned' property is %TRUE. Otherwise, the first scan will catch any
* existing volumes or mounts that the plugin is interested in.
*/
void
rb_removable_media_manager_scan (RBRemovableMediaManager *manager)
{
RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (manager);
GHashTableIter iter;
GList *list, *it;
gpointer hkey, hvalue;
priv->scanned = TRUE;
/* check volumes first */
list = g_volume_monitor_get_volumes (priv->volume_monitor);
/* - check for volumes that have disappeared */
g_hash_table_iter_init (&iter, priv->volume_mapping);
while (g_hash_table_iter_next (&iter, &hkey, &hvalue)) {
GVolume *volume = G_VOLUME (hkey);
if (g_list_index (list, volume) == -1) {
/* volume has vanished */
rb_removable_media_manager_remove_volume (manager, volume);
}
}
/* - check for newly added volumes */
for (it = list; it != NULL; it = g_list_next (it)) {
GVolume *volume = G_VOLUME (it->data);
rb_removable_media_manager_add_volume (manager, volume);
g_object_unref (volume);
}
g_list_free (list);
/* check mounts */
list = g_volume_monitor_get_mounts (priv->volume_monitor);
/* - check for mounts that have disappeared */
g_hash_table_iter_init (&iter, priv->mount_mapping);
while (g_hash_table_iter_next (&iter, &hkey, &hvalue)) {
GMount *mount = G_MOUNT (hkey);
if (g_list_index (list, mount) == -1) {
rb_removable_media_manager_remove_mount (manager, mount);
}
}
/* - check for newly added mounts */
for (it = list; it != NULL; it = g_list_next (it)) {
GMount *mount = G_MOUNT (it->data);
rb_removable_media_manager_add_mount (manager, mount);
g_object_unref (mount);
}
g_list_free (list);
/* - check devices */
#if defined(HAVE_GUDEV)
list = g_udev_client_query_by_subsystem (priv->gudev_client, "usb");
for (it = list; it != NULL; it = g_list_next (it)) {
/* pretend the device was just added */
uevent_cb (priv->gudev_client, "add", G_UDEV_DEVICE (it->data), manager);
}
g_list_free (list);
#endif
}
int
main (int argc, char **argv)
{
g_autoptr(GError) error = NULL;
setlocale (LC_ALL, "");
if (argc < 5 || (argc % 2) != 1)
{
g_printerr ("Usage: %s REPO MOUNT-ROOT COLLECTION-ID REF-NAME [COLLECTION-ID REF-NAME …]\n", argv[0]);
return 1;
}
g_autoptr(GMainContext) context = g_main_context_new ();
g_main_context_push_thread_default (context);
g_autoptr(OstreeRepo) parent_repo = ostree_repo_open_at (AT_FDCWD, argv[1], NULL, &error);
g_assert_no_error (error);
/* Set up a mock volume. */
g_autoptr(GFile) mount_root = g_file_new_for_commandline_arg (argv[2]);
g_autoptr(GMount) mount = G_MOUNT (ostree_mock_mount_new ("mount", mount_root));
g_autoptr(GList) mounts = g_list_prepend (NULL, mount);
g_autoptr(GVolumeMonitor) monitor = ostree_mock_volume_monitor_new (mounts, NULL);
g_autoptr(OstreeRepoFinderMount) finder = ostree_repo_finder_mount_new (monitor);
/* Resolve the refs. */
g_autoptr(GPtrArray) refs = g_ptr_array_new_with_free_func ((GDestroyNotify) collection_ref_free0);
for (gsize i = 3; i < argc; i += 2)
{
const char *collection_id = argv[i];
const char *ref_name = argv[i + 1];
g_ptr_array_add (refs, ostree_collection_ref_new (collection_id, ref_name));
}
g_ptr_array_add (refs, NULL); /* NULL terminator */
g_autoptr(GAsyncResult) result = NULL;
ostree_repo_finder_resolve_async (OSTREE_REPO_FINDER (finder),
(const OstreeCollectionRef * const *) refs->pdata,
parent_repo, NULL, result_cb, &result);
while (result == NULL)
g_main_context_iteration (context, TRUE);
g_autoptr(GPtrArray) results = ostree_repo_finder_resolve_finish (OSTREE_REPO_FINDER (finder),
result, &error);
g_assert_no_error (error);
/* Check that the results are correct: the invalid refs should have been
* ignored, and the valid results canonicalised and deduplicated. */
for (gsize i = 0; i < results->len; i++)
{
const OstreeRepoFinderResult *result = g_ptr_array_index (results, i);
GHashTableIter iter;
OstreeCollectionRef *ref;
const gchar *checksum;
g_hash_table_iter_init (&iter, result->ref_to_checksum);
while (g_hash_table_iter_next (&iter, (gpointer *) &ref, (gpointer *) &checksum))
g_print ("%" G_GSIZE_FORMAT " %s %s %s %s\n",
i, ostree_remote_get_name (result->remote),
ref->collection_id, ref->ref_name,
checksum);
}
g_main_context_pop_thread_default (context);
return 0;
}
