gchar*
get_friendly_volume_name(LibHalContext* ctx, LibHalVolume* volume)
{
char* ret, *tmp;
char* partition_name = NULL;
int partition_num;
ret = libhal_volume_get_label(volume);
if(ret && ret[0] != 0) return g_strdup(ret);
/* Try to describe the device */
const char* assoc_udi = libhal_volume_get_storage_device_udi(volume);
LibHalDrive* assoc_drv = NULL;
if(assoc_udi) assoc_drv = libhal_drive_from_udi(ctx, assoc_udi);
if(assoc_drv) {
partition_num = (libhal_volume_is_partition(volume) ?
(int)libhal_volume_get_partition_number(volume) :
-1);
if(partition_num > 0) {
/* Try to get the name */
tmp = libhal_volume_get_partition_label(volume);
if(tmp && tmp[0] != 0)
partition_name = g_strdup(tmp);
else
partition_name = g_strdup_printf(_("Partition %d"), partition_num);
}
/* if device is partition we can tell where it's actually mounted */
tmp = get_friendly_drive_name(assoc_drv);
if(partition_name) {
ret = g_strdup_printf(_("%s on %s"), partition_name, tmp);
g_free(partition_name);
}
else {
ret = g_strdup_printf(_("(Unknown Volume) on %s"), tmp);
}
g_free(tmp);
libhal_drive_free(assoc_drv);
return ret;
}
ret = _("(Unknown Volume)");
return g_strdup(ret);
}
// 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;
}
void
format_volume_free(FormatVolume* fvol)
{
g_assert(fvol != NULL);
if(fvol->volume)
libhal_volume_free(fvol->volume);
if(fvol->drive)
libhal_drive_free(fvol->drive);
if(fvol->icon)
g_object_unref(fvol->icon);
if(fvol->friendly_name)
g_free(fvol->friendly_name);
if(fvol->udi)
g_free(fvol->udi);
if(fvol->drive_udi)
g_free(fvol->drive_udi);
if(fvol->mountpoint)
g_free(fvol->mountpoint);
g_free(fvol);
}
static void
thunar_vfs_volume_manager_hal_device_added (LibHalContext *context,
const gchar *udi)
{
ThunarVfsVolumeManagerHal *manager_hal = libhal_ctx_get_user_data (context);
ThunarVfsVolumeHal *volume_hal;
LibHalVolume *hv;
LibHalDrive *hd;
const gchar *drive_udi;
_thunar_vfs_return_if_fail (THUNAR_VFS_IS_VOLUME_MANAGER_HAL (manager_hal));
_thunar_vfs_return_if_fail (manager_hal->context == context);
/* check if we have a volume here */
hv = libhal_volume_from_udi (context, udi);
/* HAL might want us to ignore this volume for some reason */
if (G_UNLIKELY (hv != NULL && libhal_volume_should_ignore (hv)))
{
libhal_volume_free (hv);
return;
}
/* emit the "device-added" signal (to support thunar-volman) */
g_signal_emit_by_name (G_OBJECT (manager_hal), "device-added", udi);
if (G_LIKELY (hv != NULL))
{
/* check if we have a mountable file system here */
if (libhal_volume_get_fsusage (hv) == LIBHAL_VOLUME_USAGE_MOUNTABLE_FILESYSTEM)
{
/* determine the UDI of the drive to which this volume belongs */
drive_udi = libhal_volume_get_storage_device_udi (hv);
if (G_LIKELY (drive_udi != NULL))
{
/* determine the drive for the volume */
hd = libhal_drive_from_udi (context, drive_udi);
if (G_LIKELY (hd != NULL))
{
/* check if we already have a volume object for the UDI */
volume_hal = thunar_vfs_volume_manager_hal_get_volume_by_udi (manager_hal, udi);
if (G_LIKELY (volume_hal == NULL))
{
/* otherwise, we allocate a new volume object */
volume_hal = g_object_new (THUNAR_VFS_TYPE_VOLUME_HAL, NULL);
volume_hal->udi = g_strdup (udi);
}
/* update the volume object with the new data from the HAL volume/drive */
thunar_vfs_volume_hal_update (volume_hal, context, hv, hd);
/* add the volume object to our list if we allocated a new one */
if (g_list_find (THUNAR_VFS_VOLUME_MANAGER (manager_hal)->volumes, volume_hal) == NULL)
{
/* add the volume to the volume manager */
thunar_vfs_volume_manager_add (THUNAR_VFS_VOLUME_MANAGER (manager_hal), THUNAR_VFS_VOLUME (volume_hal));
/* release the reference on the volume */
g_object_unref (G_OBJECT (volume_hal));
}
/* release the HAL drive */
libhal_drive_free (hd);
}
}
}
/* release the HAL volume */
libhal_volume_free (hv);
}
else
{
/* but maybe we have a floppy disk drive here */
hd = libhal_drive_from_udi (context, udi);
if (G_UNLIKELY (hd == NULL))
return;
/* check if we have a floppy disk drive */
if (G_LIKELY (libhal_drive_get_type (hd) == LIBHAL_DRIVE_TYPE_FLOPPY))
{
/* check if we already have a volume object for the UDI */
volume_hal = thunar_vfs_volume_manager_hal_get_volume_by_udi (manager_hal, udi);
if (G_LIKELY (volume_hal == NULL))
{
/* otherwise, we allocate a new volume object */
volume_hal = g_object_new (THUNAR_VFS_TYPE_VOLUME_HAL, NULL);
volume_hal->udi = g_strdup (udi);
}
/* update the volume object with the new data from the HAL volume/drive */
thunar_vfs_volume_hal_update (volume_hal, context, NULL, hd);
/* add the volume object to our list if we allocated a new one */
if (g_list_find (THUNAR_VFS_VOLUME_MANAGER (manager_hal)->volumes, volume_hal) == NULL)
{
/* add the volume to the volume manager */
thunar_vfs_volume_manager_add (THUNAR_VFS_VOLUME_MANAGER (manager_hal), THUNAR_VFS_VOLUME (volume_hal));
/* release the reference on the volume */
g_object_unref (G_OBJECT (volume_hal));
}
}
/* release the HAL drive */
libhal_drive_free (hd);
}
}
static void
thunar_vfs_volume_manager_hal_update_volume_by_udi (ThunarVfsVolumeManagerHal *manager_hal,
const gchar *udi)
{
ThunarVfsVolumeHal *volume_hal;
LibHalVolume *hv = NULL;
LibHalDrive *hd = NULL;
const gchar *drive_udi;
/* check if we have a volume for the UDI */
volume_hal = thunar_vfs_volume_manager_hal_get_volume_by_udi (manager_hal, udi);
if (G_UNLIKELY (volume_hal == NULL))
return;
/* check if we have a volume here */
hv = libhal_volume_from_udi (manager_hal->context, udi);
if (G_UNLIKELY (hv == NULL))
{
/* check if we have a drive here */
hd = libhal_drive_from_udi (manager_hal->context, udi);
if (G_UNLIKELY (hd == NULL))
{
/* the device is no longer a drive or volume, so drop it */
thunar_vfs_volume_manager_hal_device_removed (manager_hal->context, udi);
return;
}
/* update the drive with the new HAL drive/volume */
thunar_vfs_volume_hal_update (volume_hal, manager_hal->context, NULL, hd);
/* release the drive */
libhal_drive_free (hd);
}
else
{
/* determine the UDI of the drive to which this volume belongs */
drive_udi = libhal_volume_get_storage_device_udi (hv);
if (G_LIKELY (drive_udi != NULL))
{
/* determine the drive for the volume */
hd = libhal_drive_from_udi (manager_hal->context, drive_udi);
}
/* check if we have the drive for the volume */
if (G_LIKELY (hd != NULL))
{
/* update the volume with the new HAL drive/volume */
thunar_vfs_volume_hal_update (volume_hal, manager_hal->context, hv, hd);
/* release the drive */
libhal_drive_free (hd);
}
else
{
/* unable to determine the drive, volume gone? */
thunar_vfs_volume_manager_hal_device_removed (manager_hal->context, udi);
}
/* release the volume */
libhal_volume_free (hv);
}
}
static void
thunar_vfs_volume_manager_hal_init (ThunarVfsVolumeManagerHal *manager_hal)
{
LibHalDrive *hd;
DBusError error;
gchar **drive_udis;
gchar **udis;
gint n_drive_udis;
gint n_udis;
gint n, m;
/* initialize the D-BUS error */
dbus_error_init (&error);
/* allocate a HAL context */
manager_hal->context = libhal_ctx_new ();
if (G_UNLIKELY (manager_hal->context == NULL))
return;
/* try to connect to the system bus */
manager_hal->dbus_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
if (G_UNLIKELY (manager_hal->dbus_connection == NULL))
goto failed;
/* setup the D-BUS connection for the HAL context */
libhal_ctx_set_dbus_connection (manager_hal->context, manager_hal->dbus_connection);
/* connect our manager object to the HAL context */
libhal_ctx_set_user_data (manager_hal->context, manager_hal);
/* setup callbacks */
libhal_ctx_set_device_added (manager_hal->context, thunar_vfs_volume_manager_hal_device_added);
libhal_ctx_set_device_removed (manager_hal->context, thunar_vfs_volume_manager_hal_device_removed);
libhal_ctx_set_device_new_capability (manager_hal->context, thunar_vfs_volume_manager_hal_device_new_capability);
libhal_ctx_set_device_lost_capability (manager_hal->context, thunar_vfs_volume_manager_hal_device_lost_capability);
libhal_ctx_set_device_property_modified (manager_hal->context, thunar_vfs_volume_manager_hal_device_property_modified);
libhal_ctx_set_device_condition (manager_hal->context, thunar_vfs_volume_manager_hal_device_condition);
/* try to initialize the HAL context */
if (!libhal_ctx_init (manager_hal->context, &error))
goto failed;
/* setup the D-BUS connection with the GLib main loop */
dbus_connection_setup_with_g_main (manager_hal->dbus_connection, NULL);
/* lookup all drives currently known to HAL */
drive_udis = libhal_find_device_by_capability (manager_hal->context, "storage", &n_drive_udis, &error);
if (G_LIKELY (drive_udis != NULL))
{
/* process all drives UDIs */
for (m = 0; m < n_drive_udis; ++m)
{
/* determine the LibHalDrive for the drive UDI */
hd = libhal_drive_from_udi (manager_hal->context, drive_udis[m]);
if (G_UNLIKELY (hd == NULL))
continue;
/* check if we have a floppy disk here */
if (libhal_drive_get_type (hd) == LIBHAL_DRIVE_TYPE_FLOPPY)
{
/* add the drive based on the UDI */
thunar_vfs_volume_manager_hal_device_added (manager_hal->context, drive_udis[m]);
}
else
{
/* determine all volumes for the given drive */
udis = libhal_drive_find_all_volumes (manager_hal->context, hd, &n_udis);
if (G_LIKELY (udis != NULL))
{
/* add volumes for all given UDIs */
for (n = 0; n < n_udis; ++n)
{
/* add the volume based on the UDI */
thunar_vfs_volume_manager_hal_device_added (manager_hal->context, udis[n]);
/* release the UDI (HAL bug #5279) */
free (udis[n]);
}
/* release the UDIs array (HAL bug #5279) */
free (udis);
}
}
/* release the hal drive */
libhal_drive_free (hd);
}
/* release the drive UDIs */
libhal_free_string_array (drive_udis);
}
/* watch all devices for changes */
if (!libhal_device_property_watch_all (manager_hal->context, &error))
goto failed;
return;
failed:
/* release the HAL context */
if (G_LIKELY (manager_hal->context != NULL))
{
libhal_ctx_free (manager_hal->context);
manager_hal->context = NULL;
}
/* print a warning message */
if (dbus_error_is_set (&error))
{
g_warning (_("Failed to connect to the HAL daemon: %s"), error.message);
dbus_error_free (&error);
}
}
