static PropertyCacheItem*
property_cache_item_get (const char *hal_device_udi)
{
PropertyCacheItem * pci = g_new0 (PropertyCacheItem,1);
DBusError err;
dbus_error_init (&err);
pci->bus_no_present = libhal_device_property_exists (halctx, hal_device_udi,
"usb_device.bus_number", &err);
if (dbus_error_is_set (&err)) {
HAL_ERROR (("Error: [%s]/[%s]", err.name, err.message));
dbus_error_free (&err);
}
if (pci->bus_no_present)
pci->bus_no = libhal_device_get_property_int (halctx, hal_device_udi,
"usb_device.bus_number", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
pci->port_no_present = libhal_device_property_exists (halctx, hal_device_udi,
"usb_device.linux.device_number", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
if (pci->port_no_present)
pci->port_no = libhal_device_get_property_int (halctx, hal_device_udi,
"usb_device.linux.device_number", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
pci->csr_is_dual_present = libhal_device_property_exists (halctx, hal_device_udi,
"battery.csr.is_dual", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
if (pci->csr_is_dual_present)
pci->csr_is_dual = libhal_device_get_property_bool (halctx, hal_device_udi,
"battery.csr.is_dual", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
pci->current_charge_present = libhal_device_property_exists (halctx, hal_device_udi,
"battery.charge_level.current", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
if (pci->current_charge_present)
pci->current_charge = libhal_device_get_property_int (halctx, hal_device_udi,
"battery.charge_level.current", &err);
LIBHAL_FREE_DBUS_ERROR (&err);
return pci;
}
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
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) );
}
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;
}
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;
}
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;
}
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"));
}
/* Callback function, called when a new device has been inserted. */
static void
device_added(LibHalContext *context, const char *did)
{
const char *dudi, *fstype;
char *dev, *mountp, *mountable, *label, *locked_reason;
LibHalVolume *volume;
LibHalDrive *drive;
struct device_t *device;
if (libhal_device_property_exists(context, did, "info.locked",
(DBusError *)NULL)
&& libhal_device_get_property_bool(context, did, "info.locked",
(DBusError *)NULL)) {
if (debug_mode_flag) {
locked_reason = libhal_device_get_property_string(
context, did, "info.locked.reason",
(DBusError *)NULL);
if (locked_reason) {
if (debug_mode_flag)
printf("%s%d: %s\n", __FILE__, __LINE__, locked_reason);
libhal_free_string(locked_reason);
}
}
return;
}
if (!libhal_device_query_capability(context, did, "volume",
(DBusError *)NULL))
return;
label = libhal_device_get_property_string(context, did, "volume.label",
(DBusError *)NULL);
if (!(mountable = libhal_device_get_property_string(
context, did, "volume.fsusage", (DBusError *)NULL))
|| strcmp(mountable, "filesystem"))
goto out;
if (!(volume = libhal_volume_from_udi(context, did)))
goto out;
if (!(dudi = libhal_volume_get_storage_device_udi(volume)))
goto out;
if (!(drive = libhal_drive_from_udi(context, dudi)))
goto out;
if (!libhal_drive_is_hotpluggable(drive)
&& !libhal_drive_uses_removable_media(drive))
goto out;
if (!(fstype = libhal_volume_get_fstype(volume)))
goto out;
if (!(dev = libhal_device_get_property_string(context, did, "block.device",
(DBusError *)NULL)))
goto out;
mountp = get_mount_point(dev, label);
if (!mountp)
goto out;
device = get_device(mountp, did, dev, label, fstype, volume, drive);
if(!is_mounted(device)) {
free_device(device);
goto out;
}
if (!device)
goto out;
consider_fstab(device);
device->hook = malloc(2*sizeof(char*));
if(!file_exists(HOOK_PATH)) {
device->hook[0] = get_hook(device, "mount");
device->hook[1] = get_hook(device, "umount");
}
else {
device->hook[0] = NULL;
device->hook[1] = NULL;
}
if (file_exists(device->mountp) < 0)
mkdir(device->mountp, 0750);
do_mount(device) < 0 ? free_device(device) : add_to_device_list(device);
if (device) {
if (!add_fstab_entry(device))
device->should_remove_entry = 1;
if (debug_mode_flag)
debug_dump_device(device);
}
if (device->hook[0]) run_hook(0, device);
out:
if (mountable)
libhal_free_string(mountable);
if (label)
libhal_free_string(label);
}