static void print_record(struct udev_device *device) {
const char *str;
int i;
struct udev_list_entry *list_entry;
printf("P: %s\n", udev_device_get_devpath(device));
str = udev_device_get_devnode(device);
if (str != NULL)
printf("N: %s\n", str + STRLEN("/dev/"));
i = udev_device_get_devlink_priority(device);
if (i != 0)
printf("L: %i\n", i);
udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(device))
printf("S: %s\n",
udev_list_entry_get_name(list_entry) + STRLEN("/dev/"));
udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
printf("E: %s=%s\n",
udev_list_entry_get_name(list_entry),
udev_list_entry_get_value(list_entry));
printf("\n");
}
static void make_device_msg(DBusMessageIter *dict, struct udev_device *device)
{
const char *key, *str;
struct udev_list_entry *list_entry;
mylog_trace("start %s", __func__);
mylog_trace("%s add action", __func__);
str = udev_device_get_action(device);
if (str != NULL)
mydbus_dict_append_entry(dict, "action", DBUS_TYPE_STRING, &str);
mylog_trace("%s add subsystem", __func__);
str = udev_device_get_subsystem(device);
if (str != NULL)
mydbus_dict_append_entry(dict, "subsystem", DBUS_TYPE_STRING, &str);
mylog_trace("%s add properties", __func__);
udev_list_entry_foreach(list_entry,
udev_device_get_properties_list_entry(device))
{
key = udev_list_entry_get_name(list_entry);
str = udev_list_entry_get_value(list_entry);
mydbus_dict_append_entry(dict,
key,
DBUS_TYPE_STRING,
&str);
}
/**
* gnome_pnp_ids_get_pnp_id:
* @pnp_ids: a #GnomePnpIds object
* @pnp_id: the PNP ID to look for
*
* Find the full manufacturer name for the given PNP ID.
*
* Returns: (transfer full): a new string representing the manufacturer name,
* or %NULL when not found.
*/
gchar *
gnome_pnp_ids_get_pnp_id (GnomePnpIds *pnp_ids, const gchar *pnp_id)
{
#ifdef HAVE_UDEV
GnomePnpIdsPrivate *priv = pnp_ids->priv;
struct udev_list_entry *list_entry, *l;
char *modalias;
char *ret = NULL;
modalias = g_strdup_printf ("acpi:%s:", pnp_id);
list_entry = udev_hwdb_get_properties_list_entry(priv->hwdb, modalias, 0);
g_free (modalias);
if (list_entry == NULL)
return ret;
/* Try to get the model specific string */
l = udev_list_entry_get_by_name (list_entry, "ID_MODEL_FROM_DATABASE");
if (l == NULL)
l = udev_list_entry_get_by_name (list_entry, "ID_VENDOR_FROM_DATABASE");
if (l == NULL)
return ret;
ret = g_strdup (udev_list_entry_get_value (l));
return ret;
#else
return g_strdup ("Undefined");
#endif
}
char *batocomp(const bdaddr_t *ba)
{
struct udev *udev;
struct udev_hwdb *hwdb;
struct udev_list_entry *head, *entry;
char modalias[11], *comp = NULL;
sprintf(modalias, "OUI:%2.2X%2.2X%2.2X", ba->b[5], ba->b[4], ba->b[3]);
udev = udev_new();
if (!udev)
return NULL;
hwdb = udev_hwdb_new(udev);
if (!hwdb)
goto done;
head = udev_hwdb_get_properties_list_entry(hwdb, modalias, 0);
udev_list_entry_foreach(entry, head) {
const char *name = udev_list_entry_get_name(entry);
if (name && !strcmp(name, "ID_OUI_FROM_DATABASE")) {
comp = strdup(udev_list_entry_get_value(entry));
break;
}
}
hwdb = udev_hwdb_unref(hwdb);
done:
udev = udev_unref(udev);
return comp;
}
int udev_builtin_hwdb_lookup(struct udev_device *dev,
const char *prefix, const char *modalias,
const char *filter, bool test) {
struct udev_list_entry *list;
struct udev_list_entry *entry;
int n = 0;
if (!hwdb)
return -ENOENT;
if (prefix) {
_cleanup_free_ const char *lookup;
lookup = strjoin(prefix, modalias, NULL);
if (!lookup)
return -ENOMEM;
list = udev_hwdb_get_properties_list_entry(hwdb, lookup, 0);
} else
list = udev_hwdb_get_properties_list_entry(hwdb, modalias, 0);
udev_list_entry_foreach(entry, list) {
if (filter && fnmatch(filter, udev_list_entry_get_name(entry), FNM_NOESCAPE) != 0)
continue;
if (udev_builtin_add_property(dev, test,
udev_list_entry_get_name(entry),
udev_list_entry_get_value(entry)) < 0)
return -ENOMEM;
n++;
}
return n;
}
static int list_entry2table(lua_State *L, UdevListEntry *list) {
UdevListEntry *entry;
lua_newtable(L);
udev_list_entry_foreach(entry, list) {
lua_pushstring(L, lowerCase(L, udev_list_entry_get_name(entry)));
lua_pushstring(L, udev_list_entry_get_value(entry));
lua_settable(L, -3);
}
static const char *hwdb_get(const char *modalias, const char *key)
{
struct udev_list_entry *entry;
udev_list_entry_foreach(entry, udev_hwdb_get_properties_list_entry(hwdb, modalias, 0))
if (strcmp(udev_list_entry_get_name(entry), key) == 0)
return udev_list_entry_get_value(entry);
return NULL;
}
/**
* Search all Joystick devices
*/
gboolean search_devices(GList **list_controllers) {
int i;
Controller_info *ctrl_info;
struct udev *udev;
struct udev_device *dev;
for(i = 0; i < 32; ++i) {
gchar *str = NULL;
str = g_strdup_printf("/dev/input/js%d", i);
int fd = open(str, O_RDONLY);
if (fd < 0) {
//printf("Could not found joystick: %s\n", str->str);
break;
} else {
ctrl_info = g_malloc(sizeof(Controller_info));
uint8_t num_axis = 0;
uint8_t num_button = 0;
ioctl(fd, JSIOCGAXES, &num_axis);
ioctl(fd, JSIOCGBUTTONS, &num_button);
ctrl_info->filename = g_strdup(str);
ctrl_info->num_axis = num_axis;
ctrl_info->num_buttons = num_button;
// Get Name
char name_c_str[1024];
if (ioctl(fd, JSIOCGNAME(sizeof(name_c_str)), name_c_str) < 0) {
printf("%s : %s", str, strerror(errno));
break;
} else {
ctrl_info->name = g_convert_with_fallback(name_c_str, sizeof(name_c_str), "UTF-8", "ISO-8859-1", NULL, NULL, NULL, NULL);
}
/* Create the udev object */
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
exit(0);
}
dev = udev_device_new_from_subsystem_sysname(udev, "input", g_strdup_printf("js%d", i));
if (dev == NULL)
break;
ctrl_info->serial = uint32_atoi(g_strdup_printf("%s%s", udev_list_entry_get_value(udev_list_entry_get_by_name(udev_device_get_properties_list_entry(dev), "ID_VENDOR_ID")), udev_list_entry_get_value(udev_list_entry_get_by_name(udev_device_get_properties_list_entry(dev), "ID_MODEL_ID"))));
udev_device_unref(dev);
udev_unref(udev);
printf("%s : %d, %d, 0x%08x\n", ctrl_info->name, ctrl_info->num_axis, ctrl_info->num_buttons, ctrl_info->serial);
}
*list_controllers = g_list_append(*list_controllers, ctrl_info);
close(fd);
}
return TRUE;
}
static const char *
get_udev_property(struct udev_device *device, const char *name)
{
struct udev_list_entry *entry;
udev_list_entry_foreach (entry,
udev_device_get_properties_list_entry (device))
{
if (strcmp (udev_list_entry_get_name (entry), name) == 0)
return udev_list_entry_get_value (entry);
}
return NULL;
}
int main ()
{
udev = udev_new();
if(!udev) {
fprintf(stderr, "Can't create udev.\n");
exit(EXIT_FAILURE);
}
mon = udev_monitor_new_from_netlink(udev, "udev");
udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL);
udev_monitor_enable_receiving(mon);
while(1)
{
if (mon != NULL)
FD_SET(udev_monitor_get_fd(mon), &readfds);
select(udev_monitor_get_fd(mon) + 1, &readfds, NULL, NULL, NULL);
if ((mon != NULL) && FD_ISSET(udev_monitor_get_fd(mon), &readfds))
{
dev = udev_monitor_receive_device(mon);
if(dev) {
device = (char *) udev_device_get_sysname(dev);
}
}
devnum = udev_device_get_devnum(dev);
major = major(devnum);
minor = minor(devnum);
action = udev_device_get_action(dev);
printf("Processing device %s %d:%d\n", action, major, minor);
struct udev_list_entry * props = udev_device_get_properties_list_entry(dev);
while(props != NULL)
{
printf("%s = %s\n", udev_list_entry_get_name(props), udev_list_entry_get_value(props));
props = udev_list_entry_get_next (props);
}
props = udev_device_get_sysattr_list_entry(dev);
while(props != NULL)
{
printf("%s = %s\n", udev_list_entry_get_name(props), udev_device_get_sysattr_value(dev, udev_list_entry_get_name(props)));
props = udev_list_entry_get_next (props);
}
}
return 0;
}
static void print_device(struct udev_device *device, const char *source, int prop) {
struct timespec ts;
assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);
printf("%-6s[%"PRI_TIME".%06"PRI_NSEC"] %-8s %s (%s)\n",
source,
ts.tv_sec, (nsec_t)ts.tv_nsec/1000,
udev_device_get_action(device),
udev_device_get_devpath(device),
udev_device_get_subsystem(device));
if (prop) {
struct udev_list_entry *list_entry;
udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
printf("%s=%s\n",
udev_list_entry_get_name(list_entry),
udev_list_entry_get_value(list_entry));
printf("\n");
}
}
static void print_device(struct udev_device *device, const char *source, int prop)
{
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
printf("%-6s[%llu.%06u] %-8s %s (%s)\n",
source,
(unsigned long long) ts.tv_sec, (unsigned int) ts.tv_nsec/1000,
udev_device_get_action(device),
udev_device_get_devpath(device),
udev_device_get_subsystem(device));
if (prop) {
struct udev_list_entry *list_entry;
udev_list_entry_foreach(list_entry, udev_device_get_properties_list_entry(device))
printf("%s=%s\n",
udev_list_entry_get_name(list_entry),
udev_list_entry_get_value(list_entry));
printf("\n");
}
}
void
UdevSubsystem::print_info(udev_device* device)
{
log_debug("/---------------------------------------------");
log_debug("devpath: " << udev_device_get_devpath(device));
if (udev_device_get_action(device))
log_debug("action: " << udev_device_get_action(device));
//log_debug("init: " << udev_device_get_is_initialized(device));
if (udev_device_get_subsystem(device))
log_debug("subsystem: " << udev_device_get_subsystem(device));
if (udev_device_get_devtype(device))
log_debug("devtype: " << udev_device_get_devtype(device));
if (udev_device_get_syspath(device))
log_debug("syspath: " << udev_device_get_syspath(device));
if (udev_device_get_sysname(device))
log_debug("sysname: " << udev_device_get_sysname(device));
if (udev_device_get_sysnum(device))
log_debug("sysnum: " << udev_device_get_sysnum(device));
if (udev_device_get_devnode(device))
log_debug("devnode: " << udev_device_get_devnode(device));
if (udev_device_get_driver(device))
log_debug("driver: " << udev_device_get_driver(device));
if (udev_device_get_action(device))
log_debug("action: " << udev_device_get_action(device));
//udev_device_get_sysattr_value(device, "busnum");
//udev_device_get_sysattr_value(device, "devnum");
#if 0
// FIXME: only works with newer versions of libudev
{
log_debug("list: ");
struct udev_list_entry* it = udev_device_get_tags_list_entry(device);
while((it = udev_list_entry_get_next(it)) != 0)
{
log_debug(" "
<< udev_list_entry_get_name(it) << " = "
<< udev_list_entry_get_value(it)
);
}
}
{
log_debug("properties: ");
struct udev_list_entry* it = udev_device_get_properties_list_entry(device);
while((it = udev_list_entry_get_next(it)) != 0)
{
log_debug(" "
<< udev_list_entry_get_name(it) << " = "
<< udev_list_entry_get_value(it)
);
}
}
{
log_debug("devlist: ");
struct udev_list_entry* it = udev_device_get_tags_list_entry(device);
while((it = udev_list_entry_get_next(it)) != 0)
{
log_debug(" "
<< udev_list_entry_get_name(it) << " = "
<< udev_list_entry_get_value(it)
);
}
}
#endif
log_debug("\\----------------------------------------------");
}
static int node_permissions_apply(struct udev_device *dev, bool apply,
mode_t mode, uid_t uid, gid_t gid,
struct udev_list *seclabel_list) {
const char *devnode = udev_device_get_devnode(dev);
dev_t devnum = udev_device_get_devnum(dev);
struct stat stats;
struct udev_list_entry *entry;
int err = 0;
if (streq(udev_device_get_subsystem(dev), "block"))
mode |= S_IFBLK;
else
mode |= S_IFCHR;
if (lstat(devnode, &stats) != 0) {
err = -errno;
log_debug_errno(errno, "can not stat() node '%s' (%m)", devnode);
goto out;
}
if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) {
err = -EEXIST;
log_debug("found node '%s' with non-matching devnum %s, skip handling",
udev_device_get_devnode(dev), udev_device_get_id_filename(dev));
goto out;
}
if (apply) {
bool selinux = false;
bool smack = false;
if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {
log_debug("set permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
err = chmod(devnode, mode);
if (err < 0)
log_warning_errno(errno, "setting mode of %s to %#o failed: %m", devnode, mode);
err = chown(devnode, uid, gid);
if (err < 0)
log_warning_errno(errno, "setting owner of %s to uid=%u, gid=%u failed: %m", devnode, uid, gid);
} else {
log_debug("preserve permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);
}
/* apply SECLABEL{$module}=$label */
udev_list_entry_foreach(entry, udev_list_get_entry(seclabel_list)) {
const char *name, *label;
int r;
name = udev_list_entry_get_name(entry);
label = udev_list_entry_get_value(entry);
if (streq(name, "selinux")) {
selinux = true;
r = mac_selinux_apply(devnode, label);
if (r < 0)
log_error_errno(r, "SECLABEL: failed to set SELinux label '%s': %m", label);
else
log_debug("SECLABEL: set SELinux label '%s'", label);
} else if (streq(name, "smack")) {
smack = true;
r = mac_smack_apply(devnode, label);
if (r < 0)
log_error_errno(r, "SECLABEL: failed to set SMACK label '%s': %m", label);
else
log_debug("SECLABEL: set SMACK label '%s'", label);
} else
log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);
}
/* set the defaults */
if (!selinux)
mac_selinux_fix(devnode, true, false);
if (!smack)
mac_smack_apply(devnode, NULL);
}
/* always update timestamp when we re-use the node, like on media change events */
utimensat(AT_FDCWD, devnode, NULL, 0);
out:
return err;
}
static int builtin_keyboard(struct udev_device *dev, int argc, char *argv[], bool test) {
struct udev_list_entry *entry;
struct {
unsigned int scan;
unsigned int key;
} map[1024];
unsigned int map_count = 0;
unsigned int release[1024];
unsigned int release_count = 0;
udev_list_entry_foreach(entry, udev_device_get_properties_list_entry(dev)) {
const char *key;
unsigned int scancode;
char *endptr;
const char *keycode;
const struct key *k;
key = udev_list_entry_get_name(entry);
if (!startswith(key, "KEYBOARD_KEY_"))
continue;
/* KEYBOARD_KEY_<hex scan code>=<key identifier string> */
scancode = strtoul(key + 13, &endptr, 16);
if (endptr[0] != '\0') {
log_error("Error, unable to parse scan code from '%s'", key);
continue;
}
keycode = udev_list_entry_get_value(entry);
/* a leading '!' needs a force-release entry */
if (keycode[0] == '!') {
keycode++;
release[release_count] = scancode;
if (release_count < ELEMENTSOF(release)-1)
release_count++;
if (keycode[0] == '\0')
continue;
}
/* translate identifier to key code */
k = keyboard_lookup_key(keycode, strlen(keycode));
if (!k) {
log_error("Error, unknown key identifier '%s'", keycode);
continue;
}
map[map_count].scan = scancode;
map[map_count].key = k->id;
if (map_count < ELEMENTSOF(map)-1)
map_count++;
}
if (map_count > 0 || release_count > 0) {
const char *node;
int fd;
unsigned int i;
node = udev_device_get_devnode(dev);
if (!node) {
log_error("Error, no device node for '%s'", udev_device_get_syspath(dev));
return EXIT_FAILURE;
}
fd = open(udev_device_get_devnode(dev), O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);
if (fd < 0) {
log_error("Error, opening device '%s': %m", node);
return EXIT_FAILURE;
}
/* install list of map codes */
for (i = 0; i < map_count; i++) {
log_debug("keyboard: mapping scan code %d (0x%x) to key code %d (0x%x)",
map[i].scan, map[i].scan, map[i].key, map[i].key);
if (ioctl(fd, EVIOCSKEYCODE, &map[i]) < 0)
log_error("Error calling EVIOCSKEYCODE on device node '%s' (scan code 0x%x, key code %d): %m", node, map[i].scan, map[i].key);
}
/* install list of force-release codes */
if (release_count > 0)
install_force_release(dev, release, release_count);
close(fd);
}
return EXIT_SUCCESS;
}
static void
udev_monitor_watcher (struct udev_monitor *udev_monitor,
NihIoWatch * watch,
NihIoEvents events)
{
struct udev_device * udev_device;
nih_local char * subsystem = NULL;
nih_local char * action = NULL;
nih_local char * kernel = NULL;
nih_local char * devpath = NULL;
nih_local char * devname = NULL;
nih_local char * name = NULL;
nih_local char ** env = NULL;
const char * value = NULL;
size_t env_len = 0;
DBusPendingCall * pending_call;
char *(*copy_string)(const void *, const char *) = NULL;
udev_device = udev_monitor_receive_device (udev_monitor);
if (! udev_device)
return;
copy_string = no_strip_udev_data ? nih_strdup : make_safe_string;
value = udev_device_get_subsystem (udev_device);
subsystem = value ? copy_string (NULL, value) : NULL;
value = udev_device_get_action (udev_device);
action = value ? copy_string (NULL, value) : NULL;
value = udev_device_get_sysname (udev_device);
kernel = value ? copy_string (NULL, value) : NULL;
value = udev_device_get_devpath (udev_device);
devpath = value ? copy_string (NULL, value) : NULL;
value = udev_device_get_devnode (udev_device);
devname = value ? copy_string (NULL, value) : NULL;
/* Protect against the "impossible" */
if (! action)
goto out;
if (! strcmp (action, "add")) {
name = NIH_MUST (nih_sprintf (NULL, "%s-device-added",
subsystem));
} else if (! strcmp (action, "change")) {
name = NIH_MUST (nih_sprintf (NULL, "%s-device-changed",
subsystem));
} else if (! strcmp (action, "remove")) {
name = NIH_MUST (nih_sprintf (NULL, "%s-device-removed",
subsystem));
} else {
name = NIH_MUST (nih_sprintf (NULL, "%s-device-%s",
subsystem, action));
}
env = NIH_MUST (nih_str_array_new (NULL));
if (kernel) {
nih_local char *var = NULL;
var = NIH_MUST (nih_sprintf (NULL, "KERNEL=%s", kernel));
NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
}
if (devpath) {
nih_local char *var = NULL;
var = NIH_MUST (nih_sprintf (NULL, "DEVPATH=%s", devpath));
NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
}
if (devname) {
nih_local char *var = NULL;
var = NIH_MUST (nih_sprintf (NULL, "DEVNAME=%s", devname));
NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
}
if (subsystem) {
nih_local char *var = NULL;
var = NIH_MUST (nih_sprintf (NULL, "SUBSYSTEM=%s", subsystem));
NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
}
if (action) {
nih_local char *var = NULL;
var = NIH_MUST (nih_sprintf (NULL, "ACTION=%s", action));
NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
}
for (struct udev_list_entry *list_entry = udev_device_get_properties_list_entry (udev_device);
list_entry != NULL;
list_entry = udev_list_entry_get_next (list_entry)) {
nih_local char *udev_name = NULL;
nih_local char *udev_value = NULL;
nih_local char *var = NULL;
udev_name = copy_string (NULL, udev_list_entry_get_name (list_entry));
if (! strcmp (udev_name, "DEVPATH"))
continue;
if (! strcmp (udev_name, "DEVNAME"))
continue;
if (! strcmp (udev_name, "SUBSYSTEM"))
continue;
if (! strcmp (udev_name, "ACTION"))
continue;
udev_value = copy_string (NULL, udev_list_entry_get_value (list_entry));
var = NIH_MUST (nih_sprintf (NULL, "%s=%s", udev_name, udev_value));
NIH_MUST (nih_str_array_addp (&env, NULL, &env_len, var));
}
nih_debug ("%s %s", name, devname ? devname : "");
pending_call = upstart_emit_event (upstart,
name, env, FALSE,
NULL, emit_event_error, NULL,
NIH_DBUS_TIMEOUT_NEVER);
if (! pending_call) {
NihError *err;
int saved = errno;
err = nih_error_get ();
nih_warn ("%s", err->message);
if (saved != ENOMEM && subsystem)
nih_warn ("Likely that udev '%s' event contains binary garbage", subsystem);
nih_free (err);
}
dbus_pending_call_unref (pending_call);
out:
udev_device_unref (udev_device);
}
static void get_video_devices (ofGstCamData & cam_data)
{
int fd, ok;
struct udev * my_udev;
struct udev_enumerate * enumerate;
struct udev_list_entry * list;
struct udev_list_entry * entry;
my_udev = udev_new();
enumerate = udev_enumerate_new(my_udev);
udev_enumerate_scan_devices(enumerate);
list = udev_enumerate_get_list_entry(enumerate);
/*udev_list_entry_foreach(entry,list){
const char * name = udev_list_entry_get_name(entry);
struct udev_device * device = udev_device_new_from_syspath(my_udev, name);
const char * subsystem = udev_device_get_subsystem(device);
if(strcmp(subsystem,"video4linux")==0){
num_devices++;
}
}*/
ofLog (OF_LOG_NOTICE, "Probing devices with udev...");
/* Initialize webcam structures */
udev_list_entry_foreach(entry,list){
const char * name = udev_list_entry_get_name(entry);
struct udev_device * device = udev_device_new_from_syspath(my_udev, name);
string subsystem = udev_device_get_subsystem(device);
if(subsystem != "video4linux") continue;
const char *gstreamer_src, *product_name;
struct v4l2_capability v2cap;
struct video_capability v1cap;
string vendor_id;
string product_id;
const char * dev_node = udev_device_get_devnode(device);
struct udev_list_entry * properties = udev_device_get_properties_list_entry(device);
struct udev_list_entry * property;
udev_list_entry_foreach(property,properties){
const char * name = udev_list_entry_get_name(property);
if(strcmp(name,"ID_VENDOR_ID")==0){
vendor_id = udev_list_entry_get_value(property);
}
if(strcmp(name,"ID_MODEL_ID")==0){
product_id = udev_list_entry_get_value(property);
}
}
ofLog (OF_LOG_NOTICE, "Found device " + vendor_id + ":" + product_id + ", getting capabilities...");
/* vbi devices support capture capability too, but cannot be used,
* so detect them by device name */
if (strstr (dev_node, "vbi"))
{
ofLog (OF_LOG_WARNING, "Skipping vbi device: %s", dev_node);
continue;
}
if ((fd = open (dev_node, O_RDONLY | O_NONBLOCK)) < 0)
{
ofLog (OF_LOG_WARNING, "Failed to open %s: %s", dev_node, strerror (errno));
continue;
}
ok = ioctl (fd, VIDIOC_QUERYCAP, &v2cap);
if (ok < 0)
{
ok = ioctl (fd, VIDIOCGCAP, &v1cap);
if (ok < 0)
{
ofLog (OF_LOG_WARNING, "Error while probing v4l capabilities for %s: %s",
dev_node, strerror (errno));
close (fd);
continue;
}
ofLog (OF_LOG_NOTICE,"Detected v4l device: %s", v1cap.name);
ofLog (OF_LOG_NOTICE,"Device type: %d", v1cap.type);
gstreamer_src = "v4lsrc";
product_name = v1cap.name;
}
else
{
guint cap = v2cap.capabilities;
ofLog (OF_LOG_NOTICE,"Detected v4l2 device: %s", v2cap.card);
ofLog (OF_LOG_NOTICE,"Driver: %s, version: %d", v2cap.driver, v2cap.version);
/* g_print ("Bus info: %s\n", v2cap.bus_info); */ /* Doesn't seem anything useful */
ofLog (OF_LOG_NOTICE,"Capabilities: 0x%08X", v2cap.capabilities);
if (!(cap & V4L2_CAP_VIDEO_CAPTURE))
{
ofLog (OF_LOG_NOTICE,"Device %s seems to not have the capture capability, (radio tuner?)\n"
"Removing it from device list.", dev_node);
close (fd);
continue;
}
gstreamer_src = "v4l2src";
product_name = (char *) v2cap.card;
}
ofGstDevice gst_device;
gst_device.video_device = dev_node;
gst_device.gstreamer_src = gstreamer_src;
gst_device.product_name = product_name;
cam_data.webcam_devices.push_back(gst_device);
/*cam_data.webcam_devices[cam_data.num_webcam_devices].video_device = dev_node;
cam_data.webcam_devices[cam_data.num_webcam_devices].gstreamer_src = gstreamer_src;
cam_data.webcam_devices[cam_data.num_webcam_devices].product_name = product_name;
cam_data.webcam_devices[cam_data.num_webcam_devices].num_video_formats = 0;
cam_data.webcam_devices[cam_data.num_webcam_devices].supported_resolutions =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
cam_data.num_webcam_devices++;*/
close (fd);
}
cam_data.bInited=true;
}
static void
device_added(struct udev_device *udev_device)
{
const char *path, *name = NULL;
char *config_info = NULL;
const char *syspath;
const char *tags_prop;
const char *key, *value, *tmp;
InputOption *options = NULL, *tmpo;
InputAttributes attrs = {};
DeviceIntPtr dev = NULL;
struct udev_list_entry *set, *entry;
struct udev_device *parent;
int rc;
path = udev_device_get_devnode(udev_device);
syspath = udev_device_get_syspath(udev_device);
if (!path || !syspath)
return;
if (!udev_device_get_property_value(udev_device, "ID_INPUT")) {
LogMessageVerb(X_INFO, 10,
"config/udev: ignoring device %s without "
"property ID_INPUT set\n",
path);
return;
}
options = calloc(sizeof(*options), 1);
if (!options)
return;
options->key = strdup("_source");
options->value = strdup("server/udev");
if (!options->key || !options->value)
goto unwind;
parent = udev_device_get_parent(udev_device);
if (parent) {
const char *ppath = udev_device_get_devnode(parent);
const char *product = udev_device_get_property_value(parent, "PRODUCT");
const char *pnp_id = udev_device_get_sysattr_value(parent, "id");
unsigned int usb_vendor, usb_model;
name = udev_device_get_sysattr_value(parent, "name");
LOG_SYSATTR(ppath, "name", name);
if (!name) {
name = udev_device_get_property_value(parent, "NAME");
LOG_PROPERTY(ppath, "NAME", name);
}
if (pnp_id)
attrs.pnp_id = strdup(pnp_id);
LOG_SYSATTR(ppath, "id", pnp_id);
/* construct USB ID in lowercase hex - "0000:ffff" */
if (product && sscanf(product, "%*x/%4x/%4x/%*x", &usb_vendor, &usb_model) == 2) {
if (asprintf(&attrs.usb_id, "%04x:%04x", usb_vendor, usb_model)
== -1)
attrs.usb_id = NULL;
else
LOG_PROPERTY(path, "PRODUCT", product);
}
}
if (!name)
name = "(unnamed)";
else
attrs.product = strdup(name);
add_option(&options, "name", name);
add_option(&options, "path", path);
add_option(&options, "device", path);
if (path)
attrs.device = strdup(path);
tags_prop = udev_device_get_property_value(udev_device, "ID_INPUT.tags");
LOG_PROPERTY(path, "ID_INPUT.tags", tags_prop);
attrs.tags = xstrtokenize(tags_prop, ",");
if (asprintf(&config_info, "udev:%s", syspath) == -1) {
config_info = NULL;
goto unwind;
}
if (device_is_duplicate(config_info)) {
LogMessage(X_WARNING, "config/udev: device %s already added. "
"Ignoring.\n", name);
goto unwind;
}
set = udev_device_get_properties_list_entry(udev_device);
udev_list_entry_foreach(entry, set) {
key = udev_list_entry_get_name(entry);
if (!key)
continue;
value = udev_list_entry_get_value(entry);
if (!strncasecmp(key, UDEV_XKB_PROP_KEY,
sizeof(UDEV_XKB_PROP_KEY) - 1)) {
LOG_PROPERTY(path, key, value);
tmp = key + sizeof(UDEV_XKB_PROP_KEY) - 1;
if (!strcasecmp(tmp, "rules"))
add_option(&options, "xkb_rules", value);
else if (!strcasecmp(tmp, "layout"))
add_option(&options, "xkb_layout", value);
else if (!strcasecmp(tmp, "variant"))
add_option(&options, "xkb_variant", value);
else if (!strcasecmp(tmp, "model"))
add_option(&options, "xkb_model", value);
else if (!strcasecmp(tmp, "options"))
add_option(&options, "xkb_options", value);
} else if (!strcmp(key, "ID_VENDOR")) {
LOG_PROPERTY(path, key, value);
attrs.vendor = strdup(value);
} else if (!strcmp(key, "ID_INPUT_KEY")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_KEYBOARD;
} else if (!strcmp(key, "ID_INPUT_MOUSE")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_POINTER;
} else if (!strcmp(key, "ID_INPUT_JOYSTICK")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_JOYSTICK;
} else if (!strcmp(key, "ID_INPUT_TABLET")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_TABLET;
} else if (!strcmp(key, "ID_INPUT_TOUCHPAD")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_TOUCHPAD;
} else if (!strcmp(key, "ID_INPUT_TOUCHSCREEN")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_TOUCHSCREEN;
}
}
static int builtin_keyboard(struct udev_device *dev, int argc, char *argv[], bool test) {
struct udev_list_entry *entry;
unsigned release[1024];
unsigned release_count = 0;
_cleanup_close_ int fd = -1;
const char *node;
node = udev_device_get_devnode(dev);
if (!node) {
log_error("No device node for \"%s\"", udev_device_get_syspath(dev));
return EXIT_FAILURE;
}
udev_list_entry_foreach(entry, udev_device_get_properties_list_entry(dev)) {
const char *key;
char *endptr;
key = udev_list_entry_get_name(entry);
if (startswith(key, "KEYBOARD_KEY_")) {
const char *keycode;
unsigned scancode;
/* KEYBOARD_KEY_<hex scan code>=<key identifier string> */
scancode = strtoul(key + 13, &endptr, 16);
if (endptr[0] != '\0') {
log_warning("Unable to parse scan code from \"%s\"", key);
continue;
}
keycode = udev_list_entry_get_value(entry);
/* a leading '!' needs a force-release entry */
if (keycode[0] == '!') {
keycode++;
release[release_count] = scancode;
if (release_count < ELEMENTSOF(release)-1)
release_count++;
if (keycode[0] == '\0')
continue;
}
if (fd == -1) {
fd = open_device(node);
if (fd < 0)
return EXIT_FAILURE;
}
map_keycode(fd, node, scancode, keycode);
} else if (startswith(key, "EVDEV_ABS_")) {
unsigned evcode;
/* EVDEV_ABS_<EV_ABS code>=<min>:<max>:<res>:<fuzz>:<flat> */
evcode = strtoul(key + 10, &endptr, 16);
if (endptr[0] != '\0') {
log_warning("Unable to parse EV_ABS code from \"%s\"", key);
continue;
}
if (fd == -1) {
fd = open_device(node);
if (fd < 0)
return EXIT_FAILURE;
}
override_abs(fd, node, evcode, udev_list_entry_get_value(entry));
} else if (streq(key, "POINTINGSTICK_SENSITIVITY"))
set_trackpoint_sensitivity(dev, udev_list_entry_get_value(entry));
}
/* install list of force-release codes */
if (release_count > 0)
install_force_release(dev, release, release_count);
return EXIT_SUCCESS;
}
static int adm_monitor(struct udev *udev, int argc, char *argv[]) {
struct sigaction act = {};
sigset_t mask;
bool prop = false;
bool print_kernel = false;
bool print_udev = false;
_cleanup_udev_list_cleanup_ struct udev_list subsystem_match_list;
_cleanup_udev_list_cleanup_ struct udev_list tag_match_list;
_cleanup_udev_monitor_unref_ struct udev_monitor *udev_monitor = NULL;
_cleanup_udev_monitor_unref_ struct udev_monitor *kernel_monitor = NULL;
_cleanup_close_ int fd_ep = -1;
int fd_kernel = -1, fd_udev = -1;
struct epoll_event ep_kernel, ep_udev;
int c;
static const struct option options[] = {
{ "property", no_argument, NULL, 'p' },
{ "environment", no_argument, NULL, 'e' }, /* alias for -p */
{ "kernel", no_argument, NULL, 'k' },
{ "udev", no_argument, NULL, 'u' },
{ "subsystem-match", required_argument, NULL, 's' },
{ "tag-match", required_argument, NULL, 't' },
{ "help", no_argument, NULL, 'h' },
{}
};
udev_list_init(udev, &subsystem_match_list, true);
udev_list_init(udev, &tag_match_list, true);
while ((c = getopt_long(argc, argv, "pekus:t:h", options, NULL)) >= 0)
switch (c) {
case 'p':
case 'e':
prop = true;
break;
case 'k':
print_kernel = true;
break;
case 'u':
print_udev = true;
break;
case 's':
{
char subsys[UTIL_NAME_SIZE];
char *devtype;
strscpy(subsys, sizeof(subsys), optarg);
devtype = strchr(subsys, '/');
if (devtype != NULL) {
devtype[0] = '\0';
devtype++;
}
udev_list_entry_add(&subsystem_match_list, subsys, devtype);
break;
}
case 't':
udev_list_entry_add(&tag_match_list, optarg, NULL);
break;
case 'h':
help();
return 0;
default:
return 1;
}
if (!print_kernel && !print_udev) {
print_kernel = true;
print_udev = true;
}
/* set signal handlers */
act.sa_handler = sig_handler;
act.sa_flags = SA_RESTART;
sigaction(SIGINT, &act, NULL);
sigaction(SIGTERM, &act, NULL);
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
/* Callers are expecting to see events as they happen: Line buffering */
setlinebuf(stdout);
fd_ep = epoll_create1(EPOLL_CLOEXEC);
if (fd_ep < 0) {
log_error_errno(errno, "error creating epoll fd: %m");
return 1;
}
printf("monitor will print the received events for:\n");
if (print_udev) {
struct udev_list_entry *entry;
udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
if (udev_monitor == NULL) {
fprintf(stderr, "error: unable to create netlink socket\n");
return 1;
}
udev_monitor_set_receive_buffer_size(udev_monitor, 128*1024*1024);
fd_udev = udev_monitor_get_fd(udev_monitor);
udev_list_entry_foreach(entry, udev_list_get_entry(&subsystem_match_list)) {
const char *subsys = udev_list_entry_get_name(entry);
const char *devtype = udev_list_entry_get_value(entry);
if (udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, subsys, devtype) < 0)
fprintf(stderr, "error: unable to apply subsystem filter '%s'\n", subsys);
}
udev_list_entry_foreach(entry, udev_list_get_entry(&tag_match_list)) {
const char *tag = udev_list_entry_get_name(entry);
if (udev_monitor_filter_add_match_tag(udev_monitor, tag) < 0)
fprintf(stderr, "error: unable to apply tag filter '%s'\n", tag);
}
if (udev_monitor_enable_receiving(udev_monitor) < 0) {
fprintf(stderr, "error: unable to subscribe to udev events\n");
return 2;
}
memzero(&ep_udev, sizeof(struct epoll_event));
ep_udev.events = EPOLLIN;
ep_udev.data.fd = fd_udev;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_udev, &ep_udev) < 0) {
log_error_errno(errno, "fail to add fd to epoll: %m");
return 2;
}
printf("UDEV - the event which udev sends out after rule processing\n");
}
if (print_kernel) {
struct udev_list_entry *entry;
kernel_monitor = udev_monitor_new_from_netlink(udev, "kernel");
if (kernel_monitor == NULL) {
fprintf(stderr, "error: unable to create netlink socket\n");
return 3;
}
udev_monitor_set_receive_buffer_size(kernel_monitor, 128*1024*1024);
fd_kernel = udev_monitor_get_fd(kernel_monitor);
udev_list_entry_foreach(entry, udev_list_get_entry(&subsystem_match_list)) {
const char *subsys = udev_list_entry_get_name(entry);
if (udev_monitor_filter_add_match_subsystem_devtype(kernel_monitor, subsys, NULL) < 0)
fprintf(stderr, "error: unable to apply subsystem filter '%s'\n", subsys);
}
if (udev_monitor_enable_receiving(kernel_monitor) < 0) {
fprintf(stderr, "error: unable to subscribe to kernel events\n");
return 4;
}
memzero(&ep_kernel, sizeof(struct epoll_event));
ep_kernel.events = EPOLLIN;
ep_kernel.data.fd = fd_kernel;
if (epoll_ctl(fd_ep, EPOLL_CTL_ADD, fd_kernel, &ep_kernel) < 0) {
log_error_errno(errno, "fail to add fd to epoll: %m");
return 5;
}
printf("KERNEL - the kernel uevent\n");
}
printf("\n");
while (!udev_exit) {
int fdcount;
struct epoll_event ev[4];
int i;
fdcount = epoll_wait(fd_ep, ev, ELEMENTSOF(ev), -1);
if (fdcount < 0) {
if (errno != EINTR)
fprintf(stderr, "error receiving uevent message: %m\n");
continue;
}
for (i = 0; i < fdcount; i++) {
if (ev[i].data.fd == fd_kernel && ev[i].events & EPOLLIN) {
struct udev_device *device;
device = udev_monitor_receive_device(kernel_monitor);
if (device == NULL)
continue;
print_device(device, "KERNEL", prop);
udev_device_unref(device);
} else if (ev[i].data.fd == fd_udev && ev[i].events & EPOLLIN) {
struct udev_device *device;
device = udev_monitor_receive_device(udev_monitor);
if (device == NULL)
continue;
print_device(device, "UDEV", prop);
udev_device_unref(device);
}
}
}
return 0;
}
int main( int argc, char** argv ) {
int rc = 0;
char pathbuf[PATH_MAX+1];
struct udev* udev_client = NULL;
struct udev_monitor* monitor = NULL;
int monitor_fd = 0;
struct udev_device* dev = NULL;
struct pollfd pfd[1];
int num_events = INT_MAX;
int num_forks = 0;
// usage: $0 [num events to process [num times to fork]]
if( argc > 1 ) {
char* tmp = NULL;
num_events = (int)strtol( argv[1], &tmp, 10 );
if( tmp == argv[1] || *tmp != '\0' ) {
fprintf(stderr, "Usage: %s [number of events to process [number of times to fork]]\n", argv[0] );
exit(1);
}
if( argc > 2 ) {
num_forks = (int)strtol( argv[2], &tmp, 10 );
if( tmp == argv[2] || *tmp != '\0' ) {
fprintf(stderr, "Usage: %s [number of events to process [number of times to fork]]\n", argv[0] );
exit(1);
}
}
}
// make sure events dir exists
log_trace("events directory '%s'", UDEV_FS_EVENTS_DIR);
rc = mkdir( UDEV_FS_EVENTS_DIR, 0700 );
if( rc != 0 ) {
rc = -errno;
if( rc != -EEXIST ) {
log_error("mkdir('%s') rc = %d", UDEV_FS_EVENTS_DIR, rc );
exit(1);
}
}
udev_monitor_fs_events_path( "", pathbuf, 0 );
printf("Watching '%s'\n", pathbuf );
udev_client = udev_new();
if( udev_client == NULL ) {
// OOM
exit(2);
}
monitor = udev_monitor_new_from_netlink( udev_client, "udev" );
if( monitor == NULL ) {
// OOM or error
udev_unref( udev_client );
exit(2);
}
printf("Press Ctrl-C to quit\n");
monitor_fd = udev_monitor_get_fd( monitor );
if( monitor_fd < 0 ) {
rc = -errno;
log_error("udev_monitor_get_fd rc = %d\n", rc );
exit(3);
}
pfd[0].fd = monitor_fd;
pfd[0].events = POLLIN;
while( num_events > 0 ) {
// wait for the next device
rc = poll( pfd, 1, -1 );
if( rc < 0 ) {
log_error("poll(%d) rc = %d\n", monitor_fd, rc );
break;
}
// get devices
while( num_events > 0 ) {
dev = udev_monitor_receive_device( monitor );
if( dev == NULL ) {
break;
}
int pid = getpid();
struct udev_list_entry *list_entry = NULL;
printf("[%d] [%d] ACTION: '%s'\n", pid, num_events, udev_device_get_action( dev ) );
printf("[%d] [%d] SEQNUM: %llu\n", pid, num_events, udev_device_get_seqnum( dev ) );
printf("[%d] [%d] USEC: %llu\n", pid, num_events, udev_device_get_usec_since_initialized( dev ) );
printf("[%d] [%d] DEVNODE: '%s'\n", pid, num_events, udev_device_get_devnode( dev ) );
printf("[%d] [%d] DEVPATH: '%s'\n", pid, num_events, udev_device_get_devpath( dev ) );
printf("[%d] [%d] SYSNAME: '%s'\n", pid, num_events, udev_device_get_sysname( dev ) );
printf("[%d] [%d] SYSPATH: '%s'\n", pid, num_events, udev_device_get_syspath( dev ) );
printf("[%d] [%d] SUBSYSTEM: '%s'\n", pid, num_events, udev_device_get_subsystem( dev ) );
printf("[%d] [%d] DEVTYPE: '%s'\n", pid, num_events, udev_device_get_devtype( dev ) );
printf("[%d] [%d] SYSNUM: '%s'\n", pid, num_events, udev_device_get_sysnum( dev ) );
printf("[%d] [%d] DRIVER: '%s'\n", pid, num_events, udev_device_get_driver( dev ) );
printf("[%d] [%d] DEVNUM: %d:%d\n", pid, num_events, major( udev_device_get_devnum( dev ) ), minor( udev_device_get_devnum( dev ) ) );
printf("[%d] [%d] IFINDEX: '%s'\n", pid, num_events, udev_device_get_property_value( dev, "IFINDEX" ) );
printf("[%d] [%d] DEVMODE: '%s'\n", pid, num_events, udev_device_get_property_value( dev, "DEVMODE" ) );
printf("[%d] [%d] DEVUID: '%s'\n", pid, num_events, udev_device_get_property_value( dev, "DEVUID" ) );
printf("[%d] [%d] DEVGID: '%s'\n", pid, num_events, udev_device_get_property_value( dev, "DEVGID" ) );
list_entry = udev_device_get_devlinks_list_entry( dev );
udev_list_entry_foreach( list_entry, udev_list_entry_get_next( list_entry )) {
printf("[%d] [%d] devlink: '%s'\n", pid, num_events, udev_list_entry_get_name( list_entry ) );
}
list_entry = udev_device_get_properties_list_entry( dev );
udev_list_entry_foreach( list_entry, udev_list_entry_get_next( list_entry )) {
printf("[%d] [%d] property: '%s' = '%s'\n", pid, num_events, udev_list_entry_get_name( list_entry ), udev_list_entry_get_value( list_entry ) );
}
list_entry = udev_device_get_tags_list_entry( dev );
udev_list_entry_foreach( list_entry, udev_list_entry_get_next( list_entry )) {
printf("[%d] [%d] tag: '%s'\n", pid, num_events, udev_list_entry_get_name( list_entry ) );
}
static void
device_added(struct udev_device *udev_device)
{
const char *path, *name = NULL;
char *config_info = NULL;
const char *syspath;
const char *tags_prop;
const char *key, *value, *tmp;
InputOption *input_options;
InputAttributes attrs = { };
DeviceIntPtr dev = NULL;
struct udev_list_entry *set, *entry;
struct udev_device *parent;
int rc;
const char *dev_seat;
path = udev_device_get_devnode(udev_device);
syspath = udev_device_get_syspath(udev_device);
if (!path || !syspath)
return;
dev_seat = udev_device_get_property_value(udev_device, "ID_SEAT");
if (!dev_seat)
dev_seat = "seat0";
if (SeatId && strcmp(dev_seat, SeatId))
return;
if (!SeatId && strcmp(dev_seat, "seat0"))
return;
#ifdef CONFIG_UDEV_KMS
if (!strcmp(udev_device_get_subsystem(udev_device), "drm")) {
const char *sysname = udev_device_get_sysname(udev_device);
if (strncmp(sysname, "card", 4) != 0)
return;
LogMessage(X_INFO, "config/udev: Adding drm device (%s)\n", path);
config_udev_odev_setup_attribs(path, syspath, NewGPUDeviceRequest);
return;
}
#endif
if (!udev_device_get_property_value(udev_device, "ID_INPUT")) {
LogMessageVerb(X_INFO, 10,
"config/udev: ignoring device %s without "
"property ID_INPUT set\n", path);
return;
}
input_options = input_option_new(NULL, "_source", "server/udev");
if (!input_options)
return;
parent = udev_device_get_parent(udev_device);
if (parent) {
const char *ppath = udev_device_get_devnode(parent);
const char *product = udev_device_get_property_value(parent, "PRODUCT");
const char *pnp_id = udev_device_get_sysattr_value(parent, "id");
unsigned int usb_vendor, usb_model;
name = udev_device_get_sysattr_value(parent, "name");
LOG_SYSATTR(ppath, "name", name);
if (!name) {
name = udev_device_get_property_value(parent, "NAME");
LOG_PROPERTY(ppath, "NAME", name);
}
/* construct USB ID in lowercase hex - "0000:ffff" */
if (product &&
sscanf(product, "%*x/%4x/%4x/%*x", &usb_vendor, &usb_model) == 2) {
if (asprintf(&attrs.usb_id, "%04x:%04x", usb_vendor, usb_model)
== -1)
attrs.usb_id = NULL;
else
LOG_PROPERTY(ppath, "PRODUCT", product);
}
while (!pnp_id && (parent = udev_device_get_parent(parent))) {
pnp_id = udev_device_get_sysattr_value(parent, "id");
if (!pnp_id)
continue;
attrs.pnp_id = strdup(pnp_id);
ppath = udev_device_get_devnode(parent);
LOG_SYSATTR(ppath, "id", pnp_id);
}
}
if (!name)
name = "(unnamed)";
else
attrs.product = strdup(name);
input_options = input_option_new(input_options, "name", name);
input_options = input_option_new(input_options, "path", path);
input_options = input_option_new(input_options, "device", path);
if (path)
attrs.device = strdup(path);
tags_prop = udev_device_get_property_value(udev_device, "ID_INPUT.tags");
LOG_PROPERTY(path, "ID_INPUT.tags", tags_prop);
attrs.tags = xstrtokenize(tags_prop, ",");
if (asprintf(&config_info, "udev:%s", syspath) == -1) {
config_info = NULL;
goto unwind;
}
if (device_is_duplicate(config_info)) {
LogMessage(X_WARNING, "config/udev: device %s already added. "
"Ignoring.\n", name);
goto unwind;
}
set = udev_device_get_properties_list_entry(udev_device);
udev_list_entry_foreach(entry, set) {
key = udev_list_entry_get_name(entry);
if (!key)
continue;
value = udev_list_entry_get_value(entry);
if (!strncasecmp(key, UDEV_XKB_PROP_KEY, sizeof(UDEV_XKB_PROP_KEY) - 1)) {
LOG_PROPERTY(path, key, value);
tmp = key + sizeof(UDEV_XKB_PROP_KEY) - 1;
if (!strcasecmp(tmp, "rules"))
input_options =
input_option_new(input_options, "xkb_rules", value);
else if (!strcasecmp(tmp, "layout"))
input_options =
input_option_new(input_options, "xkb_layout", value);
else if (!strcasecmp(tmp, "variant"))
input_options =
input_option_new(input_options, "xkb_variant", value);
else if (!strcasecmp(tmp, "model"))
input_options =
input_option_new(input_options, "xkb_model", value);
else if (!strcasecmp(tmp, "options"))
input_options =
input_option_new(input_options, "xkb_options", value);
}
else if (!strcmp(key, "ID_VENDOR")) {
LOG_PROPERTY(path, key, value);
attrs.vendor = strdup(value);
}
else if (!strcmp(key, "ID_INPUT_KEY")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_KEYBOARD;
}
else if (!strcmp(key, "ID_INPUT_MOUSE")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_POINTER;
}
else if (!strcmp(key, "ID_INPUT_JOYSTICK")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_JOYSTICK;
}
else if (!strcmp(key, "ID_INPUT_TABLET")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_TABLET;
}
else if (!strcmp(key, "ID_INPUT_TOUCHPAD")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_TOUCHPAD;
}
else if (!strcmp(key, "ID_INPUT_TOUCHSCREEN")) {
LOG_PROPERTY(path, key, value);
attrs.flags |= ATTR_TOUCHSCREEN;
}
}
