8658f5d923
Add support for HAL-based hotplugging, in which we just get the list of input devices and properties from HAL. Requires an FDI which is not yet in mainline HAL.
370 lines
10 KiB
C
370 lines
10 KiB
C
/*
|
|
* Copyright © 2006-2007 Daniel Stone
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation, and that the name of the copyright holders and/or authors
|
|
* not be used in advertising or publicity pertaining to distribution of the
|
|
* software without specific, written prior permission. The copyright holders
|
|
* and/or authors make no representations about the suitability of this
|
|
* software for any purpose. It is provided "as is" without express or
|
|
* implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS AND/OR AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD
|
|
* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND/OR AUTHORS BE LIABLE
|
|
* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
|
|
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
|
|
* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#endif
|
|
|
|
#include <dbus/dbus.h>
|
|
#include <hal/libhal.h>
|
|
#include <string.h>
|
|
#include <sys/select.h>
|
|
|
|
#include "input.h"
|
|
#include "inputstr.h"
|
|
#include "hotplug.h"
|
|
#include "config-backends.h"
|
|
#include "os.h"
|
|
|
|
#define TYPE_NONE 0
|
|
#define TYPE_KEYS 1
|
|
#define TYPE_POINTER 2
|
|
|
|
struct config_hal_info {
|
|
DBusConnection *system_bus;
|
|
LibHalContext *hal_ctx;
|
|
};
|
|
|
|
static void
|
|
remove_device(DeviceIntPtr dev)
|
|
{
|
|
DebugF("[config/hal] removing device %s\n", dev->name);
|
|
|
|
/* Call PIE here so we don't try to dereference a device that's
|
|
* already been removed. */
|
|
OsBlockSignals();
|
|
ProcessInputEvents();
|
|
DeleteInputDeviceRequest(dev);
|
|
OsReleaseSignals();
|
|
}
|
|
|
|
static void
|
|
device_removed(LibHalContext *ctx, const char *udi)
|
|
{
|
|
DeviceIntPtr dev;
|
|
char *value;
|
|
|
|
value = xalloc(strlen(udi) + 5); /* "hal:" + NULL */
|
|
if (!value)
|
|
return;
|
|
sprintf(value, "hal:%s", udi);
|
|
|
|
for (dev = inputInfo.devices; dev; dev = dev->next) {
|
|
if (dev->config_info && strcmp(dev->config_info, value) == 0)
|
|
remove_device(dev);
|
|
}
|
|
for (dev = inputInfo.off_devices; dev; dev = dev->next) {
|
|
if (dev->config_info && strcmp(dev->config_info, value) == 0)
|
|
remove_device(dev);
|
|
}
|
|
|
|
xfree(value);
|
|
}
|
|
|
|
static void
|
|
add_option(InputOption **options, const char *key, const char *value)
|
|
{
|
|
if (!value || *value == '\0')
|
|
return;
|
|
|
|
for (; *options; options = &(*options)->next)
|
|
;
|
|
*options = xcalloc(sizeof(**options), 1);
|
|
(*options)->key = xstrdup(key);
|
|
(*options)->value = xstrdup(value);
|
|
(*options)->next = NULL;
|
|
}
|
|
|
|
static char *
|
|
get_prop_string(LibHalContext *hal_ctx, const char *udi, const char *name,
|
|
DBusError *error)
|
|
{
|
|
char *prop, *ret;
|
|
|
|
prop = libhal_device_get_property_string(hal_ctx, udi, name, error);
|
|
DebugF(" [config/hal] getting %s on %s returned %s\n", name, udi, prop);
|
|
if (prop) {
|
|
ret = xstrdup(prop);
|
|
libhal_free_string(prop);
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static char *
|
|
get_prop_string_array(LibHalContext *hal_ctx, const char *udi, const char *prop,
|
|
DBusError *error)
|
|
{
|
|
char **props, *ret, *str;
|
|
int i, len = 0;
|
|
|
|
props = libhal_device_get_property_strlist(hal_ctx, udi, prop, error);
|
|
if (props) {
|
|
for (i = 0; props[i]; i++)
|
|
len += strlen(props[i]);
|
|
|
|
ret = xcalloc(sizeof(char), len + i); /* i - 1 commas, 1 NULL */
|
|
if (!ret) {
|
|
libhal_free_string_array(props);
|
|
return NULL;
|
|
}
|
|
|
|
str = ret;
|
|
for (i = 0; props[i]; i++) {
|
|
str = strcpy(str, props[i]);
|
|
*str++ = ',';
|
|
}
|
|
*str = '\0';
|
|
|
|
libhal_free_string_array(props);
|
|
}
|
|
else {
|
|
return NULL;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
device_added(LibHalContext *hal_ctx, const char *udi)
|
|
{
|
|
char **props;
|
|
char *path = NULL, *driver = NULL, *name = NULL, *xkb_rules = NULL;
|
|
char *xkb_model = NULL, *xkb_layout = NULL, *xkb_variant = NULL;
|
|
char *xkb_options = NULL, *config_info = NULL;
|
|
InputOption *options = NULL;
|
|
DeviceIntPtr dev;
|
|
DBusError error;
|
|
int type = TYPE_NONE;
|
|
int i;
|
|
|
|
dbus_error_init(&error);
|
|
|
|
props = libhal_device_get_property_strlist(hal_ctx, udi,
|
|
"info.capabilities", &error);
|
|
if (!props) {
|
|
DebugF("[config/hal] couldn't get capabilities for %s: %s (%s)\n",
|
|
udi, error.name, error.message);
|
|
goto out_error;
|
|
}
|
|
for (i = 0; props[i]; i++) {
|
|
/* input.keys is the new, of which input.keyboard is a subset, but
|
|
* input.keyboard is the old 'we have keys', so we have to keep it
|
|
* around. */
|
|
if (strcmp(props[i], "input.keys") == 0 ||
|
|
strcmp(props[i], "input.keyboard") == 0)
|
|
type |= TYPE_KEYS;
|
|
if (strcmp(props[i], "input.mouse") == 0)
|
|
type |= TYPE_POINTER;
|
|
}
|
|
libhal_free_string_array(props);
|
|
|
|
if (type == TYPE_NONE)
|
|
goto out_error;
|
|
|
|
driver = get_prop_string(hal_ctx, udi, "input.x11_driver", &error);
|
|
path = get_prop_string(hal_ctx, udi, "input.device", &error);
|
|
if (!driver || !path) {
|
|
DebugF("[config/hal] no driver or path specified for %s\n", udi);
|
|
goto unwind;
|
|
}
|
|
name = get_prop_string(hal_ctx, udi, "info.product", &error);
|
|
if (!name)
|
|
name = xstrdup("(unnamed)");
|
|
|
|
if (type & TYPE_KEYS) {
|
|
xkb_rules = get_prop_string(hal_ctx, udi, "input.xkb_rules", &error);
|
|
xkb_model = get_prop_string(hal_ctx, udi, "input.xkb_model", &error);
|
|
xkb_layout = get_prop_string(hal_ctx, udi, "input.xkb_layout", &error);
|
|
xkb_variant = get_prop_string(hal_ctx, udi, "input.xkb_variant",
|
|
&error);
|
|
xkb_options = get_prop_string_array(hal_ctx, udi, "input.xkb_options",
|
|
&error);
|
|
}
|
|
|
|
options = xcalloc(sizeof(*options), 1);
|
|
options->key = xstrdup("_source");
|
|
options->value = xstrdup("server/hal");
|
|
if (!options->key || !options->value) {
|
|
ErrorF("[config] couldn't allocate first key/value pair\n");
|
|
goto unwind;
|
|
}
|
|
|
|
add_option(&options, "path", path);
|
|
add_option(&options, "driver", driver);
|
|
add_option(&options, "name", name);
|
|
config_info = xalloc(strlen(udi) + 5); /* "hal:" and NULL */
|
|
if (!config_info)
|
|
goto unwind;
|
|
sprintf(config_info, "hal:%s", udi);
|
|
|
|
if (xkb_model)
|
|
add_option(&options, "xkb_model", xkb_model);
|
|
if (xkb_layout)
|
|
add_option(&options, "xkb_layout", xkb_layout);
|
|
if (xkb_variant)
|
|
add_option(&options, "xkb_variant", xkb_variant);
|
|
if (xkb_options)
|
|
add_option(&options, "xkb_options", xkb_options);
|
|
|
|
if (NewInputDeviceRequest(options, &dev) != Success) {
|
|
DebugF("[config/hal] NewInputDeviceRequest failed\n");
|
|
goto unwind;
|
|
}
|
|
|
|
for (; dev; dev = dev->next)
|
|
dev->config_info = xstrdup(config_info);
|
|
|
|
unwind:
|
|
if (path)
|
|
xfree(path);
|
|
if (driver)
|
|
xfree(driver);
|
|
if (name)
|
|
xfree(name);
|
|
if (xkb_rules)
|
|
xfree(xkb_rules);
|
|
if (xkb_model)
|
|
xfree(xkb_model);
|
|
if (xkb_layout)
|
|
xfree(xkb_layout);
|
|
if (xkb_options)
|
|
xfree(xkb_options);
|
|
if (config_info)
|
|
xfree(config_info);
|
|
|
|
out_error:
|
|
dbus_error_free(&error);
|
|
|
|
return;
|
|
}
|
|
|
|
static void
|
|
disconnect_hook(void *data)
|
|
{
|
|
DBusError error;
|
|
struct config_hal_info *info = data;
|
|
|
|
if (info->hal_ctx) {
|
|
dbus_error_init(&error);
|
|
if (!libhal_ctx_shutdown(info->hal_ctx, &error))
|
|
DebugF("[config/hal] couldn't shut down context?\n");
|
|
libhal_ctx_free(info->hal_ctx);
|
|
dbus_error_free(&error);
|
|
}
|
|
|
|
info->hal_ctx = NULL;
|
|
info->system_bus = NULL;
|
|
}
|
|
|
|
static void
|
|
connect_hook(DBusConnection *connection, void *data)
|
|
{
|
|
DBusError error;
|
|
struct config_hal_info *info = data;
|
|
char **devices;
|
|
int num_devices, i;
|
|
|
|
info->system_bus = connection;
|
|
|
|
dbus_error_init(&error);
|
|
|
|
if (!info->hal_ctx)
|
|
info->hal_ctx = libhal_ctx_new();
|
|
if (!info->hal_ctx) {
|
|
ErrorF("[config/hal] couldn't create HAL context\n");
|
|
goto out_err;
|
|
}
|
|
|
|
if (!libhal_ctx_set_dbus_connection(info->hal_ctx, info->system_bus)) {
|
|
ErrorF("[config/hal] couldn't associate HAL context with bus\n");
|
|
goto out_ctx;
|
|
}
|
|
if (!libhal_ctx_init(info->hal_ctx, &error)) {
|
|
ErrorF("[config/hal] couldn't initialise context: %s (%s)\n",
|
|
error.name, error.message);
|
|
goto out_ctx;
|
|
}
|
|
if (!libhal_device_property_watch_all(info->hal_ctx, &error)) {
|
|
ErrorF("[config/hal] couldn't watch all properties: %s (%s)\n",
|
|
error.name, error.message);
|
|
goto out_ctx2;
|
|
}
|
|
libhal_ctx_set_device_added(info->hal_ctx, device_added);
|
|
libhal_ctx_set_device_removed(info->hal_ctx, device_removed);
|
|
|
|
devices = libhal_find_device_by_capability(info->hal_ctx, "input",
|
|
&num_devices, &error);
|
|
for (i = 0; i < num_devices; i++)
|
|
device_added(info->hal_ctx, devices[i]);
|
|
libhal_free_string_array(devices);
|
|
|
|
dbus_error_free(&error);
|
|
|
|
return;
|
|
|
|
out_ctx2:
|
|
if (!libhal_ctx_shutdown(info->hal_ctx, &error))
|
|
DebugF("[config/hal] couldn't shut down context?\n");
|
|
out_ctx:
|
|
libhal_ctx_free(info->hal_ctx);
|
|
out_err:
|
|
dbus_error_free(&error);
|
|
|
|
info->hal_ctx = NULL;
|
|
info->system_bus = NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
static struct config_hal_info hal_info;
|
|
static struct config_dbus_core_hook hook = {
|
|
.connect = connect_hook,
|
|
.disconnect = disconnect_hook,
|
|
.data = &hal_info,
|
|
};
|
|
|
|
int
|
|
config_hal_init(void)
|
|
{
|
|
memset(&hal_info, 0, sizeof(hal_info));
|
|
hal_info.system_bus = NULL;
|
|
hal_info.hal_ctx = NULL;
|
|
|
|
if (!config_dbus_core_add_hook(&hook)) {
|
|
ErrorF("[config/hal] failed to add D-Bus hook\n");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void
|
|
config_hal_fini(void)
|
|
{
|
|
config_dbus_core_remove_hook(&hook);
|
|
}
|