// 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; }
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)); }
/* Callback function, called when a new device has been inserted. */ static void device_added(LibHalContext *context, const char *did) { const char *dudi, *fstype; char *dev, *mountp, *mountable, *label, *locked_reason; LibHalVolume *volume; LibHalDrive *drive; struct device_t *device; if (libhal_device_property_exists(context, did, "info.locked", (DBusError *)NULL) && libhal_device_get_property_bool(context, did, "info.locked", (DBusError *)NULL)) { if (debug_mode_flag) { locked_reason = libhal_device_get_property_string( context, did, "info.locked.reason", (DBusError *)NULL); if (locked_reason) { if (debug_mode_flag) printf("%s%d: %s\n", __FILE__, __LINE__, locked_reason); libhal_free_string(locked_reason); } } return; } if (!libhal_device_query_capability(context, did, "volume", (DBusError *)NULL)) return; label = libhal_device_get_property_string(context, did, "volume.label", (DBusError *)NULL); if (!(mountable = libhal_device_get_property_string( context, did, "volume.fsusage", (DBusError *)NULL)) || strcmp(mountable, "filesystem")) goto out; if (!(volume = libhal_volume_from_udi(context, did))) goto out; if (!(dudi = libhal_volume_get_storage_device_udi(volume))) goto out; if (!(drive = libhal_drive_from_udi(context, dudi))) goto out; if (!libhal_drive_is_hotpluggable(drive) && !libhal_drive_uses_removable_media(drive)) goto out; if (!(fstype = libhal_volume_get_fstype(volume))) goto out; if (!(dev = libhal_device_get_property_string(context, did, "block.device", (DBusError *)NULL))) goto out; mountp = get_mount_point(dev, label); if (!mountp) goto out; device = get_device(mountp, did, dev, label, fstype, volume, drive); if(!is_mounted(device)) { free_device(device); goto out; } if (!device) goto out; consider_fstab(device); device->hook = malloc(2*sizeof(char*)); if(!file_exists(HOOK_PATH)) { device->hook[0] = get_hook(device, "mount"); device->hook[1] = get_hook(device, "umount"); } else { device->hook[0] = NULL; device->hook[1] = NULL; } if (file_exists(device->mountp) < 0) mkdir(device->mountp, 0750); do_mount(device) < 0 ? free_device(device) : add_to_device_list(device); if (device) { if (!add_fstab_entry(device)) device->should_remove_entry = 1; if (debug_mode_flag) debug_dump_device(device); } if (device->hook[0]) run_hook(0, device); out: if (mountable) libhal_free_string(mountable); if (label) libhal_free_string(label); }