void
on_format_button_clicked(GtkWidget* w, gpointer user_data)
{
FormatDialog* dialog = g_object_get_data( G_OBJECT(gtk_widget_get_toplevel(w)), "userdata" );
FormatVolume* vol;
gchar* fs = NULL;
gboolean do_encrypt = FALSE;
/* Figure out the device params */
GtkTreeIter iter;
if(!gtk_combo_box_get_active_iter(dialog->volume_combo, &iter))
return;
if( !(vol = get_cached_device_from_treeiter(dialog, &iter)) )
return;
fs = get_fs_from_menu(dialog);
if(!fs) goto error_out;
if(!warn_user_of_impending_doom(dialog, vol)) {
g_debug("User cancelled format!");
goto error_out;
}
/* TODO: Here's where we'll add the floppy support */
gboolean create_table = !(vol->volume || libhal_drive_no_partitions_hint(vol->drive));
start_operation(dialog, 2 + (create_table ? 1 : 0) + (do_encrypt ? 1 : 0));
if(create_table) {
do_next_operation(dialog, _("Creating partition table..."));
/* TODO: Figure out what to do if any other partition is mounted on this drive */
if(!(vol = write_partition_table(dialog, vol, fs)))
goto error_out;
if(!vol->volume)
goto error_out;
}
if(do_encrypt) {
/* TODO: Set up encryption here */
}
g_debug("Creating filesystem on %s...\n", vol->friendly_name);
do_next_operation(dialog, _("Creating filesystem..."));
do_mkfs(dialog, libhal_volume_get_device_file(vol->volume));
do_next_operation(dialog, _("Syncing changes..."));
g_spawn_command_line_sync("sync", NULL, NULL, NULL, NULL);
error_out:
if(fs)
g_free(fs);
return;
}
static int pusb_volume_mount(t_pusb_options *opts, LibHalVolume **volume,
LibHalContext *ctx)
{
char command[1024];
char tempname[32];
const char *devname;
const char *udi;
const char *fs;
snprintf(tempname, sizeof(tempname), "pam_usb%d", getpid());
if (!(devname = libhal_volume_get_device_file(*volume)))
{
log_error("Unable to retrieve device filename\n");
return (0);
}
fs = libhal_volume_get_fstype(*volume);
log_debug("Attempting to mount device %s with label %s\n",
devname, tempname);
if (!fs)
snprintf(command, sizeof(command), "pmount -A -s %s %s",
devname, tempname);
else
snprintf(command, sizeof(command), "pmount -A -s -t %s %s %s",
fs, devname, tempname);
log_debug("Executing \"%s\"\n", command);
if (system(command) != 0)
{
log_error("Mount failed\n");
return (0);
}
udi = libhal_volume_get_udi(*volume);
if (!udi)
{
log_error("Unable to retrieve volume UDI\n");
return (0);
}
udi = strdup(udi);
libhal_volume_free(*volume);
*volume = libhal_volume_from_udi(ctx, udi);
free((char *)udi);
log_debug("Mount succeeded.\n");
return (1);
}
static void
thunar_vfs_volume_hal_update (ThunarVfsVolumeHal *volume_hal,
LibHalContext *context,
LibHalVolume *hv,
LibHalDrive *hd)
{
gchar *desired_mount_point;
gchar *mount_root;
gchar *basename;
gchar *filename;
_thunar_vfs_return_if_fail (THUNAR_VFS_IS_VOLUME_HAL (volume_hal));
_thunar_vfs_return_if_fail (hd != NULL);
/* reset the volume status */
volume_hal->status = 0;
/* determine the new device file */
g_free (volume_hal->device_file);
volume_hal->device_file = g_strdup ((hv != NULL) ? libhal_volume_get_device_file (hv) : libhal_drive_get_device_file (hd));
/* compute a usable display name for the volume/drive */
g_free (volume_hal->device_label);
volume_hal->device_label = (hv == NULL)
? exo_hal_drive_compute_display_name (context, hd)
: exo_hal_volume_compute_display_name (context, hv, hd);
if (G_UNLIKELY (volume_hal->device_label == NULL))
{
/* use the basename of the device file as label */
volume_hal->device_label = g_path_get_basename (volume_hal->device_file);
}
/* compute a usable list of icon names for the volume/drive */
g_list_foreach (volume_hal->icon_list, (GFunc) g_free, NULL);
g_list_free (volume_hal->icon_list);
volume_hal->icon_list = (hv == NULL)
? exo_hal_drive_compute_icon_list (context, hd)
: exo_hal_volume_compute_icon_list (context, hv, hd);
/* release the previous mount point (if any) */
if (G_LIKELY (volume_hal->mount_point != NULL))
{
thunar_vfs_path_unref (volume_hal->mount_point);
volume_hal->mount_point = NULL;
}
/* determine the type of the volume */
switch (libhal_drive_get_type (hd))
{
case LIBHAL_DRIVE_TYPE_CDROM:
/* check if we have a pure audio CD without any data track */
if (libhal_volume_disc_has_audio (hv) && !libhal_volume_disc_has_data (hv))
{
/* special treatment for pure audio CDs */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_AUDIO_CD;
}
else
{
/* check which kind of CD-ROM/DVD we have */
switch (libhal_volume_get_disc_type (hv))
{
case LIBHAL_VOLUME_DISC_TYPE_CDROM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDROM;
break;
case LIBHAL_VOLUME_DISC_TYPE_CDR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDR;
break;
case LIBHAL_VOLUME_DISC_TYPE_CDRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDRW;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDROM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDROM;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDRAM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDRAM;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDR;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDRW;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDPLUSR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDPLUSR;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDPLUSRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDPLUSRW;
break;
default:
/* unsupported disc type */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_UNKNOWN;
break;
}
}
break;
case LIBHAL_DRIVE_TYPE_FLOPPY:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_FLOPPY;
break;
case LIBHAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_AUDIO_PLAYER;
break;
case LIBHAL_DRIVE_TYPE_SMART_MEDIA:
case LIBHAL_DRIVE_TYPE_SD_MMC:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_MEMORY_CARD;
break;
default:
/* check if the drive is connected to the USB bus */
if (libhal_drive_get_bus (hd) == LIBHAL_DRIVE_BUS_USB)
{
/* we consider the drive to be an USB stick */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_USBSTICK;
}
else if (libhal_drive_uses_removable_media (hd)
|| libhal_drive_is_hotpluggable (hd))
{
/* fallback to generic removable disk */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_REMOVABLE_DISK;
}
else
{
/* fallback to harddisk drive */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_HARDDISK;
}
break;
}
/* either we have a volume, which means we have media, or
* a drive, which means non-pollable then, so it's present
*/
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_PRESENT;
/* figure out if the volume is mountable */
if(hv != NULL && libhal_volume_get_fsusage (hv) == LIBHAL_VOLUME_USAGE_MOUNTABLE_FILESYSTEM)
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTABLE;
/* check if the drive requires eject */
volume_hal->requires_eject = libhal_drive_requires_eject (hd);
/* check if the volume is currently mounted */
if (hv != NULL && libhal_volume_is_mounted (hv))
{
/* try to determine the new mount point */
volume_hal->mount_point = thunar_vfs_path_new (libhal_volume_get_mount_point (hv), NULL);
/* we only mark the volume as mounted if we have a valid mount point */
if (G_LIKELY (volume_hal->mount_point != NULL))
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTED | THUNAR_VFS_VOLUME_STATUS_PRESENT;
}
else
{
/* we don't trust HAL, so let's see what the kernel says about the volume */
volume_hal->mount_point = thunar_vfs_volume_hal_find_active_mount_point (volume_hal);
/* we must have been mounted successfully if we have a mount point */
if (G_LIKELY (volume_hal->mount_point != NULL))
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTED | THUNAR_VFS_VOLUME_STATUS_PRESENT;
}
/* check if we have to figure out the mount point ourself */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* ask HAL for the default mount root (falling back to /media otherwise) */
mount_root = libhal_device_get_property_string (context, "/org/freedesktop/Hal/devices/computer", "storage.policy.default.mount_root", NULL);
if (G_UNLIKELY (mount_root == NULL || !g_path_is_absolute (mount_root)))
{
/* fallback to /media (seems to be sane) */
g_free (mount_root);
mount_root = g_strdup ("/media");
}
/* lets see, maybe /etc/fstab knows where to mount */
volume_hal->mount_point = thunar_vfs_volume_hal_find_fstab_mount_point (volume_hal);
/* if we still don't have a mount point, ask HAL */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* determine the desired mount point and prepend the mount root */
desired_mount_point = libhal_device_get_property_string (context, volume_hal->udi, "volume.policy.desired_mount_point", NULL);
if (G_LIKELY (desired_mount_point != NULL && *desired_mount_point != '\0'))
{
filename = g_build_filename (mount_root, desired_mount_point, NULL);
volume_hal->mount_point = thunar_vfs_path_new (filename, NULL);
g_free (filename);
}
libhal_free_string (desired_mount_point);
}
/* ok, last fallback, just use <mount-root>/<device> */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* <mount-root>/<device> looks like a good idea */
basename = g_path_get_basename (volume_hal->device_file);
filename = g_build_filename (mount_root, basename, NULL);
volume_hal->mount_point = thunar_vfs_path_new (filename, NULL);
g_free (filename);
g_free (basename);
}
/* release the mount root */
g_free (mount_root);
}
/* if we get here, we must have a valid mount point */
g_assert (volume_hal->mount_point != NULL);
/* emit the "changed" signal */
thunar_vfs_volume_changed (THUNAR_VFS_VOLUME (volume_hal));
}
