END_TEST
START_TEST(test_uinput_create_device_from_fd)
{
struct libevdev *dev, *dev2;
struct libevdev_uinput *uidev;
int fd, fd2;
unsigned int type, code;
int rc;
const char *devnode;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
fd = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd, -1);
rc = libevdev_uinput_create_from_device(dev, fd, &uidev);
ck_assert_int_eq(rc, 0);
ck_assert(uidev != NULL);
ck_assert_int_eq(libevdev_uinput_get_fd(uidev), fd);
devnode = libevdev_uinput_get_devnode(uidev);
ck_assert(devnode != NULL);
fd2 = open(devnode, O_RDONLY);
ck_assert_int_gt(fd2, -1);
rc = libevdev_new_from_fd(fd2, &dev2);
ck_assert_int_eq(rc, 0);
for (type = 0; type < EV_CNT; type++) {
int max = libevdev_event_type_get_max(type);
if (max == -1)
continue;
for (code = 0; code < max; code++) {
ck_assert_int_eq(libevdev_has_event_code(dev, type, code),
libevdev_has_event_code(dev2, type, code));
}
}
libevdev_free(dev);
libevdev_free(dev2);
libevdev_uinput_destroy(uidev);
close(fd);
close(fd2);
}
int power_key_resume_handler_init(void)
{
const char *node_path;
char *full_path;
GDir *input_dir;
int rc = 1;
struct libevdev *dev = NULL;
input_dir = g_dir_open("/dev/input", 0, NULL);
if (!input_dir) {
g_warning("Failed to reach /dev/input directory");
return -ENODEV;
}
while ((node_path = g_dir_read_name(input_dir)) != NULL) {
full_path = g_strdup_printf("/dev/input/%s", node_path);
if (g_file_test(node_path, G_FILE_TEST_IS_DIR))
continue;
input_source_fd = open(full_path, O_RDONLY|O_NONBLOCK);
g_free(full_path);
if (input_source_fd < 0)
continue;
rc = libevdev_new_from_fd(input_source_fd, &dev);
if (rc < 0) {
fprintf(stderr, "Failed to init libevdev (%s)\n", strerror(-rc));
close(input_source_fd);
input_source_fd = -1;
continue;
}
if (libevdev_has_event_code(dev, EV_KEY, KEY_POWER)) {
libevdev_free(dev);
break;
}
libevdev_free(dev);
close(input_source_fd);
input_source_fd = -1;
}
if (input_source_fd < 0)
return -ENODEV;
channel = g_io_channel_unix_new(input_source_fd);
g_io_channel_set_encoding(channel, NULL, NULL);
readwatch = g_io_add_watch(channel, G_IO_IN | G_IO_HUP | G_IO_NVAL, _handle_input_event, NULL);
return 0;
}
struct adhoc* adhoc_init(int fd) {
struct adhoc *adhoc = calloc(1, sizeof(struct adhoc));
int r = libevdev_new_from_fd(fd, &adhoc->dev);
if (r) {
error(0, -r, "libevdev_new_from_fd failed");
goto creation_error;
}
const char *name = libevdev_get_name(adhoc->dev);
if (strcmp(name, "SMART SB680 Interactive Whiteboard") == 0)
adhoc->internal_calls = internal_calls_sb680;
else if (strcmp(name, "SMART SB885 Interactive Whiteboard") == 0)
adhoc->internal_calls = internal_calls_sb885;
else {
fprintf(stderr, "unknown device: %s\n", name);
goto device_error;
}
#ifdef DEBUG
fprintf(stderr, "device: %s\n", name);
#endif
if (adhoc->internal_calls.init(adhoc))
goto device_error;
return adhoc;
device_error:
libevdev_free(adhoc->dev);
creation_error:
free(adhoc);
return NULL;
}
FTNoIR_Protocol::~FTNoIR_Protocol()
{
if (uidev)
libevdev_uinput_destroy(uidev);
if (dev)
libevdev_free(dev);
}
END_TEST
START_TEST(test_empty_sync)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_event ev;
rc = test_create_device(&uidev, &dev,
EV_SYN, SYN_REPORT,
EV_SYN, SYN_DROPPED,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_MIDDLE,
EV_KEY, BTN_RIGHT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, -EAGAIN);
uinput_device_free(uidev);
libevdev_free(dev);
}
int
main (int argc, char **argv) {
int rc;
int fd;
const char *path;
struct libevdev *dev;
struct measurements measurements = {0};
if (argc < 2)
return usage();
path = argv[1];
if (path[0] == '-')
return usage();
fd = open(path, O_RDONLY|O_NONBLOCK);
if (fd < 0) {
fprintf(stderr, "Error opening the device: %s\n", strerror(errno));
return 1;
}
rc = libevdev_new_from_fd(fd, &dev);
if (rc != 0) {
fprintf(stderr, "Error fetching the device info: %s\n", strerror(-rc));
return 1;
}
if (libevdev_grab(dev, LIBEVDEV_GRAB) != 0) {
fprintf(stderr, "Error: cannot grab the device, something else is grabbing it.\n");
fprintf(stderr, "Use 'fuser -v %s' to find processes with an open fd\n", path);
return 1;
}
libevdev_grab(dev, LIBEVDEV_UNGRAB);
printf("Mouse %s on %s\n", libevdev_get_name(dev), path);
printf("Move the device 250mm/10in or more along the x-axis.\n");
printf("Pause 3 seconds before movement to reset, Ctrl+C to exit.\n");
setbuf(stdout, NULL);
rc = mainloop(dev, &measurements);
printf("\n");
print_summary(&measurements);
printf("\n");
printf("Entry for hwdb match (replace XXX with the resolution in DPI):\n"
"mouse:%s:v%04xp%04x:name:%s:\n"
" MOUSE_DPI=XXX@%d\n",
bustype(libevdev_get_id_bustype(dev)),
libevdev_get_id_vendor(dev),
libevdev_get_id_product(dev),
libevdev_get_name(dev),
(int)measurements.max_frequency);
libevdev_free(dev);
close(fd);
return rc;
}
evdevDevice::~evdevDevice()
{
if (m_initialized)
{
libevdev_free(m_dev);
close(m_fd);
}
}
void joystick_linux::open_joystick(const char *p_path) {
int joy_num = get_free_joy_slot();
int fd = open(p_path, O_RDONLY | O_NONBLOCK);
if (fd != -1 && joy_num != -1) {
int rc = libevdev_new_from_fd(fd, &joysticks[joy_num].dev);
if (rc < 0) {
fprintf(stderr, "Failed to init libevdev (%s)\n", strerror(-rc));
return;
}
libevdev *dev = joysticks[joy_num].dev;
//check if the device supports basic gamepad events, prevents certain keyboards from
//being detected as joysticks
if (libevdev_has_event_type(dev, EV_ABS) && libevdev_has_event_type(dev, EV_KEY) &&
(libevdev_has_event_code(dev, EV_KEY, BTN_A) || libevdev_has_event_code(dev, EV_KEY, BTN_THUMBL) || libevdev_has_event_code(dev, EV_KEY, BTN_TOP))) {
char uid[128];
String name = libevdev_get_name(dev);
uint16_t bus = __bswap_16(libevdev_get_id_bustype(dev));
uint16_t vendor = __bswap_16(libevdev_get_id_vendor(dev));
uint16_t product = __bswap_16(libevdev_get_id_product(dev));
uint16_t version = __bswap_16(libevdev_get_id_version(dev));
joysticks[joy_num].reset();
Joystick &joy = joysticks[joy_num];
joy.fd = fd;
joy.devpath = String(p_path);
setup_joystick_properties(joy_num);
sprintf(uid, "%04x%04x", bus, 0);
if (vendor && product && version) {
sprintf(uid + String(uid).length(), "%04x%04x%04x%04x%04x%04x", vendor,0,product,0,version,0);
input->joy_connection_changed(joy_num, true, name, uid);
}
else {
String uidname = uid;
int uidlen = MIN(name.length(), 11);
for (int i=0; i<uidlen; i++) {
uidname = uidname + _hex_str(name[i]);
}
uidname += "00";
input->joy_connection_changed(joy_num, true, name, uidname);
}
}
else {
//device is not a gamepad, clean up
libevdev_free(dev);
close(fd);
}
}
}
END_TEST
START_TEST(test_uinput_events)
{
struct libevdev *dev;
struct libevdev_uinput *uidev;
int fd, fd2;
int rc;
const char *devnode;
int i;
const int nevents = 5;
struct input_event events[] = { {{0, 0}, EV_REL, REL_X, 1},
{{0, 0}, EV_REL, REL_Y, -1},
{{0, 0}, EV_SYN, SYN_REPORT, 0},
{{0, 0}, EV_KEY, BTN_LEFT, 1},
{{0, 0}, EV_SYN, SYN_REPORT, 0}};
struct input_event events_read[nevents];
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_type(dev, EV_KEY);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, NULL);
fd = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd, -1);
rc = libevdev_uinput_create_from_device(dev, fd, &uidev);
ck_assert_int_eq(rc, 0);
ck_assert(uidev != NULL);
devnode = libevdev_uinput_get_devnode(uidev);
ck_assert(devnode != NULL);
fd2 = open(devnode, O_RDONLY);
for (i = 0; i < nevents; i++)
libevdev_uinput_write_event(uidev, events[i].type, events[i].code, events[i].value);
rc = read(fd2, events_read, sizeof(events_read));
ck_assert_int_eq(rc, sizeof(events_read));
for (i = 0; i < nevents; i++) {
ck_assert_int_eq(events[i].type, events_read[i].type);
ck_assert_int_eq(events[i].code, events_read[i].code);
ck_assert_int_eq(events[i].value, events_read[i].value);
}
libevdev_free(dev);
libevdev_uinput_destroy(uidev);
close(fd);
close(fd2);
}
END_TEST
START_TEST(test_syn_delta_button)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_event ev;
rc = test_create_device(&uidev, &dev,
EV_SYN, SYN_REPORT,
EV_SYN, SYN_DROPPED,
EV_REL, REL_X,
EV_REL, REL_Y,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_MIDDLE,
EV_KEY, BTN_RIGHT,
EV_KEY, KEY_MAX,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
uinput_device_event(uidev, EV_KEY, BTN_RIGHT, 1);
uinput_device_event(uidev, EV_KEY, KEY_MAX, 1);
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_KEY);
ck_assert_int_eq(ev.code, BTN_LEFT);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_KEY);
ck_assert_int_eq(ev.code, BTN_RIGHT);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_KEY);
ck_assert_int_eq(ev.code, KEY_MAX);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_SYN);
ck_assert_int_eq(ev.code, SYN_REPORT);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, -EAGAIN);
ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT));
ck_assert(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT));
ck_assert(!libevdev_get_event_value(dev, EV_KEY, BTN_MIDDLE));
ck_assert(libevdev_get_event_value(dev, EV_KEY, KEY_MAX));
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_uinput_check_syspath_time)
{
struct libevdev *dev;
struct libevdev_uinput *uidev, *uidev2;
const char *syspath, *syspath2;
int fd, fd2;
int rc;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
fd = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd, -1);
fd2 = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd2, -1);
rc = libevdev_uinput_create_from_device(dev, fd, &uidev);
ck_assert_int_eq(rc, 0);
/* sleep for 1.5 seconds. sysfs resolution is 1 second, so
creating both devices without delay means
libevdev_uinput_get_syspath can't actually differ between
them. By waiting, we get different ctime for uidev and uidev2,
and exercise that part of the code.
*/
usleep(1500000);
/* create a second one to test the syspath time filtering code */
rc = libevdev_uinput_create_from_device(dev, fd2, &uidev2);
ck_assert_int_eq(rc, 0);
syspath = libevdev_uinput_get_syspath(uidev);
ck_assert(syspath != NULL);
/* get syspath twice returns same pointer */
syspath2 = libevdev_uinput_get_syspath(uidev);
ck_assert(syspath == syspath2);
/* second dev has different syspath */
syspath2 = libevdev_uinput_get_syspath(uidev2);
ck_assert(strcmp(syspath, syspath2) != 0);
libevdev_free(dev);
libevdev_uinput_destroy(uidev);
libevdev_uinput_destroy(uidev2);
close(fd);
close(fd2);
}
END_TEST
START_TEST(test_uinput_properties)
{
struct libevdev *dev, *dev2;
struct libevdev_uinput *uidev;
int fd;
int rc;
const char *devnode;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_type(dev, EV_KEY);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
libevdev_enable_event_code(dev, EV_KEY, BTN_LEFT, NULL);
libevdev_enable_property(dev, INPUT_PROP_BUTTONPAD);
libevdev_enable_property(dev, INPUT_PROP_MAX);
rc = libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev);
ck_assert_int_eq(rc, 0);
ck_assert(uidev != NULL);
devnode = libevdev_uinput_get_devnode(uidev);
ck_assert(devnode != NULL);
fd = open(devnode, O_RDONLY);
ck_assert_int_gt(fd, -1);
rc = libevdev_new_from_fd(fd, &dev2);
ck_assert_int_eq(rc, 0);
ck_assert(libevdev_has_property(dev2, INPUT_PROP_BUTTONPAD));
ck_assert(libevdev_has_property(dev2, INPUT_PROP_MAX));
libevdev_free(dev);
libevdev_free(dev2);
libevdev_uinput_destroy(uidev);
close(fd);
}
END_TEST
START_TEST(test_syn_delta_sw)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_event ev;
rc = test_create_device(&uidev, &dev,
EV_SYN, SYN_REPORT,
EV_SYN, SYN_DROPPED,
EV_SW, SW_LID,
EV_SW, SW_MICROPHONE_INSERT,
EV_SW, SW_MAX,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
uinput_device_event(uidev, EV_SW, SW_LID, 1);
uinput_device_event(uidev, EV_SW, SW_MICROPHONE_INSERT, 1);
uinput_device_event(uidev, EV_SW, SW_MAX, 1);
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_SW);
ck_assert_int_eq(ev.code, SW_LID);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_SW);
ck_assert_int_eq(ev.code, SW_MICROPHONE_INSERT);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_SW);
ck_assert_int_eq(ev.code, SW_MAX);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_SYN);
ck_assert_int_eq(ev.code, SYN_REPORT);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, -EAGAIN);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MICROPHONE_INSERT), 1);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_MAX), 1);
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_event_mt_value_setters_current_slot)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_absinfo abs[5];
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_MT_POSITION_X;
abs[1].maximum = 1000;
abs[2].value = ABS_Y;
abs[2].maximum = 1000;
abs[3].value = ABS_MT_POSITION_Y;
abs[3].maximum = 1000;
abs[4].value = ABS_MT_SLOT;
abs[4].maximum = 2;
rc = test_create_abs_device(&uidev, &dev,
5, abs,
EV_SYN, SYN_REPORT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
/* set_event_value/get_event_value works on the current slot */
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 1), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 1);
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_POSITION_X), 1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 1), 0);
ck_assert_int_eq(libevdev_get_current_slot(dev), 1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_POSITION_X, 2), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
ck_assert_int_eq(libevdev_get_slot_value(dev, 1, ABS_MT_POSITION_X), 2);
/* set slot 0, but current is still slot 1 */
ck_assert_int_eq(libevdev_set_slot_value(dev, 0, ABS_MT_POSITION_X, 3), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 2);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_MT_SLOT, 0), 0);
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_MT_POSITION_X), 3);
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_incomplete_sync)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_event ev;
struct input_absinfo abs[2];
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_Y;
abs[1].maximum = 1000;
rc = test_create_abs_device(&uidev, &dev,
2, abs,
EV_SYN, SYN_REPORT,
EV_SYN, SYN_DROPPED,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_MIDDLE,
EV_KEY, BTN_RIGHT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
uinput_device_event(uidev, EV_KEY, BTN_LEFT, 1);
uinput_device_event(uidev, EV_ABS, ABS_X, 100);
uinput_device_event(uidev, EV_ABS, ABS_Y, 500);
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_FORCE_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_SYNC, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SYNC);
ck_assert_int_eq(ev.type, EV_KEY);
ck_assert_int_eq(ev.code, BTN_LEFT);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
ck_assert_int_eq(rc, -EAGAIN);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 100);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 500);
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_uinput_check_syspath_name)
{
struct libevdev *dev;
struct libevdev_uinput *uidev, *uidev2;
const char *syspath, *syspath2;
int fd, fd2;
int rc;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
fd = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd, -1);
fd2 = open(UINPUT_NODE, O_RDWR);
ck_assert_int_gt(fd2, -1);
rc = libevdev_uinput_create_from_device(dev, fd, &uidev);
ck_assert_int_eq(rc, 0);
/* create a second one to stress the syspath filtering code */
libevdev_set_name(dev, TEST_DEVICE_NAME " 2");
rc = libevdev_uinput_create_from_device(dev, fd2, &uidev2);
ck_assert_int_eq(rc, 0);
syspath = libevdev_uinput_get_syspath(uidev);
ck_assert(syspath != NULL);
/* get syspath twice returns same pointer */
syspath2 = libevdev_uinput_get_syspath(uidev);
ck_assert(syspath == syspath2);
/* second dev has different syspath */
syspath2 = libevdev_uinput_get_syspath(uidev2);
ck_assert(strcmp(syspath, syspath2) != 0);
libevdev_free(dev);
libevdev_uinput_destroy(uidev);
libevdev_uinput_destroy(uidev2);
close(fd);
close(fd2);
}
bool evdevDevice::IsValid() const
{
int current_fd = libevdev_get_fd(m_dev);
if (current_fd == -1)
return false;
libevdev* device;
if (libevdev_new_from_fd(current_fd, &device) != 0)
{
close(current_fd);
return false;
}
libevdev_free(device);
return true;
}
FTNoIR_Protocol::FTNoIR_Protocol() : dev(NULL), uidev(NULL)
{
int error = 0;
dev = libevdev_new();
if (!dev)
goto error;
CHECK_LIBEVDEV(libevdev_enable_property(dev, INPUT_PROP_BUTTONPAD));
libevdev_set_name(dev, "opentrack headpose");
struct input_absinfo absinfo;
absinfo.minimum = min_input;
absinfo.maximum = max_input;
absinfo.resolution = 1;
absinfo.value = mid_input;
absinfo.flat = 1;
absinfo.fuzz = 0;
CHECK_LIBEVDEV(libevdev_enable_event_type(dev, EV_ABS));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_ABS, ABS_X, &absinfo));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_ABS, ABS_Y, &absinfo));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_ABS, ABS_Z, &absinfo));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_ABS, ABS_RX, &absinfo));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_ABS, ABS_RY, &absinfo));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_ABS, ABS_RZ, &absinfo));
/* do not remove next 3 lines or udev scripts won't assign 0664 permissions -sh */
CHECK_LIBEVDEV(libevdev_enable_event_type(dev, EV_KEY));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_KEY, BTN_JOYSTICK, NULL));
CHECK_LIBEVDEV(libevdev_enable_event_code(dev, EV_KEY, BTN_TRIGGER, NULL));
CHECK_LIBEVDEV(libevdev_uinput_create_from_device(dev, LIBEVDEV_UINPUT_OPEN_MANAGED, &uidev));
return;
error:
if (uidev)
libevdev_uinput_destroy(uidev);
if (dev)
libevdev_free(dev);
if (error)
fprintf(stderr, "libevdev error: %d\n", error);
uidev = NULL;
dev = NULL;
}
END_TEST
START_TEST(test_event_values_invalid)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_absinfo abs[2];
int value;
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_Y;
abs[1].maximum = 1000;
rc = test_create_abs_device(&uidev, &dev,
2, abs,
EV_SYN, SYN_REPORT,
EV_SYN, SYN_DROPPED,
EV_REL, REL_X,
EV_REL, REL_Y,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_MIDDLE,
EV_KEY, BTN_RIGHT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_EXTRA), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Z), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Z), 0);
value = 0xab;
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_KEY, BTN_EXTRA, &value), 0);
ck_assert_int_eq(value, 0xab);
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_ABS, ABS_Z, &value), 0);
ck_assert_int_eq(value, 0xab);
ck_assert_int_eq(libevdev_fetch_event_value(dev, EV_REL, REL_Z, &value), 0);
ck_assert_int_eq(value, 0xab);
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_mt_event_values_invalid)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_absinfo abs[5];
int value;
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_MT_POSITION_X;
abs[1].maximum = 1000;
abs[2].value = ABS_Y;
abs[2].maximum = 1000;
abs[3].value = ABS_MT_POSITION_Y;
abs[3].maximum = 1000;
abs[4].value = ABS_MT_SLOT;
abs[4].maximum = 2;
rc = test_create_abs_device(&uidev, &dev,
5, abs,
EV_SYN, SYN_REPORT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
ck_assert_int_eq(libevdev_get_current_slot(dev), 0);
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_MT_TOUCH_MINOR), 0);
value = 0xab;
ck_assert_int_eq(libevdev_fetch_slot_value(dev, 0, ABS_MT_TOUCH_MINOR, &value), 0);
ck_assert_int_eq(value, 0xab);
ck_assert_int_eq(libevdev_get_slot_value(dev, 10, ABS_MT_POSITION_X), 0);
ck_assert_int_eq(libevdev_get_slot_value(dev, 0, ABS_X), 0);
uinput_device_free(uidev);
libevdev_free(dev);
}
void joystick_linux::close_joystick(int p_id) {
if (p_id == -1) {
for (int i=0; i<JOYSTICKS_MAX; i++) {
close_joystick(i);
};
return;
}
else if (p_id < 0) return;
Joystick &joy = joysticks[p_id];
if (joy.fd != -1) {
libevdev_free(joy.dev);
close(joy.fd);
joy.fd = -1;
input->joy_connection_changed(p_id, false, "");
};
};
END_TEST
START_TEST(test_event_code_filtered)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_event ev;
rc = test_create_device(&uidev, &dev,
EV_REL, REL_X,
EV_REL, REL_Y,
EV_KEY, BTN_LEFT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
libevdev_disable_event_code(dev, EV_REL, REL_X);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
ck_assert_int_eq(rc, -EAGAIN);
uinput_device_event(uidev, EV_REL, REL_X, 1);
uinput_device_event(uidev, EV_REL, REL_Y, 1);
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
ck_assert_int_eq(ev.type, EV_REL);
ck_assert_int_eq(ev.code, REL_Y);
ck_assert_int_eq(ev.value, 1);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
ck_assert_int_eq(rc, LIBEVDEV_READ_STATUS_SUCCESS);
ck_assert_int_eq(ev.type, EV_SYN);
ck_assert_int_eq(ev.code, SYN_REPORT);
rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
ck_assert_int_eq(rc, -EAGAIN);
libevdev_free(dev);
uinput_device_free(uidev);
}
END_TEST
START_TEST(test_event_mt_value_setters_invalid)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_absinfo abs[5];
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_MT_POSITION_X;
abs[1].maximum = 1000;
abs[2].value = ABS_Y;
abs[2].maximum = 1000;
abs[3].value = ABS_MT_POSITION_Y;
abs[3].maximum = 1000;
abs[4].value = ABS_MT_SLOT;
abs[4].maximum = 2;
rc = test_create_abs_device(&uidev, &dev,
5, abs,
EV_SYN, SYN_REPORT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
/* invalid axis */
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_Z, 1), -1);
/* valid, but non-mt axis */
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_X, 1), -1);
/* invalid mt axis */
ck_assert_int_eq(libevdev_set_slot_value(dev, 1, ABS_MT_PRESSURE, 1), -1);
/* invalid slot no */
ck_assert_int_eq(libevdev_set_slot_value(dev, 4, ABS_X, 1), -1);
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_has_event_pending)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_event ev;
rc = test_create_device(&uidev, &dev,
EV_REL, REL_X,
EV_REL, REL_Y,
EV_KEY, BTN_LEFT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
uinput_device_event(uidev, EV_REL, REL_X, 1);
uinput_device_event(uidev, EV_REL, REL_Y, 1);
uinput_device_event(uidev, EV_SYN, SYN_REPORT, 0);
ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev);
ck_assert_int_eq(libevdev_has_event_pending(dev), 1);
while ((rc = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &ev)) != -EAGAIN)
;
ck_assert_int_eq(libevdev_has_event_pending(dev), 0);
libevdev_change_fd(dev, -1);
ck_assert_int_eq(libevdev_has_event_pending(dev), -EBADF);
libevdev_free(dev);
uinput_device_free(uidev);
}
int main(int argc, char **argv)
{
struct libevdev *dev = NULL;
struct libevdev_uinput *uidev = NULL;
int fd, ret;
if (argc < 2){
fprintf(stderr, "Usage: %s <event device>\n", argv[0]);
return 1;
}
//open the event device file descriptor
fd = open(argv[1], O_RDONLY);
if (fd < 0) {perror("Failed to open device"); return fd;}
//create a libevdev device from the event file descriptor
ret = libevdev_new_from_fd(fd, &dev);
if (ret < 0) {perror("Failed to create libevdev device"); return ret;}
//create a device connected to the virtual device interface /dev/uinput
ret = libevdev_uinput_create_from_device(
dev,
LIBEVDEV_UINPUT_OPEN_MANAGED,
&uidev);
if (ret < 0) {perror("Failed to create uinput device"); return ret;}
sleep(1);
//EVIOCGRAB the event, this means no other client will receive the events from the device, including your window manager.
// "This is generally a bad idea. Don't do this." - libevdev documentation
//We need to do this to avoid douplicate keyboard events.
ret = libevdev_grab(dev, LIBEVDEV_GRAB);
//start the interceptor and never return
intercept(uidev, dev);
libevdev_uinput_destroy(uidev);
libevdev_grab(dev, LIBEVDEV_UNGRAB);
libevdev_free(dev);
return ret;
}
END_TEST
START_TEST(test_event_value_setters_invalid)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_absinfo abs[2];
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_Y;
abs[1].maximum = 1000;
rc = test_create_abs_device(&uidev, &dev,
2, abs,
EV_SYN, SYN_REPORT,
EV_REL, REL_X,
EV_REL, REL_Y,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_MIDDLE,
EV_KEY, BTN_RIGHT,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
ck_assert_int_eq(libevdev_set_event_value(dev, EV_REL, REL_X, 1), -1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_DOCK, 1), -1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Z, 1), -1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_MAX + 1, 0, 1), -1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SYN, SYN_REPORT, 0), -1);
uinput_device_free(uidev);
libevdev_free(dev);
}
END_TEST
START_TEST(test_uinput_create_device_invalid)
{
struct libevdev *dev;
struct libevdev_uinput *uidev = NULL;
int rc;
dev = libevdev_new();
ck_assert(dev != NULL);
libevdev_set_name(dev, TEST_DEVICE_NAME);
libevdev_enable_event_type(dev, EV_SYN);
libevdev_enable_event_type(dev, EV_REL);
libevdev_enable_event_code(dev, EV_REL, REL_X, NULL);
libevdev_enable_event_code(dev, EV_REL, REL_Y, NULL);
libevdev_set_log_function(test_logfunc_ignore_error, NULL);
rc = libevdev_uinput_create_from_device(dev, -1, &uidev);
ck_assert_int_eq(rc, -EBADF);
ck_assert(uidev == NULL);
libevdev_set_log_function(test_logfunc_abort_on_error, NULL);
libevdev_free(dev);
}
void adhoc_exit(struct adhoc *adhoc) {
adhoc->internal_calls.exit(adhoc);
libevdev_free(adhoc->dev);
free(adhoc);
}
int
main(int argc, char **argv)
{
struct libevdev *dev = NULL;
int fd = -1;
int rc = EXIT_FAILURE;
enum mode mode;
const char *path;
struct input_absinfo absinfo;
int axis = -1;
int led = -1;
int led_state = -1;
unsigned int changes = 0; /* bitmask of changes */
int xres = 0,
yres = 0;
mode = parse_options_mode(argc, argv);
switch (mode) {
case MODE_HELP:
rc = EXIT_SUCCESS;
/* fallthrough */
case MODE_NONE:
usage();
goto out;
case MODE_ABS:
rc = parse_options_abs(argc, argv, &changes, &axis,
&absinfo);
break;
case MODE_LED:
rc = parse_options_led(argc, argv, &led, &led_state);
break;
case MODE_RESOLUTION:
rc = parse_options_resolution(argc, argv, &xres,
&yres);
break;
default:
fprintf(stderr,
"++?????++ Out of Cheese Error. Redo From Start.\n");
goto out;
}
if (rc != EXIT_SUCCESS)
goto out;
if (optind >= argc) {
rc = EXIT_FAILURE;
usage();
goto out;
}
path = argv[optind];
fd = open(path, O_RDWR);
if (fd < 0) {
rc = EXIT_FAILURE;
perror("Failed to open device");
goto out;
}
rc = libevdev_new_from_fd(fd, &dev);
if (rc < 0) {
fprintf(stderr, "Failed to init libevdev (%s)\n", strerror(-rc));
goto out;
}
switch (mode) {
case MODE_ABS:
set_abs(dev, changes, axis, &absinfo);
break;
case MODE_LED:
set_led(dev, led, led_state);
break;
case MODE_RESOLUTION:
set_resolution(dev, xres, yres);
break;
default:
break;
}
out:
libevdev_free(dev);
if (fd != -1)
close(fd);
return rc;
}
END_TEST
START_TEST(test_event_value_setters)
{
struct uinput_device* uidev;
struct libevdev *dev;
int rc;
struct input_absinfo abs[2];
memset(abs, 0, sizeof(abs));
abs[0].value = ABS_X;
abs[0].maximum = 1000;
abs[1].value = ABS_Y;
abs[1].maximum = 1000;
rc = test_create_abs_device(&uidev, &dev,
2, abs,
EV_SYN, SYN_REPORT,
EV_REL, REL_X,
EV_REL, REL_Y,
EV_KEY, BTN_LEFT,
EV_KEY, BTN_MIDDLE,
EV_KEY, BTN_RIGHT,
EV_LED, LED_NUML,
EV_LED, LED_CAPSL,
EV_SW, SW_LID,
EV_SW, SW_TABLET_MODE,
-1);
ck_assert_msg(rc == 0, "Failed to create device: %s", strerror(-rc));
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_X), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_REL, REL_Y), 0);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_LEFT, 1), 0);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_KEY, BTN_RIGHT, 1), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_LEFT), 1);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_KEY, BTN_RIGHT), 1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_X, 10), 0);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_ABS, ABS_Y, 20), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_X), 10);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_ABS, ABS_Y), 20);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_NUML, 1), 0);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_LED, LED_CAPSL, 1), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_NUML), 1);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_LED, LED_CAPSL), 1);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_LID, 1), 0);
ck_assert_int_eq(libevdev_set_event_value(dev, EV_SW, SW_TABLET_MODE, 1), 0);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_LID), 1);
ck_assert_int_eq(libevdev_get_event_value(dev, EV_SW, SW_TABLET_MODE), 1);
uinput_device_free(uidev);
libevdev_free(dev);
}
