void on_libhal_device_added_removed(LibHalContext *ctx, const char *udi)
{
g_debug("Added / Removed!");
if( !libhal_device_query_capability(ctx, udi, "volume", NULL) &&
!libhal_device_query_capability(ctx, udi, "storage", NULL) )
return;
FormatDialog* dialog = libhal_ctx_get_user_data(ctx);
update_dialog(dialog);
}
void on_libhal_prop_modified (LibHalContext *ctx,
const char *udi,
const char *key,
dbus_bool_t is_removed,
dbus_bool_t is_added)
{
g_debug("Prop Modified!");
if( !libhal_device_query_capability(ctx, udi, "volume", NULL) &&
!libhal_device_query_capability(ctx, udi, "storage", NULL) )
return;
FormatDialog* dialog = libhal_ctx_get_user_data(ctx);
update_dialog(dialog);
}
/* ARGSUSED */
static void
rmm_device_removed(LibHalContext *ctx, const char *udi)
{
if (libhal_device_query_capability(hal_ctx, udi, "volume", NULL)) {
volume_removed(udi);
}
}
gboolean
ac_adapter_update(LibHalContext *ctx, const char *udi, int fd)
{
LibHalChangeSet *cs;
DBusError error;
HAL_DEBUG(("ac_adapter_update() enter"));
dbus_error_init(&error);
if (!libhal_device_query_capability(ctx, udi, "ac_adapter", &error)) {
my_dbus_error_free(&error);
libhal_device_add_capability(ctx, udi, "ac_adapter", &error);
if ((cs = libhal_device_new_changeset(udi)) == NULL) {
my_dbus_error_free(&error);
return (FALSE);
}
libhal_changeset_set_property_string(cs, "info.product",
"AC Adapter");
libhal_changeset_set_property_string(cs, "info.category",
"ac_adapter");
my_dbus_error_free(&error);
libhal_device_commit_changeset(ctx, cs, &error);
libhal_device_free_changeset(cs);
}
ac_adapter_present(ctx, udi, fd);
battery_update_all(ctx);
my_dbus_error_free(&error);
HAL_DEBUG(("ac_adapter_update() exit"));
return (TRUE);
}
/* ARGSUSED */
static void
rmm_device_condition(LibHalContext *ctx, const char *udi,
const char *name, const char *detail)
{
if ((strcmp(name, "EjectPressed") == 0) &&
libhal_device_query_capability(hal_ctx, udi, "storage", NULL)) {
storage_eject_pressed(udi);
}
}
static void
device_added_callback (LibHalContext *ctx, const char *udi)
{
gchar *type_string;
gchar *class_string;
int type;
const gchar *element;
gchar *pipeline, *description;
gboolean ignore;
if (!libhal_device_query_capability (ctx, udi, "alsa", NULL)) {
return;
}
/* filter out "digitizer", "modem", "none", "unknown" */
class_string = libhal_device_get_property_string (ctx, udi, "alsa.pcm_class", NULL);
ignore = class_string != NULL
&& strcmp (class_string, "generic") != 0
&& strcmp (class_string, "multi") != 0;
libhal_free_string (class_string);
if (ignore) {
return;
}
type_string = libhal_device_get_property_string (ctx, udi, "alsa.type", NULL);
if (strcmp (type_string, "playback") == 0) {
type = AUDIO_PLAYBACK;
element = "halaudiosink";
} else if (strcmp (type_string, "capture") == 0) {
type = AUDIO_CAPTURE;
element = "halaudiosrc";
} else {
type = -1;
element = NULL;
}
libhal_free_string (type_string);
if (type == -1) {
return;
}
pipeline = g_strdup_printf ("%s udi=%s", element, udi);
description = libhal_device_get_property_string (ctx, udi, "alsa.device_id", NULL);
add_device (type, pipeline, description, NULL);
g_free (pipeline);
libhal_free_string (description);
}
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;
}
/*
* gst_hal_get_alsa_element:
* @ctx: a #LibHalContext which should be used for querying HAL.
* @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_alsa_element (LibHalContext * ctx, const gchar * udi,
GstHalDeviceType device_type)
{
char *type, *element = NULL, *string = NULL;
DBusError error;
dbus_error_init (&error);
if (!libhal_device_query_capability (ctx, udi, "alsa", &error)) {
if (dbus_error_is_set (&error)) {
GST_DEBUG ("Failed querying %s for alsa capability: %s: %s",
udi, error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
} else {
GST_DEBUG ("UDI %s has no alsa capability", udi);
}
return NULL;
}
type = libhal_device_get_property_string (ctx, udi, "alsa.type", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has alsa capabilities but no alsa.type property: %s, %s",
udi, error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (!type) {
GST_DEBUG ("UDI %s has empty alsa.type property", udi);
return NULL;
}
if (strcmp (type, "playback") == 0 && device_type == GST_HAL_AUDIOSINK)
element = "alsasink";
else if (strcmp (type, "capture") == 0 && device_type == GST_HAL_AUDIOSRC)
element = "alsasrc";
libhal_free_string (type);
if (element) {
int card, device;
card = libhal_device_get_property_int (ctx, udi, "alsa.card", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has no alsa.card property: %s: %s", udi, error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (card == -1) {
GST_DEBUG ("UDI %s has no alsa.card property", udi);
return NULL;
}
device = libhal_device_get_property_int (ctx, udi, "alsa.device", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has no alsa.device property: %s: %s", udi, error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (device == -1) {
GST_DEBUG ("UDI %s has no alsa.device property", udi);
return NULL;
}
/* This is a bit dodgy, since it makes lots of assumptions about the way
* alsa is set up. In any case, only munge the device string for playback */
if (strcmp (element, "alsasink") == 0 && device == 0) {
/* handle default device specially to use
* dmix, dsnoop, and softvol if appropriate */
string = g_strdup_printf ("%s device=default:%d", element, card);
} else {
string =
g_strdup_printf ("%s device=plughw:%d,%d", element, card, device);
}
}
return string;
}
/*
* gst_hal_get_oss_element:
* @ctx: a #LibHalContext which should be used for querying HAL.
* @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_oss_element (LibHalContext * ctx, const gchar * udi,
GstHalDeviceType device_type)
{
char *type, *element = NULL, *string = NULL;
DBusError error;
dbus_error_init (&error);
if (!libhal_device_query_capability (ctx, udi, "oss", &error)) {
if (dbus_error_is_set (&error)) {
GST_DEBUG ("Failed querying %s for oss capability: %s: %s", udi,
error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
} else {
GST_DEBUG ("UDI %s has no oss capability", udi);
}
return NULL;
}
type = libhal_device_get_property_string (ctx, udi, "oss.type", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has oss capabilities but no oss.type property: %s, %s",
udi, error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (!type) {
GST_DEBUG ("UDI %s has empty oss.type property", udi);
return NULL;
}
if (strcmp (type, "pcm") == 0) {
if (device_type == GST_HAL_AUDIOSINK)
element = "osssink";
else if (device_type == GST_HAL_AUDIOSRC)
element = "osssrc";
}
libhal_free_string (type);
if (element) {
char *device = NULL;
device =
libhal_device_get_property_string (ctx, udi, "oss.device_file", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG
("UDI %s has oss capabilities but no oss.device_file property: %s, %s",
udi, error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (!device) {
GST_DEBUG ("UDI %s has empty oss.device_file property", udi);
return NULL;
}
string = g_strdup_printf ("%s device=%s", element, device);
libhal_free_string (device);
}
return string;
}
/* 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);
}
