int
main (int argc, char *argv[])
{
DBusConnection *dbus_connection;
DBusError error;
const char *commandline;
hal_set_proc_title_init (argc, argv);
setup_logger ();
dbus_error_init (&error);
if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
HAL_WARNING (("Unable to init libhal context"));
goto out;
}
if ((dbus_connection = libhal_ctx_get_dbus_connection(ctx)) == NULL) {
HAL_WARNING (("Cannot get DBus connection"));
goto out;
}
if ((commandline = getenv ("SINGLETON_COMMAND_LINE")) == NULL) {
HAL_WARNING (("SINGLETON_COMMAND_LINE not set"));
goto out;
}
libhal_ctx_set_singleton_device_added (ctx, add_device);
libhal_ctx_set_singleton_device_removed (ctx, remove_device);
dbus_connection_setup_with_g_main (dbus_connection, NULL);
dbus_connection_set_exit_on_disconnect (dbus_connection, 0);
if (!libhal_device_singleton_addon_is_ready (ctx, commandline, &error)) {
goto out;
}
leds = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
gmain = g_main_loop_new (NULL, FALSE);
g_main_loop_run (gmain);
return 0;
out:
HAL_DEBUG (("An error occured, exiting cleanly"));
LIBHAL_FREE_DBUS_ERROR (&error);
if (ctx != NULL) {
libhal_ctx_shutdown (ctx, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
libhal_ctx_free (ctx);
}
return 0;
}
/*
* Dump all devices.
*/
int
dump_all_devices(LibHalContext *hal_ctx)
{
int i;
int num_devices;
char **device_names;
DBusError error;
dbus_error_init(&error);
if (!(device_names =
libhal_get_all_devices(hal_ctx, &num_devices, &error))) {
fprintf(stderr, "Empty HAL device list.\n");
LIBHAL_FREE_DBUS_ERROR(&error);
return (31);
}
for (i = 0; i < num_devices; i++) {
prt_dev_props(hal_ctx, device_names[i]);
}
libhal_free_string_array(device_names);
dbus_error_free(&error);
return (0);
}
int
list_battery_devices(LibHalContext *hal_ctx)
{
int i;
int num_devices;
char **device_names;
DBusError error;
dbus_error_init(&error);
if (!(device_names = libhal_manager_find_device_string_match(hal_ctx,
"info.category",
"battery", &num_devices, &error))) {
fprintf(stderr, "Empty HAL device list.\n");
LIBHAL_FREE_DBUS_ERROR(&error);
return (31);
}
for (i = 0; i < num_devices; i++) {
if (libhal_device_get_property_bool(hal_ctx, device_names[i],
"battery.present",
&error)) {
printf("%s\n", device_names[i]);
}
}
libhal_free_string_array(device_names);
dbus_error_free(&error);
return (0);
}
int remove_udi(LibHalContext *hal_ctx, char *arg)
{
DBusError error;
char *udi;
if (!arg) return 11;
if (*arg == '/') {
udi = arg;
} else {
#ifdef HAVE_ASPRINTF
asprintf(&udi, "/org/freedesktop/Hal/devices/%s", arg);
#else
udi = calloc(1, sizeof ("/org/freedesktop/Hal/devices/%s") + strlen(arg));
sprintf(udi, "/org/freedesktop/Hal/devices/%s", arg);
#endif
}
dbus_error_init(&error);
if (opt.remove) {
if (!libhal_remove_device(hal_ctx, udi, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 12;
}
fprintf(stderr, "removed: %s\n", udi);
return 13;
}
return 0;
}
static gboolean
poll_for_media (gpointer user_data)
{
if (check_lock_state) {
DBusError error;
dbus_bool_t should_poll;
check_lock_state = FALSE;
HAL_INFO (("Checking whether device %s is locked on HAL", device_file));
dbus_error_init (&error);
if (libhal_device_is_locked_by_others (ctx, udi, "org.freedesktop.Hal.Device.Storage", &error)) {
HAL_INFO (("... device %s is locked on HAL", device_file));
is_locked_by_hal = TRUE;
update_proc_title ();
LIBHAL_FREE_DBUS_ERROR (&error);
goto skip_check;
} else {
HAL_INFO (("... device %s is not locked on HAL", device_file));
is_locked_by_hal = FALSE;
}
LIBHAL_FREE_DBUS_ERROR (&error);
should_poll = libhal_device_get_property_bool (ctx, udi, "storage.media_check_enabled", &error);
LIBHAL_FREE_DBUS_ERROR (&error);
polling_disabled = !should_poll;
update_proc_title ();
}
/* TODO: we could remove the timeout completely... */
if (is_locked_by_hal || polling_disabled)
goto skip_check;
poll_for_media_force ();
skip_check:
return TRUE;
}
static dbus_bool_t
unmount_cleartext_devices (LibHalContext *ctx, const char *udi)
{
DBusError error;
char **clear_devices;
int num_clear_devices;
dbus_bool_t ret;
ret = FALSE;
/* check if the volume we back is mounted.. if it is.. unmount it */
dbus_error_init (&error);
clear_devices = libhal_manager_find_device_string_match (ctx,
"volume.crypto_luks.clear.backing_volume",
udi,
&num_clear_devices,
&error);
if (clear_devices != NULL && num_clear_devices > 0) {
int i;
ret = TRUE;
for (i = 0; i < num_clear_devices; i++) {
char *clear_udi;
clear_udi = clear_devices[i];
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, clear_udi, "volume.is_mounted", &error)) {
HAL_DEBUG (("Forcing unmount of child '%s' (crypto)", clear_udi));
force_unmount (ctx, clear_udi);
}
}
libhal_free_string_array (clear_devices);
}
LIBHAL_FREE_DBUS_ERROR (&error);
return ret;
}
void find_devices(void)
{
DBusError error;
dbus_error_init(&error);
if (ac_adapters)
libhal_free_string_array(ac_adapters);
ac_adapters = libhal_find_device_by_capability(hal_ctx, "ac_adapter",
&num_ac_adapters, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "error: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
}
if (batteries)
libhal_free_string_array(batteries);
batteries = libhal_find_device_by_capability(hal_ctx, "battery",
&num_batteries, &error);
if (dbus_error_is_set(&error)) {
fprintf(stderr, "error: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
}
}
int connect_hal(void)
{
DBusError error;
dbus_error_init(&error);
dbus_ctx = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
if (dbus_ctx == NULL) {
fprintf(stderr, "error: dbus_bus_get: %s: %s\n",
error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
return 0;
}
hal_ctx = libhal_ctx_new();
if (hal_ctx == NULL) {
fprintf(stderr, "error: libhal_ctx_new\n");
LIBHAL_FREE_DBUS_ERROR(&error);
return 0;
}
if (!libhal_ctx_set_dbus_connection(hal_ctx, dbus_ctx)) {
fprintf(stderr, "error: libhal_ctx_set_dbus_connection: %s: %s\n",
error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
return 0;
}
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 0;
}
return 1;
}
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;
}
/**
* setstr:
* @buf: The non tabbed prefixed, null terminated string
* @str: The strings to compare with e.g. "Vendor:"
* @prop: The HAL property to set
*
* Return TRUE is found, FALSE otherwise.
*
* Finds the start of a null terminated string and sets HAL property if valid.
*/
static int
setstr (char *buf, char *str, char *prop)
{
DBusError error;
char *value;
if (strbegin (buf, str)) {
dbus_error_init (&error);
value = buf + strlen (str) + 1;
if (strcmp (value, "Not Specified") == 0)
goto out;
libhal_device_set_property_string (hfp_ctx, hfp_udi, prop, value, &hfp_error);
LIBHAL_FREE_DBUS_ERROR (&hfp_error);
hfp_info ("Setting %s='%s'", prop, value);
return TRUE;
}
out:
return FALSE;
}
static gboolean
get_system_idle_from_ck (void)
{
gboolean ret;
DBusError error;
DBusMessage *message;
DBusMessage *reply;
ret = FALSE;
message = dbus_message_new_method_call ("org.freedesktop.ConsoleKit",
"/org/freedesktop/ConsoleKit/Manager",
"org.freedesktop.ConsoleKit.Manager",
"GetSystemIdleHint");
dbus_error_init (&error);
reply = dbus_connection_send_with_reply_and_block (con, message, -1, &error);
if (reply == NULL || dbus_error_is_set (&error)) {
HAL_ERROR (("Error doing Manager.GetSystemIdleHint on ConsoleKit: %s: %s", error.name, error.message));
dbus_message_unref (message);
if (reply != NULL)
dbus_message_unref (reply);
goto error;
}
if (!dbus_message_get_args (reply, NULL,
DBUS_TYPE_BOOLEAN, &(system_is_idle),
DBUS_TYPE_INVALID)) {
HAL_ERROR (("Invalid GetSystemIdleHint reply from CK"));
goto error;
}
dbus_message_unref (message);
dbus_message_unref (reply);
ret = TRUE;
error:
LIBHAL_FREE_DBUS_ERROR (&error);
return ret;
}
int main(int argc, char **argv)
{
DBusError error;
DBusConnection *conn;
LibHalContext *hal_ctx;
int i, err;
opterr = 0;
opt.list = 1;
while ((i = getopt_long(argc, argv, "a:hr:", options, NULL)) != -1) {
switch (i) {
case 'a':
opt.add = 1;
opt.list = 0;
opt.udi = optarg;
break;
case 'r':
opt.remove = 1;
opt.list = 0;
opt.udi = optarg;
break;
case 'h':
help();
return 0;
default:
help();
return 1;
}
}
dbus_error_init(&error);
if (!(conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
fprintf(stderr, "error: dbus_bus_get: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 2;
}
/* fprintf(stderr, "connected to: %s\n", dbus_bus_get_unique_name(conn)); */
if (!(hal_ctx = libhal_ctx_new())) return 3;
if (!libhal_ctx_set_dbus_connection(hal_ctx, conn)) return 4;
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 5;
}
err = 0;
if (opt.list)
err = dump_devices(hal_ctx, argv[optind]);
else if (opt.remove)
err = remove_udi(hal_ctx, opt.udi);
else if (opt.add)
err = add_udi(hal_ctx, opt.udi);
else
err = 6;
libhal_ctx_shutdown(hal_ctx, &error);
libhal_ctx_free(hal_ctx);
dbus_connection_unref(conn);
dbus_error_free(&error);
return err;
}
/* Thanks to lmctl code. I'd LOVE, REALLY LOVE to see some docs though... */
static void
check_battery (const char *hal_device_udi, PropertyCacheItem *pci)
{
struct usb_device *curr_device;
usb_dev_handle *handle;
char buf[80];
DBusError err;
unsigned int addr;
int is_dual = 0;
int percentage = 0;
if (pci == NULL)
return;
HAL_DEBUG (("CSR device: [%s]", hal_device_udi));
is_dual = pci->csr_is_dual;
/* Which of subdevices to address */
HAL_DEBUG (("Is dual: %d", is_dual));
addr = is_dual? 1<<8 : 0;
curr_device = find_device (pci);
if (curr_device == NULL) {
HAL_ERROR (("Device %s not found", hal_device_udi));
return;
}
handle = usb_open (curr_device);
if (handle == NULL) {
HAL_ERROR (("Could not open usb device"));
return;
}
if (!usb_control_msg (handle, 0xc0, 0x09, 0x03|addr, 0x00|addr,
buf, 8, TIMEOUT) != 8) {
if ((P0 == 0x3b) && (P4 == 0)) {
HAL_DEBUG (("Receiver busy, trying again later"));
} else {
int current_charge = P5 & 0x07;
HAL_DEBUG (("Charge level: %d->%d", pci->current_charge, current_charge));
if (current_charge != pci->current_charge) {
pci->current_charge = current_charge;
dbus_error_init (&err);
libhal_device_set_property_int (halctx, hal_device_udi,
"battery.charge_level.current", current_charge, &err);
LIBHAL_FREE_DBUS_ERROR (&err);
if (current_charge != 0) {
percentage = (100.0 / 7.0) * current_charge;
libhal_device_set_property_int (halctx, hal_device_udi,
"battery.charge_level.percentage", percentage, &err);
} else {
libhal_device_remove_property(halctx, hal_device_udi,
"battery.charge_level.percentage", &err);
}
LIBHAL_FREE_DBUS_ERROR (&err);
}
}
} else {
perror ("Writing to USB device");
}
usb_close (handle);
}
int
main (int argc, char *argv[])
{
off_t address = 0;
size_t length = 0;
int fd;
int state;
int retval = 0;
struct pci_access *pacc;
struct pci_dev *dev;
DBusError err;
setup_logger ();
udi = getenv ("UDI");
HAL_DEBUG (("udi=%s", udi));
if (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;
}
if (!libhal_device_addon_is_ready (halctx, udi, &err)) {
retval = -4;
goto out;
}
conn = libhal_ctx_get_dbus_connection (halctx);
dbus_connection_setup_with_g_main (conn, NULL);
dbus_connection_set_exit_on_disconnect (conn, 0);
dbus_connection_add_filter (conn, filter_function, NULL, NULL);
/* Search for the graphics card. */
/* Default values: */
/* address = 0x90300000; */
/* length = 0x20000; */
pacc = pci_alloc();
pci_init(pacc);
pci_scan_bus(pacc);
for(dev=pacc->devices; dev; dev=dev->next) { /* Iterate over all devices */
pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_BASES);
if ((dev->vendor_id == 0x1002) && (dev->device_id == 0x71c5)) { // ATI X1600
address = dev->base_addr[2];
length = dev->size[2];
}
}
pci_cleanup(pacc);
HAL_DEBUG (("addr 0x%x len=%d", address, length));
if (!address) {
HAL_DEBUG (("Failed to detect ATI X1600, aborting..."));
retval = 1;
goto out;
}
fd = open ("/dev/mem", O_RDWR);
if (fd < 0) {
HAL_DEBUG (("cannot open /dev/mem"));
retval = 1;
goto out;
}
memory = mmap (NULL, length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, address);
if (memory == MAP_FAILED) {
HAL_ERROR (("mmap failed"));
retval = 2;
goto out;
}
/* Is it really necessary ? */
OUTREG(0x4dc, 0x00000005);
state = INREG(0x7ae4);
OUTREG(0x7ae4, state);
/* Allow access to porta 0x300 through 0x304 */
if (ioperm (0x300, 5, 1) < 0) {
HAL_ERROR (("ioperm failed (you should be root)."));
exit(1);
}
/* this works because we hardcoded the udi's in the <spawn> in the fdi files */
if (!libhal_device_claim_interface (halctx,
"/org/freedesktop/Hal/devices/macbook_pro_lcd_panel",
"org.freedesktop.Hal.Device.LaptopPanel",
" <method name=\"SetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"in\" type=\"i\"/>\n"
" <arg name=\"return_code\" direction=\"out\" type=\"i\"/>\n"
" </method>\n"
" <method name=\"GetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"out\" type=\"i\"/>\n"
" </method>\n",
&err)) {
HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.LaptopPanel'"));
retval = -4;
goto out;
}
if (!libhal_device_claim_interface (halctx,
"/org/freedesktop/Hal/devices/macbook_pro_light_sensor",
"org.freedesktop.Hal.Device.LightSensor",
" <method name=\"GetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"out\" type=\"ai\"/>\n"
" </method>\n",
&err)) {
HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.LightSensor'"));
retval = -4;
goto out;
}
if (!libhal_device_claim_interface (halctx,
"/org/freedesktop/Hal/devices/macbook_pro_keyboard_backlight",
"org.freedesktop.Hal.Device.KeyboardBacklight",
" <method name=\"GetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"out\" type=\"i\"/>\n"
" </method>\n"
" <method name=\"SetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"in\" type=\"i\"/>\n"
" </method>\n",
&err)) {
HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.KeyboardBacklight'"));
retval = -4;
goto out;
}
main_loop = g_main_loop_new (NULL, FALSE);
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 DBusHandlerResult
filter_function (DBusConnection *connection, DBusMessage *message, void *userdata)
{
DBusError err;
DBusMessage *reply;
const char *udi;
udi = dbus_message_get_path (message);
/*dbg ("filter_function: sender=%s destination=%s obj_path=%s interface=%s method=%s",
dbus_message_get_sender (message),
dbus_message_get_destination (message),
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));*/
reply = NULL;
dbus_error_init (&err);
if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LaptopPanel",
"SetBrightness")) {
int brightness;
if (!check_priv (halctx, connection, message, udi, "org.freedesktop.hal.power-management.lcd-panel"))
goto error;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID)) {
/* dbg ("setting brightness %d", brightness); */
if (brightness < 0 || brightness > 228) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.LaptopPanel.Invalid",
"Brightness has to be between 0 and 228!");
} else {
int return_code;
write_backlight (brightness + 27);
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
return_code = 0;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &return_code,
DBUS_TYPE_INVALID);
}
dbus_connection_send (connection, reply, NULL);
}
} else if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LaptopPanel",
"GetBrightness")) {
int brightness;
if (!check_priv (halctx, connection, message, udi, "org.freedesktop.hal.power-management.lcd-panel"))
goto error;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INVALID)) {
brightness = read_backlight () - 27;
if (brightness < 0)
brightness = 0;
if (brightness > 228)
brightness = 228;
/* dbg ("getting brightness, it's %d", brightness); */
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
}
} else if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LightSensor",
"GetBrightness")) {
int brightness[2];
if (!check_priv (halctx, connection, message, udi, "org.freedesktop.hal.power-management.light-sensor"))
goto error;
brightness[0] = read_light_sensor (FALSE); /* right */
brightness[1] = read_light_sensor (TRUE); /* left */
if (brightness[0] == -1 || brightness[1] == -1) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.LightSensors.Error",
"Error poking hardware");
dbus_connection_send (connection, reply, NULL);
} else {
int (*pb)[] = &brightness;
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
dbus_message_append_args (reply,
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &pb, 2,
DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
}
} else if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.KeyboardBacklight",
"GetBrightness")) {
if (!check_priv (halctx, connection, message, udi, "org.freedesktop.hal.power-management.keyboard-backlight"))
goto error;
/* I can't get this working so just cache last SetBrightness value :-/ */
if (last_keyboard_brightness == -1 ) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.KeyboardBacklight.Error",
"Error poking hardware");
dbus_connection_send (connection, reply, NULL);
} else {
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &last_keyboard_brightness,
DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
}
#if 0
int brightness;
brightness = read_keyboard_backlight ();
if (brightness == -1) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.KeyboardBacklight.Error",
"Error poking hardware");
dbus_connection_send (connection, reply, NULL);
} else {
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
}
#endif
} else if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.KeyboardBacklight",
"SetBrightness")) {
int brightness;
if (!check_priv (halctx, connection, message, udi, "org.freedesktop.hal.power-management.keyboard-backlight"))
goto error;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID)) {
/*dbg ("setting keyboard brightness %d", brightness);*/
if (brightness < 0 || brightness > 255) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.KeyboardBacklight.Invalid",
"Brightness has to be between 0 and 255!");
} else {
set_keyboard_backlight (brightness);
last_keyboard_brightness = brightness;
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
}
dbus_connection_send (connection, reply, NULL);
}
}
error:
if (reply != NULL)
dbus_message_unref (reply);
LIBHAL_FREE_DBUS_ERROR (&err);
return DBUS_HANDLER_RESULT_HANDLED;
}
int
main (int argc, char *argv[])
{
DBusError error;
LibHalContext *ctx_direct;
DBusConnection *con_direct;
char *bus;
char *drive_type;
char *support_media_changed_str;
char *str;
hal_set_proc_title_init (argc, argv);
/* We could drop privs if we know that the haldaemon user is
* to be able to access block devices...
*/
/*drop_privileges (1);*/
if ((udi = getenv ("UDI")) == NULL)
goto out;
if ((device_file = getenv ("HAL_PROP_BLOCK_DEVICE")) == NULL)
goto out;
if ((bus = getenv ("HAL_PROP_STORAGE_BUS")) == NULL)
goto out;
if ((drive_type = getenv ("HAL_PROP_STORAGE_DRIVE_TYPE")) == NULL)
goto out;
setup_logger ();
support_media_changed_str = getenv ("HAL_PROP_STORAGE_CDROM_SUPPORT_MEDIA_CHANGED");
if (support_media_changed_str != NULL && strcmp (support_media_changed_str, "true") == 0)
support_media_changed = TRUE;
else
support_media_changed = FALSE;
dbus_error_init (&error);
con = dbus_bus_get (DBUS_BUS_SYSTEM, &error);
if (con == NULL) {
HAL_ERROR (("Cannot connect to system bus"));
goto out;
}
loop = g_main_loop_new (NULL, FALSE);
dbus_connection_setup_with_g_main (con, NULL);
dbus_connection_set_exit_on_disconnect (con, 0);
if ((ctx_direct = libhal_ctx_init_direct (&error)) == NULL) {
HAL_ERROR (("Cannot connect to hald"));
goto out;
}
if (!libhal_device_addon_is_ready (ctx_direct, udi, &error)) {
goto out;
}
con_direct = libhal_ctx_get_dbus_connection (ctx_direct);
dbus_connection_setup_with_g_main (con_direct, NULL);
dbus_connection_set_exit_on_disconnect (con_direct, 0);
dbus_connection_add_filter (con_direct, direct_filter_function, NULL, NULL);
if ((ctx = libhal_ctx_init_direct (&error)) == NULL)
goto out;
if (!libhal_device_addon_is_ready (ctx, udi, &error))
goto out;
HAL_DEBUG (("**************************************************"));
HAL_DEBUG (("Doing addon-storage for %s (bus %s) (drive_type %s) (udi %s)", device_file, bus, drive_type, udi));
HAL_DEBUG (("**************************************************"));
if (strcmp (drive_type, "cdrom") == 0)
is_cdrom = 1;
else
is_cdrom = 0;
media_status = MEDIA_STATUS_UNKNOWN;
#ifdef HAVE_CONKIT
/* TODO: ideally we should track the sessions on the seats on
* which the device belongs to. But right now we don't really
* do multi-seat so I'm going to punt on this for now.
*/
get_system_idle_from_ck ();
dbus_bus_add_match (con,
"type='signal'"
",interface='org.freedesktop.ConsoleKit.Manager'"
",sender='org.freedesktop.ConsoleKit'"
",member='SystemIdleHintChanged'",
NULL);
dbus_bus_add_match (con,
"type='signal'"
",interface='org.freedesktop.ConsoleKit.Seat'"
",sender='org.freedesktop.ConsoleKit'"
",member='ActiveSessionChanged'",
NULL);
#endif
/* this is a bit weird; but we want to listen to signals about
* locking from hald.. and signals are not pushed over direct
* connections (for a good reason).
*/
dbus_bus_add_match (con,
"type='signal'"
",interface='org.freedesktop.Hal.Manager'"
",sender='org.freedesktop.Hal'",
NULL);
dbus_bus_add_match (con,
"type='signal'"
",interface='org.freedesktop.Hal.Manager'"
",sender='org.freedesktop.Hal'",
NULL);
str = g_strdup_printf ("type='signal'"
",interface='org.freedesktop.Hal.Device'"
",sender='org.freedesktop.Hal'"
",path='%s'",
udi);
dbus_bus_add_match (con,
str,
NULL);
g_free (str);
dbus_connection_add_filter (con, dbus_filter_function, NULL, NULL);
if (!libhal_device_claim_interface (ctx,
udi,
"org.freedesktop.Hal.Device.Storage.Removable",
" <method name=\"CheckForMedia\">\n"
" <arg name=\"call_had_sideeffect\" direction=\"out\" type=\"b\"/>\n"
" </method>\n",
&error)) {
HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.Storage.Removable'"));
goto out;
}
update_polling_interval ();
g_main_loop_run (loop);
out:
HAL_DEBUG (("An error occured, exiting cleanly"));
LIBHAL_FREE_DBUS_ERROR (&error);
if (ctx != NULL) {
libhal_ctx_shutdown (ctx, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
libhal_ctx_free (ctx);
}
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;
}
int add_properties(LibHalContext *hal_ctx, new_dev_t *nd, lh_prop_t *prop)
{
DBusError error;
lh_prop_t *p;
char *udi2 = NULL, *udi3 = NULL, **s;
LibHalPropertyType old_type;
dbus_error_init(&error);
for(p = prop; p; p = p->next) {
if (!strcmp(p->key, "udi") && p->type == LIBHAL_PROPERTY_TYPE_STRING) {
udi2 = p->v.str_value;
continue;
}
old_type = libhal_device_get_property_type(hal_ctx, nd->real_udi, p->key, &error);
dbus_error_init(&error);
if (old_type != LIBHAL_PROPERTY_TYPE_INVALID &&
( p->type != old_type || p->type == LIBHAL_PROPERTY_TYPE_STRLIST)) {
if (!libhal_device_remove_property(hal_ctx, nd->real_udi, p->key, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 41;
}
}
switch (p->type) {
case LIBHAL_PROPERTY_TYPE_INVALID:
break;
case LIBHAL_PROPERTY_TYPE_BOOLEAN:
if (!libhal_device_set_property_bool(hal_ctx, nd->real_udi, p->key, p->v.bool_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_INT32:
if (!libhal_device_set_property_int(hal_ctx, nd->real_udi, p->key, p->v.int_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_UINT64:
if (!libhal_device_set_property_uint64(hal_ctx, nd->real_udi, p->key, p->v.uint64_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_DOUBLE:
if (!libhal_device_set_property_double(hal_ctx, nd->real_udi, p->key, p->v.double_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_STRING:
if (!strcmp(p->key, "info.udi")) udi3 = p->v.str_value;
if (!libhal_device_set_property_string(hal_ctx, nd->real_udi, p->key, p->v.str_value, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
break;
case LIBHAL_PROPERTY_TYPE_STRLIST:
for(s = p->v.strlist_value; *s; s++) {
if (!libhal_device_property_strlist_append(hal_ctx, nd->real_udi, p->key, *s, &error)) {
fprintf(stderr, "%s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 42;
}
}
break;
}
}
if (udi2) udi3 = NULL;
if (udi3) udi2 = udi3;
if (udi2 && !nd->udi)
nd->udi = strdup(udi2);
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
unmount_childs (LibHalContext *ctx, const char *udi)
{
int num_volumes;
char **volumes;
DBusError error;
/* need to force unmount all partitions */
dbus_error_init (&error);
if ((volumes = libhal_manager_find_device_string_match (ctx, "block.storage_device", udi, &num_volumes, &error)) != NULL) {
int i;
for (i = 0; i < num_volumes; i++) {
char *vol_udi;
vol_udi = volumes[i];
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "block.is_volume", &error)) {
dbus_bool_t is_crypto;
/* unmount all cleartext devices associated with us */
is_crypto = unmount_cleartext_devices (ctx, vol_udi);
LIBHAL_FREE_DBUS_ERROR (&error);
if (libhal_device_get_property_bool (ctx, vol_udi, "volume.is_mounted", &error)) {
HAL_DEBUG (("Forcing unmount of child '%s'", vol_udi));
force_unmount (ctx, vol_udi);
}
/* teardown crypto */
if (is_crypto) {
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
/* tear down mapping */
HAL_DEBUG (("Teardown crypto for '%s'", vol_udi));
msg = dbus_message_new_method_call ("org.freedesktop.Hal", vol_udi,
"org.freedesktop.Hal.Device.Volume.Crypto",
"Teardown");
if (msg == NULL) {
HAL_ERROR (("Could not create dbus message for %s", vol_udi));
goto teardown_failed;
}
LIBHAL_FREE_DBUS_ERROR (&error);
if (!(reply = dbus_connection_send_with_reply_and_block (
libhal_ctx_get_dbus_connection (ctx), msg, -1, &error)) ||
dbus_error_is_set (&error)) {
HAL_DEBUG (("Teardown failed for %s: %s : %s\n", udi, error.name, error.message));
dbus_error_free (&error);
}
teardown_failed:
if (msg != NULL)
dbus_message_unref (msg);
if (reply != NULL)
dbus_message_unref (reply);
}
}
}
libhal_free_string_array (volumes);
}
LIBHAL_FREE_DBUS_ERROR (&error);
}
/* DBus filter function */
static DBusHandlerResult
filter_function (DBusConnection *connection, DBusMessage *message, void *userdata)
{
DBusError err;
DBusMessage *reply;
if (!check_priv (halctx, connection, message, dbus_message_get_path (message),
"org.freedesktop.hal.power-management.lcd-panel")) {
return DBUS_HANDLER_RESULT_HANDLED;
}
#ifdef DEBUG_OMAP_BL
dbg ("filter_function: sender=%s destination=%s obj_path=%s interface=%s method=%s",
dbus_message_get_sender (message),
dbus_message_get_destination (message),
dbus_message_get_path (message),
dbus_message_get_interface (message),
dbus_message_get_member (message));
#endif
reply = NULL;
dbus_error_init (&err);
if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LaptopPanel",
"SetBrightness")) {
int brightness;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID)) {
if (brightness < 0 || brightness > 228) {
reply = dbus_message_new_error (message,
"org.freedesktop.Hal.Device.LaptopPanel.Invalid",
"Brightness has to be between 0 and 228!");
} else {
int return_code;
bl_data.set_backlight_level (&bl_data, brightness);
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
return_code = 0;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &return_code,
DBUS_TYPE_INVALID);
}
dbus_connection_send (connection, reply, NULL);
}
} else if (dbus_message_is_method_call (message,
"org.freedesktop.Hal.Device.LaptopPanel",
"GetBrightness")) {
int brightness;
if (dbus_message_get_args (message,
&err,
DBUS_TYPE_INVALID)) {
brightness = bl_data.get_backlight_level (&bl_data);
if (brightness < bl_data.bl_min)
brightness = bl_data.bl_min;
if (brightness > bl_data.bl_max)
brightness = bl_data.bl_max;
/* dbg ("getting brightness, it's %d", brightness); */
reply = dbus_message_new_method_return (message);
if (reply == NULL)
goto error;
dbus_message_append_args (reply,
DBUS_TYPE_INT32, &brightness,
DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
}
}
error:
if (reply != NULL)
dbus_message_unref (reply);
LIBHAL_FREE_DBUS_ERROR (&err);
return DBUS_HANDLER_RESULT_HANDLED;
}
int
main (int argc, char *argv[])
{
DBusError err;
int retval = 0;
setup_logger ();
setup_cb ();
udi = getenv ("UDI");
HAL_DEBUG (("udi=%s", udi));
if (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;
}
conn = libhal_ctx_get_dbus_connection (halctx);
dbus_connection_setup_with_g_main (conn, NULL);
dbus_connection_add_filter (conn, filter_function, NULL, NULL);
if (!libhal_device_claim_interface (halctx,
"/org/freedesktop/Hal/devices/omapfb_bl",
"org.freedesktop.Hal.Device.LaptopPanel",
" <method name=\"SetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"in\" type=\"i\"/>\n"
" <arg name=\"return_code\" direction=\"out\" type=\"i\"/>\n"
" </method>\n"
" <method name=\"GetBrightness\">\n"
" <arg name=\"brightness_value\" direction=\"out\" type=\"i\"/>\n"
" </method>\n",
&err)) {
HAL_ERROR (("Cannot claim interface 'org.freedesktop.Hal.Device.LaptopPanel'"));
retval = -4;
goto out;
}
if (!libhal_device_addon_is_ready (halctx, udi, &err)) {
retval = -4;
goto out;
}
bl_data.backlight_init (&bl_data);
main_loop = g_main_loop_new (NULL, FALSE);
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;
}
/**
* main:
* @argc: Number of arguments given to program
* @argv: Arguments given to program
*
* Returns: Return code
*
* Main entry point
*/
int
main (int argc, char *argv[])
{
dbus_bool_t rc = 0;
char *udi = NULL;
char *key = NULL;
char *str_value = NULL;
dbus_int32_t int_value = 0;
dbus_uint64_t uint64_value = 0;
double double_value = 0.0f;
dbus_bool_t bool_value = TRUE;
dbus_bool_t remove = FALSE;
dbus_bool_t is_version = FALSE;
int type = PROP_INVALID;
DBusError error;
dbus_bool_t direct = FALSE;
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},
{"int", 1, NULL, 0},
{"uint64", 1, NULL, 0},
{"string", 1, NULL, 0},
{"double", 1, NULL, 0},
{"bool", 1, NULL, 0},
{"strlist-pre", 1, NULL, 0},
{"strlist-post", 1, NULL, 0},
{"strlist-rem", 1, NULL, 0},
{"direct", 0, NULL, 0},
{"remove", 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, "key") == 0) {
key = strdup (optarg);
} else if (strcmp (opt, "string") == 0) {
str_value = strdup (optarg);
type = PROP_STRING;
} else if (strcmp (opt, "int") == 0) {
int_value = strtol (optarg, NULL, 0);
type = PROP_INT;
} else if (strcmp (opt, "uint64") == 0) {
uint64_value = strtoull (optarg, NULL, 0);
type = PROP_UINT64;
} else if (strcmp (opt, "double") == 0) {
double_value = (double) atof (optarg);
type = PROP_DOUBLE;
} else if (strcmp (opt, "bool") == 0) {
if (strcmp (optarg, "true") == 0)
bool_value = TRUE;
else if (strcmp (optarg, "false") == 0)
bool_value = FALSE;
else {
usage (argc, argv);
return 1;
}
type = PROP_BOOL;
} else if (strcmp (opt, "strlist-pre") == 0) {
str_value = strdup (optarg);
type = PROP_STRLIST_PRE;
} else if (strcmp (opt, "strlist-post") == 0) {
str_value = strdup (optarg);
type = PROP_STRLIST_POST;
} else if (strcmp (opt, "strlist-rem") == 0) {
str_value = strdup (optarg);
type = PROP_STRLIST_REM;
} else if (strcmp (opt, "remove") == 0) {
remove = TRUE;
} else if (strcmp (opt, "direct") == 0) {
direct = TRUE;
} else if (strcmp (opt, "udi") == 0) {
udi = strdup (optarg);
} else if (strcmp (opt, "version") == 0) {
is_version = TRUE;
}
break;
default:
usage (argc, argv);
return 1;
break;
}
}
if (is_version) {
printf ("hal-set-property " PACKAGE_VERSION "\n");
return 0;
}
/* must have at least one, but not neither or both */
if ((remove && type != PROP_INVALID) || ((!remove) && type == PROP_INVALID)) {
usage (argc, argv);
return 1;
}
fprintf (stderr, "\n");
dbus_error_init (&error);
if (direct) {
if ((hal_ctx = libhal_ctx_init_direct (&error)) == NULL) {
fprintf (stderr, "error: libhal_ctx_init_direct\n");
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
} else {
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);
dbus_error_free (&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;
}
}
if (remove) {
rc = libhal_device_remove_property (hal_ctx, udi, key, &error);
if (!rc) {
fprintf (stderr, "error: libhal_device_remove_property: %s: %s\n", error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return 1;
}
} else {
switch (type) {
case PROP_STRING:
rc = libhal_device_set_property_string (hal_ctx, udi, key, str_value, &error);
break;
case PROP_INT:
rc = libhal_device_set_property_int (hal_ctx, udi, key, int_value, &error);
break;
case PROP_UINT64:
rc = libhal_device_set_property_uint64 (hal_ctx, udi, key, uint64_value, &error);
break;
case PROP_DOUBLE:
rc = libhal_device_set_property_double (hal_ctx, udi, key, double_value, &error);
break;
case PROP_BOOL:
rc = libhal_device_set_property_bool (hal_ctx, udi, key, bool_value, &error);
break;
case PROP_STRLIST_PRE:
rc = libhal_device_property_strlist_prepend (hal_ctx, udi, key, str_value, &error);
break;
case PROP_STRLIST_POST:
rc = libhal_device_property_strlist_append (hal_ctx, udi, key, str_value, &error);
break;
case PROP_STRLIST_REM:
rc = libhal_device_property_strlist_remove (hal_ctx, udi, key, str_value, &error);
break;
}
if (!rc) {
fprintf (stderr, "error: libhal_device_set_property: %s: %s\n", error.name, error.message);
dbus_error_free (&error);
return 1;
}
}
return rc ? 0 : 1;
}
/*
* gst_hal_get_alsa_element:
* @ctx: a #LibHalContext which should be used for querying HAL.
* @udi: a #gchar corresponding to the UDI you want to get.
* @device_type: a #GstHalDeviceType specifying the wanted device type.
*
* Get Hal UDI @udi's string value.
*
* Returns: a newly allocated #gchar string containing the appropriate pipeline
* for UDI @udi, or NULL in the case of an error..
*/
static gchar *
gst_hal_get_alsa_element (LibHalContext * ctx, const gchar * udi,
GstHalDeviceType device_type)
{
char *type, *element = NULL, *string = NULL;
DBusError error;
dbus_error_init (&error);
if (!libhal_device_query_capability (ctx, udi, "alsa", &error)) {
if (dbus_error_is_set (&error)) {
GST_DEBUG ("Failed querying %s for alsa capability: %s: %s",
udi, error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
} else {
GST_DEBUG ("UDI %s has no alsa capability", udi);
}
return NULL;
}
type = libhal_device_get_property_string (ctx, udi, "alsa.type", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has alsa capabilities but no alsa.type property: %s, %s",
udi, error.name, error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (!type) {
GST_DEBUG ("UDI %s has empty alsa.type property", udi);
return NULL;
}
if (strcmp (type, "playback") == 0 && device_type == GST_HAL_AUDIOSINK)
element = "alsasink";
else if (strcmp (type, "capture") == 0 && device_type == GST_HAL_AUDIOSRC)
element = "alsasrc";
libhal_free_string (type);
if (element) {
int card, device;
card = libhal_device_get_property_int (ctx, udi, "alsa.card", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has no alsa.card property: %s: %s", udi, error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (card == -1) {
GST_DEBUG ("UDI %s has no alsa.card property", udi);
return NULL;
}
device = libhal_device_get_property_int (ctx, udi, "alsa.device", &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("UDI %s has no alsa.device property: %s: %s", udi, error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
return NULL;
} else if (device == -1) {
GST_DEBUG ("UDI %s has no alsa.device property", udi);
return NULL;
}
/* This is a bit dodgy, since it makes lots of assumptions about the way
* alsa is set up. In any case, only munge the device string for playback */
if (strcmp (element, "alsasink") == 0 && device == 0) {
/* handle default device specially to use
* dmix, dsnoop, and softvol if appropriate */
string = g_strdup_printf ("%s device=default:%d", element, card);
} else {
string =
g_strdup_printf ("%s device=plughw:%d,%d", element, card, device);
}
}
return string;
}
/*
* gst_hal_get_string:
* @udi: a #gchar corresponding to the UDI you want to get.
* @device_type: a #GstHalDeviceType specifying the wanted device type.
*
* Get Hal UDI @udi's string value.
*
* Returns: a newly allocated #gchar string containing the appropriate pipeline
* for UDI @udi, or NULL in the case of an error..
*/
static gchar *
gst_hal_get_string (const gchar * udi, GstHalDeviceType device_type)
{
DBusError error;
LibHalContext *ctx;
char *string = NULL;
/* Don't query HAL for NULL UDIs. Passing NULL as UDI to HAL gives
* an assertion failure in D-Bus when running with
* DBUS_FATAL_WARNINGS=1. */
if (!udi)
return NULL;
dbus_error_init (&error);
ctx = libhal_ctx_new ();
/* Should only happen on OOM */
g_return_val_if_fail (ctx != NULL, NULL);
if (!libhal_ctx_set_dbus_connection (ctx, dbus_bus_get (DBUS_BUS_SYSTEM,
&error))) {
GST_DEBUG ("Unable to set DBus connection: %s: %s", error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
goto ctx_free;
}
if (!libhal_ctx_init (ctx, &error)) {
GST_DEBUG ("Unable to set init HAL context: %s: %s", error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
goto ctx_free;
}
/* Now first check if UDI is an alsa device, then oss and then
* check the childs of the given device. If there are alsa and oss
* children the first alsa one is used. */
string = gst_hal_get_alsa_element (ctx, udi, device_type);
if (!string)
string = gst_hal_get_oss_element (ctx, udi, device_type);
if (!string) {
int num_childs;
char **childs = NULL;
/* now try if one of the direct subdevices supports ALSA or OSS */
childs =
libhal_manager_find_device_string_match (ctx, "info.parent", udi,
&num_childs, &error);
if (dbus_error_is_set (&error)) {
GST_DEBUG ("Unable to retrieve childs of %s: %s: %s", udi, error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
goto ctx_shutdown;
}
if (childs && num_childs > 0) {
int i;
char *alsa_string = NULL, *oss_string = NULL;
for (i = 0; i < num_childs && !alsa_string; i++) {
alsa_string = gst_hal_get_alsa_element (ctx, childs[i], device_type);
if (!oss_string)
oss_string = gst_hal_get_oss_element (ctx, childs[i], device_type);
}
if (alsa_string) {
string = alsa_string;
g_free (oss_string);
} else if (oss_string) {
string = oss_string;
}
}
libhal_free_string_array (childs);
}
ctx_shutdown:
if (!libhal_ctx_shutdown (ctx, &error)) {
GST_DEBUG ("Closing connection to HAL failed: %s: %s", error.name,
error.message);
LIBHAL_FREE_DBUS_ERROR (&error);
}
ctx_free:
libhal_ctx_free (ctx);
if (string == NULL) {
GST_WARNING ("Problem finding a HAL audio device for udi %s", udi);
} else {
GST_INFO ("Using %s", string);
}
return string;
}
int
main(int argc, char **argv)
{
DBusError error;
DBusConnection *conn;
LibHalContext *hal_ctx;
int err;
int c;
int all = 0;
int list = 0;
int dev = 0;
char *dev_name;
if (argc < 2) {
return (0);
}
while ((c = getopt(argc, argv, "ald:")) != EOF) {
switch (c) {
case 'a':
all = 1;
break;
case 'l':
list = 1;
break;
case 'd':
dev = 1;
dev_name = optarg;
break;
default:
exit(1);
}
}
dbus_error_init(&error);
if (!(conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error))) {
fprintf(stderr, "error: dbus_bus_get: %s: %s\n",
error.name, error.message);
LIBHAL_FREE_DBUS_ERROR(&error);
return (2);
}
if (!(hal_ctx = libhal_ctx_new())) {
return (3);
}
if (!libhal_ctx_set_dbus_connection(hal_ctx, conn)) {
return (4);
}
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 (5);
}
err = 0;
if (list) {
err = list_battery_devices(hal_ctx);
}
if (all) {
err = dump_all_devices(hal_ctx);
}
if (dev) {
err = dump_device(hal_ctx, dev_name);
}
libhal_ctx_shutdown(hal_ctx, &error);
libhal_ctx_free(hal_ctx);
dbus_connection_unref(conn);
dbus_error_free(&error);
return (err);
}
GSList*
build_volume_list(LibHalContext* ctx,
enum FormatVolumeType type,
GHashTable* icon_cache,
int icon_width, int icon_height)
{
const char* capability = "";
char** device_udis;
int i, device_udi_count = 0;
GSList* device_list = NULL;
DBusError error;
switch(type) {
case FORMATVOLUMETYPE_VOLUME:
capability = "volume";
break;
case FORMATVOLUMETYPE_DRIVE:
capability = "storage";
break;
}
/* Pull the storage (or volume) list from HAL */
dbus_error_init (&error);
if ( (device_udis = libhal_find_device_by_capability (ctx, capability, &device_udi_count, &error) ) == NULL) {
LIBHAL_FREE_DBUS_ERROR (&error);
goto out;
}
/* if we use libhal_device_get-property() instead of
* libhal_volume_get_mount_mount_point() we have to setup DBusError and
* some other things, the problem is do we like to have (null) in the gui
* when libhal-storage cannot discover where a partition is mounted?
* if so we can remove the DBusError code and use the libhal-storage func
* to retrive the mount point.
* (or maybe we can check if is_partition == null and then don't strdup
* it.
* It returns null when a device is marked as swap or mounted via
* cryptdisk or even if it's not listed in /etc/fstab
*/
/* Now we use libhal-storage to get the info */
FormatVolume* current;
const char* icon_path;
for(i=0; i < device_udi_count; i++) {
current = g_new0(FormatVolume, 1);
g_debug("udi: %s", device_udis[i]);
current->udi = g_strdup(device_udis[i]);
switch(type) {
case FORMATVOLUMETYPE_VOLUME:
current->volume = libhal_volume_from_udi(ctx, device_udis[i]);
if(!current->volume) {
g_free(current);
continue;
}
/* FIXME: This tastes like wrong */
current->icon = NULL;
current->friendly_name = get_friendly_volume_info(ctx, current->volume);
current->drive_udi = g_strdup(libhal_volume_get_storage_device_udi(current->volume));
current->mountpoint = g_strdup(libhal_volume_get_mount_point(current->volume));
break;
case FORMATVOLUMETYPE_DRIVE:
current->drive = libhal_drive_from_udi(ctx, device_udis[i]);
if(!current->drive) {
g_free(current);
continue;
}
g_debug("Icon drive: %s; Icon volume: %s",
libhal_drive_get_dedicated_icon_drive(current->drive),
libhal_drive_get_dedicated_icon_volume(current->drive));
icon_path = libhal_drive_get_dedicated_icon_drive(current->drive);
current->icon = load_icon_from_cache(icon_path, icon_cache, icon_width, icon_height);
current->friendly_name = get_friendly_drive_info(current->drive);
break;
}
/* Do some last minute sanity checks */
if(!current->friendly_name) current->friendly_name = "";
device_list = g_slist_prepend(device_list, current);
}
if(device_udis)
libhal_free_string_array(device_udis);
out:
return device_list;
}
/* returns: whether the state changed */
static gboolean
poll_for_media_force (void)
{
int fd;
int got_media;
int old_media_status;
got_media = FALSE;
old_media_status = media_status;
if (is_cdrom) {
int drive;
fd = open (device_file, O_RDONLY | O_NONBLOCK | O_EXCL);
if (fd < 0 && errno == EBUSY) {
/* this means the disc is mounted or some other app,
* like a cd burner, has already opened O_EXCL */
/* HOWEVER, when starting hald, a disc may be
* mounted; so check /etc/mtab to see if it
* actually is mounted. If it is we retry to open
* without O_EXCL
*/
if (!is_mounted (device_file)) {
if (!is_locked_via_o_excl) {
is_locked_via_o_excl = TRUE;
update_proc_title ();
} else {
is_locked_via_o_excl = TRUE;
}
goto skip_check;
}
fd = open (device_file, O_RDONLY | O_NONBLOCK);
}
if (fd < 0) {
HAL_ERROR (("open failed for %s: %s", device_file, strerror (errno)));
goto skip_check;
}
if (is_locked_via_o_excl) {
is_locked_via_o_excl = FALSE;
update_proc_title ();
}
/* Check if a disc is in the drive
*
* @todo Use MMC-2 API if applicable
*/
drive = ioctl (fd, CDROM_DRIVE_STATUS, CDSL_CURRENT);
switch (drive) {
case CDS_NO_INFO:
case CDS_NO_DISC:
case CDS_TRAY_OPEN:
case CDS_DRIVE_NOT_READY:
break;
case CDS_DISC_OK:
/* some CD-ROMs report CDS_DISK_OK even with an open
* tray; if media check has the same value two times in
* a row then this seems to be the case and we must not
* report that there is a media in it. */
if (support_media_changed &&
ioctl (fd, CDROM_MEDIA_CHANGED, CDSL_CURRENT) &&
ioctl (fd, CDROM_MEDIA_CHANGED, CDSL_CURRENT)) {
} else {
got_media = TRUE;
}
break;
case -1:
HAL_ERROR (("CDROM_DRIVE_STATUS failed: %s\n", strerror(errno)));
break;
default:
break;
}
/* check if eject button was pressed */
if (got_media) {
unsigned char cdb[10] = { 0x4a, 1, 0, 0, 16, 0, 0, 0, 8, 0};
unsigned char buffer[8];
struct sg_io_hdr sg_h;
int retval;
memset(buffer, 0, sizeof(buffer));
memset(&sg_h, 0, sizeof(struct sg_io_hdr));
sg_h.interface_id = 'S';
sg_h.cmd_len = sizeof(cdb);
sg_h.dxfer_direction = SG_DXFER_FROM_DEV;
sg_h.dxfer_len = sizeof(buffer);
sg_h.dxferp = buffer;
sg_h.cmdp = cdb;
sg_h.timeout = 5000;
retval = ioctl(fd, SG_IO, &sg_h);
if (retval == 0 && sg_h.status == 0 && (buffer[4] & 0x0f) == 0x01) {
DBusError error;
/* emit signal from drive device object */
dbus_error_init (&error);
libhal_device_emit_condition (ctx, udi, "EjectPressed", "", &error);
LIBHAL_FREE_DBUS_ERROR (&error);
}
}
close (fd);
} else {
fd = open (device_file, O_RDONLY);
if (fd < 0 && errno == ENOMEDIUM) {
got_media = FALSE;
} else if (fd >= 0) {
got_media = TRUE;
close (fd);
} else {
HAL_ERROR (("open failed for %s: %s", device_file, strerror (errno)));
goto skip_check;
}
}
/* set correct state on startup, this avoid endless loops if there was a media in the device on startup */
if (media_status == MEDIA_STATUS_UNKNOWN) {
if (got_media)
media_status = MEDIA_STATUS_NO_MEDIA;
else
media_status = MEDIA_STATUS_GOT_MEDIA;
}
switch (media_status) {
case MEDIA_STATUS_GOT_MEDIA:
if (!got_media) {
DBusError error;
HAL_DEBUG (("Media removal detected on %s", device_file));
libhal_device_set_property_bool (ctx, udi, "storage.removable.media_available", FALSE, NULL);
libhal_device_set_property_string (ctx, udi, "storage.partitioning_scheme", "", NULL);
/* attempt to unmount all childs */
unmount_childs (ctx, udi);
/* could have a fs on the main block device; do a rescan to remove it */
dbus_error_init (&error);
libhal_device_rescan (ctx, udi, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
/* have to this to trigger appropriate hotplug events */
fd = open (device_file, O_RDONLY | O_NONBLOCK);
if (fd >= 0) {
ioctl (fd, BLKRRPART);
close (fd);
}
}
break;
case MEDIA_STATUS_NO_MEDIA:
if (got_media) {
DBusError error;
HAL_DEBUG (("Media insertion detected on %s", device_file));
/* our probe will trigger the appropriate hotplug events */
libhal_device_set_property_bool (
ctx, udi, "storage.removable.media_available", TRUE, NULL);
/* could have a fs on the main block device; do a rescan to add it */
dbus_error_init (&error);
libhal_device_rescan (ctx, udi, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
}
break;
case MEDIA_STATUS_UNKNOWN:
default:
break;
}
/* update our current status */
if (got_media)
media_status = MEDIA_STATUS_GOT_MEDIA;
else
media_status = MEDIA_STATUS_NO_MEDIA;
/*HAL_DEBUG (("polling %s; got media=%d", device_file, got_media));*/
skip_check:
return old_media_status != media_status;
}
/** 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;
}
/**
* main:
* @argc: Number of arguments given to program
* @argv: Arguments given to program
*
* Returns: Return code
*
* Main entry point
*/
int
main (int argc, char *argv[])
{
int ret;
DBusError error;
char buf[512];
char *nbuf;
int dmipipe[2];
int nullfd;
FILE *f;
int dmiparser_state = DMIPARSER_STATE_IGNORE;
/* on some system chassis pops up several times,
* so only take the first entry for each
*/
int dmiparser_done_bios = FALSE;
int dmiparser_done_system = FALSE;
int dmiparser_done_chassis = FALSE;
uint i;
struct stat s;
const char *path = NULL;
const char *possible_paths[] = {
"/usr/sbin/dmidecode",
"/bin/dmidecode",
"/sbin/dmidecode",
"/usr/local/sbin/dmidecode",
};
/* assume failure */
ret = 1;
setup_logger ();
dbus_error_init (&error);
udi = getenv ("UDI");
if (udi == NULL) {
HAL_ERROR (("UDI not set"));
goto out;
}
if ((ctx = libhal_ctx_init_direct (&error)) == NULL) {
HAL_ERROR (("ctx init failed"));
goto out;
}
/* find the path to dmidecode */
for (i = 0; i < sizeof (possible_paths) / sizeof (char *); i++) {
if (stat (possible_paths[i], &s) == 0 && S_ISREG (s.st_mode)) {
path = possible_paths[i];
break;
}
}
if (path == NULL) {
HAL_ERROR(("Could not find dmidecode, exit!"));
exit(1);
}
if(pipe (dmipipe) == -1) {
HAL_ERROR(("Could not create pipe (error: '%s'), exit!", strerror(errno)));
exit(1);
}
if ((f = fdopen (dmipipe[0], "r")) == NULL) {
HAL_ERROR(("Could not open file (error: '%s'), exit!", strerror(errno)));
exit(1);
}
if ((nullfd = open ("/dev/null", O_RDONLY)) == -1){
HAL_ERROR(("Could not open /dev/null (error: '%s'), exit!", strerror(errno)));
exit(1);
}
/* fork the child process */
switch (fork ()) {
case 0:
/* child */
dup2 (nullfd, STDIN_FILENO);
dup2 (dmipipe[1], STDOUT_FILENO);
close (dmipipe[0]);
close (dmipipe[1]);
/* execute the child */
execl (path, path, NULL);
/* throw an error if we ever reach this point */
HAL_ERROR (("Failed to execute dmidecode!"));
exit (1);
break;
case -1:
HAL_ERROR (("Cannot fork!"));
goto out;
}
/* parent continues from here */
/* close unused descriptor */
close (dmipipe[1]);
/* read the output of the child */
while(fgets (buf, sizeof(buf), f) != NULL)
{
int j;
unsigned int len;
unsigned int tabs = 0;
/* trim whitespace */
len = strlen (buf);
/* check that will fit in buffer */
if (len >= sizeof (buf))
continue;
/* not big enough for data, and protects us from underflow */
if (len < 3) {
dmiparser_state = DMIPARSER_STATE_IGNORE;
continue;
}
/* find out number of leading tabs */
if (buf[0] == '\t' && buf[1] == '\t')
tabs = 2; /* this is list data */
else if (buf[0] == '\t')
tabs = 1; /* this is data, 0 is section type */
if (tabs == 2)
/* we do not proccess data at depth 2 */
continue;
/* set the section type */
if (tabs == 0) {
if (!dmiparser_done_bios && strbegin (buf, "BIOS Information"))
dmiparser_state = DMIPARSER_STATE_BIOS;
else if (!dmiparser_done_system && strbegin (buf, "System Information"))
dmiparser_state = DMIPARSER_STATE_SYSTEM;
else if (!dmiparser_done_chassis && strbegin (buf, "Chassis Information"))
dmiparser_state = DMIPARSER_STATE_CHASSIS;
else if (!dmiparser_done_chassis && strbegin (buf, "Base Board Information"))
dmiparser_state = DMIPARSER_STATE_BOARD;
else
/*
* We do not match the other sections,
* or sections we have processed before
*/
dmiparser_state = DMIPARSER_STATE_IGNORE;
continue; /* next line */
}
/* we are not in a section we know, no point continueing */
if (dmiparser_state == DMIPARSER_STATE_IGNORE)
continue;
/* return success only if there was something usefull to parse */
ret = 0;
/* removes the leading tab */
nbuf = &buf[1];
/* removes the trailing spaces */
for (j = len - 2; isspace (nbuf[j]) && j >= 0; --j)
nbuf[j] = '\0';
if (dmiparser_state == DMIPARSER_STATE_BIOS) {
setstr (nbuf, "Vendor:", "system.firmware.vendor");
setstr (nbuf, "Version:", "system.firmware.version");
setstr (nbuf, "Release Date:", "system.firmware.release_date");
dmiparser_done_bios = TRUE;
} else if (dmiparser_state == DMIPARSER_STATE_SYSTEM) {
setstr (nbuf, "Manufacturer:", "system.hardware.vendor");
setstr (nbuf, "Product Name:", "system.hardware.product");
setstr (nbuf, "Version:", "system.hardware.version");
setstr (nbuf, "Serial Number:", "system.hardware.serial");
setstr (nbuf, "UUID:", "system.hardware.uuid");
dmiparser_done_system = TRUE;
} else if (dmiparser_state == DMIPARSER_STATE_CHASSIS) {
setstr (nbuf, "Manufacturer:", "system.chassis.manufacturer");
setstr (nbuf, "Type:", "system.chassis.type");
dmiparser_done_chassis = TRUE;
} else if (dmiparser_state == DMIPARSER_STATE_BOARD) {
setstr (nbuf, "Manufacturer:", "system.board.vendor");
setstr (nbuf, "Product Name:", "system.board.product");
setstr (nbuf, "Version:", "system.board.version");
setstr (nbuf, "Serial Number:", "system.board.serial");
dmiparser_done_system = TRUE;
}
}
/* as read to EOF, close */
fclose (f);
out:
LIBHAL_FREE_DBUS_ERROR (&error);
/* free ctx */
if (ctx != NULL) {
libhal_ctx_shutdown (ctx, &error);
LIBHAL_FREE_DBUS_ERROR (&error);
libhal_ctx_free (ctx);
}
return ret;
}
