static int rsct_usbdev_scan_serial(char **devices, int i_devices,
rsct_usbdev_t **usbdev_list) {
int i;
for (i=0; i<i_devices; i++) {
const char *udi=devices[i];
if (libhal_device_exists(global_hal_context->ctx, udi, &(global_hal_context->dbus_error))) {
char *busType;
busType=libhal_device_get_property_string(global_hal_context->ctx, udi, "info.subsystem", NULL);
if (busType==NULL)
busType=libhal_device_get_property_string(global_hal_context->ctx, udi, "info.bus", NULL);
if (busType) {
if (strcasecmp(busType, "tty")==0) {
char *parent_udi;
/* ttyUSB device, get USB info from parent */
parent_udi=libhal_device_get_property_string(global_hal_context->ctx,
udi,
"info.parent",
NULL);
if (parent_udi) {
rsct_usbdev_t *d;
char *path;
/* find device entry for parent */
d=rsct_usbdev_list_findByUDI(*usbdev_list, parent_udi);
if (d) {
int port;
port=libhal_device_get_property_int(global_hal_context->ctx,
udi,
"serial.port",
NULL);
d->port=port;
path=libhal_device_get_property_string(global_hal_context->ctx,
udi,
"serial.device",
NULL);
if (path) {
strncpy(d->deviceNodePath, path, sizeof(d->deviceNodePath)-1);
d->deviceNodePath[sizeof(d->deviceNodePath)-1]=0;
libhal_free_string(path);
}
}
libhal_free_string(parent_udi);
}
else {
fprintf(stderr, "RSCT: Parent for serial device not found\n");
}
} /* if tty */
libhal_free_string(busType);
} /* if bus type */
} /* if device exists */
} /* for */
return 0;
}
static gboolean hal_get_ipod_usb_position (LibHalContext *ctx, const char *udi,
int *usb_bus_number, int *usb_device_number)
{
char *parent_udi;
char *subsystem;
gboolean found_ids;
DBusError error;
parent_udi = NULL;
subsystem = NULL;
found_ids = FALSE;
dbus_error_init (&error);
while (TRUE) {
parent_udi = libhal_device_get_property_string (ctx, udi,
"info.parent", &error);
if (parent_udi == NULL || dbus_error_is_set (&error))
goto end;
udi = parent_udi;
subsystem = libhal_device_get_property_string (ctx, udi,
"linux.subsystem",
&error);
if (subsystem == NULL || dbus_error_is_set (&error)) {
dbus_error_free (&error);
dbus_error_init (&error);
continue;
}
if (strcmp (subsystem, "usb") == 0) {
*usb_bus_number = libhal_device_get_property_int (ctx, udi,
"usb.bus_number", &error);
if (dbus_error_is_set (&error)) {
goto end;
}
*usb_device_number = libhal_device_get_property_int (ctx, udi,
"usb.linux.device_number", &error);
if (dbus_error_is_set (&error)) {
goto end;
}
found_ids = TRUE;
goto end;
}
}
end:
libhal_free_string (parent_udi);
libhal_free_string (subsystem);
if (dbus_error_is_set (&error)) {
g_print ("Error: %s\n", error.message);
dbus_error_free (&error);
}
return found_ids;
}
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);
}
void CHALManager::UpdateDevice(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))
return;
for (unsigned int i = 0; i < m_Volumes.size(); i++)
{
if (strcmp(m_Volumes[i].UDI.c_str(), udi) == 0)
{
CLog::Log(LOGDEBUG, "HAL: Update - %s | %s", CHALManager::StorageTypeToString(dev.Type), dev.toString().c_str());
if (g_advancedSettings.m_handleMounting) // If the device was mounted by XBMC before it's still mounted by XBMC.
dev.MountedByXBMC = m_Volumes[i].MountedByXBMC;
if (!dev.Mounted && m_Volumes[i].Mounted)
CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, g_localizeStrings.Get(13023), dev.FriendlyName.c_str(), TOAST_DISPLAY_TIME, false);
m_Volumes[i] = dev;
break;
}
}
}
libhal_free_string(category);
}
// Helper function. creates a CStorageDevice from a HAL udi
bool CHALManager::DeviceFromVolumeUdi(const char *udi, CStorageDevice *device)
{
if (g_HalManager.m_Context == NULL)
return false;
LibHalVolume *tempVolume;
LibHalDrive *tempDrive;
bool Created = false;
tempVolume = libhal_volume_from_udi(g_HalManager.m_Context, udi);
if (tempVolume)
{
const char *DriveUdi = libhal_volume_get_storage_device_udi(tempVolume);
tempDrive = libhal_drive_from_udi(g_HalManager.m_Context, DriveUdi);
if (tempDrive)
{
char * FriendlyName = libhal_device_get_property_string(g_HalManager.m_Context, udi, "info.product", NULL);
device->FriendlyName = FriendlyName;
libhal_free_string(FriendlyName);
char *block = libhal_device_get_property_string(g_HalManager.m_Context, udi, "block.device", NULL);
device->DevID = block;
libhal_free_string(block);
device->HotPlugged = (bool)libhal_drive_is_hotpluggable(tempDrive);
device->Type = libhal_drive_get_type(tempDrive);
device->Mounted = (bool)libhal_volume_is_mounted(tempVolume);
device->MountPoint = libhal_volume_get_mount_point(tempVolume);
if (device->Mounted)
URIUtils::AddSlashAtEnd(device->MountPoint);
device->Label = libhal_volume_get_label(tempVolume);
device->UUID = libhal_volume_get_uuid(tempVolume);
device->FileSystem = libhal_volume_get_fstype(tempVolume);
device->HalIgnore = libhal_device_get_property_bool(g_HalManager.m_Context, udi, "volume.ignore", NULL);
ApproveDevice(device);
libhal_drive_free(tempDrive);
Created = true;
}
else
CLog::Log(LOGERROR, "HAL: Couldn't create a Drive even if we had a volume - %s", udi);
libhal_volume_free(tempVolume);
}
return Created;
}
static char *
uuid_get_from_hal(void)
{
LibHalContext *ctx;
DBusError error;
DBusConnection *con;
dbus_error_init(&error);
if (!(con = dbus_bus_get(DBUS_BUS_SYSTEM, &error)) ) {
goto bailout_nobus;
}
ctx = libhal_ctx_new();
libhal_ctx_set_dbus_connection(ctx, con);
if (!libhal_ctx_init(ctx, &error)) {
goto bailout;
}
if (!libhal_device_property_exists(ctx,
UUID_PATH,
UUID_PROPERTY,
&error)) {
goto bailout;
}
char *uuid = libhal_device_get_property_string(ctx,
UUID_PATH,
UUID_PROPERTY,
&error);
if (looks_like_a_uuid (uuid)) {
return uuid;
}
bailout:
{
DBusError ctxerror;
dbus_error_init(&ctxerror);
if (!(libhal_ctx_shutdown(ctx, &ctxerror))) {
dbus_error_free(&ctxerror);
}
}
libhal_ctx_free(ctx);
//dbus_connection_unref(con);
bailout_nobus:
if (dbus_error_is_set(&error)) {
/*printf("Error %s\n", error.name);*/
dbus_error_free(&error);
}
return NULL;
}
static void
copykeyval (char *key, char *compat_key)
{
char *value;
value = libhal_device_get_property_string (hfp_ctx, hfp_udi, key, NULL);
if (value != NULL) {
hfp_info ("Copying %s -> %s", key, compat_key);
libhal_device_set_property_string (hfp_ctx, hfp_udi, compat_key, value, NULL);
}
}
static char *
get_prop_string(LibHalContext *hal_ctx, const char *udi, const char *name)
{
char *prop, *ret;
prop = libhal_device_get_property_string(hal_ctx, udi, name, NULL);
DebugF(" [config/hal] getting %s on %s returned %s\n", name, udi, prop);
if (prop) {
ret = xstrdup(prop);
libhal_free_string(prop);
}
else {
return NULL;
}
return ret;
}
static char *
get_prop_string(LibHalContext *hal_ctx, const char *udi, const char *name)
{
char *prop, *ret;
prop = libhal_device_get_property_string(hal_ctx, udi, name, NULL);
LogMessageVerb(X_INFO, 10, "config/hal: getting %s on %s returned %s\n", name, udi, prop ? prop : "(null)");
if (prop) {
ret = xstrdup(prop);
libhal_free_string(prop);
}
else {
return NULL;
}
return ret;
}
static int get_str_prop(LibHalContext *ctxt, const char *udi,
const char *prop, char **val_p)
{
char *val = libhal_device_get_property_string(ctxt, udi, prop, NULL);
if (val) {
if (*val) {
*val_p = val;
return 0;
} else {
/* Treat empty strings as NULL values */
VIR_FREE(val);
}
}
return -1;
}
int
open_device(LibHalContext *ctx, char *udi)
{
char path[HAL_PATH_MAX] = "/devices";
char *devfs_path;
DBusError error;
dbus_error_init(&error);
devfs_path = libhal_device_get_property_string(ctx, udi,
"solaris.devfs_path", &error);
my_dbus_error_free(&error);
if (devfs_path == NULL) {
return (-1);
}
strlcat(path, devfs_path, HAL_PATH_MAX);
libhal_free_string(devfs_path);
return (open(path, O_RDONLY | O_NONBLOCK));
}
static void hal_property_modified(LibHalContext *ctx, const char *udi,
const char *key, dbus_bool_t is_removed, dbus_bool_t is_added)
{
if (!strcmp(key, "volume.is_mounted")) {
if (libhal_device_get_property_bool(ctx, udi, "volume.is_mounted", NULL)) {
char *mountpoint = libhal_device_get_property_string(
ctx, udi, "volume.mount_point", NULL);
if (!strncmp(MEDIA_DIR, mountpoint, strlen(MEDIA_DIR))) {
add_mount(udi, mountpoint);
}
if (mountpoint)
libhal_free_string(mountpoint);
} else {
remove_mount(udi);
}
update_status();
}
}
static boolean_t
volume_should_mount(const char *udi)
{
char *storage_device = NULL;
int ret = B_FALSE;
if (libhal_device_get_property_bool(hal_ctx, udi,
"volume.ignore", NULL)) {
goto out;
}
/* get the backing storage device */
if (!(storage_device = libhal_device_get_property_string(hal_ctx, udi,
"block.storage_device", NULL))) {
dprintf("cannot get block.storage_device\n");
goto out;
}
/* we handle either removable or hotpluggable */
if (!libhal_device_get_property_bool(hal_ctx, storage_device,
"storage.removable", NULL) &&
!libhal_device_get_property_bool(hal_ctx, storage_device,
"storage.hotpluggable", NULL)) {
goto out;
}
/* ignore if claimed by another volume manager */
if (libhal_device_get_property_bool(hal_ctx, storage_device,
"info.claimed", NULL)) {
goto out;
}
ret = B_TRUE;
out:
libhal_free_string(storage_device);
return (ret);
}
static void
device_added_callback( LibHalContext *ctx, const char *udi )
{
if( libhal_device_property_exists( ctx, udi, "battery", NULL ) )
{
char *type = libhal_device_get_property_string( ctx, udi,
"battery.type",
NULL );
if( type )
{
/* We only track 'primary' batteries (ie: to avoid monitoring
* batteries in cordless mice or UPSes etc.)
*/
if( !strcmp( type, "primary" ) )
add_to_list( ctx, &batteries, udi, sizeof (struct battery_info) );
libhal_free_string( type );
}
}
if( libhal_device_property_exists( ctx, udi, "ac_adapter", NULL ) )
add_to_list( ctx, &adaptors, udi, sizeof (struct adaptor_info) );
}
/* 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);
}
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;
}
int
main (int argc, char *argv[])
{
DBusError err;
int retval = 0;
hal_set_proc_title_init (argc, argv);
setup_logger ();
device_udi = getenv ("UDI");
HAL_DEBUG (("device:[%s]", device_udi));
if (device_udi == NULL) {
HAL_ERROR (("No device specified"));
return -2;
}
dbus_error_init (&err);
if ((halctx = libhal_ctx_init_direct (&err)) == NULL) {
HAL_ERROR (("Cannot connect to hald"));
retval = -3;
goto out;
}
/* update_properties */
libhal_device_set_property_bool (halctx, device_udi,
"battery.present", TRUE, &err);
LIBHAL_FREE_DBUS_ERROR (&err);
if (!libhal_device_property_exists (halctx, device_udi,
"battery.is_rechargeable", &err)) {
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_device_set_property_bool (halctx, device_udi,
"battery.is_rechargeable", FALSE, &err);
}
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_device_set_property_int (halctx, device_udi,
"battery.charge_level.design", 7, &err);
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_device_set_property_int (halctx, device_udi,
"battery.charge_level.last_full", 7, &err);
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_device_set_property_string (halctx, device_udi,
"info.category", "battery", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_device_set_property_string (halctx, device_udi,
"battery.command_interface", "csr", &err);
/* monitor change */
libhal_ctx_set_device_property_modified (halctx, property_modified);
/* Initial fillup */
dev_props = property_cache_item_get (device_udi);
HAL_ERROR (("** Initial fillup done"));
/* init usb */
usb_init ();
/* do coldplug */
check_all_batteries (NULL);
/* only add capability when initial charge_level key has been set */
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_device_add_capability (halctx, device_udi, "battery", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
if (!libhal_device_addon_is_ready (halctx, device_udi, &err)) {
retval = -4;
goto out;
}
hal_set_proc_title ("hald-addon-usb-csr: listening on '%s'",
libhal_device_get_property_string(halctx, device_udi,
"info.product", &err));
main_loop = g_main_loop_new (NULL, FALSE);
#ifdef HAVE_GLIB_2_14
g_timeout_add_seconds (TIMEOUT, check_all_batteries, NULL);
#else
g_timeout_add (1000L * TIMEOUT, check_all_batteries, NULL);
#endif
g_main_loop_run (main_loop);
return 0;
out:
HAL_DEBUG (("An error occured, exiting cleanly"));
LIBHAL_FREE_DBUS_ERROR (&err);
if (halctx != NULL) {
libhal_ctx_shutdown (halctx, &err);
LIBHAL_FREE_DBUS_ERROR (&err);
libhal_ctx_free (halctx);
}
return retval;
}
int
prt_dev_props(LibHalContext *hal_ctx, char *dev_name)
{
LibHalPropertySet *props;
LibHalPropertySetIterator it;
DBusError error;
int type;
char *devfs_path;
dbus_error_init(&error);
if (!(props =
libhal_device_get_all_properties(hal_ctx, dev_name, &error))) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
dbus_error_free(&error);
return (1);
}
devfs_path = libhal_device_get_property_string(hal_ctx,
dev_name, "solaris.devfs_path", &error);
if (devfs_path) {
printf("devfs path:%s\n", devfs_path);
libhal_free_string(devfs_path);
}
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'\n",
libhal_psi_get_key(&it),
libhal_psi_get_string(&it));
break;
case LIBHAL_PROPERTY_TYPE_INT32:
printf("%s:%d\n",
libhal_psi_get_key(&it),
libhal_psi_get_int(&it));
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
printf("%s:%lld\n",
libhal_psi_get_key(&it),
(long long) libhal_psi_get_uint64(&it));
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
printf("%s:%g\n",
libhal_psi_get_key(&it),
libhal_psi_get_double(&it));
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
printf("%s:%s\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(" }\n");
}
break;
default:
printf("Unknown type:%d=0x%02x\n",
type, type);
break;
}
}
libhal_free_property_set(props);
printf("\n");
dbus_error_free(&error);
return (0);
}
/*
* 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;
}
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;
};
$NetBSD$
--- src/modules/module-hal-detect.c.orig 2012-07-19 11:29:39.000000000 +0000
+++ src/modules/module-hal-detect.c
@@ -334,6 +334,11 @@ static int hal_device_load_oss(struct us
/* We store only one entry per card, hence we look for the originating device */
originating_udi = libhal_device_get_property_string(u->context, udi, "oss.originating_device", &error);
+ if (dbus_error_is_set(&error) || !originating_udi) {
+ if (dbus_error_is_set(&error))
+ dbus_error_free(&error);
+ originating_udi = libhal_device_get_property_string(u->context, udi, "sound.originating_device", &error);
+ }
if (dbus_error_is_set(&error) || !originating_udi)
goto fail;
static void
force_unmount (LibHalContext *ctx, const char *udi)
{
DBusError error;
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
char **options = NULL;
unsigned int num_options = 0;
DBusConnection *dbus_connection;
char *device_file;
dbus_error_init (&error);
dbus_connection = libhal_ctx_get_dbus_connection (ctx);
msg = dbus_message_new_method_call ("org.freedesktop.Hal", udi,
"org.freedesktop.Hal.Device.Volume",
"Unmount");
if (msg == NULL) {
HAL_DEBUG (("Could not create dbus message for %s", udi));
goto out;
}
options = calloc (1, sizeof (char *));
if (options == NULL) {
HAL_DEBUG (("Could not allocate options array"));
goto out;
}
device_file = libhal_device_get_property_string (ctx, udi, "block.device", &error);
if (device_file != NULL) {
libhal_free_string (device_file);
}
dbus_error_free (&error);
if (!dbus_message_append_args (msg,
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &options, num_options,
DBUS_TYPE_INVALID)) {
HAL_DEBUG (("Could not append args to dbus message for %s", udi));
goto out;
}
if (!(reply = dbus_connection_send_with_reply_and_block (dbus_connection, msg, -1, &error))) {
HAL_DEBUG (("Unmount failed for %s: %s : %s\n", udi, error.name, error.message));
goto out;
}
if (dbus_error_is_set (&error)) {
HAL_DEBUG (("Unmount failed for %s\n%s : %s\n", udi, error.name, error.message));
goto out;
}
HAL_DEBUG (("Succesfully unmounted udi '%s'", udi));
out:
dbus_error_free (&error);
if (options != NULL)
free (options);
if (msg != NULL)
dbus_message_unref (msg);
if (reply != NULL)
dbus_message_unref (reply);
}
/** Entry point
*
* @param argc Number of arguments given to program
* @param argv Arguments given to program
* @return Return code
*/
int
main (int argc, char *argv[])
{
char *udi = NULL;
char *key = NULL;
int type;
dbus_bool_t is_hex = FALSE;
dbus_bool_t is_verbose = FALSE;
dbus_bool_t is_version = FALSE;
char *str;
DBusError error;
if (argc <= 1) {
usage (argc, argv);
return 1;
}
while (1) {
int c;
int option_index = 0;
const char *opt;
static struct option long_options[] = {
{"udi", 1, NULL, 0},
{"key", 1, NULL, 0},
{"hex", 0, NULL, 0},
{"verbose", 0, NULL, 0},
{"version", 0, NULL, 0},
{"help", 0, NULL, 0},
{NULL, 0, NULL, 0}
};
c = getopt_long (argc, argv, "",
long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 0:
opt = long_options[option_index].name;
if (strcmp (opt, "help") == 0) {
usage (argc, argv);
return 0;
} else if (strcmp (opt, "hex") == 0) {
is_hex = TRUE;
} else if (strcmp (opt, "verbose") == 0) {
is_verbose = TRUE;
} else if (strcmp (opt, "version") == 0) {
is_version = TRUE;
} else if (strcmp (opt, "key") == 0) {
key = strdup (optarg);
} else if (strcmp (opt, "udi") == 0) {
udi = strdup (optarg);
}
break;
default:
usage (argc, argv);
return 1;
break;
}
}
if (is_version) {
printf ("hal-get-property " PACKAGE_VERSION "\n");
return 0;
}
if (udi == NULL || key == NULL) {
usage (argc, argv);
return 1;
}
dbus_error_init (&error);
if ((hal_ctx = libhal_ctx_new ()) == NULL) {
fprintf (stderr, "error: libhal_ctx_new\n");
return 1;
}
if (!libhal_ctx_set_dbus_connection (hal_ctx, dbus_bus_get (DBUS_BUS_SYSTEM, &error))) {
fprintf (stderr, "error: libhal_ctx_set_dbus_connection: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
if (!libhal_ctx_init (hal_ctx, &error)) {
if (dbus_error_is_set(&error)) {
fprintf (stderr, "error: libhal_ctx_init: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
}
fprintf (stderr, "Could not initialise connection to hald.\n"
"Normally this means the HAL daemon (hald) is not running or not ready.\n");
return 1;
}
type = libhal_device_get_property_type (hal_ctx, udi, key, &error);
if (type == LIBHAL_PROPERTY_TYPE_INVALID) {
fprintf (stderr, "error: libhal_device_get_property_type: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
/* emit the value to stdout */
switch (type) {
case LIBHAL_PROPERTY_TYPE_STRING:
str = libhal_device_get_property_string (hal_ctx, udi, key, &error);
if (is_verbose)
printf ("Type is string\n");
printf ("%s\n", str);
libhal_free_string (str);
break;
case LIBHAL_PROPERTY_TYPE_INT32:
if (is_verbose)
printf ("Type is integer (shown in %s)\n",
(is_hex ? "hexadecimal" : "decimal"));
printf ((is_hex ? "%x\n" : "%d\n"),
libhal_device_get_property_int (hal_ctx, udi, key, &error));
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
if (is_verbose)
printf ("Type is uint64 (shown in %s)\n",
(is_hex ? "hexadecimal" : "decimal"));
printf ((is_hex ? "%llx\n" : "%llu\n"),
(long long unsigned int) libhal_device_get_property_uint64 (hal_ctx, udi, key, &error));
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
if (is_verbose)
printf ("Type is double\n");
printf ("%f\n",
libhal_device_get_property_double (hal_ctx, udi, key, &error));
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
if (is_verbose)
printf ("Type is boolean\n");
printf ("%s\n",
libhal_device_get_property_bool (hal_ctx, udi, key, &error) ? "true" : "false");
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
{
unsigned int i;
char **strlist;
if ((strlist = libhal_device_get_property_strlist (hal_ctx, udi, key, &error)) != NULL) {
for (i = 0; strlist[i] != 0; i++) {
printf ("%s", strlist[i]);
if (strlist[i+1] != NULL)
printf (" ");
}
}
break;
}
default:
printf ("Unknown type %d='%c'\n", type, type);
return 1;
break;
}
if (dbus_error_is_set (&error)) {
fprintf (stderr, "error: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
return 1;
}
return 0;
}
static void
get_video_devices (ofGstCamData & cam_data)
{
int i, fd, ok;
int num_udis = 0;
char **udis;
DBusError error;
LibHalContext *hal_ctx;
cam_data.num_webcam_devices = 0;
g_print ("Probing devices with HAL...\n");
dbus_error_init (&error);
hal_ctx = libhal_ctx_new ();
if (hal_ctx == NULL)
{
g_warning ("Could not create libhal context");
dbus_error_free (&error);
goto fallback;
}
if (!libhal_ctx_set_dbus_connection (hal_ctx, dbus_bus_get (DBUS_BUS_SYSTEM, &error)))
{
g_warning ("libhal_ctx_set_dbus_connection: %s: %s", error.name, error.message);
dbus_error_free (&error);
goto fallback;
}
if (!libhal_ctx_init (hal_ctx, &error))
{
if (dbus_error_is_set (&error))
{
g_warning ("libhal_ctx_init: %s: %s", error.name, error.message);
dbus_error_free (&error);
}
g_warning ("Could not initialise connection to hald.\n"
"Normally this means the HAL daemon (hald) is not running or not ready");
goto fallback;
}
udis = libhal_find_device_by_capability (hal_ctx, "video4linux", &num_udis, &error);
if (dbus_error_is_set (&error))
{
g_warning ("libhal_find_device_by_capability: %s: %s", error.name, error.message);
dbus_error_free (&error);
goto fallback;
}
/* Initialize webcam structures */
cam_data.webcam_devices = new ofGstDevice[num_udis];
for (i = 0; i < num_udis; i++)
{
char *device;
char *parent_udi = NULL;
char *subsystem = NULL;
char *gstreamer_src, *product_name;
struct v4l2_capability v2cap;
struct video_capability v1cap;
gint vendor_id = 0;
gint product_id = 0;
gchar *property_name = NULL;
parent_udi = libhal_device_get_property_string (hal_ctx, udis[i], "info.parent", &error);
if (dbus_error_is_set (&error))
{
g_warning ("error getting parent for %s: %s: %s", udis[i], error.name, error.message);
dbus_error_free (&error);
}
if (parent_udi != NULL) {
subsystem = libhal_device_get_property_string (hal_ctx, parent_udi, "info.subsystem", NULL);
if (subsystem == NULL) continue;
property_name = g_strjoin (".", subsystem, "vendor_id", NULL);
vendor_id = libhal_device_get_property_int (hal_ctx, parent_udi, property_name , &error);
if (dbus_error_is_set (&error)) {
g_warning ("error getting vendor id: %s: %s", error.name, error.message);
dbus_error_free (&error);
}
g_free (property_name);
property_name = g_strjoin (".", subsystem, "product_id", NULL);
product_id = libhal_device_get_property_int (hal_ctx, parent_udi, property_name, &error);
if (dbus_error_is_set (&error)) {
g_warning ("error getting product id: %s: %s", error.name, error.message);
dbus_error_free (&error);
}
g_free (property_name);
libhal_free_string (subsystem);
libhal_free_string (parent_udi);
}
g_print ("Found device %04x:%04x, getting capabilities...\n", vendor_id, product_id);
device = libhal_device_get_property_string (hal_ctx, udis[i], "video4linux.device", &error);
if (dbus_error_is_set (&error))
{
g_warning ("error getting V4L device for %s: %s: %s", udis[i], error.name, error.message);
dbus_error_free (&error);
continue;
}
/* vbi devices support capture capability too, but cannot be used,
* so detect them by device name */
if (strstr (device, "vbi"))
{
g_print ("Skipping vbi device: %s\n", device);
libhal_free_string (device);
continue;
}
if ((fd = open (device, O_RDONLY | O_NONBLOCK)) < 0)
{
g_warning ("Failed to open %s: %s", device, strerror (errno));
libhal_free_string (device);
continue;
}
ok = ioctl (fd, VIDIOC_QUERYCAP, &v2cap);
if (ok < 0)
{
ok = ioctl (fd, VIDIOCGCAP, &v1cap);
if (ok < 0)
{
g_warning ("Error while probing v4l capabilities for %s: %s",
device, strerror (errno));
libhal_free_string (device);
close (fd);
continue;
}
g_print ("Detected v4l device: %s\n", v1cap.name);
g_print ("Device type: %d\n", v1cap.type);
gstreamer_src = "v4lsrc";
product_name = v1cap.name;
}
else
{
guint cap = v2cap.capabilities;
g_print ("Detected v4l2 device: %s\n", v2cap.card);
g_print ("Driver: %s, version: %d\n", v2cap.driver, v2cap.version);
/* g_print ("Bus info: %s\n", v2cap.bus_info); */ /* Doesn't seem anything useful */
g_print ("Capabilities: 0x%08X\n", v2cap.capabilities);
if (!(cap & V4L2_CAP_VIDEO_CAPTURE))
{
g_print ("Device %s seems to not have the capture capability, (radio tuner?)\n"
"Removing it from device list.\n", device);
libhal_free_string (device);
close (fd);
continue;
}
gstreamer_src = "v4l2src";
product_name = (char *) v2cap.card;
}
g_print ("\n");
cam_data.webcam_devices[cam_data.num_webcam_devices].hal_udi = g_strdup (udis[i]);
cam_data.webcam_devices[cam_data.num_webcam_devices].video_device = g_strdup (device);
cam_data.webcam_devices[cam_data.num_webcam_devices].gstreamer_src = g_strdup (gstreamer_src);
cam_data.webcam_devices[cam_data.num_webcam_devices].product_name = g_strdup (product_name);
cam_data.webcam_devices[cam_data.num_webcam_devices].num_video_formats = 0;
cam_data.webcam_devices[cam_data.num_webcam_devices].supported_resolutions =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
cam_data.num_webcam_devices++;
libhal_free_string (device);
close (fd);
}
libhal_free_string_array (udis);
if (cam_data.num_webcam_devices == 0)
{
/* Create a fake device so that resolution changing stil works even if the
* computer doesn't have a webcam. */
fallback:
if (num_udis == 0)
{
cam_data.webcam_devices = new ofGstDevice;
}
cam_data.webcam_devices[0].num_video_formats = 0;
cam_data.webcam_devices[0].hal_udi = g_strdup ("oF_fake_videodevice");
}
cam_data.bInited=true;
}
static void
thunar_vfs_volume_hal_update (ThunarVfsVolumeHal *volume_hal,
LibHalContext *context,
LibHalVolume *hv,
LibHalDrive *hd)
{
gchar *desired_mount_point;
gchar *mount_root;
gchar *basename;
gchar *filename;
_thunar_vfs_return_if_fail (THUNAR_VFS_IS_VOLUME_HAL (volume_hal));
_thunar_vfs_return_if_fail (hd != NULL);
/* reset the volume status */
volume_hal->status = 0;
/* determine the new device file */
g_free (volume_hal->device_file);
volume_hal->device_file = g_strdup ((hv != NULL) ? libhal_volume_get_device_file (hv) : libhal_drive_get_device_file (hd));
/* compute a usable display name for the volume/drive */
g_free (volume_hal->device_label);
volume_hal->device_label = (hv == NULL)
? exo_hal_drive_compute_display_name (context, hd)
: exo_hal_volume_compute_display_name (context, hv, hd);
if (G_UNLIKELY (volume_hal->device_label == NULL))
{
/* use the basename of the device file as label */
volume_hal->device_label = g_path_get_basename (volume_hal->device_file);
}
/* compute a usable list of icon names for the volume/drive */
g_list_foreach (volume_hal->icon_list, (GFunc) g_free, NULL);
g_list_free (volume_hal->icon_list);
volume_hal->icon_list = (hv == NULL)
? exo_hal_drive_compute_icon_list (context, hd)
: exo_hal_volume_compute_icon_list (context, hv, hd);
/* release the previous mount point (if any) */
if (G_LIKELY (volume_hal->mount_point != NULL))
{
thunar_vfs_path_unref (volume_hal->mount_point);
volume_hal->mount_point = NULL;
}
/* determine the type of the volume */
switch (libhal_drive_get_type (hd))
{
case LIBHAL_DRIVE_TYPE_CDROM:
/* check if we have a pure audio CD without any data track */
if (libhal_volume_disc_has_audio (hv) && !libhal_volume_disc_has_data (hv))
{
/* special treatment for pure audio CDs */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_AUDIO_CD;
}
else
{
/* check which kind of CD-ROM/DVD we have */
switch (libhal_volume_get_disc_type (hv))
{
case LIBHAL_VOLUME_DISC_TYPE_CDROM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDROM;
break;
case LIBHAL_VOLUME_DISC_TYPE_CDR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDR;
break;
case LIBHAL_VOLUME_DISC_TYPE_CDRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_CDRW;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDROM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDROM;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDRAM:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDRAM;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDR;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDRW;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDPLUSR:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDPLUSR;
break;
case LIBHAL_VOLUME_DISC_TYPE_DVDPLUSRW:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_DVDPLUSRW;
break;
default:
/* unsupported disc type */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_UNKNOWN;
break;
}
}
break;
case LIBHAL_DRIVE_TYPE_FLOPPY:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_FLOPPY;
break;
case LIBHAL_DRIVE_TYPE_PORTABLE_AUDIO_PLAYER:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_AUDIO_PLAYER;
break;
case LIBHAL_DRIVE_TYPE_SMART_MEDIA:
case LIBHAL_DRIVE_TYPE_SD_MMC:
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_MEMORY_CARD;
break;
default:
/* check if the drive is connected to the USB bus */
if (libhal_drive_get_bus (hd) == LIBHAL_DRIVE_BUS_USB)
{
/* we consider the drive to be an USB stick */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_USBSTICK;
}
else if (libhal_drive_uses_removable_media (hd)
|| libhal_drive_is_hotpluggable (hd))
{
/* fallback to generic removable disk */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_REMOVABLE_DISK;
}
else
{
/* fallback to harddisk drive */
volume_hal->kind = THUNAR_VFS_VOLUME_KIND_HARDDISK;
}
break;
}
/* either we have a volume, which means we have media, or
* a drive, which means non-pollable then, so it's present
*/
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_PRESENT;
/* figure out if the volume is mountable */
if(hv != NULL && libhal_volume_get_fsusage (hv) == LIBHAL_VOLUME_USAGE_MOUNTABLE_FILESYSTEM)
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTABLE;
/* check if the drive requires eject */
volume_hal->requires_eject = libhal_drive_requires_eject (hd);
/* check if the volume is currently mounted */
if (hv != NULL && libhal_volume_is_mounted (hv))
{
/* try to determine the new mount point */
volume_hal->mount_point = thunar_vfs_path_new (libhal_volume_get_mount_point (hv), NULL);
/* we only mark the volume as mounted if we have a valid mount point */
if (G_LIKELY (volume_hal->mount_point != NULL))
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTED | THUNAR_VFS_VOLUME_STATUS_PRESENT;
}
else
{
/* we don't trust HAL, so let's see what the kernel says about the volume */
volume_hal->mount_point = thunar_vfs_volume_hal_find_active_mount_point (volume_hal);
/* we must have been mounted successfully if we have a mount point */
if (G_LIKELY (volume_hal->mount_point != NULL))
volume_hal->status |= THUNAR_VFS_VOLUME_STATUS_MOUNTED | THUNAR_VFS_VOLUME_STATUS_PRESENT;
}
/* check if we have to figure out the mount point ourself */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* ask HAL for the default mount root (falling back to /media otherwise) */
mount_root = libhal_device_get_property_string (context, "/org/freedesktop/Hal/devices/computer", "storage.policy.default.mount_root", NULL);
if (G_UNLIKELY (mount_root == NULL || !g_path_is_absolute (mount_root)))
{
/* fallback to /media (seems to be sane) */
g_free (mount_root);
mount_root = g_strdup ("/media");
}
/* lets see, maybe /etc/fstab knows where to mount */
volume_hal->mount_point = thunar_vfs_volume_hal_find_fstab_mount_point (volume_hal);
/* if we still don't have a mount point, ask HAL */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* determine the desired mount point and prepend the mount root */
desired_mount_point = libhal_device_get_property_string (context, volume_hal->udi, "volume.policy.desired_mount_point", NULL);
if (G_LIKELY (desired_mount_point != NULL && *desired_mount_point != '\0'))
{
filename = g_build_filename (mount_root, desired_mount_point, NULL);
volume_hal->mount_point = thunar_vfs_path_new (filename, NULL);
g_free (filename);
}
libhal_free_string (desired_mount_point);
}
/* ok, last fallback, just use <mount-root>/<device> */
if (G_UNLIKELY (volume_hal->mount_point == NULL))
{
/* <mount-root>/<device> looks like a good idea */
basename = g_path_get_basename (volume_hal->device_file);
filename = g_build_filename (mount_root, basename, NULL);
volume_hal->mount_point = thunar_vfs_path_new (filename, NULL);
g_free (filename);
g_free (basename);
}
/* release the mount root */
g_free (mount_root);
}
/* if we get here, we must have a valid mount point */
g_assert (volume_hal->mount_point != NULL);
/* emit the "changed" signal */
thunar_vfs_volume_changed (THUNAR_VFS_VOLUME (volume_hal));
}
/*
* 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;
}
static void
battery_dynamic_update(LibHalContext *ctx, const char *udi, int fd)
{
int reporting_rate;
int reporting_current;
int reporting_lastfull;
int design_voltage;
int present_voltage;
char *reporting_unit;
int remaining_time;
int remaining_percentage;
gboolean charging;
gboolean discharging;
acpi_bst_t bst;
LibHalChangeSet *cs;
DBusError error;
static int counter = 0;
HAL_DEBUG(("battery_dynamic_update() enter"));
bzero(&bst, sizeof (bst));
if (ioctl(fd, BATT_IOC_STATUS, &bst) < 0) {
return;
}
charging = bst.bst_state & BATT_BST_CHARGING ? TRUE : FALSE;
discharging = bst.bst_state & BATT_BST_DISCHARGING ? TRUE : FALSE;
/* No need to continue if battery is essentially idle. */
if (counter && !charging && !discharging) {
return;
}
dbus_error_init(&error);
libhal_device_set_property_bool(ctx, udi, "battery.is_rechargeable",
TRUE, &error);
my_dbus_error_free(&error);
if (libhal_device_property_exists(ctx, udi,
"battery.charge_level.percentage", &error)) {
remaining_percentage = libhal_device_get_property_int(ctx, udi,
"battery.charge_level.percentage", &error);
if ((remaining_percentage == 100) && charging) {
charging = FALSE;
}
}
libhal_device_set_property_bool(ctx, udi,
"battery.rechargeable.is_charging", charging, &error);
my_dbus_error_free(&error);
libhal_device_set_property_bool(ctx, udi,
"battery.rechargeable.is_discharging", discharging, &error);
my_dbus_error_free(&error);
reporting_current = bst.bst_rem_cap;
libhal_device_set_property_int(ctx, udi, "battery.reporting.current",
bst.bst_rem_cap, &error);
my_dbus_error_free(&error);
reporting_rate = bst.bst_rate;
libhal_device_set_property_int(ctx, udi, "battery.reporting.rate",
bst.bst_rate, &error);
my_dbus_error_free(&error);
present_voltage = bst.bst_voltage;
libhal_device_set_property_int(ctx, udi, "battery.voltage.present",
bst.bst_voltage, &error);
/* get all the data we know */
my_dbus_error_free(&error);
reporting_unit = libhal_device_get_property_string(ctx, udi,
"battery.reporting.unit", &error);
my_dbus_error_free(&error);
reporting_lastfull = libhal_device_get_property_int(ctx, udi,
"battery.reporting.last_full", &error);
/*
* Convert mAh to mWh since util_compute_time_remaining() works
* for mWh.
*/
if (reporting_unit && strcmp(reporting_unit, "mAh") == 0) {
my_dbus_error_free(&error);
design_voltage = libhal_device_get_property_int(ctx, udi,
"battery.voltage.design", &error);
/*
* If the present_voltage is inaccurate, set it to the
* design_voltage.
*/
if (((present_voltage * 10) < design_voltage) ||
(present_voltage <= 0) ||
(present_voltage > design_voltage)) {
present_voltage = design_voltage;
}
reporting_rate = (reporting_rate * present_voltage) / 1000;
reporting_lastfull = (reporting_lastfull * present_voltage) /
1000;
reporting_current = (reporting_current * present_voltage) /
1000;
}
/* Make sure the current charge does not exceed the full charge */
if (reporting_current > reporting_lastfull) {
reporting_current = reporting_lastfull;
}
if (!charging && !discharging) {
counter++;
reporting_rate = 0;
}
if ((cs = libhal_device_new_changeset(udi)) == NULL) {
HAL_DEBUG(("Cannot allocate changeset"));
libhal_free_string(reporting_unit);
my_dbus_error_free(&error);
return;
}
libhal_changeset_set_property_int(cs, "battery.charge_level.rate",
reporting_rate);
libhal_changeset_set_property_int(cs,
"battery.charge_level.last_full", reporting_lastfull);
libhal_changeset_set_property_int(cs,
"battery.charge_level.current", reporting_current);
remaining_percentage = util_compute_percentage_charge(udi,
reporting_current, reporting_lastfull);
remaining_time = util_compute_time_remaining(udi, reporting_rate,
reporting_current, reporting_lastfull, discharging, charging, 0);
/*
* Some batteries give bad remaining_time estimates relative to
* the charge level.
*/
if (charging && ((remaining_time < 30) || ((remaining_time < 300) &&
(remaining_percentage < 95)) || (remaining_percentage > 97))) {
remaining_time = util_compute_time_remaining(udi,
reporting_rate, reporting_current, reporting_lastfull,
discharging, charging, 1);
}
if (remaining_percentage > 0) {
libhal_changeset_set_property_int(cs,
"battery.charge_level.percentage", remaining_percentage);
} else {
my_dbus_error_free(&error);
libhal_device_remove_property(ctx, udi,
"battery.charge_level.percentage", &error);
}
if ((remaining_percentage == 100) && charging) {
battery_last_full(cs, fd);
}
/*
* remaining_percentage is more accurate so we handle cases
* where the remaining_time cannot be correct.
*/
if ((!charging && !discharging) || ((remaining_percentage == 100) &&
!discharging)) {
remaining_time = 0;
}
if (remaining_time < 0) {
my_dbus_error_free(&error);
libhal_device_remove_property(ctx, udi,
"battery.remaining_time", &error);
} else if (remaining_time >= 0) {
libhal_changeset_set_property_int(cs,
"battery.remaining_time", remaining_time);
}
my_dbus_error_free(&error);
libhal_device_commit_changeset(ctx, cs, &error);
libhal_device_free_changeset(cs);
libhal_free_string(reporting_unit);
my_dbus_error_free(&error);
HAL_DEBUG(("battery_dynamic_update() exit"));
}
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 int rsct_usbdev_scan_nonserial(char **devices, int i_devices,
rsct_usbdev_t **usbdev_list) {
int i;
for (i=0; i<i_devices; i++) {
const char *udi=devices[i];
if (libhal_device_exists(global_hal_context->ctx, udi, &(global_hal_context->dbus_error))) {
char *busType;
busType=libhal_device_get_property_string(global_hal_context->ctx, udi, "info.subsystem", NULL);
if (busType && (strcasecmp(busType, "usb")!=0)) {
libhal_free_string(busType);
busType=NULL; /* non-USB devices are handled below */
}
if (busType==NULL)
busType=libhal_device_get_property_string(global_hal_context->ctx, udi, "info.bus", NULL);
if (busType) {
if (strcasecmp(busType, "usb")==0) {
/* USB device, look for LibUSB info */
if (libhal_device_property_exists(global_hal_context->ctx, udi, "usb.bus_number", NULL) &&
libhal_device_property_exists(global_hal_context->ctx, udi, "usb.linux.device_number", NULL)){
int busId;
int busPos;
int vendorId;
int productId;
char pbuff[256];
struct stat st;
int havePath=0;
busId=libhal_device_get_property_int(global_hal_context->ctx,
udi,
"usb.bus_number",
NULL);
busPos=libhal_device_get_property_int(global_hal_context->ctx,
udi,
"usb.linux.device_number",
NULL);
vendorId=libhal_device_get_property_int(global_hal_context->ctx,
udi,
"usb.vendor_id",
NULL);
productId=libhal_device_get_property_int(global_hal_context->ctx,
udi,
"usb.product_id",
NULL);
if (vendorId==0xc4b && rsct_usbdev_list_findByBus(*usbdev_list, busId, busPos)==NULL) {
rsct_usbdev_t *d;
char *serial=NULL;
char *productName=NULL;
d=rsct_usbdev_new();
d->busId=busId;
d->busPos=busPos;
d->vendorId=vendorId;
d->productId=productId;
snprintf(d->halPath, sizeof(d->halPath)-1,
"usb:%04x/%04x:libhal:%s",
d->vendorId,
d->productId,
udi);
d->halPath[sizeof(d->halPath)-1]=0;
/* set HAL UDI */
strncpy(d->halUDI, udi, sizeof(d->halUDI)-1);
d->halUDI[sizeof(d->halUDI)-1]=0;
/* determine path for LibUSB */
snprintf(pbuff, sizeof(pbuff)-1,
"/dev/bus/usb/%03d/%03d",
busId, busPos);
pbuff[sizeof(pbuff)-1]=0;
if (stat(pbuff, &st)==0) {
havePath=1;
}
else {
snprintf(pbuff, sizeof(pbuff)-1,
"/proc/bus/usb/%03d/%03d",
busId, busPos);
pbuff[sizeof(pbuff)-1]=0;
if (stat(pbuff, &st)==0) {
havePath=1;
}
}
if (havePath) {
strncpy(d->usbPath, pbuff, sizeof(d->usbPath)-1);
d->usbPath[sizeof(d->usbPath)-1]=0;
strncpy(d->deviceNodePath, pbuff, sizeof(d->deviceNodePath)-1);
d->deviceNodePath[sizeof(d->deviceNodePath)-1]=0;
}
/* generate path for CTAPI/IFD */
snprintf(d->path, sizeof(d->path)-1,
"usb:%04x/%04x:libusb:%03d:%03d",
d->vendorId,
d->productId,
d->busId,
d->busPos);
serial=libhal_device_get_property_string(global_hal_context->ctx,
udi,
"usb.serial",
NULL);
if (serial) {
strncpy(d->serial, serial, sizeof(d->serial)-1);
d->serial[sizeof(d->serial)-1]=0;
libhal_free_string(serial);
}
/* get product name from parent.
* Please note: This udi refers to the *_ifX HAL device, and it's product name
* is the product name of the interface ("USB Vendor Specific Interface") rather than
* that of the device itself.
* Therefore we must access the parent in order to find the product name of the device.
*/
if (1) {
char *parent_udi;
/* ttyUSB device, get USB info from parent */
parent_udi=libhal_device_get_property_string(global_hal_context->ctx,
udi,
"info.parent",
NULL);
if (parent_udi) {
productName=libhal_device_get_property_string(global_hal_context->ctx,
parent_udi,
"usb_device.product",
NULL);
libhal_free_string(parent_udi);
}
}
if (productName) {
strncpy(d->productName, productName, sizeof(d->productName)-1);
d->productName[sizeof(d->productName)-1]=0;
libhal_free_string(productName);
}
/* all set, add device */
rsct_usbdev_list_add(usbdev_list, d);
}
}
} /* if USB */
libhal_free_string(busType);
} /* if bus type */
} /* if device exists */
} /* for */
return 0;
}
char *
battstat_hal_initialise (void (*callback) (void))
{
DBusConnection *connection;
LibHalContext *ctx;
DBusError error;
char *error_str;
char **devices;
int i, num;
status_updated_callback = callback;
if( battstat_hal_ctx != NULL )
return g_strdup( "Already initialised!" );
dbus_error_init( &error );
if( (connection = dbus_bus_get( DBUS_BUS_SYSTEM, &error )) == NULL )
goto error_out;
dbus_connection_setup_with_g_main( connection, g_main_context_default() );
if( (ctx = libhal_ctx_new()) == NULL )
{
dbus_set_error( &error, _("HAL error"), _("Could not create libhal_ctx") );
goto error_out;
}
libhal_ctx_set_device_property_modified( ctx, property_callback );
libhal_ctx_set_device_added( ctx, device_added_callback );
libhal_ctx_set_device_removed( ctx, device_removed_callback );
libhal_ctx_set_dbus_connection( ctx, connection );
if( libhal_ctx_init( ctx, &error ) == 0 )
goto error_freectx;
devices = libhal_find_device_by_capability( ctx, "battery", &num, &error );
if( devices == NULL )
goto error_shutdownctx;
/* FIXME: for now, if 0 battery devices are present on first scan, then fail.
* This allows fallover to the legacy (ACPI, APM, etc) backends if the
* installed version of HAL doesn't know about batteries. This check should
* be removed at some point in the future (maybe circa MATE 2.13..).
*/
if( num == 0 )
{
dbus_free_string_array( devices );
dbus_set_error( &error, _("HAL error"), _("No batteries found") );
goto error_shutdownctx;
}
for( i = 0; i < num; i++ )
{
char *type = libhal_device_get_property_string( ctx, devices[i],
"battery.type",
&error );
if( type )
{
/* We only track 'primary' batteries (ie: to avoid monitoring
* batteries in cordless mice or UPSes etc.)
*/
if( !strcmp( type, "primary" ) )
add_to_list( ctx, &batteries, devices[i],
sizeof (struct battery_info) );
libhal_free_string( type );
}
}
dbus_free_string_array( devices );
devices = libhal_find_device_by_capability( ctx, "ac_adapter", &num, &error );
if( devices == NULL )
{
batteries = free_entire_list( batteries );
goto error_shutdownctx;
}
for( i = 0; i < num; i++ )
add_to_list( ctx, &adaptors, devices[i], sizeof (struct adaptor_info) );
dbus_free_string_array( devices );
dbus_error_free( &error );
battstat_hal_ctx = ctx;
return NULL;
error_shutdownctx:
libhal_ctx_shutdown( ctx, NULL );
error_freectx:
libhal_ctx_free( ctx );
error_out:
error_str = g_strdup_printf( _("Unable to initialise HAL: %s: %s"),
error.name, error.message );
dbus_error_free( &error );
return error_str;
}
