/**
* Start mount operation and wait in loop until it is finished. This method is
* called from thread which is trying to read from location.
*/
nsresult
nsGIOInputStream::MountVolume() {
GMountOperation* mount_op = g_mount_operation_new();
g_signal_connect (mount_op, "ask-password",
G_CALLBACK (mount_operation_ask_password), mChannel);
mMountRes = MOUNT_OPERATION_IN_PROGRESS;
/* g_file_mount_enclosing_volume uses a dbus request to mount the volume.
Callback mount_enclosing_volume_finished is called in main thread
(not this thread on which this method is called). */
g_file_mount_enclosing_volume(mHandle,
G_MOUNT_MOUNT_NONE,
mount_op,
nullptr,
mount_enclosing_volume_finished,
this);
mozilla::MonitorAutoLock mon(mMonitorMountInProgress);
/* Waiting for finish of mount operation thread */
while (mMountRes == MOUNT_OPERATION_IN_PROGRESS)
mon.Wait();
g_object_unref(mount_op);
if (mMountRes == MOUNT_OPERATION_FAILED) {
return MapGIOResult(mMountErrorCode);
} else {
return NS_OK;
}
}
void browse_callback(GObject *widget, gpointer user_data)
{
GFile *file;
char *address, *uri;
address = g_strdup (g_object_get_data (widget, "address"));
if (address == NULL) {
GtkWidget *dialog, *selector, *content_area;
int response_id;
dialog = gtk_dialog_new_with_buttons(_("Select Device to Browse"), NULL,
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
gtk_dialog_add_button (GTK_DIALOG (dialog), _("_Browse"), GTK_RESPONSE_ACCEPT);
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog),
GTK_RESPONSE_ACCEPT, FALSE);
gtk_window_set_default_size(GTK_WINDOW(dialog), 480, 400);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (content_area), 2);
selector = bluetooth_chooser_new(_("Select device to browse"));
gtk_container_set_border_width(GTK_CONTAINER(selector), 5);
gtk_widget_show(selector);
g_object_set(selector,
"show-searching", FALSE,
"show-device-category", FALSE,
"show-device-type", TRUE,
"device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED,
"device-service-filter", "OBEXFileTransfer",
NULL);
g_signal_connect(selector, "selected-device-changed",
G_CALLBACK(select_device_changed), dialog);
gtk_container_add (GTK_CONTAINER (content_area), selector);
address = NULL;
response_id = gtk_dialog_run (GTK_DIALOG (dialog));
if (response_id == GTK_RESPONSE_ACCEPT)
g_object_get (G_OBJECT (selector), "device-selected", &address, NULL);
gtk_widget_destroy (dialog);
if (response_id != GTK_RESPONSE_ACCEPT)
return;
}
uri = g_strdup_printf ("obex://[%s]/", address);
g_free (address);
file = g_file_new_for_uri (uri);
g_free (uri);
g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE, NULL, NULL, mount_finish_cb, NULL);
g_object_unref (file);
}
/* This is a somewhat hacky way to get FTP to almost work. The proper way to
* get FTP to _really_ work involves hacking GIO to have APIs to handle
* canoncial URLs.
*/
static GFile *
webkit_soup_request_file_ensure_file_ftp (SoupURI *uri,
GCancellable *cancellable,
GError **error)
{
SoupURI *host;
char *s;
GFile *file, *result;
GMount *mount;
host = soup_uri_copy_host (uri);
s = soup_uri_to_string (host, FALSE);
file = g_file_new_for_uri (s);
soup_uri_free (host);
g_free (s);
mount = g_file_find_enclosing_mount (file, cancellable, error);
if (mount == NULL && g_file_supports_thread_contexts (file)) {
GMainContext *context = g_main_context_new ();
GMainLoop *loop = g_main_loop_new (context, FALSE);
g_clear_error (error);
g_main_context_push_thread_default (context);
g_file_mount_enclosing_volume (file,
G_MOUNT_MOUNT_NONE,
NULL, /* FIXME! */
cancellable,
webkit_soup_request_file_ftp_main_loop_quit,
loop);
g_main_loop_run (loop);
g_main_context_pop_thread_default (context);
g_main_loop_unref (loop);
g_main_context_unref (context);
mount = g_file_find_enclosing_mount (file, cancellable, error);
}
if (mount == NULL)
return NULL;
g_object_unref (file);
file = g_mount_get_default_location (mount);
g_object_unref (mount);
s = g_strdup (uri->path);
if (strchr (s, ';'))
*strchr (s, ';') = 0;
result = g_file_resolve_relative_path (file, s);
g_free (s);
g_object_unref (file);
return result;
}
static gboolean
_panel_show_handle_error (const gchar *uri,
GdkScreen *screen,
GError *local_error,
GError **error)
{
if (local_error == NULL)
return TRUE;
else if (g_error_matches (local_error,
G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
g_error_free (local_error);
return TRUE;
}
else if (g_error_matches (local_error,
G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) {
GFile *file;
PanelShowMountOperationHandle *handle;
handle = g_slice_new (PanelShowMountOperationHandle);
file = g_file_new_for_uri (uri);
/* If it's not mounted, try to mount it ourselves */
handle->mount_op = gtk_mount_operation_new (NULL);
gtk_mount_operation_set_screen (GTK_MOUNT_OPERATION (handle->mount_op),
screen);
handle->screen = screen;
g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE,
handle->mount_op, NULL,
_panel_show_mount_async_callback,
handle);
g_object_unref (file);
return TRUE;
}
else if (error != NULL)
g_propagate_error (error, local_error);
else {
_panel_show_error_dialog (uri, screen, local_error->message);
g_error_free (local_error);
}
return FALSE;
}
static void
mount (GFile *file)
{
GMountOperation *op;
if (file == NULL)
return;
op = new_mount_op ();
if (mount_mountable)
g_file_mount_mountable (file, 0, op, NULL, mount_mountable_done_cb, op);
else
g_file_mount_enclosing_volume (file, 0, op, NULL, mount_done_cb, op);
outstanding_mounts++;
}
static gboolean
mount_enclosing_volume (GFile *file,
GError **error)
{
GMountOperation *operation = gtk_mount_operation_new (NULL);
g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE,
operation,
NULL,
(GAsyncReadyCallback) mount_volume_ready,
error);
gtk_main ();
g_object_unref (operation);
return (*error == NULL);
}
static gboolean
message_handler (GstBus * bus, GstMessage * message, gpointer user_data)
{
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ELEMENT:{
const GstStructure *s = gst_message_get_structure (message);
const gchar *name = gst_structure_get_name (s);
if (strcmp (name, "not-mounted") == 0) {
GMountOperation *mop = gtk_mount_operation_new (NULL);
GFile *file =
G_FILE (g_value_get_object (gst_structure_get_value (s, "file")));
g_print ("not-mounted\n");
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_bus_set_flushing (bus, TRUE);
g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE,
mop, NULL, mount_cb, bus);
g_object_unref (mop);
}
break;
}
case GST_MESSAGE_EOS:
g_print ("EOS\n");
gtk_main_quit ();
break;
case GST_MESSAGE_ERROR:{
GError *err = NULL;
gst_message_parse_error (message, &err, NULL);
g_print ("error: %s\n", err->message);
g_clear_error (&err);
gtk_main_quit ();
break;
}
default:
break;
}
return TRUE;
}
static void on_find_enclosing_mount_ready (GObject * object, GAsyncResult * res, gpointer data)
{
GError *error = NULL;
GDownloadable *download = G_DOWNLOADABLE (data);
GMount *mount = g_file_find_enclosing_mount_finish (G_FILE(object), res, &error);
g_assert (download != NULL);
if (mount) {
handle_error (error);
GMountOperation * operation = g_mount_operation_new ();
g_mount_operation_set_anonymous (operation, TRUE);
g_file_mount_enclosing_volume (download->priv->remote_file, 0, operation, NULL, on_mount_enclosing_ready, data);
// TODO: ask username & password
g_object_unref (operation);
g_object_unref (mount);
} else {
after_mount_enclosing_volume (download);
}
}
static void
get_folder_content_done_cb (GError *error,
gpointer user_data)
{
LoadData *load_data = user_data;
FrFileSelectorDialog *self = load_data->dialog;
GtkListStore *list_store;
GList *scan;
GtkTreeIter iter;
GDateTime *today;
int sort_column_id;
GtkSortType sort_order;
GHashTable *selected_files;
if (error != NULL) {
if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED)) {
GMountOperation *operation;
operation = gtk_mount_operation_new (GTK_WINDOW (self));
g_file_mount_enclosing_volume (load_data->folder,
G_MOUNT_MOUNT_NONE,
operation,
load_data->cancellable,
folder_mount_enclosing_volume_ready_cb,
load_data);
g_object_unref (operation);
return;
}
if (! g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
_gtk_error_dialog_run (GTK_WINDOW (self), _("Could not load the location"), "%s", error->message);
if (load_data->dialog->priv->current_operation == load_data)
load_data->dialog->priv->current_operation = NULL;
load_data_free (load_data);
return;
}
load_data->files = g_list_reverse (load_data->files);
today = g_date_time_new_now_local ();
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), &sort_column_id, &sort_order);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, 0);
selected_files = g_hash_table_new (g_file_hash, (GEqualFunc) g_file_equal);
for (scan = load_data->files_to_select; scan; scan = scan->next)
g_hash_table_insert(selected_files, scan->data, GINT_TO_POINTER (1));
list_store = GTK_LIST_STORE (GET_WIDGET ("files_liststore"));
gtk_list_store_clear (list_store);
for (scan = load_data->files; scan; scan = scan->next) {
FileInfo *file_info = scan->data;
GdkPixbuf *icon_pixbuf;
char *size;
GTimeVal timeval;
GDateTime *datetime;
char *modified;
char *collate_key;
gboolean is_folder;
if (! self->priv->show_hidden && g_file_info_get_is_hidden (file_info->info))
continue;
gtk_list_store_append (list_store, &iter);
icon_pixbuf = gth_icon_cache_get_pixbuf (self->priv->icon_cache, g_file_info_get_icon (file_info->info));
size = g_format_size (g_file_info_get_size (file_info->info));
g_file_info_get_modification_time (file_info->info, &timeval);
datetime = g_date_time_new_from_timeval_local (&timeval);
modified = g_date_time_format (datetime, _g_date_time_same_day (datetime, today) ? "%X" : "%x");
collate_key = g_utf8_collate_key_for_filename (g_file_info_get_display_name (file_info->info), -1);
is_folder = (g_file_info_get_file_type (file_info->info) == G_FILE_TYPE_DIRECTORY);
gtk_list_store_set (list_store, &iter,
FILE_LIST_COLUMN_ICON, icon_pixbuf,
FILE_LIST_COLUMN_NAME, g_file_info_get_display_name (file_info->info),
FILE_LIST_COLUMN_SIZE, (is_folder ? "" : size),
FILE_LIST_COLUMN_MODIFIED, modified,
FILE_LIST_COLUMN_FILE, file_info->file,
FILE_LIST_COLUMN_NAME_ORDER, collate_key,
FILE_LIST_COLUMN_SIZE_ORDER, g_file_info_get_size (file_info->info),
FILE_LIST_COLUMN_MODIFIED_ORDER, timeval.tv_sec,
FILE_LIST_COLUMN_IS_FOLDER, is_folder,
FILE_LIST_COLUMN_IS_SELECTED, (g_hash_table_lookup (selected_files, file_info->file) != NULL),
-1);
g_free (collate_key);
g_free (modified);
g_date_time_unref (datetime);
g_free (size);
_g_object_unref (icon_pixbuf);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("files_liststore")), sort_column_id, sort_order);
set_current_folder (self, load_data->folder);
if (load_data->dialog->priv->current_operation == load_data)
load_data->dialog->priv->current_operation = NULL;
g_hash_table_unref (selected_files);
g_date_time_unref (today);
load_data_free (load_data);
}
static gboolean fm_do_mount(GtkWindow* parent, GObject* obj, MountAction action, gboolean interactive)
{
gboolean ret;
struct MountData* data = g_new0(struct MountData, 1);
/* bug #3615234: it seems GtkMountOperations is buggy and sometimes leaves
parent window reference intact while destroys itself so it leads to
severe memory corruption, therefore we pass here NULL as parent window
to gtk_mount_operation_new() to not bind it to anything as a workaround */
GMountOperation* op = interactive ? gtk_mount_operation_new(NULL) : NULL;
GCancellable* cancellable = g_cancellable_new();
data->loop = g_main_loop_new (NULL, TRUE);
data->action = action;
switch(data->action)
{
case MOUNT_VOLUME:
g_volume_mount(G_VOLUME(obj), 0, op, cancellable, on_mount_action_finished, data);
break;
case MOUNT_GFILE:
g_file_mount_enclosing_volume(G_FILE(obj), 0, op, cancellable, on_mount_action_finished, data);
break;
case UMOUNT_MOUNT:
prepare_unmount(G_MOUNT(obj));
g_mount_unmount_with_operation(G_MOUNT(obj), G_MOUNT_UNMOUNT_NONE, op, cancellable, on_mount_action_finished, data);
break;
case EJECT_MOUNT:
prepare_unmount(G_MOUNT(obj));
g_mount_eject_with_operation(G_MOUNT(obj), G_MOUNT_UNMOUNT_NONE, op, cancellable, on_mount_action_finished, data);
break;
case EJECT_VOLUME:
{
GMount* mnt = g_volume_get_mount(G_VOLUME(obj));
if (mnt) /* it might be unmounted already */
{
prepare_unmount(mnt);
g_object_unref(mnt);
}
g_volume_eject_with_operation(G_VOLUME(obj), G_MOUNT_UNMOUNT_NONE, op, cancellable, on_mount_action_finished, data);
}
break;
}
/* FIXME: create progress window with busy cursor */
if (g_main_loop_is_running(data->loop))
{
GDK_THREADS_LEAVE();
g_main_loop_run(data->loop);
GDK_THREADS_ENTER();
}
g_main_loop_unref(data->loop);
ret = data->ret;
if(data->err)
{
if(interactive)
{
if(data->err->domain == G_IO_ERROR)
{
if(data->err->code == G_IO_ERROR_FAILED)
{
/* Generate a more human-readable error message instead of using a gvfs one. */
/* The original error message is something like:
* Error unmounting: umount exited with exit code 1:
* helper failed with: umount: only root can unmount
* UUID=18cbf00c-e65f-445a-bccc-11964bdea05d from /media/sda4 */
/* Why they pass this back to us?
* This is not human-readable for the users at all. */
if(strstr(data->err->message, "only root can "))
{
g_debug("%s", data->err->message);
g_free(data->err->message);
data->err->message = g_strdup(_("Only system administrators have the permission to do this."));
}
}
else if(data->err->code == G_IO_ERROR_FAILED_HANDLED)
interactive = FALSE;
}
if(interactive)
fm_show_error(parent, NULL, data->err->message);
}
g_error_free(data->err);
}
g_free(data);
g_object_unref(cancellable);
if(op)
g_object_unref(op);
return ret;
}
gboolean
file_remote_mount_file (Gimp *gimp,
GFile *file,
GimpProgress *progress,
GError **error)
{
GMountOperation *operation;
RemoteMount mount = { 0, };
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (G_IS_FILE (file), FALSE);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
mount.progress = progress;
mount.main_loop = g_main_loop_new (NULL, FALSE);
operation = gimp_get_mount_operation (gimp, progress);
if (progress)
{
gimp_progress_start (progress, TRUE, _("Mounting remote volume"));
mount.cancellable = g_cancellable_new ();
g_signal_connect (progress, "cancel",
G_CALLBACK (file_remote_mount_file_cancel),
&mount);
}
g_file_mount_enclosing_volume (file, G_MOUNT_MOUNT_NONE,
operation, mount.cancellable,
(GAsyncReadyCallback) file_remote_mount_volume_ready,
&mount);
g_main_loop_run (mount.main_loop);
g_main_loop_unref (mount.main_loop);
if (progress)
{
g_signal_handlers_disconnect_by_func (progress,
file_remote_mount_file_cancel,
&mount);
g_object_unref (mount.cancellable);
gimp_progress_end (progress);
}
g_object_unref (operation);
if (mount.error)
{
if (mount.error->domain != G_IO_ERROR ||
mount.error->code != G_IO_ERROR_ALREADY_MOUNTED)
{
g_propagate_error (error, mount.error);
return FALSE;
}
else
{
g_clear_error (&mount.error);
}
}
return TRUE;
}