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;
}
