char * rb_gvolume_get_udi (GVolume *volume, gpointer ctx) { char *udi, *dev, **udis; int num_udis; g_return_val_if_fail (volume != NULL, NULL); g_return_val_if_fail (G_IS_VOLUME (volume), NULL); g_return_val_if_fail (ctx != NULL, NULL); udi = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_HAL_UDI); if (udi != NULL) return udi; dev = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); udis = libhal_manager_find_device_string_match ((LibHalContext *) ctx, "block.device", dev, &num_udis, NULL); if (udis == NULL || num_udis < 1) { libhal_free_string_array (udis); return NULL; } udi = g_strdup (udis[0]); libhal_free_string_array (udis); return udi; }
static gboolean ignore_volume (GVolume *volume) { gboolean ret = TRUE; char *path; GDrive *drive; /* Ignore drive? */ drive = g_volume_get_drive (volume); if (drive != NULL && ignore_drive (drive)) { g_object_unref (drive); return TRUE; } g_clear_object (&drive); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (path != NULL) { ret = FALSE; g_free (path); } else { GRL_DEBUG ("%s: Not adding volume %s as it has no identifier", __FUNCTION__, g_volume_get_name (volume)); } return ret; }
GVolume * tvm_g_volume_monitor_get_volume_for_kind (GVolumeMonitor *monitor, const gchar *kind, const gchar *identifier) { GVolume *volume = NULL; GList *volumes; GList *lp; gchar *value; g_return_val_if_fail (G_IS_VOLUME_MONITOR (monitor), NULL); g_return_val_if_fail (kind != NULL && *kind != '\0', NULL); g_return_val_if_fail (identifier != NULL && *identifier != '\0', NULL); volumes = g_volume_monitor_get_volumes (monitor); for (lp = volumes; volume == NULL && lp != NULL; lp = lp->next) { value = g_volume_get_identifier (lp->data, kind); if (value != NULL) { if (g_strcmp0 (value, identifier) == 0) volume = g_object_ref (lp->data); g_free (value); } g_object_unref (lp->data); } g_list_free (volumes); return volume; }
static gboolean volume_is_blank (GVolume *volume) { BraseroMediumMonitor *monitor; BraseroMedium *medium; BraseroDrive *drive; gchar *device; gboolean is_blank; is_blank = FALSE; device = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (!device) return FALSE; DEBUG_PRINT ("Got device: %s\n", device); monitor = brasero_medium_monitor_get_default (); drive = brasero_medium_monitor_get_drive (monitor, device); g_object_unref (monitor); g_free (device); if (drive == NULL) return FALSE; medium = brasero_drive_get_medium (drive); is_blank = (brasero_medium_get_status (medium) & BRASERO_MEDIUM_BLANK); g_object_unref (drive); return is_blank; }
void on_vol_added(GVolumeMonitor* vm, GVolume* vol, gpointer user_data) { FmPlacesModel* model = FM_PLACES_MODEL(user_data); g_debug("add vol: %p, uuid: %s, udi: %s", vol, g_volume_get_identifier(vol, "uuid"), g_volume_get_identifier(vol, "hal-udi")); add_vol(model, vol, NULL); update_sep_tp(model); }
static GList * add_volume (GList *media_list, GVolume *volume, GDrive *drive, GrlOpticalMediaSource *source) { char *name, *icon_uri; GIcon *icon; char *device_path, *id; GrlMedia * media; GMount *mount; device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (device_path == NULL) return media_list; /* Is it an audio CD or a blank media */ mount = g_volume_get_mount (volume); if (mount != NULL) { GFile *root; root = g_mount_get_root (mount); g_object_unref (mount); if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) { /* We don't add Audio CDs, or blank media */ g_object_unref (root); g_free (device_path); return media_list; } g_object_unref (root); } media = grl_media_video_new (); id = g_filename_to_uri (device_path, NULL, NULL); g_free (device_path); grl_media_set_id (media, id); g_free (id); /* Work out an icon to display */ icon = g_volume_get_icon (volume); icon_uri = get_uri_for_gicon (icon); g_object_unref (icon); grl_media_set_thumbnail (media, icon_uri); g_free (icon_uri); /* Get the volume's pretty name for the menu label */ name = g_volume_get_name (volume); g_strstrip (name); grl_media_set_title (media, name); g_free (name); grl_media_set_mime (media, "x-special/device-block"); return g_list_prepend (media_list, media); }
static void mount_with_device_file_cb (GObject *object, GAsyncResult *res, gpointer user_data) { GVolume *volume; gboolean succeeded; GError *error = NULL; volume = G_VOLUME (object); succeeded = g_volume_mount_finish (volume, res, &error); if (!succeeded) { g_printerr (_("Error mounting %s: %s\n"), g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), error->message); g_error_free (error); success = FALSE; } else { GMount *mount; GFile *root; char *mount_path; mount = g_volume_get_mount (volume); root = g_mount_get_root (mount); mount_path = g_file_get_path (root); g_print (_("Mounted %s at %s\n"), g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), mount_path); g_object_unref (mount); g_object_unref (root); g_free (mount_path); } outstanding_mounts--; if (outstanding_mounts == 0) g_main_loop_quit (main_loop); }
static int is_sdb(GVolume* volume) { char* dev_path = g_volume_get_identifier(volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (dev_path == NULL) { return 0; } int is_sdb = strstr(dev_path, "/dev/sdb") != NULL; free(dev_path); return is_sdb; }
static gchar * get_device_path (NemoAction *action, NemoFile *file) { GMount *mount = nemo_file_get_mount (file); GVolume *volume = g_mount_get_volume (mount); gchar *ret = NULL; if (action->escape_space) { gchar *id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); ret = eel_str_escape_spaces (id); g_free (id); } else { ret = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); } g_object_unref (mount); g_object_unref (volume); return ret; }
static void debug_device_info (RBGenericPlayerSource *source, GMount *mount, const char *what) { char *dbg; char *path; RBGenericPlayerSourcePrivate *priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source); GVolume *volume; volume = g_mount_get_volume (mount); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); rb_debug ("device information for %s from %s", path, what); g_free (path); g_object_unref (volume); if (priv->audio_folders != NULL) { dbg = g_strjoinv (", ", priv->audio_folders); rb_debug ("audio folders: %s", dbg); g_free (dbg); } else { rb_debug ("no audio folders set"); } if (priv->output_mime_types != NULL) { dbg = g_strjoinv (", ", priv->output_mime_types); rb_debug ("output types: %s", dbg); g_free (dbg); } else { rb_debug ("no output types set"); } if (priv->playlist_format_unknown) { rb_debug ("playlist format is unknown"); } else { if (priv->playlist_format_m3u) rb_debug ("M3U playlist format is supported"); if (priv->playlist_format_pls) rb_debug ("PLS playlist format is supported"); if (priv->playlist_format_iriver_pla) rb_debug ("iRiver PLA playlist format is supported"); } if (priv->playlist_path != NULL) { rb_debug ("playlist path: %s", priv->playlist_path); } else { rb_debug ("no playlist path is set"); } if (priv->folder_depth == -1) { rb_debug ("audio folder depth is not set"); } else { rb_debug ("audio folder depth: %d", priv->folder_depth); } }
static gchar * xfdesktop_volume_icon_get_identifier(XfdesktopIcon *icon) { XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon); gchar *uuid; uuid = g_volume_get_identifier(volume_icon->priv->volume, G_VOLUME_IDENTIFIER_KIND_UUID); if(uuid == NULL) return g_strdup(xfdesktop_volume_icon_peek_label(icon)); return uuid; }
static gboolean check_dvd_video (GVolume *volume) { GFile *file; char *udi, *device_path, *mount_path; gboolean result; GMount *mount; if (!volume) return FALSE; mount = g_volume_get_mount (volume); if (!mount) return FALSE; file = g_mount_get_root (mount); g_object_unref (mount); if (!file) return FALSE; mount_path = g_file_get_path (file); g_object_unref (file); device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); udi = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_HAL_UDI); result = gvm_check_dvd_only (udi, device_path, mount_path); g_free (device_path); g_free (udi); g_free (mount_path); return result; }
RBRemovableMediaSource * rb_generic_player_source_new (RBShell *shell, GMount *mount) { RBGenericPlayerSource *source; RhythmDBEntryType entry_type; RhythmDBEntryType error_type; RhythmDBEntryType ignore_type; RhythmDB *db; GVolume *volume; char *name; char *path; g_assert (rb_generic_player_is_mount_player (mount)); volume = g_mount_get_volume (mount); g_object_get (G_OBJECT (shell), "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("generic audio player: %s", path); entry_type = rhythmdb_entry_register_type (db, name); g_free (name); name = g_strdup_printf ("generic audio player (ignore): %s", path); ignore_type = rhythmdb_entry_register_type (db, name); g_free (name); name = g_strdup_printf ("generic audio player (errors): %s", path); error_type = rhythmdb_entry_register_type (db, name); g_free (name); g_object_unref (db); g_object_unref (volume); g_free (path); source = RB_GENERIC_PLAYER_SOURCE (g_object_new (RB_TYPE_GENERIC_PLAYER_SOURCE, "entry-type", entry_type, "ignore-entry-type", ignore_type, "error-entry-type", error_type, "mount", mount, "shell", shell, "source-group", RB_SOURCE_GROUP_DEVICES, NULL)); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_REMOVABLE_MEDIA_SOURCE (source); }
char * rb_ipod_helpers_get_device (RBSource *source) { GMount *mount; GVolume *volume; char *device; g_object_get (RB_SOURCE (source), "mount", &mount, NULL); volume = g_mount_get_volume (mount); device = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (G_OBJECT (volume)); g_object_unref (G_OBJECT (mount)); return device; }
void GioLister::DeviceInfo::ReadVolumeInfo(GVolume* volume) { this->volume.reset_without_add(volume); if (!volume) return; volume_name = ConvertAndFree(g_volume_get_name(volume)); volume_uuid = ConvertAndFree(g_volume_get_uuid(volume)); volume_unix_device = ConvertAndFree(g_volume_get_identifier( volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE)); GFile* root = g_volume_get_activation_root(volume); if (root) { volume_root_uri = g_file_get_uri(root); g_object_unref(root); } }
static gpointer rb_audiocd_load_songs (RBAudioCdSource *source) { RBAudioCdSourcePrivate *priv = AUDIOCD_SOURCE_GET_PRIVATE (source); RhythmDB *db; GVolume *volume; g_object_get (source, "volume", &volume, NULL); priv->device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (volume); db = get_db_for_source (source); rb_debug ("loading Audio CD from %s", priv->device_path); /* create a cdda gstreamer element, to get cd info from */ priv->cdda = gst_element_make_from_uri (GST_URI_SRC, "cdda://", NULL); if (!priv->cdda) { gdk_threads_enter (); rb_error_dialog (NULL, _("Couldn't load Audio CD"), _("Rhythmbox could not get access to the CD device.")); gdk_threads_leave (); goto error_out; } rb_debug ("cdda longname: %s", gst_element_factory_get_longname (gst_element_get_factory (priv->cdda))); g_object_set (G_OBJECT (priv->cdda), "device", priv->device_path, NULL); priv->pipeline = gst_pipeline_new ("pipeline"); priv->fakesink = gst_element_factory_make ("fakesink", "fakesink"); gst_bin_add_many (GST_BIN (priv->pipeline), priv->cdda, priv->fakesink, NULL); gst_element_link (priv->cdda, priv->fakesink); /* disable paranoia (if using cdparanoia) since we're only reading track information here. * this reduces cdparanoia's cache size, so the process is much faster. */ if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "paranoia-mode")) g_object_set (source, "paranoia-mode", 0, NULL); if (rb_audiocd_scan_songs (source, db)) rb_audiocd_load_metadata (source, db); error_out: g_object_unref (db); g_object_unref (source); return NULL; }
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; }
/** * rb_removable_media_manager_get_gudev_device: * @manager: the #RBRemovableMediaManager * @volume: the #GVolume * * Finds the #GUdevDevice for the volume. * * Return value: (transfer full): the #GUDevDevice instance, if any */ GObject * rb_removable_media_manager_get_gudev_device (RBRemovableMediaManager *manager, GVolume *volume) { #if defined(HAVE_GUDEV) RBRemovableMediaManagerPrivate *priv = GET_PRIVATE (manager); char *devpath; GUdevDevice *udevice = NULL; devpath = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (devpath != NULL) udevice = g_udev_client_query_by_device_file (priv->gudev_client, devpath); g_free (devpath); return G_OBJECT (udevice); #else return NULL; #endif }
static void mount_with_device_file (const char *device_file) { GVolumeMonitor *volume_monitor; GList *volumes; GList *l; volume_monitor = g_volume_monitor_get(); volumes = g_volume_monitor_get_volumes (volume_monitor); for (l = volumes; l != NULL; l = l->next) { GVolume *volume = G_VOLUME (l->data); gchar *id; id = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (g_strcmp0 (id, device_file) == 0) { GMountOperation *op; op = new_mount_op (); g_volume_mount (volume, G_MOUNT_MOUNT_NONE, op, NULL, mount_with_device_file_cb, id); outstanding_mounts++; } else g_free (id); } g_list_free_full (volumes, g_object_unref); if (outstanding_mounts == 0) { print_error ("%s: %s", device_file, _("No volume for device file")); success = FALSE; } g_object_unref (volume_monitor); }
static void mount_with_device_file (const char *device_file) { GVolumeMonitor *volume_monitor; GList *volumes; GList *l; volume_monitor = g_volume_monitor_get(); volumes = g_volume_monitor_get_volumes (volume_monitor); for (l = volumes; l != NULL; l = l->next) { GVolume *volume = G_VOLUME (l->data); if (g_strcmp0 (g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), device_file) == 0) { GMountOperation *op; op = new_mount_op (); g_volume_mount (volume, G_MOUNT_MOUNT_NONE, op, NULL, mount_with_device_file_cb, op); outstanding_mounts++; } } g_list_foreach (volumes, (GFunc) g_object_unref, NULL); g_list_free (volumes); if (outstanding_mounts == 0) { g_print (_("No volume for device file %s\n"), device_file); return; } g_object_unref (volume_monitor); }
RBSource * rb_psp_source_new (GObject *plugin, RBShell *shell, GMount *mount, MPIDDevice *device_info) { RBPspSource *source; RhythmDBEntryType *entry_type; RhythmDB *db; char *name; char *path; GVolume *volume; g_assert (rb_psp_is_mount_player (mount, device_info)); volume = g_mount_get_volume (mount); g_object_get (G_OBJECT (shell), "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("psp: %s", path); entry_type = g_object_new (RHYTHMDB_TYPE_ENTRY_TYPE, "db", db, "name", name, "save-to-disk", FALSE, "category", RHYTHMDB_ENTRY_NORMAL, NULL); rhythmdb_register_entry_type (db, entry_type); g_object_unref (db); g_free (name); g_free (path); g_object_unref (volume); source = RB_PSP_SOURCE (g_object_new (RB_TYPE_PSP_SOURCE, "plugin", plugin, "entry-type", entry_type, "mount", mount, "shell", shell, "device-info", device_info, NULL)); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_SOURCE (source); }
static void cmd_duplicate_cd (GtkAction *action, RBDiscRecorderPlugin *pi) { gchar *device; GVolume *volume; if (!pi->selected_source) return; g_object_get (pi->selected_source, "volume", &volume, NULL); if (G_IS_VOLUME (volume)) device = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); else device = NULL; g_object_unref (volume); rb_disc_recorder_plugin_start_burning (pi, device, TRUE); g_free (device); }
static GMount * totem_get_mount_for_dvd (const char *uri) { GMount *mount; char *path; mount = NULL; path = g_strdup (uri + strlen ("dvd://")); /* If it's a device, we need to find the volume that corresponds to it, * and then the mount for the volume */ if (g_str_has_prefix (path, "/dev/")) { GVolumeMonitor *volume_monitor; GList *volumes, *l; volume_monitor = g_volume_monitor_get (); volumes = g_volume_monitor_get_volumes (volume_monitor); g_object_unref (volume_monitor); for (l = volumes; l != NULL; l = l->next) { char *id; id = g_volume_get_identifier (l->data, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (g_strcmp0 (id, path) == 0) { g_free (id); mount = g_volume_get_mount (l->data); break; } g_free (id); } g_list_foreach (volumes, (GFunc) g_object_unref, NULL); g_list_free (volumes); } else { mount = totem_get_mount_for_uri (path); g_free (path); } /* We have a path to the file itself */ return mount; }
RBSource * rb_audiocd_source_new (RBPlugin *plugin, RBShell *shell, GVolume *volume) { GObject *source; RhythmDBEntryType entry_type; RhythmDB *db; char *name; char *path; g_object_get (shell, "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("audiocd: %s", path); entry_type = rhythmdb_entry_register_type (db, name); g_free (name); g_free (path); g_object_unref (db); entry_type->category = RHYTHMDB_ENTRY_NORMAL; entry_type->can_sync_metadata = (RhythmDBEntryCanSyncFunc)rb_true_function; /* TODO save the metadata somewhere */ entry_type->sync_metadata = (RhythmDBEntrySyncFunc)rb_null_function; entry_type->entry_type_data_size = sizeof(RBAudioCDEntryData); source = g_object_new (RB_TYPE_AUDIOCD_SOURCE, "entry-type", entry_type, "volume", volume, "shell", shell, "sorting-key", NULL, "source-group", RB_SOURCE_GROUP_DEVICES, "plugin", plugin, NULL); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_SOURCE (source); }
RBRemovableMediaSource * rb_nokia770_source_new (RBPlugin *plugin, RBShell *shell, GMount *mount, MPIDDevice *device_info) { RBNokia770Source *source; RhythmDBEntryType entry_type; RhythmDB *db; GVolume *volume; char *name; char *path; g_assert (rb_nokia770_is_mount_player (mount, device_info)); volume = g_mount_get_volume (mount); g_object_get (G_OBJECT (shell), "db", &db, NULL); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); name = g_strdup_printf ("nokia770: %s", path); entry_type = rhythmdb_entry_register_type (db, name); g_object_unref (db); g_free (name); g_free (path); g_object_unref (volume); source = RB_NOKIA770_SOURCE (g_object_new (RB_TYPE_NOKIA770_SOURCE, "plugin", plugin, "entry-type", entry_type, "ignore-entry-type", RHYTHMDB_ENTRY_TYPE_INVALID, "error-entry-type", RHYTHMDB_ENTRY_TYPE_INVALID, "mount", mount, "shell", shell, "source-group", RB_SOURCE_GROUP_DEVICES, "device-info", device_info, NULL)); rb_shell_register_entry_type_for_source (shell, RB_SOURCE (source), entry_type); return RB_REMOVABLE_MEDIA_SOURCE (source); }
static void cmd_duplicate_cd (GtkAction *action, RBCdRecorderPlugin *pi) { if (pi->selected_source != NULL) { GVolume *volume; char *device_path, *cmd; GError *error = NULL; g_object_get (G_OBJECT (pi->selected_source), "volume", &volume, NULL); device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); g_object_unref (volume); cmd = g_strconcat ("nautilus-cd-burner --source-device=", device_path, NULL); if (!g_spawn_command_line_async (cmd, &error)) { GtkWidget *dialog; GtkWidget *toplevel; toplevel = gtk_widget_get_toplevel (GTK_WIDGET (pi->selected_source)); dialog = gtk_message_dialog_new_with_markup (GTK_WINDOW (toplevel), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "<b>%s</b>\n\n%s\n%s: %s", _("Could not duplicate disc"), _("Rhythmbox could not duplicate the disc"), _("Reason"), error->message); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); g_error_free (error); } g_free (cmd); } }
static void dump_volume_identifiers (GVolume *volume) { char **identifiers; int i; if (volume == NULL) { rb_debug ("mount has no volume"); return; } /* dump all volume identifiers in debug output */ identifiers = g_volume_enumerate_identifiers (volume); if (identifiers != NULL) { for (i = 0; identifiers[i] != NULL; i++) { char *ident; ident = g_volume_get_identifier (volume, identifiers[i]); rb_debug ("%s = %s", identifiers[i], ident); } g_strfreev (identifiers); } }
static void list_volumes (GList *volumes, int indent, gboolean only_with_no_drive) { GList *l, *mounts; int c, i; GMount *mount; GVolume *volume; GDrive *drive; char *name; char *uuid; GFile *activation_root; char **ids; GIcon *icon; char *type_name; const gchar *sort_key; for (c = 0, l = volumes; l != NULL; l = l->next, c++) { volume = (GVolume *) l->data; if (only_with_no_drive) { drive = g_volume_get_drive (volume); if (drive != NULL) { g_object_unref (drive); continue; } } name = g_volume_get_name (volume); g_print ("%*sVolume(%d): %s\n", indent, "", c, name); g_free (name); type_name = get_type_name (volume); g_print ("%*sType: %s\n", indent+2, "", type_name); g_free (type_name); if (extra_detail) { ids = g_volume_enumerate_identifiers (volume); if (ids && ids[0] != NULL) { g_print ("%*sids:\n", indent+2, ""); for (i = 0; ids[i] != NULL; i++) { char *id = g_volume_get_identifier (volume, ids[i]); g_print ("%*s %s: '%s'\n", indent+2, "", ids[i], id); g_free (id); } } g_strfreev (ids); uuid = g_volume_get_uuid (volume); if (uuid) g_print ("%*suuid=%s\n", indent + 2, "", uuid); activation_root = g_volume_get_activation_root (volume); if (activation_root) { char *uri; uri = g_file_get_uri (activation_root); g_print ("%*sactivation_root=%s\n", indent + 2, "", uri); g_free (uri); g_object_unref (activation_root); } icon = g_volume_get_icon (volume); if (icon) { if (G_IS_THEMED_ICON (icon)) show_themed_icon_names (G_THEMED_ICON (icon), indent + 2); g_object_unref (icon); } g_print ("%*scan_mount=%d\n", indent + 2, "", g_volume_can_mount (volume)); g_print ("%*scan_eject=%d\n", indent + 2, "", g_volume_can_eject (volume)); g_print ("%*sshould_automount=%d\n", indent + 2, "", g_volume_should_automount (volume)); sort_key = g_volume_get_sort_key (volume); if (sort_key != NULL) g_print ("%*ssort_key=%s\n", indent + 2, "", sort_key); g_free (uuid); } mount = g_volume_get_mount (volume); if (mount) { mounts = g_list_prepend (NULL, mount); list_mounts (mounts, indent + 2, FALSE); g_list_free (mounts); g_object_unref (mount); } } }
void on_vol_added(GVolumeMonitor* vm, GVolume* vol, gpointer user_data) { g_debug("add vol: %p, uuid: %s, udi: %s", vol, g_volume_get_identifier(vol, "uuid"), g_volume_get_identifier(vol, "hal-udi")); add_vol(vol); }
int main (int argc, char *argv[]) { int ret; GError *error; MduPool *pool; MduDevice *device; MduDevice *device_to_unmount; MduDevice *device_to_mount; MduPresentable *volume; gchar *volume_name; gchar *confirmation_secondary; GtkWidget *dialog; gint response; gchar *fs_type; gchar *fs_label; gboolean encrypt; gchar *passphrase; gboolean save_passphrase_in_keyring; gboolean save_passphrase_in_keyring_session; GMainLoop *loop; GVolumeMonitor *gvolume_monitor; GList *l; GList *gvolumes; GVolume *gvolume; GMount *gmount; gboolean take_ownership; FormatData *format_data; MduPresentable *toplevel; gchar *drive_name; gchar *format_desc; gchar *formatting_desc; gchar *size_str; gint grace_timeout_id; ret = 1; pool = NULL; device = NULL; device_to_unmount = NULL; device_to_mount = NULL; volume = NULL; volume_name = NULL; confirmation_secondary = NULL; dialog = NULL; fs_type = NULL; fs_label = NULL; passphrase = NULL; loop = NULL; volume = NULL; gmount = NULL; gvolume_monitor = NULL; gvolumes = NULL; gvolume = NULL; gmount = NULL; format_data = NULL; toplevel = NULL; drive_name = NULL; format_desc = NULL; formatting_desc = NULL; size_str = NULL; #if !GLIB_CHECK_VERSION (2, 32, 0) g_thread_init (NULL); #endif /* Initialize gettext support */ bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Initialize gtk */ error = NULL; if (! gtk_init_with_args (&argc, &argv, NULL, entries, GETTEXT_PACKAGE, &error)) { g_printerr ("Could not parse arguments: %s\n", error->message); g_error_free (error); goto out; } loop = g_main_loop_new (NULL, FALSE); g_set_prgname ("mdu-format-tool"); g_set_application_name (_("Mate Disk Utility formatting tool")); if (device_file == NULL) { g_printerr ("Incorrect usage. Try --help.\n"); goto out; } pool = mdu_pool_new (); if (pool == NULL) { g_warning ("Unable to get device pool"); goto out; } device = mdu_pool_get_by_device_file (pool, device_file); if (device == NULL) { g_printerr ("No device for %s\n", device_file); goto out; } /* if the user specified a luks device, find the slave backing device */ if (mdu_device_is_luks_cleartext (device)) { const gchar *slave; slave = mdu_device_luks_cleartext_get_slave (device); g_object_ref (device); device = mdu_pool_get_by_object_path (pool, slave); /* don't support LUKS in LUKS... */ g_assert (!mdu_device_is_luks_cleartext (device)); } volume = mdu_pool_get_volume_by_device (pool, device); if (volume == NULL) { g_printerr ("%s is not a volume\n", device_file); goto out; } volume_name = mdu_presentable_get_name (volume); toplevel = mdu_presentable_get_toplevel (MDU_PRESENTABLE (volume)); if (toplevel != NULL && MDU_IS_DRIVE (toplevel)) { drive_name = mdu_presentable_get_name (toplevel); } size_str = mdu_util_get_size_for_display (mdu_device_get_size (device), FALSE, FALSE); if (drive_name != NULL) { if (mdu_device_is_partition (device)) { /* Translators: First argument is the partition number, second argument is the drive name, * third argument is the size (e.g. 10 GB) */ format_desc = g_strdup_printf (_("Format partition %d of %s (%s)"), mdu_device_partition_get_number (device), drive_name, size_str); /* Translators: First argument is the partition number, second argument is the drive name, * third argument is the size (e.g. 10 GB) */ formatting_desc = g_strdup_printf (_("Formatting partition %d of %s (%s)"), mdu_device_partition_get_number (device), drive_name, size_str); } else { /* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */ format_desc = g_strdup_printf (_("Format %s (%s)"), drive_name, size_str); /* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */ formatting_desc = g_strdup_printf (_("Formatting %s (%s)"), drive_name, size_str); } } else { /* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */ format_desc = g_strdup_printf (_("Format %s Volume (%s)"), size_str, mdu_device_get_device_file (device)); /* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */ formatting_desc = g_strdup_printf (_("Formatting %s Volume (%s)"), size_str, mdu_device_get_device_file (device)); } dialog = mdu_format_dialog_new (NULL, /* no parent window */ volume, MDU_FORMAT_DIALOG_FLAGS_SIMPLE | MDU_FORMAT_DIALOG_FLAGS_DISK_UTILITY_BUTTON); gtk_window_set_title (GTK_WINDOW (dialog), format_desc); gtk_window_set_icon_name (GTK_WINDOW (dialog), "caja-mdu"); gtk_widget_show_all (dialog); response = gtk_dialog_run (GTK_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_OK: break; case GTK_RESPONSE_ACCEPT: gtk_widget_destroy (dialog); dialog = NULL; launch_mate_disk (device_file); goto out; default: /* explicit fallthrough */ case GTK_RESPONSE_CANCEL: goto out; } fs_type = mdu_format_dialog_get_fs_type (MDU_FORMAT_DIALOG (dialog)); fs_label = mdu_format_dialog_get_fs_label (MDU_FORMAT_DIALOG (dialog)); encrypt = mdu_format_dialog_get_encrypt (MDU_FORMAT_DIALOG (dialog)); gtk_widget_destroy (dialog); dialog = NULL; /* Ask for passphrase if needed */ passphrase = NULL; save_passphrase_in_keyring = FALSE; save_passphrase_in_keyring_session = FALSE; if (encrypt) { passphrase = mdu_util_dialog_ask_for_new_secret (NULL, &save_passphrase_in_keyring, &save_passphrase_in_keyring_session); if (passphrase == NULL) goto out; } take_ownership = (g_strcmp0 (fs_type, "vfat") != 0); format_data = g_new0 (FormatData, 1); format_data->loop = loop; format_data->error = NULL; dialog = mdu_format_progress_dialog_new (NULL, device, _("Preparing...")); gtk_window_set_title (GTK_WINDOW (dialog), formatting_desc); gtk_widget_show_all (dialog); g_signal_connect (dialog, "response", G_CALLBACK (on_progress_dialog_response), format_data); /* first a small 2.5 sec window to allow the user to cancel before initiating */ grace_timeout_id = g_timeout_add (2500, on_grace_timeout, format_data); g_main_loop_run (loop); g_source_remove (grace_timeout_id); if (format_data->error != NULL && format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_CANCELLED) { /* cancelled already, we are done */ goto out; } /* then unmount the mount if needed; we use GIO for this to handle tearing * down LUKS; first determine the device to unmount */ if (mdu_device_is_luks (device)) { const gchar *holder; holder = mdu_device_luks_get_holder (device); device_to_unmount = mdu_pool_get_by_object_path (pool, holder); } else { device_to_unmount = g_object_ref (device); } g_assert (device_to_unmount != NULL); gvolume_monitor = g_volume_monitor_get (); gvolumes = g_volume_monitor_get_volumes (gvolume_monitor); for (l = gvolumes; l != NULL; l = l->next) { GVolume *v = G_VOLUME (l->data); if (g_strcmp0 (g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), mdu_device_get_device_file (device_to_unmount)) == 0) { gvolume = g_object_ref (v); break; } } if (gvolume != NULL) { gmount = g_volume_get_mount (gvolume); if (gmount != NULL) { GMountOperation *mount_op; mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Unmounting...")); mount_op = gtk_mount_operation_new (GTK_WINDOW (dialog)); g_mount_unmount_with_operation (gmount, G_MOUNT_UNMOUNT_NONE, mount_op, NULL, unmount_cb, format_data); g_object_unref (mount_op); g_main_loop_run (format_data->loop); if (format_data->error != NULL) { if (!(format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_FAILED_HANDLED)) { gchar *primary; primary = g_strdup_printf (_("Unable to format '%s'"), volume_name); show_error_dialog (NULL, primary, format_data->error->message); g_free (primary); } g_error_free (format_data->error); goto out; } } } /* and now, kick off the operation */ mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Formatting...")); mdu_device_op_filesystem_create (device, fs_type, fs_label, passphrase, take_ownership, fs_create_cb, format_data); again: g_main_loop_run (loop); if (format_data->error != NULL) { gtk_widget_destroy (dialog); dialog = NULL; if (format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_CANCELLED) { mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Cancelling...")); /* cancel the job; no callback since op_filesystem_create will return an error */ mdu_device_op_cancel_job (device, NULL, NULL); goto again; } else { show_error_dialog (NULL, _("Error formatting volume"), format_data->error->message); g_error_free (format_data->error); } goto out; } /* ugh, DeviceKit-disks bug - spin around in the mainloop for some time to ensure we * have gotten all changes */ mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Mounting volume...")); g_timeout_add (1500, on_hack_timeout, loop); g_main_loop_run (loop); /* OK, peachy, now mount the volume and open a window */ if (passphrase != NULL) { const gchar *cleartext_objpath; g_assert (mdu_device_is_luks (device)); cleartext_objpath = mdu_device_luks_get_holder (device); device_to_mount = mdu_pool_get_by_object_path (pool, cleartext_objpath); } else { device_to_mount = g_object_ref (device); } mdu_device_op_filesystem_mount (device_to_mount, NULL, fs_mount_cb, format_data); g_main_loop_run (loop); gtk_widget_destroy (dialog); dialog = NULL; if (format_data->error != NULL) { show_error_dialog (NULL, _("Error mounting device"), format_data->error->message); g_error_free (format_data->error); goto out; } /* open file manager */ launch_file_manager (format_data->mount_point); g_free (format_data->mount_point); /* save passphrase in keyring if requested */ if (passphrase != NULL && (save_passphrase_in_keyring || save_passphrase_in_keyring_session)) { if (!mdu_util_save_secret (device, passphrase, save_passphrase_in_keyring_session)) { show_error_dialog (NULL, _("Error storing passphrase in keyring"), ""); goto out; } } ret = 0; out: if (toplevel != NULL) g_object_unref (toplevel); g_free (drive_name); g_free (size_str); g_free (format_desc); g_free (formatting_desc); if (gmount != NULL) g_object_unref (gmount); if (gvolume != NULL) g_object_unref (gvolume); g_list_foreach (gvolumes, (GFunc) g_object_unref, NULL); if (gvolume_monitor != NULL) g_object_unref (gvolume_monitor); g_free (confirmation_secondary); g_free (volume_name); g_free (passphrase); g_free (fs_type); g_free (fs_label); g_free (device_file); if (loop != NULL) g_main_loop_unref (loop); if (dialog != NULL) gtk_widget_destroy (dialog); if (volume != NULL) g_object_unref (volume); if (device != NULL) g_object_unref (device); if (device_to_unmount != NULL) g_object_unref (device_to_unmount); if (device_to_mount != NULL) g_object_unref (device_to_mount); if (pool != NULL) g_object_unref (pool); if (format_data != NULL) g_free (format_data); return ret; }