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; }