static gboolean hal_backend_set_artwork_formats (ItdbBackend *itdb_backend, enum ArtworkType type, const GList *formats) { HalBackend *backend = (HalBackend *)itdb_backend; const GList *it; hal_backend_set_artwork_type_supported (itdb_backend, type, (formats != NULL)); for (it = formats; it != NULL; it = it->next) { char *format_str; format_str = get_format_string (it->data, type); libhal_device_property_strlist_append (backend->ctx, backend->udi, LIBGPOD_HAL_NS"ipod.images.formats", format_str, NULL); g_free (format_str); } return TRUE; }
int add_network_printer(LibHalContext *ctx, char *base, char *hostaddr, char *device, char *community) { DBusError error; int rc = -1; char udi[128]; char *tmp_udi = NULL; static char *parent = NULL; char *manufacturer = NULL, *model = NULL, *description = NULL, *uri = NULL, *sn, *serial; sn = serial = pseudo_serialno_from_addr(hostaddr); if (parent == NULL) parent = getenv("UDI"); dbus_error_init(&error); network_device_name_to_udi(udi, sizeof (udi), base, serial, NULL); if (libhal_device_exists(ctx, udi, &error) == TRUE) goto out; if ((tmp_udi = libhal_new_device(ctx, &error)) == NULL) goto out; snmp_printer_info(hostaddr, community, &manufacturer, &model, &description, &serial, NULL, &uri); libhal_device_set_property_string(ctx, tmp_udi, "info.parent", parent, &error); libhal_device_set_property_string(ctx, tmp_udi, "info.category", "printer", &error); libhal_device_property_strlist_append(ctx, tmp_udi, "info.capabilities", "printer", &error); libhal_device_property_strlist_append(ctx, tmp_udi, "info.capabilities", "network_device", &error); libhal_device_set_property_string(ctx, tmp_udi, "network_device.address", hostaddr, &error); if ((community != NULL) && (strcasecmp(community, "public") != 0)) libhal_device_set_property_string(ctx, tmp_udi, "network_device.snmp_community", community, &error); if ((uri != NULL) || (device != NULL)) libhal_device_set_property_string(ctx, tmp_udi, "printer.device", (uri ? uri : device), &error); if (serial != NULL) libhal_device_set_property_string(ctx, tmp_udi, "printer.serial", serial, &error); if (manufacturer != NULL) libhal_device_set_property_string(ctx, tmp_udi, "printer.vendor", manufacturer, &error); if (model != NULL) libhal_device_set_property_string(ctx, tmp_udi, "printer.product", model, &error); if (description != NULL) libhal_device_set_property_string(ctx, tmp_udi, "printer.description", description, &error); /* commit the changes to the new UDI */ rc = libhal_device_commit_to_gdl(ctx, tmp_udi, udi, &error); out: HAL_DEBUG(("result: %s (%s): %s, %s, %s, %s, %s", hostaddr, udi, NP(manufacturer), NP(model), NP(description), NP(serial), NP(uri))); if (tmp_udi != NULL) free(tmp_udi); if (manufacturer != NULL) free(manufacturer); if (model != NULL) free(model); if (description != NULL) free(description); if (uri != NULL) free(uri); if (sn != NULL) free(sn); if (dbus_error_is_set(&error)) { HAL_WARNING(("%s: %s", error.name, error.message)); dbus_error_free(&error); } HAL_DEBUG(("add: %s (%s)", hostaddr, udi)); return (rc); }
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; }
/** * 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; }
int main (int argc, char **argv) { char *device_file; int fd = -1; int report_id; report_desc_t report_desc; struct hid_data *data; hid_item_t item; boolean is_keyboard = FALSE; boolean is_keypad = FALSE; boolean is_mouse = FALSE; boolean is_joystick = FALSE; if (! hfp_init(argc, argv)) goto end; device_file = getenv("HAL_PROP_HIDDEV_DEVICE"); if (! device_file) goto end; fd = open(device_file, O_RDONLY); if (fd < 0) goto end; /* give a meaningful process title for ps(1) */ setproctitle("%s", device_file); #ifdef HAVE_LIBUSB20 report_id = hid_get_report_id(fd); if (report_id == -1) #else if (ioctl(fd, USB_GET_REPORT_ID, &report_id) < 0) #endif goto end; hid_init(NULL); report_desc = hid_get_report_desc(fd); if (! report_desc) goto end; for (data = hid_start_parse(report_desc, ~0, report_id); hid_get_item(data, &item);) if (item.kind == hid_collection) { if (item.collection == HID_COLLECTION_APPLICATION) { const char *page; char *full_page; int i; page = hid_usage_page(HID_PAGE(item.usage)); full_page = hfp_strdup_printf("%s Page", page); for (i = 0; full_page[i] != 0; i++) if (full_page[i] == '_') full_page[i] = ' '; libhal_device_property_strlist_append(hfp_ctx, hfp_udi, "hiddev.application_pages", full_page, &hfp_error); hfp_free(full_page); } switch (item.usage) { case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE): is_mouse = TRUE; break; case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_JOYSTICK): case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_GAME_PAD): is_joystick = TRUE; break; case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD): is_keyboard = TRUE; break; case HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYPAD): is_keypad = TRUE; break; } } hid_end_parse(data); hid_dispose_report_desc(report_desc); if (is_keyboard || is_mouse || is_joystick || is_keypad) { libhal_device_add_capability(hfp_ctx, hfp_udi, "input", &hfp_error); libhal_device_set_property_string(hfp_ctx, hfp_udi, "info.category", "input", &hfp_error); libhal_device_set_property_string(hfp_ctx, hfp_udi, "input.device", device_file, &hfp_error); } if (is_keyboard) libhal_device_add_capability(hfp_ctx, hfp_udi, "input.keyboard", &hfp_error); if (is_keypad) libhal_device_add_capability(hfp_ctx, hfp_udi, "input.keypad", &hfp_error); if (is_keyboard || is_keypad) libhal_device_add_capability(hfp_ctx, hfp_udi, "input.keys", &hfp_error); if (is_mouse) libhal_device_add_capability(hfp_ctx, hfp_udi, "input.mouse", &hfp_error); if (is_joystick) libhal_device_add_capability(hfp_ctx, hfp_udi, "input.joystick", &hfp_error); end: return 0; }