GSList* get_volumes_mounted_on_drive(LibHalContext* ctx, LibHalDrive* drive) { /* FIXME: This sucks - HAL doesn't report mounted volumes correctly */ GSList* volume_list = NULL; int num_vols = 0; char** vol_udis = libhal_drive_find_all_volumes(ctx, drive, &num_vols); if(num_vols <= 0 || vol_udis == NULL) goto out; int i=0; for(i=0; i < num_vols; i++) { LibHalVolume* current; if(!vol_udis[i]) break; current = libhal_volume_from_udi(ctx, vol_udis[i]); if(!current) continue; if(libhal_volume_is_mounted(current)) volume_list = g_slist_prepend(volume_list, g_strdup(vol_udis[i])); libhal_volume_free(current); } libhal_free_string_array(vol_udis); out: return volume_list; }
// Helper function. creates a CStorageDevice from a HAL udi bool CHALManager::DeviceFromVolumeUdi(const char *udi, CStorageDevice *device) { if (g_HalManager.m_Context == NULL) return false; LibHalVolume *tempVolume; LibHalDrive *tempDrive; bool Created = false; tempVolume = libhal_volume_from_udi(g_HalManager.m_Context, udi); if (tempVolume) { const char *DriveUdi = libhal_volume_get_storage_device_udi(tempVolume); tempDrive = libhal_drive_from_udi(g_HalManager.m_Context, DriveUdi); if (tempDrive) { char * FriendlyName = libhal_device_get_property_string(g_HalManager.m_Context, udi, "info.product", NULL); device->FriendlyName = FriendlyName; libhal_free_string(FriendlyName); char *block = libhal_device_get_property_string(g_HalManager.m_Context, udi, "block.device", NULL); device->DevID = block; libhal_free_string(block); device->HotPlugged = (bool)libhal_drive_is_hotpluggable(tempDrive); device->Type = libhal_drive_get_type(tempDrive); device->Mounted = (bool)libhal_volume_is_mounted(tempVolume); device->MountPoint = libhal_volume_get_mount_point(tempVolume); if (device->Mounted) URIUtils::AddSlashAtEnd(device->MountPoint); device->Label = libhal_volume_get_label(tempVolume); device->UUID = libhal_volume_get_uuid(tempVolume); device->FileSystem = libhal_volume_get_fstype(tempVolume); device->HalIgnore = libhal_device_get_property_bool(g_HalManager.m_Context, udi, "volume.ignore", NULL); ApproveDevice(device); libhal_drive_free(tempDrive); Created = true; } else CLog::Log(LOGERROR, "HAL: Couldn't create a Drive even if we had a volume - %s", udi); libhal_volume_free(tempVolume); } return Created; }
LibHalVolume *pusb_volume_get(t_pusb_options *opts, LibHalContext *ctx) { LibHalVolume *volume; if (!(volume = pusb_volume_probe(opts, ctx))) return (NULL); log_debug("Found volume %s\n", opts->device.volume_uuid); if (libhal_volume_is_mounted(volume)) { log_debug("Volume is already mounted.\n"); return (volume); } if (!pusb_volume_mount(opts, &volume, ctx)) { libhal_volume_free(volume); return (NULL); } return (volume); }
gboolean warn_user_of_impending_doom(FormatDialog* dialog, FormatVolume* target) { GSList* mounted_list = NULL; /* Figure out if we're about to run over any live partitions first */ if(target->volume) { if(libhal_volume_is_mounted(target->volume)) { mounted_list = g_slist_prepend(mounted_list, get_friendly_volume_name(dialog->hal_context, target->volume)); } } else { mounted_list = get_volumes_mounted_on_drive(dialog->hal_context, target->drive); } gchar* message; gchar* name = (target->volume ? get_friendly_volume_name(dialog->hal_context, target->volume) : get_friendly_drive_name(target->drive)); /* Come up with the error message */ if(!mounted_list) { message = g_strdup_printf(_("Formatting will irreversibly destroy all data on %s. " "Are you sure you want to continue?"), name); } else { /* FIXME: There are a ton of malloc's here */ int i; GSList* iter; gchar* tmp_list[65]; /* TODO: It'd be cool if these were hyperlinks that opened nautilus at the mountpoint! */ for(iter = mounted_list, i=0; iter != NULL && i < 64; iter = iter->next, i++) { FormatVolume* current = get_cached_device_from_udi(dialog, (char*)iter->data); g_debug("Mounted: %s", iter->data); if(!current) continue; gchar* mountpoint = libhal_volume_get_mount_point(current->volume); tmp_list[i] = g_strdup_printf( _("%s mounted at %s"), current->friendly_name, mountpoint); } tmp_list[i] = NULL; gchar* vol_list = g_strjoinv("\n", tmp_list); message = g_strdup_printf( _("Formatting will irreversibly destroy all data on %s, " "including these volumes currently in use:" "\n\n%s\n\n" "Are you sure you want to continue?"), name, vol_list); /* Free our stuff */ g_free(vol_list); for(int i=0; i < 64; i++) { if(!tmp_list[i]) break; g_free(tmp_list[i]); } } g_free(name); /* Show the dialog and get the response back */ GtkWidget* messagebox; messagebox = gtk_message_dialog_new(GTK_WINDOW(dialog->toplevel), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, _("Formatting will erase data")); gtk_message_dialog_format_secondary_markup(GTK_MESSAGE_DIALOG(messagebox), message); gtk_dialog_add_buttons(GTK_DIALOG(messagebox), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Format device"), GTK_RESPONSE_OK, NULL); int id = gtk_dialog_run(GTK_DIALOG(messagebox)); gtk_widget_destroy(messagebox); return (id == GTK_RESPONSE_OK); }
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)); }