static void
unmount_childs (LibHalContext *ctx, const char *udi)
{
DBusError error;
int num_volumes;
char **volumes;
dbus_error_init (&error);
/* need to force unmount all partitions */
if ((volumes = libhal_manager_find_device_string_match (
ctx, "block.storage_device", udi, &num_volumes, &error)) != NULL) {
dbus_error_free (&error);
int i;
for (i = 0; i < num_volumes; i++) {
char *vol_udi;
vol_udi = volumes[i];
if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
dbus_error_free (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
dbus_error_free (&error);
HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
force_unmount (ctx, vol_udi);
}
}
}
libhal_free_string_array (volumes);
}
my_dbus_error_free (&error);
}
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;
}
int
list_battery_devices(LibHalContext *hal_ctx)
{
int i;
int num_devices;
char **device_names;
DBusError error;
dbus_error_init(&error);
if (!(device_names = libhal_manager_find_device_string_match(hal_ctx,
"info.category",
"battery", &num_devices, &error))) {
fprintf(stderr, "Empty HAL device list.\n");
LIBHAL_FREE_DBUS_ERROR(&error);
return (31);
}
for (i = 0; i < num_devices; i++) {
if (libhal_device_get_property_bool(hal_ctx, device_names[i],
"battery.present",
&error)) {
printf("%s\n", device_names[i]);
}
}
libhal_free_string_array(device_names);
dbus_error_free(&error);
return (0);
}
static gboolean
ac_adapter_update_all(LibHalContext *ctx)
{
int i;
int num_devices;
char **ac_adapter_devices;
int fd;
DBusError error;
HAL_DEBUG(("ac_adapter_update_all() enter"));
dbus_error_init(&error);
if ((ac_adapter_devices = libhal_manager_find_device_string_match(
ctx, "info.category", "ac_adapter", &num_devices, &error)) !=
NULL) {
for (i = 0; i < num_devices; i++) {
if ((fd = open_device(ctx, ac_adapter_devices[i]))
== -1) {
continue;
}
ac_adapter_present(ctx, ac_adapter_devices[i], fd);
close(fd);
}
libhal_free_string_array(ac_adapter_devices);
}
my_dbus_error_free(&error);
HAL_DEBUG(("ac_adapter_update_all() exit"));
return (TRUE);
}
static gboolean
battery_update_all(LibHalContext *ctx)
{
int i;
int num_devices;
char **battery_devices;
int fd;
DBusError error;
HAL_DEBUG(("battery_update_all() enter"));
dbus_error_init(&error);
if ((battery_devices = libhal_manager_find_device_string_match
(ctx, "info.category", "battery", &num_devices, &error)) !=
NULL) {
for (i = 0; i < num_devices; i++) {
my_dbus_error_free(&error);
if (libhal_device_get_property_bool(ctx,
battery_devices[i], "battery.present", &error)) {
if ((fd = open_device(ctx,
battery_devices[i])) == -1) {
continue;
}
battery_dynamic_update(ctx, battery_devices[i],
fd);
close(fd);
}
}
libhal_free_string_array(battery_devices);
}
my_dbus_error_free(&error);
HAL_DEBUG(("battery_update_all() exit"));
return (TRUE);
}
static dbus_bool_t
unmount_cleartext_devices (LibHalContext *ctx, const char *udi)
{
DBusError error;
char **clear_devices;
int num_clear_devices;
dbus_bool_t ret;
ret = FALSE;
/* check if the volume we back is mounted.. if it is.. unmount it */
dbus_error_init (&error);
clear_devices = libhal_manager_find_device_string_match (ctx,
"volume.crypto_luks.clear.backing_volume",
udi,
&num_clear_devices,
&error);
if (clear_devices != NULL && num_clear_devices > 0) {
int i;
ret = TRUE;
for (i = 0; i < num_clear_devices; i++) {
char *clear_udi;
clear_udi = clear_devices[i];
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, clear_udi, "volume.is_mounted", &error)) {
HAL_DEBUG (("Forcing unmount of child '%s' (crypto)", clear_udi));
force_unmount (ctx, clear_udi);
}
}
libhal_free_string_array (clear_devices);
}
LIBHAL_FREE_DBUS_ERROR (&error);
return ret;
}
int
main (int argc, char *argv[])
{
int fd, rfd;
int ret;
char *udi;
char *device_file, *raw_device_file;
char *devpath, *rdevpath;
boolean_t is_dos;
int dos_num;
LibHalContext *ctx = NULL;
DBusError error;
DBusConnection *conn;
char *parent_udi;
char *storage_device;
char *is_disc_str;
int fdc;
dbus_bool_t is_disc = FALSE;
dbus_bool_t is_floppy = FALSE;
unsigned int block_size;
dbus_uint64_t vol_size;
dbus_bool_t has_data = TRUE; /* probe for fs by default */
dbus_bool_t has_audio = FALSE;
char *partition_scheme = NULL;
dbus_uint64_t partition_start = 0;
int partition_number = 0;
struct vtoc vtoc;
dk_gpt_t *gpt;
struct dk_minfo mi;
int i, dos_cnt;
fstyp_handle_t fstyp_handle;
int systid, relsect, numsect;
off_t probe_offset = 0;
int num_volumes;
char **volumes;
dbus_uint64_t v_start;
const char *fstype;
nvlist_t *fsattr;
fd = rfd = -1;
ret = 1;
if ((udi = getenv ("UDI")) == NULL) {
goto out;
}
if ((device_file = getenv ("HAL_PROP_BLOCK_DEVICE")) == NULL) {
goto out;
}
if ((raw_device_file = getenv ("HAL_PROP_BLOCK_SOLARIS_RAW_DEVICE")) == NULL) {
goto out;
}
if (!dos_to_dev(device_file, &rdevpath, &dos_num)) {
rdevpath = raw_device_file;
}
if (!(is_dos = dos_to_dev(device_file, &devpath, &dos_num))) {
devpath = device_file;
}
if ((parent_udi = getenv ("HAL_PROP_INFO_PARENT")) == NULL) {
goto out;
}
if ((storage_device = getenv ("HAL_PROP_BLOCK_STORAGE_DEVICE")) == NULL) {
goto out;
}
is_disc_str = getenv ("HAL_PROP_VOLUME_IS_DISC");
if (is_disc_str != NULL && strcmp (is_disc_str, "true") == 0) {
is_disc = TRUE;
} else {
is_disc = FALSE;
}
drop_privileges ();
setup_logger ();
dbus_error_init (&error);
if ((ctx = libhal_ctx_init_direct (&error)) == NULL)
goto out;
HAL_DEBUG (("Doing probe-volume for %s\n", device_file));
fd = open (devpath, O_RDONLY | O_NONBLOCK);
if (fd < 0) {
goto out;
}
rfd = open (rdevpath, O_RDONLY | O_NONBLOCK);
if (rfd < 0) {
goto out;
}
/* if it's a floppy with no media, bail out */
if (ioctl(rfd, FDGETCHANGE, &fdc) == 0) {
is_floppy = TRUE;
if (fdc & FDGC_CURRENT) {
goto out;
}
}
/* block size and total size */
if (ioctl(rfd, DKIOCGMEDIAINFO, &mi) != -1) {
block_size = mi.dki_lbsize;
vol_size = mi.dki_capacity * block_size;
} else if (errno == ENXIO) {
/* driver supports ioctl, but media is not available */
goto out;
} else {
/* driver does not support ioctl, e.g. lofi */
block_size = 512;
vol_size = 0;
}
libhal_device_set_property_int (ctx, udi, "volume.block_size", block_size, &error);
my_dbus_error_free (&error);
libhal_device_set_property_uint64 (ctx, udi, "volume.size", vol_size, &error);
my_dbus_error_free (&error);
if (is_disc) {
if (!probe_disc (rfd, ctx, udi, &has_data, &has_audio)) {
HAL_DEBUG (("probe_disc failed, skipping fstyp"));
goto out;
}
/* with audio present, create volume even if fs probing fails */
if (has_audio) {
ret = 0;
}
}
if (!has_data) {
goto skip_fs;
}
/* don't support partitioned floppy */
if (is_floppy) {
goto skip_part;
}
/*
* first get partitioning info
*/
if (is_dos) {
/* for a dos drive find partition offset */
if (!find_dos_drive(fd, dos_num, &relsect, &numsect, &systid)) {
goto out;
}
partition_scheme = "mbr";
partition_start = (dbus_uint64_t)relsect * 512;
partition_number = dos_num;
probe_offset = (off_t)relsect * 512;
} else {
if ((partition_number = read_vtoc(rfd, &vtoc)) >= 0) {
if (!vtoc_one_slice_entire_disk(&vtoc)) {
partition_scheme = "smi";
if (partition_number < vtoc.v_nparts) {
if (vtoc.v_part[partition_number].p_size == 0) {
HAL_DEBUG (("zero size partition"));
}
partition_start = vtoc.v_part[partition_number].p_start * block_size;
}
}
} else if ((partition_number = efi_alloc_and_read(rfd, &gpt)) >= 0) {
partition_scheme = "gpt";
if (partition_number < gpt->efi_nparts) {
if (gpt->efi_parts[partition_number].p_size == 0) {
HAL_DEBUG (("zero size partition"));
}
partition_start = gpt->efi_parts[partition_number].p_start * block_size;
}
efi_free(gpt);
}
probe_offset = 0;
}
if (partition_scheme != NULL) {
libhal_device_set_property_string (ctx, udi, "volume.partition.scheme", partition_scheme, &error);
my_dbus_error_free (&error);
libhal_device_set_property_int (ctx, udi, "volume.partition.number", partition_number, &error);
my_dbus_error_free (&error);
libhal_device_set_property_uint64 (ctx, udi, "volume.partition.start", partition_start, &error);
my_dbus_error_free (&error);
libhal_device_set_property_bool (ctx, udi, "volume.is_partition", TRUE, &error);
my_dbus_error_free (&error);
} else {
libhal_device_set_property_bool (ctx, udi, "volume.is_partition", FALSE, &error);
my_dbus_error_free (&error);
}
/*
* ignore duplicate partitions
*/
if ((volumes = libhal_manager_find_device_string_match (
ctx, "block.storage_device", storage_device, &num_volumes, &error)) != NULL) {
my_dbus_error_free (&error);
for (i = 0; i < num_volumes; i++) {
if (strcmp (udi, volumes[i]) == 0) {
continue; /* skip self */
}
v_start = libhal_device_get_property_uint64 (ctx, volumes[i], "volume.partition.start", &error);
if (dbus_error_is_set(&error)) {
dbus_error_free(&error);
continue;
}
if (v_start == partition_start) {
HAL_DEBUG (("duplicate partition"));
goto out;
}
}
libhal_free_string_array (volumes);
}
skip_part:
/*
* now determine fs type
*
* XXX We could get better performance from block device,
* but for now we use raw device because:
*
* - fstyp_udfs has a bug that it only works on raw
*
* - sd has a bug that causes extremely slow reads
* and incorrect probing of hybrid audio/data media
*/
if (fstyp_init(rfd, probe_offset, NULL, &fstyp_handle) != 0) {
HAL_DEBUG (("fstyp_init failed"));
goto out;
}
if ((fstyp_ident(fstyp_handle, NULL, &fstype) != 0) ||
(fstyp_get_attr(fstyp_handle, &fsattr) != 0)) {
HAL_DEBUG (("fstyp ident or get_attr failed"));
fstyp_fini(fstyp_handle);
goto out;
}
set_fstyp_properties (ctx, udi, fstype, fsattr);
if (strcmp (fstype, "hsfs") == 0) {
hsfs_contents (fd, probe_offset, ctx, udi);
}
fstyp_fini(fstyp_handle);
skip_fs:
ret = 0;
out:
if (fd >= 0)
close (fd);
if (rfd >= 0)
close (rfd);
if (ctx != NULL) {
my_dbus_error_free (&error);
libhal_ctx_shutdown (ctx, &error);
libhal_ctx_free (ctx);
}
return ret;
}
int
main (int argc, char **argv)
{
char *device_file;
char *parent_udi;
char *grandparent_udi;
char *parent_drive_type;
int fd = -1;
struct volume_id *vid = NULL;
int ret = 1;
gboolean has_children;
gboolean is_swap;
gboolean is_cdrom;
gboolean is_partition = FALSE;
gboolean has_audio = FALSE;
gboolean has_data = FALSE;
gboolean is_blank = FALSE;
const char *usage;
char *label;
unsigned int sector_size = 0;
off_t media_size = 0;
if (! hfp_init(argc, argv))
goto end;
device_file = getenv("HAL_PROP_BLOCK_DEVICE");
if (! device_file)
goto end;
parent_udi = getenv("HAL_PROP_INFO_PARENT");
if (! parent_udi)
goto end;
/* give a meaningful process title for ps(1) */
setproctitle("%s", device_file);
has_children = hfp_getenv_bool("HF_HAS_CHILDREN");
is_swap = hfp_getenv_bool("HF_IS_SWAP");
fd = open(device_file, O_RDONLY);
if (fd < 0)
goto end;
parent_drive_type = libhal_device_get_property_string(hfp_ctx, parent_udi, "storage.drive_type", &hfp_error);
dbus_error_free(&hfp_error);
grandparent_udi = libhal_device_get_property_string(hfp_ctx, parent_udi, "info.parent", &hfp_error);
dbus_error_free(&hfp_error);
is_cdrom = parent_drive_type && ! strcmp(parent_drive_type, "cdrom");
g_free(parent_drive_type);
if (is_cdrom)
{
hf_probe_volume_get_disc_info(fd, &has_audio, &has_data);
is_blank = (! has_audio && ! has_data);
}
ioctl(fd, DIOCGMEDIASIZE, &media_size);
/*
* We only check for filesystems if the volume has no children,
* otherwise volume_id might find a filesystem in what is actually
* the first child partition of the volume.
*
* If hald (which has looked at the partition type) reports that it
* is a swap partition, we probe it nevertheless in case the
* partition type is incorrect.
*/
if (! has_children && ! (is_cdrom && ! has_data))
{
vid = volume_id_open_fd(fd);
if (vid)
{
if (volume_id_probe_all(vid, 0, media_size) == 0)
has_data = TRUE;
else
{
volume_id_close(vid);
vid = NULL;
}
}
}
if (! has_children && ! is_swap && ! has_audio && ! has_data && ! is_blank)
goto end;
libhal_device_add_capability(hfp_ctx, hfp_udi, "volume", &hfp_error);
if (is_cdrom)
{
HFPCDROM *cdrom;
int type;
guint64 capacity;
libhal_device_set_property_string(hfp_ctx, hfp_udi, "info.category", "volume.disc", &hfp_error);
libhal_device_add_capability(hfp_ctx, hfp_udi, "volume.disc", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.has_audio", has_audio, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.has_data", has_data, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_vcd", FALSE, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_svcd", FALSE, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_videodvd", FALSE, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_appendable", FALSE, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_blank", is_blank, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", FALSE, &hfp_error);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "unknown", &hfp_error);
/* the following code was adapted from linux's probe-volume.c */
cdrom = hfp_cdrom_new_from_fd(fd, device_file, grandparent_udi);
if (cdrom)
{
type = get_disc_type(cdrom);
if (type != -1)
switch (type)
{
case 0x08: /* CD-ROM */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "cd_rom", &hfp_error);
break;
case 0x09: /* CD-R */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "cd_r", &hfp_error);
break;
case 0x0a: /* CD-RW */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "cd_rw", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
case 0x10: /* DVD-ROM */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_rom", &hfp_error);
break;
case 0x11: /* DVD-R Sequential */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_r", &hfp_error);
break;
case 0x12: /* DVD-RAM */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_ram", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
case 0x13: /* DVD-RW Restricted Overwrite */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_rw", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
case 0x14: /* DVD-RW Sequential */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_rw", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
case 0x1A: /* DVD+RW */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_plus_rw", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
case 0x1B: /* DVD+R */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_plus_r", &hfp_error);
break;
case 0x2B: /* DVD+R Double Layer */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "dvd_plus_r_dl", &hfp_error);
break;
case 0x40: /* BD-ROM */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "bd_rom", &hfp_error);
break;
case 0x41: /* BD-R Sequential */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "bd_r", &hfp_error);
break;
case 0x42: /* BD-R Random */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "bd_r", &hfp_error);
break;
case 0x43: /* BD-RE */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "bd_re", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
case 0x50: /* HD DVD-ROM */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "hddvd_rom", &hfp_error);
break;
case 0x51: /* HD DVD-R */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "hddvd_r", &hfp_error);
break;
case 0x52: /* HD DVD-Rewritable */
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.disc.type", "hddvd_rw", &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
break;
}
if (get_disc_capacity_for_type(cdrom, type, &capacity) == 0)
libhal_device_set_property_uint64(hfp_ctx, hfp_udi, "volume.disc.capacity", capacity, &hfp_error);
/*
* linux's probe-volume.c: "on some hardware the get_disc_type
* call fails, so we use this as a backup".
*/
if (disc_is_rewritable(cdrom))
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.disc.is_rewritable", TRUE, &hfp_error);
if (disc_is_appendable(cdrom))
libhal_device_set_property_bool (hfp_ctx, hfp_udi, "volume.disc.is_appendable", TRUE, &hfp_error);
hfp_cdrom_free(cdrom);
}
if (has_data && vid && (! strcmp(vid->type, "iso9660") ||
! strcmp(vid->type, "udf")))
hf_probe_volume_advanced_disc_detect(fd);
}
else
{
libhal_device_set_property_string(hfp_ctx, hfp_udi, "info.category", "volume", &hfp_error);
if (libhal_device_query_capability(hfp_ctx, parent_udi, "storage", &hfp_error))
{
char *geom_class;
char *type;
char *scheme;
int number;
guint64 mediasize;
guint64 offset;
geom_class = getenv("HF_VOLUME_GEOM_CLASS");
if (geom_class)
{
if (hf_probe_volume_get_partition_info(geom_class, device_file, &number, &type, &scheme, &mediasize, &offset))
{
is_partition = TRUE;
libhal_device_set_property_int(hfp_ctx, hfp_udi, "volume.partition.number", number, &hfp_error);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.partition.scheme", scheme, &hfp_error);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.partition.type", type, &hfp_error);
/* FIXME We need to fill in the supported partition flags. */
libhal_device_set_property_uint64(hfp_ctx, hfp_udi, "volume.partition.media_size", mediasize, &hfp_error);
libhal_device_set_property_uint64(hfp_ctx, hfp_udi, "volume.partition.start", offset, &hfp_error);
if (! strcmp(scheme, "gpt"))
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.partition.uuid", type, &hfp_error);
if (! strcmp(scheme, "gpt") || ! strcmp(scheme, "apm"))
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.partition.label", "", &hfp_error);
g_free(type);
g_free(scheme);
}
}
}
else
dbus_error_free(&hfp_error);
}
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.is_disc", is_cdrom, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.is_partition", is_partition, &hfp_error);
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.ignore", has_children || is_swap, &hfp_error);
#ifdef HAVE_LIBUFS
if (vid && ! strcmp (vid->type, "ufs"))
{
struct uufsd ufsdisk;
if (ufs_disk_fillout(&ufsdisk, device_file) == 0)
{
char ufsid[64];
char **ufs_devs = NULL;
int num_udis;
int i;
snprintf(ufsid, sizeof(ufsid), "%08x%08x", ufsdisk.d_fs.fs_id[0], ufsdisk.d_fs.fs_id[1]);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.freebsd.ufsid", ufsid, &hfp_error);
dbus_error_free(&hfp_error);
ufs_devs = libhal_manager_find_device_string_match(hfp_ctx,
"volume.freebsd.ufsid",
ufsid,
&num_udis,
&hfp_error);
dbus_error_free(&hfp_error);
for (i = 0; i < num_udis; i++)
{
if (ufs_devs[i] != NULL && strcmp(ufs_devs[i], hfp_udi))
{
gboolean mounted;
mounted = libhal_device_get_property_bool(hfp_ctx, ufs_devs[i], "volume.is_mounted", &hfp_error);
dbus_error_free(&hfp_error);
if (mounted)
{
libhal_device_set_property_bool(hfp_ctx, hfp_udi, "volume.ignore", TRUE, &hfp_error);
dbus_error_free(&hfp_error);
break;
}
}
}
if (ufs_devs)
libhal_free_string_array(ufs_devs);
ufs_disk_close(&ufsdisk);
}
}
#endif /* HAVE_LIBUFS */
if (has_children)
usage = "partitiontable";
else if (is_swap)
usage = "other";
else
switch (vid ? vid->usage_id : (enum volume_id_usage) -1)
{
case VOLUME_ID_FILESYSTEM: usage = "filesystem"; break;
case VOLUME_ID_DISKLABEL: usage = "disklabel"; break;
case VOLUME_ID_OTHER: usage = "other"; break;
case VOLUME_ID_RAID: usage = "raid"; break;
case VOLUME_ID_CRYPTO: usage = "crypto"; break;
case VOLUME_ID_UNUSED: usage = "unused"; break;
default: usage = "unknown"; break;
}
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.fsusage", usage, &hfp_error);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.fstype", vid ? vid->type: "", &hfp_error);
if (vid && *vid->type_version)
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.fsversion", vid->type_version, &hfp_error);
label = hf_probe_volume_get_label(vid);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.label", label ? label : "", &hfp_error);
g_free(label);
libhal_device_set_property_string(hfp_ctx, hfp_udi, "volume.uuid", vid ? vid->uuid : "", &hfp_error);
ioctl(fd, DIOCGSECTORSIZE, §or_size);
if (sector_size != 0)
libhal_device_set_property_uint64(hfp_ctx, hfp_udi, "volume.block_size", sector_size, &hfp_error);
if (media_size != 0)
libhal_device_set_property_uint64(hfp_ctx, hfp_udi, "volume.size", media_size, &hfp_error);
if (sector_size != 0 && media_size != 0)
libhal_device_set_property_uint64(hfp_ctx, hfp_udi, "volume.num_blocks", media_size / sector_size, &hfp_error);
ret = 0; /* is a volume */
end:
return ret;
}
static void
unmount_childs (LibHalContext *ctx, const char *udi)
{
int num_volumes;
char **volumes;
DBusError error;
/* need to force unmount all partitions */
dbus_error_init (&error);
if ((volumes = libhal_manager_find_device_string_match (ctx, "block.storage_device", udi, &num_volumes, &error)) != NULL) {
int i;
for (i = 0; i < num_volumes; i++) {
char *vol_udi;
vol_udi = volumes[i];
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
dbus_bool_t is_crypto;
/* unmount all cleartext devices associated with us */
is_crypto = unmount_cleartext_devices (ctx, vol_udi);
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
force_unmount (ctx, vol_udi);
}
/* teardown crypto */
if (is_crypto) {
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
/* tear down mapping */
HAL_DEBUG (("Teardown crypto for '%s'", vol_udi));
msg = dbus_message_new_method_call ("org.freedesktop.Hal", vol_udi,
"org.freedesktop.Hal.Device.Volume.Crypto",
"Teardown");
if (msg == NULL) {
HAL_ERROR (("Could not create dbus message for %s", vol_udi));
goto teardown_failed;
}
LIBHAL_FREE_DBUS_ERROR (&error);
if (!(reply = dbus_connection_send_with_reply_and_block (
libhal_ctx_get_dbus_connection (ctx), msg, -1, &error)) ||
dbus_error_is_set (&error)) {
HAL_DEBUG (("Teardown failed for %s: %s : %s\n", udi, error.name, error.message));
dbus_error_free (&error);
}
teardown_failed:
if (msg != NULL)
dbus_message_unref (msg);
if (reply != NULL)
dbus_message_unref (reply);
}
}
}
libhal_free_string_array (volumes);
}
LIBHAL_FREE_DBUS_ERROR (&error);
}
/*
* gst_hal_get_string:
* @udi: a #gchar corresponding to the UDI you want to get.
* @device_type: a #GstHalDeviceType specifying the wanted device type.
*
* Get Hal UDI @udi's string value.
*
* Returns: a newly allocated #gchar string containing the appropriate pipeline
* for UDI @udi, or NULL in the case of an error..
*/
static gchar *
gst_hal_get_string (const gchar * udi, GstHalDeviceType device_type)
{
DBusError error;
LibHalContext *ctx;
char *string = NULL;
/* Don't query HAL for NULL UDIs. Passing NULL as UDI to HAL gives
* an assertion failure in D-Bus when running with
* DBUS_FATAL_WARNINGS=1. */
if (!udi)
return NULL;
dbus_error_init (&error);
ctx = libhal_ctx_new ();
/* Should only happen on OOM */
g_return_val_if_fail (ctx != NULL, NULL);
if (!libhal_ctx_set_dbus_connection (ctx, dbus_bus_get (DBUS_BUS_SYSTEM,
&error))) {
GST_DEBUG ("Unable to set DBus connection: %s: %s", error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
goto ctx_free;
}
if (!libhal_ctx_init (ctx, &error)) {
GST_DEBUG ("Unable to set init HAL context: %s: %s", error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
goto ctx_free;
}
/* Now first check if UDI is an alsa device, then oss and then
* check the childs of the given device. If there are alsa and oss
* children the first alsa one is used. */
string = gst_hal_get_alsa_element (ctx, udi, device_type);
if (!string)
string = gst_hal_get_oss_element (ctx, udi, device_type);
if (!string) {
int num_childs;
char **childs = NULL;
/* now try if one of the direct subdevices supports ALSA or OSS */
childs =
libhal_manager_find_device_string_match (ctx, "info.parent", udi,
&num_childs, &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("Unable to retrieve childs of %s: %s: %s", udi, error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
goto ctx_shutdown;
}
if (childs && num_childs > 0) {
int i;
char *alsa_string = NULL, *oss_string = NULL;
for (i = 0; i < num_childs && !alsa_string; i++) {
alsa_string = gst_hal_get_alsa_element (ctx, childs[i], device_type);
if (!oss_string)
oss_string = gst_hal_get_oss_element (ctx, childs[i], device_type);
}
if (alsa_string) {
string = alsa_string;
g_free (oss_string);
} else if (oss_string) {
string = oss_string;
}
}
libhal_free_string_array (childs);
}
ctx_shutdown:
if (!libhal_ctx_shutdown (ctx, &error)) {
GST_DEBUG ("Closing connection to HAL failed: %s: %s", error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
}
ctx_free:
libhal_ctx_free (ctx);
if (string == NULL) {
GST_WARNING ("Problem finding a HAL audio device for udi %s", udi);
} else {
GST_INFO ("Using %s", string);
}
return string;
}
static void
thunar_vfs_volume_manager_hal_device_condition (LibHalContext *context,
const gchar *udi,
const gchar *name,
const gchar *details)
{
ThunarVfsVolumeManagerHal *manager_hal = libhal_ctx_get_user_data (context);
ThunarVfsVolumeHal *volume_hal;
DBusError derror;
GList *volumes = NULL;
GList *lp;
gchar **volume_udis;
gint n_volume_udis;
gint n;
_thunar_vfs_return_if_fail (THUNAR_VFS_IS_VOLUME_MANAGER_HAL (manager_hal));
_thunar_vfs_return_if_fail (manager_hal->context == context);
/* check if the device should be ejected */
if (G_LIKELY (strcmp (name, "EjectPressed") == 0))
{
/* check if we have a volume for the device */
volume_hal = thunar_vfs_volume_manager_hal_get_volume_by_udi (manager_hal, udi);
if (G_LIKELY (volume_hal == NULL))
{
/* initialize D-Bus error */
dbus_error_init (&derror);
/* the UDI most probably identifies the drive of the volume */
volume_udis = libhal_manager_find_device_string_match (context, "info.parent", udi, &n_volume_udis, &derror);
if (G_LIKELY (volume_udis != NULL))
{
/* determine the volumes for the UDIs */
for (n = 0; n < n_volume_udis; ++n)
{
/* check if we have a mounted volume for this UDI */
volume_hal = thunar_vfs_volume_manager_hal_get_volume_by_udi (manager_hal, volume_udis[n]);
if (volume_hal != NULL && thunar_vfs_volume_is_mounted (THUNAR_VFS_VOLUME (volume_hal)))
volumes = g_list_prepend (volumes, g_object_ref (G_OBJECT (volume_hal)));
}
libhal_free_string_array (volume_udis);
}
/* free D-Bus error */
dbus_error_free (&derror);
}
else if (thunar_vfs_volume_is_mounted (THUNAR_VFS_VOLUME (volume_hal)))
{
volumes = g_list_prepend (volumes, g_object_ref (G_OBJECT (volume_hal)));
}
/* check there are any mounted volumes on the device */
if (G_LIKELY (volumes != NULL))
{
/* tell everybody, that we're about to unmount those volumes */
for (lp = volumes; lp != NULL; lp = lp->next)
{
thunar_vfs_volume_pre_unmount (lp->data);
g_object_unref (G_OBJECT (lp->data));
}
g_list_free (volumes);
/* emit the "device-eject" signal and let Thunar eject the device */
g_signal_emit_by_name (G_OBJECT (manager_hal), "device-eject", udi);
}
}
}
