static char *
get_prop_string_array(LibHalContext *hal_ctx, const char *udi, const char *prop)
{
char **props, *ret, *str;
int i, len = 0;
props = libhal_device_get_property_strlist(hal_ctx, udi, prop, NULL);
if (props) {
for (i = 0; props[i]; i++)
len += strlen(props[i]);
ret = xcalloc(sizeof(char), len + i); /* i - 1 commas, 1 NULL */
if (!ret) {
libhal_free_string_array(props);
return NULL;
}
str = ret;
for (i = 0; props[i]; i++) {
strcpy(str, props[i]);
str += strlen(props[i]);
*str++ = ',';
}
*(str-1) = '\0';
libhal_free_string_array(props);
}
else {
return NULL;
}
return ret;
}
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;
}
/*
* Dump all devices.
*/
int
dump_all_devices(LibHalContext *hal_ctx)
{
int i;
int num_devices;
char **device_names;
DBusError error;
dbus_error_init(&error);
if (!(device_names =
libhal_get_all_devices(hal_ctx, &num_devices, &error))) {
fprintf(stderr, "Empty HAL device list.\n");
LIBHAL_FREE_DBUS_ERROR(&error);
return (31);
}
for (i = 0; i < num_devices; i++) {
prt_dev_props(hal_ctx, device_names[i]);
}
libhal_free_string_array(device_names);
dbus_error_free(&error);
return (0);
}
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 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);
}
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;
}
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);
}
int rsct_usbdev_scan(rsct_usbdev_t **usbdev_list) {
int rv;
rv=rsct_usbdev_init();
if (rv)
return -1;
else {
char **devices;
int i_devices;
int rv;
devices=libhal_get_all_devices(global_hal_context->ctx, &i_devices, &(global_hal_context->dbus_error));
if (devices==NULL) {
fprintf(stderr, "RSCT: HAL not running: %s\n", global_hal_context->dbus_error.message);
return -1;
}
if (i_devices<1) {
fprintf(stderr, "RSCT: HAL returned an empty device list, this can't be right...\n");
}
rv=rsct_usbdev_scan_nonserial(devices, i_devices, usbdev_list);
if (rv==0)
rv=rsct_usbdev_scan_serial(devices, i_devices, usbdev_list);
libhal_free_string_array(devices);
return rv;
}
return 0;
}
void find_devices(void)
{
DBusError error;
dbus_error_init(&error);
if (ac_adapters)
libhal_free_string_array(ac_adapters);
ac_adapters = libhal_find_device_by_capability(hal_ctx, "ac_adapter",
&num_ac_adapters, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "error: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
}
if (batteries)
libhal_free_string_array(batteries);
batteries = libhal_find_device_by_capability(hal_ctx, "battery",
&num_batteries, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "error: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
}
}
/*
* Mount all mountable volumes
*/
static void
rmm_mount_all()
{
DBusError error;
char **udis = NULL;
int num_udis;
int i;
managed_volume_t *v;
dbus_error_init(&error);
/* get all volumes */
if ((udis = libhal_find_device_by_capability(hal_ctx, "volume",
&num_udis, &error)) == NULL) {
dprintf("mount_all: no volumes found\n");
goto out;
}
for (i = 0; i < num_udis; i++) {
/* skip if already mounted */
if (libhal_device_get_property_bool(hal_ctx, udis[i],
"volume.is_mounted", NULL)) {
dprintf("mount_all: %s already mounted\n", udis[i]);
continue;
}
if (!volume_should_mount(udis[i])) {
continue;
}
if ((v = rmm_managed_alloc(hal_ctx, udis[i])) == NULL) {
continue;
}
if (rmm_action(hal_ctx, udis[i], INSERT, &v->aa, 0, 0, 0)) {
v->my = B_TRUE;
managed_volumes = g_slist_prepend(managed_volumes, v);
} else {
rmm_managed_free(v);
}
}
out:
if (udis != NULL) {
libhal_free_string_array(udis);
}
rmm_dbus_error_free(&error);
}
/* Iterate through all devices currently on the computer. Needed mostly at startup */
void CHALManager::GenerateGDL()
{
if (m_Context == NULL)
return;
char **GDL;
int i = 0;
CLog::Log(LOGDEBUG, "HAL: Clearing old global device list, if any");
m_Volumes.clear();
CLog::Log(LOGNOTICE, "HAL: Generating global device list");
GDL = libhal_get_all_devices(g_HalManager.m_Context, &i, &m_Error);
for (i = 0; GDL[i]; i++)
{
AddDevice(GDL[i]);
}
CLog::Log(LOGINFO, "HAL: Generated global device list, found %i", i);
libhal_free_string_array(GDL);
}
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)
{
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;
}
GSList*
build_volume_list(LibHalContext* ctx,
enum FormatVolumeType type,
GHashTable* icon_cache,
int icon_width, int icon_height)
{
const char* capability = "";
char** device_udis;
int i, device_udi_count = 0;
GSList* device_list = NULL;
DBusError error;
switch(type) {
case FORMATVOLUMETYPE_VOLUME:
capability = "volume";
break;
case FORMATVOLUMETYPE_DRIVE:
capability = "storage";
break;
}
/* Pull the storage (or volume) list from HAL */
dbus_error_init (&error);
if ( (device_udis = libhal_find_device_by_capability (ctx, capability, &device_udi_count, &error) ) == NULL) {
LIBHAL_FREE_DBUS_ERROR (&error);
goto out;
}
/* if we use libhal_device_get-property() instead of
* libhal_volume_get_mount_mount_point() we have to setup DBusError and
* some other things, the problem is do we like to have (null) in the gui
* when libhal-storage cannot discover where a partition is mounted?
* if so we can remove the DBusError code and use the libhal-storage func
* to retrive the mount point.
* (or maybe we can check if is_partition == null and then don't strdup
* it.
* It returns null when a device is marked as swap or mounted via
* cryptdisk or even if it's not listed in /etc/fstab
*/
/* Now we use libhal-storage to get the info */
FormatVolume* current;
const char* icon_path;
for(i=0; i < device_udi_count; i++) {
current = g_new0(FormatVolume, 1);
g_debug("udi: %s", device_udis[i]);
current->udi = g_strdup(device_udis[i]);
switch(type) {
case FORMATVOLUMETYPE_VOLUME:
current->volume = libhal_volume_from_udi(ctx, device_udis[i]);
if(!current->volume) {
g_free(current);
continue;
}
/* FIXME: This tastes like wrong */
current->icon = NULL;
current->friendly_name = get_friendly_volume_info(ctx, current->volume);
current->drive_udi = g_strdup(libhal_volume_get_storage_device_udi(current->volume));
current->mountpoint = g_strdup(libhal_volume_get_mount_point(current->volume));
break;
case FORMATVOLUMETYPE_DRIVE:
current->drive = libhal_drive_from_udi(ctx, device_udis[i]);
if(!current->drive) {
g_free(current);
continue;
}
g_debug("Icon drive: %s; Icon volume: %s",
libhal_drive_get_dedicated_icon_drive(current->drive),
libhal_drive_get_dedicated_icon_volume(current->drive));
icon_path = libhal_drive_get_dedicated_icon_drive(current->drive);
current->icon = load_icon_from_cache(icon_path, icon_cache, icon_width, icon_height);
current->friendly_name = get_friendly_drive_info(current->drive);
break;
}
/* Do some last minute sanity checks */
if(!current->friendly_name) current->friendly_name = "";
device_list = g_slist_prepend(device_list, current);
}
if(device_udis)
libhal_free_string_array(device_udis);
out:
return device_list;
}
static int init_hal(void)
{
LibHalContext *ctx;
DBusError error;
DBusConnection *dbus_connection;
char **devices, **volumes;
int i, num;
if (!(ctx = libhal_ctx_new())) {
fprintf(stderr, "can't initialize\n");
return -1;
}
dbus_error_init(&error);
dbus_connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "%s\n", error.message);
dbus_error_free(&error);
return -1;
}
dbus_connection_setup_with_g_main(dbus_connection, NULL);
libhal_ctx_set_dbus_connection(ctx, dbus_connection);
libhal_ctx_set_device_property_modified(ctx, hal_property_modified);
if (!libhal_device_property_watch_all(ctx, &error)) {
fprintf(stderr, "%s\n", error.message);
dbus_error_free(&error);
libhal_ctx_free(ctx);
return -1;
}
if (!libhal_ctx_init(ctx, &error)) {
fprintf(stderr, "%s\n", error.message);
dbus_error_free(&error);
libhal_ctx_free(ctx);
return -1;
}
if (!(devices = libhal_get_all_devices(ctx, &num, &error))) {
fprintf(stderr, "%s\n", error.message);
dbus_error_free(&error);
libhal_ctx_shutdown(ctx, NULL);
libhal_ctx_free(ctx);
return -1;
}
libhal_free_string_array(devices);
volumes = libhal_find_device_by_capability(ctx, "volume", &num, &error);
if (dbus_error_is_set(&error)) {
printf("can't find volume devices: %s\n", error.message);
dbus_error_free(&error);
libhal_ctx_shutdown(ctx, NULL);
libhal_ctx_free(ctx);
return -1;
}
for (i = 0; i < num; i++) {
char *udi = volumes[i];
if (libhal_device_property_exists(ctx, udi, "volume.is_mounted",
NULL) && libhal_device_get_property_bool(ctx, udi,
"volume.is_mounted", NULL))
{
hal_property_modified(ctx, udi, "volume.is_mounted",
FALSE, FALSE);
hal_property_modified(ctx, udi, "volume.mount_point",
FALSE, FALSE);
}
}
libhal_free_string_array(volumes);
return 0;
}
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);
}
}
}
/* Parse newly found device and add it to our remembered devices */
void CHALManager::AddDevice(const char *udi)
{
CSingleLock lock(m_lock);
char *category;
category = libhal_device_get_property_string(m_Context, udi, "info.category", NULL);
if (category == NULL)
return;
if (strcmp(category, "volume") == 0)
{
CStorageDevice dev(udi);
if (DeviceFromVolumeUdi(udi, &dev))
{
CLog::Log(LOGDEBUG, "HAL: Added - %s | %s", CHALManager::StorageTypeToString(dev.Type), dev.toString().c_str());
HandleNewVolume(&dev);
m_Volumes.push_back(dev);
}
}
#if defined(HAS_SDL_JOYSTICK)
// Scan input devices
else if (strcmp(category, "input") == 0)
{
DBusError dbusError;
dbus_error_init(&dbusError);
char **capability;
capability =libhal_device_get_property_strlist (m_Context, udi, "info.capabilities", &dbusError);
for(char **ptr = capability; *ptr != NULL;ptr++)
{
// Reload joysticks
if(strcmp(*ptr, "input.joystick") == 0)
{
CLog::Log(LOGINFO, "HAL: Joystick plugged in");
CHALDevice dev = CHALDevice(udi);
dev.FriendlyName = libhal_device_get_property_string(m_Context, udi, "info.product", &m_Error);
m_Joysticks.push_back(dev);
if(m_Joysticks.size() < 2 || m_bMultipleJoysticksSupport)
{
// Restart SDL joystick subsystem
if (!g_Joystick.Reinitialize())
break;
if (m_Notifications)
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(13024), dev.FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
}
}
}
libhal_free_string_array(capability);
}
#endif
/*
else if (strcmp(category, "camera") == 0)
{ // PTP-Devices }
else if (strcmp(category, "bluetooth_hci") == 0)
{ // Bluetooth-Devices }
else if (strcmp(category, "portable audio player") == 0)
{ // MTP-Devices }
else if (strcmp(category, "alsa") == 0)
{ //Alsa Devices }
*/
libhal_free_string(category);
}
void CHALManager::HandleNewVolume(CStorageDevice *dev)
{
if (g_advancedSettings.m_handleMounting)
{
/* Here it can be checked if the device isn't mounted and then mount */
//TODO Have mountpoints be other than in /media/*
if (!dev->Mounted && (dev->HotPlugged || dev->Type == 2) && dev->Approved)
{
char **capability;
capability =libhal_device_get_property_strlist (m_Context, dev->UDI.c_str(), "info.capabilities", NULL);
bool Mountable = false;
if (dev->Type == 2 && (strcmp(capability[0], "volume.disc") == 0 && strcmp(capability[1], "volume") == 0)) // CD/DVD
Mountable = true;
else if ((strcmp(capability[0], "volume") == 0 && strcmp(capability[1], "block") == 0)) // HDD
Mountable = true;
if (Mountable)
{
CLog::Log(LOGNOTICE, "HAL: Trying to mount %s", dev->FriendlyName.c_str());
CStdString MountPoint;
CStdString TestPath;
if (dev->Label.size() > 0)
{
MountPoint = dev->Label.c_str();
TestPath.Format("/media/%s", MountPoint.c_str());
struct stat St;
if (stat("/media", &St) != 0)
return; //If /media doesn't exist something is wrong.
while(stat (TestPath.c_str(), &St) == 0 && S_ISDIR (St.st_mode))
{
CLog::Log(LOGDEBUG, "HAL: Proposed Mountpoint already existed");
MountPoint.append("_");
TestPath.Format("/media/%s", MountPoint.c_str());
}
}
else
{
MountPoint = StorageTypeToString(dev->Type);
TestPath.Format("/media/%s", MountPoint.c_str());
int Nbr = 0;
struct stat St;
if (stat("/media", &St) != 0)
return; //If /media doesn't exist something is wrong.
while(stat (TestPath.c_str(), &St) == 0 && S_ISDIR (St.st_mode))
{
CLog::Log(LOGDEBUG, "HAL: Proposed Mountpoint already existed");
Nbr++;
MountPoint.Format("%s%i", StorageTypeToString(dev->Type), Nbr);
TestPath.Format("/media/%s", MountPoint.c_str());
}
}
if (Mount(dev, MountPoint))
{
CLog::Log(LOGINFO, "HAL: mounted %s on %s", dev->FriendlyName.c_str(), dev->MountPoint.c_str());
if (m_Notifications)
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(13021), dev->FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
}
}
libhal_free_string_array(capability);
}
}
}
// Initialize basic HAL connection
LibHalContext *CHALManager::InitializeHal()
{
LibHalContext *ctx;
char **devices;
int nr;
if (!InitializeDBus())
return NULL;
if (!(ctx = libhal_ctx_new()))
{
CLog::Log(LOGERROR, "HAL: failed to create a HAL context!");
return NULL;
}
if (!libhal_ctx_set_dbus_connection(ctx, m_DBusSystemConnection))
CLog::Log(LOGERROR, "HAL: Failed to connect with dbus");
libhal_ctx_set_device_added(ctx, DeviceAdded);
libhal_ctx_set_device_removed(ctx, DeviceRemoved);
libhal_ctx_set_device_new_capability(ctx, DeviceNewCapability);
libhal_ctx_set_device_lost_capability(ctx, DeviceLostCapability);
libhal_ctx_set_device_property_modified(ctx, DevicePropertyModified);
libhal_ctx_set_device_condition(ctx, DeviceCondition);
if (!libhal_device_property_watch_all(ctx, &m_Error))
{
CLog::Log(LOGERROR, "HAL: Failed to set property watch %s", m_Error.message);
dbus_error_free(&m_Error);
libhal_ctx_free(ctx);
return NULL;
}
if (!libhal_ctx_init(ctx, &m_Error))
{
CLog::Log(LOGERROR, "HAL: Failed to initialize hal context: %s", m_Error.message);
dbus_error_free(&m_Error);
libhal_ctx_free(ctx);
return NULL;
}
/*
* Do something to ping the HAL daemon - the above functions will
* succeed even if hald is not running, so long as DBUS is. But we
* want to exit silently if hald is not running, to behave on
* pre-2.6 systems.
*/
if (!(devices = libhal_get_all_devices(ctx, &nr, &m_Error)))
{
CLog::Log(LOGERROR, "HAL: seems that Hal daemon is not running: %s", m_Error.message);
dbus_error_free(&m_Error);
libhal_ctx_shutdown(ctx, NULL);
libhal_ctx_free(ctx);
return NULL;
}
libhal_free_string_array(devices);
return ctx;
}
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);
}
}
gboolean
check_libhal (const char *server_addr)
{
pid_t child_pid;
child_pid = fork ();
if (child_pid == -1) {
printf ("Cannot fork\n");
exit (1);
} else if (child_pid == 0) {
DBusError error;
DBusConnection *conn;
LibHalContext *ctx;
dbus_bool_t passed;
printf ("server address='%s'\n", server_addr);
dbus_error_init (&error);
if ((conn = dbus_connection_open (server_addr, &error)) == NULL) {
printf ("Error connecting to server: %s\n", error.message);
goto fail;
}
dbus_connection_setup_with_g_main (conn, NULL);
if ((ctx = libhal_ctx_new ()) == NULL) {
printf ("Error getting libhal context\n");
goto fail;
}
libhal_ctx_set_dbus_connection (ctx, conn);
libhal_ctx_init (ctx, &error);
if (dbus_error_is_set (&error)) {
printf ("FAILED98: %s\n", error.message);
goto fail;
}
printf ("SUCCESS98\n");
libhal_device_print (ctx, "/org/freedesktop/Hal/devices/testobj1", &error);
if (dbus_error_is_set (&error)) {
printf ("FAILED99: %s\n", error.message);
goto fail;
}
printf ("SUCCESS99\n");
passed = FALSE;
{
char *val;
val = libhal_device_get_property_string (ctx, "/org/freedesktop/Hal/devices/testobj1", "test.string", &error);
if (val == NULL || strcmp (val, "fooooobar22") != 0 || dbus_error_is_set (&error)) {
libhal_free_string (val);
printf ("FAILED100\n");
goto fail;
}
printf ("SUCCESS100\n");
libhal_free_string (val);
}
{
char *val;
val = libhal_device_get_property_string (ctx, "/org/freedesktop/Hal/devices/testobj1", "test.string2", &error);
if (val == NULL || strcmp (val, "fooøةמ") != 0 || dbus_error_is_set (&error)) {
libhal_free_string (val);
printf ("FAILED101: %s\n", error.message);
goto fail;
}
libhal_free_string (val);
printf ("SUCCESS101\n");
}
{
dbus_bool_t b;
b = libhal_device_get_property_bool (
ctx, "/org/freedesktop/Hal/devices/testobj1",
"test.bool", &error);
if (!b || dbus_error_is_set (&error)) {
printf ("FAILED102: %s, %i\n", error.message, b);
goto fail;
}
printf ("SUCCESS102\n");
}
{
double val;
double expected_val = 0.53434343;
val = libhal_device_get_property_double (ctx, "/org/freedesktop/Hal/devices/testobj1",
"test.double", &error);
if ( memcmp (&val, &expected_val, sizeof (double)) != 0 || dbus_error_is_set (&error)) {
printf ("FAILED103\n");
goto fail;
}
printf ("SUCCESS103\n");
}
if (libhal_device_get_property_uint64 (
ctx, "/org/freedesktop/Hal/devices/testobj1", "test.uint64", &error) !=
((((dbus_uint64_t)1)<<35) + 5) ||
dbus_error_is_set (&error)) {
printf ("FAILED104: %s\n", error.message);
goto fail;
}
printf ("SUCCESS104\n");
{
char **val;
val = libhal_device_get_property_strlist (ctx, "/org/freedesktop/Hal/devices/testobj1", "test.strlist", &error);
if (val == NULL || dbus_error_is_set (&error)) {
libhal_free_string_array (val);
printf ("FAILED105: %s\n", error.message);
goto fail;
}
printf ("SUCCESS105\n");
if (libhal_string_array_length (val) != 2) {
libhal_free_string_array (val);
printf ("FAILED106\n");
goto fail;
}
printf ("SUCCESS106\n");
if (strcmp (val[0], "foostrlist2") != 0 ||
strcmp (val[1], "foostrlist3") != 0) {
libhal_free_string_array (val);
printf ("FAILED107\n");
goto fail;
}
printf ("SUCCESS107\n");
libhal_free_string_array (val);
}
if (libhal_device_get_property_int (
ctx, "/org/freedesktop/Hal/devices/testobj1", "test.int", &error) != 42 ||
dbus_error_is_set (&error)) {
printf ("FAILED108\n");
goto fail;
}
printf ("SUCCESS108\n");
/* tests for libhal_psi */
{
int type;
char *key;
LibHalPropertySet *pset;
LibHalPropertySetIterator it;
unsigned int psi_num_passed;
unsigned int psi_num_elems;
if ((pset = libhal_device_get_all_properties (ctx, "/org/freedesktop/Hal/devices/testobj1",
&error)) == NULL)
return FALSE;
printf ("SUCCESS110\n");
psi_num_passed = 0;
psi_num_elems = libhal_property_set_get_num_elems (pset);
for (libhal_psi_init (&it, pset); libhal_psi_has_more (&it); libhal_psi_next (&it)) {
type = libhal_psi_get_type (&it);
key = libhal_psi_get_key (&it);
switch (type) {
case LIBHAL_PROPERTY_TYPE_STRING:
if (strcmp (key, "info.udi") == 0) {
if (strcmp (libhal_psi_get_string (&it),
"/org/freedesktop/Hal/devices/testobj1") == 0) {
psi_num_passed++;
} else {
printf ("fail on %s\n", key);
}
} else if (strcmp (key, "test.string") == 0) {
if (strcmp (libhal_psi_get_string (&it),
"fooooobar22") == 0) {
psi_num_passed++;
} else {
printf ("fail on %s\n", key);
}
} else if (strcmp (key, "test.string2") == 0) {
if (strcmp (libhal_psi_get_string (&it),
"fooøةמ") == 0) {
psi_num_passed++;
} else {
printf ("fail on %s\n", key);
}
}
break;
case LIBHAL_PROPERTY_TYPE_INT32:
if (strcmp (key, "test.int") == 0) {
if (libhal_psi_get_int (&it) == 42)
psi_num_passed++;
else
printf ("fail on %s\n", key);
}
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
if (strcmp (key, "test.uint64") == 0) {
if (libhal_psi_get_uint64 (&it) == ((((dbus_uint64_t)1)<<35) + 5))
psi_num_passed++;
else
printf ("fail on %s\n", key);
}
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
if (strcmp (key, "test.bool") == 0) {
if (libhal_psi_get_bool (&it) == TRUE)
psi_num_passed++;
else
printf ("fail on %s\n", key);
}
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
if (strcmp (key, "test.double") == 0) {
double val = 0.53434343;
double val2;
val2 = libhal_psi_get_double (&it);
if (memcmp (&val, &val2, sizeof (double)) == 0)
psi_num_passed++;
else
printf ("fail on %s\n", key);
}
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
if (strcmp (key, "test.strlist") == 0) {
char **val;
val = libhal_psi_get_strlist (&it);
if (libhal_string_array_length (val) == 2 &&
strcmp (val[0], "foostrlist2") == 0 &&
strcmp (val[1], "foostrlist3") == 0 &&
val[2] == NULL)
psi_num_passed++;
else
printf ("fail on %s\n", key);
}
break;
default:
printf (" *** unknown type for key %s\n", key);
break;
}
}
libhal_free_property_set (pset);
if (psi_num_passed != psi_num_elems) {
printf ("FAILED111\n");
goto fail;
}
printf ("SUCCESS111\n");
} /* end libhal_test_psi */
printf ("Passed all libhal tests\n");
passed = TRUE;
fail:
if (dbus_error_is_set (&error))
dbus_error_free (&error);
send_tests_done (conn, passed);
exit (1);
} else {
printf ("child pid=%d\n", child_pid);
}
return TRUE;
}
/*
* Dump all devices.
*/
int dump_devices(LibHalContext *hal_ctx, char *arg)
{
int i;
int num_devices;
char **device_names;
DBusError error;
char *udi = NULL;
if (arg) {
if (*arg == '/') {
udi = arg;
} else {
#ifdef HAVE_ASPRINTF
asprintf(&udi, "/org/freedesktop/Hal/devices/%s", arg);
#else
udi = calloc(1, sizeof ("/org/freedesktop/Hal/devices/%s") + strlen(arg));
sprintf(udi, "/org/freedesktop/Hal/devices/%s", arg);
#endif
}
}
dbus_error_init(&error);
if (!udi) {
if (!(device_names = libhal_get_all_devices(hal_ctx, &num_devices, &error))) {
fprintf(stderr, "Empty HAL device list.\n");
LIBHAL_FREE_DBUS_ERROR (&error);
return 31;
}
} else {
device_names = calloc(2, sizeof *device_names);
device_names[0] = strdup(udi);
num_devices = 1;
}
for(i = 0; i < num_devices; i++) {
LibHalPropertySet *props;
LibHalPropertySetIterator it;
int type;
if (!(props = libhal_device_get_all_properties(hal_ctx, device_names[i], &error))) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
dbus_error_init(&error);
continue;
}
if (!udi)
printf("%d: ", i);
printf("udi = '%s'\n", device_names[i]);
for(libhal_psi_init(&it, props); libhal_psi_has_more(&it); libhal_psi_next(&it)) {
type = libhal_psi_get_type(&it);
switch (type) {
case LIBHAL_PROPERTY_TYPE_STRING:
printf(" %s = '%s' (string)\n",
libhal_psi_get_key(&it),
libhal_psi_get_string(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_INT32:
printf(" %s = %d (0x%x) (int)\n",
libhal_psi_get_key(&it),
libhal_psi_get_int(&it),
libhal_psi_get_int(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
printf(" %s = %lld (0x%llx) (uint64)\n",
libhal_psi_get_key(&it),
(long long) libhal_psi_get_uint64(&it),
(long long) libhal_psi_get_uint64(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
printf(" %s = %g (double)\n",
libhal_psi_get_key(&it),
libhal_psi_get_double(&it)
);
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
printf(" %s = %s (bool)\n",
libhal_psi_get_key(&it),
libhal_psi_get_bool(&it) ? "true" : "false"
);
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
{
char **strlist;
printf (" %s = { ", libhal_psi_get_key(&it));
strlist = libhal_psi_get_strlist(&it);
while (*strlist) {
printf("'%s'%s", *strlist, strlist[1] ? ", " : "");
strlist++;
}
printf(" } (string list)\n");
}
break;
default:
printf("Unknown type %d = 0x%02x\n", type, type);
break;
}
}
libhal_free_property_set(props);
printf("\n");
}
libhal_free_string_array(device_names);
dbus_error_free(&error);
return 0;
}
/*
* 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
impl_activate (PeasActivatable *bplugin)
{
RBMtpPlugin *plugin = RB_MTP_PLUGIN (bplugin);
GtkUIManager *uimanager = NULL;
RBRemovableMediaManager *rmm;
char *file = NULL;
RBShell *shell;
#if defined(HAVE_GUDEV)
gboolean rmm_scanned = FALSE;
#else
int num_mtp_devices;
LIBMTP_raw_device_t *mtp_devices;
#endif
g_object_get (plugin, "object", &shell, NULL);
g_object_get (shell,
"ui-manager", &uimanager,
"removable-media-manager", &rmm,
NULL);
/* ui */
rb_media_player_source_init_actions (shell);
plugin->action_group = gtk_action_group_new ("MTPActions");
gtk_action_group_set_translation_domain (plugin->action_group,
GETTEXT_PACKAGE);
_rb_action_group_add_display_page_actions (plugin->action_group,
G_OBJECT (shell),
rb_mtp_plugin_actions,
G_N_ELEMENTS (rb_mtp_plugin_actions));
gtk_ui_manager_insert_action_group (uimanager, plugin->action_group, 0);
file = rb_find_plugin_data_file (G_OBJECT (bplugin), "mtp-ui.xml");
plugin->ui_merge_id = gtk_ui_manager_add_ui_from_file (uimanager, file, NULL);
g_object_unref (uimanager);
g_object_unref (shell);
/* device detection */
#if defined(HAVE_GUDEV)
plugin->create_device_source_id =
g_signal_connect_object (rmm,
"create-source-device",
G_CALLBACK (create_source_device_cb),
plugin,
0);
/* only scan if we're being loaded after the initial scan has been done */
g_object_get (rmm, "scanned", &rmm_scanned, NULL);
if (rmm_scanned)
rb_removable_media_manager_scan (rmm);
#else
if (rb_mtp_plugin_setup_dbus_hal_connection (plugin) == FALSE) {
rb_debug ("not scanning for MTP devices because we couldn't get a HAL context");
g_object_unref (rmm);
return;
}
rb_profile_start ("scanning for MTP devices");
LIBMTP_Detect_Raw_Devices (&mtp_devices, &num_mtp_devices);
if (num_mtp_devices > 0) {
int num_hal_devices;
char **hal_devices;
int i;
rb_debug ("%d MTP devices found", num_mtp_devices);
hal_devices = libhal_get_all_devices (plugin->hal_context, &num_hal_devices, NULL);
for (i = 0; i < num_hal_devices; i++) {
/* should narrow this down a bit - usb only, for a start */
rb_mtp_plugin_maybe_add_source (plugin, hal_devices[i], mtp_devices, num_mtp_devices);
}
libhal_free_string_array (hal_devices);
}
if (mtp_devices != NULL) {
free (mtp_devices);
}
rb_profile_end ("scanning for MTP devices");
#endif
g_object_unref (rmm);
}
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);
}
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;
}
std::map<int, std::pair<std::string, std::string> > SerialPortEnumerator::getPorts()
{
std::map<int, std::pair<std::string, std::string> > ports;
#ifdef MACOSX
// use IOKit to enumerates devices
// get a matching dictionary to specify which IOService class we're interested in
CFMutableDictionaryRef classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
if (classesToMatch == NULL)
throw DashelException(DashelException::EnumerationError, 0, "IOServiceMatching returned a NULL dictionary");
// specify all types of serial devices
CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes));
// get an iterator to serial port services
io_iterator_t matchingServices;
kern_return_t kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, classesToMatch, &matchingServices);
if (KERN_SUCCESS != kernResult)
throw DashelException(DashelException::EnumerationError, kernResult, "IOServiceGetMatchingServices failed");
// iterate over services
io_object_t modemService;
int index = 0;
while((modemService = IOIteratorNext(matchingServices)))
{
// get path for device
CFTypeRef bsdPathAsCFString = IORegistryEntryCreateCFProperty(modemService, CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0);
if (bsdPathAsCFString)
{
std::string path;
char cStr[255];
std::string name;
bool res = CFStringGetCString((CFStringRef) bsdPathAsCFString, cStr, 255, kCFStringEncodingUTF8);
if(res)
path = cStr;
else
throw DashelException(DashelException::EnumerationError, 0, "CFStringGetCString failed");
CFRelease(bsdPathAsCFString);
CFTypeRef fn = IORegistryEntrySearchCFProperty(modemService, kIOServicePlane, CFSTR("USB Product Name"), kCFAllocatorDefault,
kIORegistryIterateRecursively | kIORegistryIterateParents);
if(fn) {
res = CFStringGetCString((CFStringRef) fn, cStr, 255, kCFStringEncodingUTF8);
if(res)
name = cStr;
else
throw DashelException(DashelException::EnumerationError, 0, "CFStringGetString failed");
CFRelease(fn);
} else
name = "Serial Port";
name = name + " (" + path + ")";
ports[index++] = std::make_pair<std::string, std::string>(path, name);
}
else
throw DashelException(DashelException::EnumerationError, 0, "IORegistryEntryCreateCFProperty returned a NULL path");
// release service
IOObjectRelease(modemService);
}
IOObjectRelease(matchingServices);
#elif defined(USE_LIBUDEV)
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
int index = 0;
udev = udev_new();
if(!udev)
throw DashelException(DashelException::EnumerationError, 0, "Cannot create udev context");
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "tty");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *sysfs_path;
struct udev_device *usb_dev;
const char * path;
struct stat st;
unsigned int maj,min;
/* Get sysfs path and create the udev device */
sysfs_path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, sysfs_path);
// Some sanity check
path = udev_device_get_devnode(dev);
if(stat(path, &st))
throw DashelException(DashelException::EnumerationError, 0, "Cannot stat serial port");
if(!S_ISCHR(st.st_mode))
throw DashelException(DashelException::EnumerationError, 0, "Serial port is not character device");
// Get the major/minor number
maj = major(st.st_rdev);
min = minor(st.st_rdev);
// Ignore all the non physical ports
if(!(maj == 2 || (maj == 4 && min < 64) || maj == 3 || maj == 5)) {
ostringstream oss;
// Check if usb, if yes get the device name
usb_dev = udev_device_get_parent_with_subsystem_devtype(dev,"usb","usb_device");
if(usb_dev)
oss << udev_device_get_sysattr_value(usb_dev,"product");
else
oss << "Serial Port";
oss << " (" << path << ")";
ports[index++] = std::make_pair<std::string, std::string>(path,oss.str());
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
#elif defined(USE_HAL)
// use HAL to enumerates devices
DBusConnection* dbusConnection = dbus_bus_get(DBUS_BUS_SYSTEM, 0);
if (!dbusConnection)
throw DashelException(DashelException::EnumerationError, 0, "cannot connect to D-BUS.");
LibHalContext* halContext = libhal_ctx_new();
if (!halContext)
throw DashelException(DashelException::EnumerationError, 0, "cannot create HAL context: cannot create context");
if (!libhal_ctx_set_dbus_connection(halContext, dbusConnection))
throw DashelException(DashelException::EnumerationError, 0, "cannot create HAL context: cannot connect to D-BUS");
if (!libhal_ctx_init(halContext, 0))
throw DashelException(DashelException::EnumerationError, 0, "cannot create HAL context: cannot init context");
int devicesCount;
char** devices = libhal_find_device_by_capability(halContext, "serial", &devicesCount, 0);
for (int i = 0; i < devicesCount; i++)
{
char* devFileName = libhal_device_get_property_string(halContext, devices[i], "serial.device", 0);
char* info = libhal_device_get_property_string(halContext, devices[i], "info.product", 0);
int port = libhal_device_get_property_int(halContext, devices[i], "serial.port", 0);
ostringstream oss;
oss << info << " " << port;
ports[devicesCount - i] = std::make_pair<std::string, std::string>(devFileName, oss.str());
libhal_free_string(info);
libhal_free_string(devFileName);
}
libhal_free_string_array(devices);
libhal_ctx_shutdown(halContext, 0);
libhal_ctx_free(halContext);
#endif
return ports;
};
static BOOL
connect_and_register(DBusConnection *connection, struct config_hal_info *info)
{
DBusError error;
char **devices;
int num_devices, i;
if (info->hal_ctx)
return TRUE; /* already registered, pretend we did something */
info->system_bus = connection;
dbus_error_init(&error);
info->hal_ctx = libhal_ctx_new();
if (!info->hal_ctx) {
LogMessage(X_ERROR, "config/hal: couldn't create HAL context\n");
goto out_err;
}
if (!libhal_ctx_set_dbus_connection(info->hal_ctx, info->system_bus)) {
LogMessage(X_ERROR, "config/hal: couldn't associate HAL context with bus\n");
goto out_err;
}
if (!libhal_ctx_init(info->hal_ctx, &error)) {
LogMessage(X_ERROR, "config/hal: couldn't initialise context: %s (%s)\n",
error.name ? error.name : "unknown error",
error.message ? error.message : "null");
goto out_err;
}
if (!libhal_device_property_watch_all(info->hal_ctx, &error)) {
LogMessage(X_ERROR, "config/hal: couldn't watch all properties: %s (%s)\n",
error.name ? error.name : "unknown error",
error.message ? error.message : "null");
goto out_ctx;
}
libhal_ctx_set_device_added(info->hal_ctx, device_added);
libhal_ctx_set_device_removed(info->hal_ctx, device_removed);
devices = libhal_find_device_by_capability(info->hal_ctx, "input",
&num_devices, &error);
/* FIXME: Get default devices if error is set. */
if (dbus_error_is_set(&error)) {
LogMessage(X_ERROR, "config/hal: couldn't find input device: %s (%s)\n",
error.name ? error.name : "unknown error",
error.message ? error.message : "null");
goto out_ctx;
}
for (i = 0; i < num_devices; i++)
device_added(info->hal_ctx, devices[i]);
libhal_free_string_array(devices);
dbus_error_free(&error);
return TRUE;
out_ctx:
dbus_error_free(&error);
if (!libhal_ctx_shutdown(info->hal_ctx, &error)) {
LogMessage(X_WARNING, "config/hal: couldn't shut down context: %s (%s)\n",
error.name ? error.name : "unknown error",
error.message ? error.message : "null");
dbus_error_free(&error);
}
out_err:
dbus_error_free(&error);
if (info->hal_ctx) {
libhal_ctx_free(info->hal_ctx);
}
info->hal_ctx = NULL;
info->system_bus = NULL;
return FALSE;
}
static void
connect_hook(DBusConnection *connection, void *data)
{
DBusError error;
struct config_hal_info *info = data;
char **devices;
int num_devices, i;
info->system_bus = connection;
dbus_error_init(&error);
if (!info->hal_ctx)
info->hal_ctx = libhal_ctx_new();
if (!info->hal_ctx) {
ErrorF("[config/hal] couldn't create HAL context\n");
goto out_err;
}
if (!libhal_ctx_set_dbus_connection(info->hal_ctx, info->system_bus)) {
ErrorF("[config/hal] couldn't associate HAL context with bus\n");
goto out_ctx;
}
if (!libhal_ctx_init(info->hal_ctx, &error)) {
ErrorF("[config/hal] couldn't initialise context: %s (%s)\n",
error.name, error.message);
goto out_ctx;
}
libhal_ctx_set_device_added(info->hal_ctx, device_added);
libhal_ctx_set_device_removed(info->hal_ctx, device_removed);
if (!libhal_device_property_watch_all(info->hal_ctx, &error)) {
ErrorF("[config/hal] couldn't watch all properties: %s (%s)\n",
error.name, error.message);
goto out_ctx2;
}
devices = libhal_find_device_by_capability(info->hal_ctx, "input",
&num_devices, &error);
/* FIXME: Get default devices if error is set. */
for (i = 0; i < num_devices; i++)
device_added(info->hal_ctx, devices[i]);
libhal_free_string_array(devices);
dbus_error_free(&error);
return;
out_ctx2:
if (!libhal_ctx_shutdown(info->hal_ctx, &error))
DebugF("[config/hal] couldn't shut down context: %s (%s)\n",
error.name, error.message);
out_ctx:
libhal_ctx_free(info->hal_ctx);
out_err:
dbus_error_free(&error);
info->hal_ctx = NULL;
info->system_bus = NULL;
return;
}
