mirror of
https://gitlab.freedesktop.org/libinput/libinput.git
synced 2025-12-20 06:50:05 +01:00
e7a9c07ffe
Where a fuzz is defined in the 60-evdev.hwdb, we rely on a udev builtin to
set the kernel device to that fuzz value. Unfortunately that happens after our
program is called with this order of events:
1. 60-evdev.rules calls IMPORT(builtin) for the hwdb which sets the EVDEV_ABS_*
properties. It also sets RUN{builtin}=keyboard but that's not invoked yet.
2. 90-libinput-fuzz-override.rules calls IMPORT{program} for our fuzz override
bits. That sets the kernel fuzz value to 0 and sets the LIBINPUT_FUZZ_*
propertie
3. The keyboard builtin is run once all the rules have been processed.
Our problem is that where the fuzz is set in a hwdb entry, the kernel fuzz is
still unset when we get to look at it, so we always end up with a fuzz of zero
for us and a nonzero kernel fuzz.
Work around this by checking the EVDEV_ABS property, extracting the fuzz from
there and re-printing that property without the fuzz. This way we ensure the
kernel remains at zero fuzz and we use the one from the hwdb instead.
Fixes #346
Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
126 lines
3.6 KiB
C
126 lines
3.6 KiB
C
/*
|
|
* Copyright © 2019 Red Hat, Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the next
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
* Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <check.h>
|
|
|
|
/* remove the main() from the included program so we can define our own */
|
|
#define main __disabled
|
|
int main(int argc, char **argv);
|
|
#include "libinput-fuzz-extract.c"
|
|
#undef main
|
|
|
|
START_TEST(test_parse_ev_abs)
|
|
{
|
|
struct test {
|
|
uint32_t which;
|
|
const char *prop;
|
|
int min, max, res, fuzz, flat;
|
|
|
|
} tests[] = {
|
|
{ .which = (MIN|MAX),
|
|
.prop = "1:2",
|
|
.min = 1, .max = 2 },
|
|
{ .which = (MIN|MAX),
|
|
.prop = "1:2:",
|
|
.min = 1, .max = 2 },
|
|
{ .which = (MIN|MAX|RES),
|
|
.prop = "10:20:30",
|
|
.min = 10, .max = 20, .res = 30 },
|
|
{ .which = (RES),
|
|
.prop = "::100",
|
|
.res = 100 },
|
|
{ .which = (MIN),
|
|
.prop = "10:",
|
|
.min = 10 },
|
|
{ .which = (MAX|RES),
|
|
.prop = ":10:1001",
|
|
.max = 10, .res = 1001 },
|
|
{ .which = (MIN|MAX|RES|FUZZ),
|
|
.prop = "1:2:3:4",
|
|
.min = 1, .max = 2, .res = 3, .fuzz = 4},
|
|
{ .which = (MIN|MAX|RES|FUZZ|FLAT),
|
|
.prop = "1:2:3:4:5",
|
|
.min = 1, .max = 2, .res = 3, .fuzz = 4, .flat = 5},
|
|
{ .which = (MIN|RES|FUZZ|FLAT),
|
|
.prop = "1::3:4:50",
|
|
.min = 1, .res = 3, .fuzz = 4, .flat = 50},
|
|
{ .which = FUZZ|FLAT,
|
|
.prop = ":::5:60",
|
|
.fuzz = 5, .flat = 60},
|
|
{ .which = FUZZ,
|
|
.prop = ":::5:",
|
|
.fuzz = 5 },
|
|
{ .which = RES, .prop = "::12::",
|
|
.res = 12 },
|
|
/* Malformed property but parsing this one makes us more
|
|
* future proof */
|
|
{ .which = (RES|FUZZ|FLAT), .prop = "::12:1:2:3:4:5:6",
|
|
.res = 12, .fuzz = 1, .flat = 2 },
|
|
{ .which = 0, .prop = ":::::" },
|
|
{ .which = 0, .prop = ":" },
|
|
{ .which = 0, .prop = "" },
|
|
{ .which = 0, .prop = ":asb::::" },
|
|
{ .which = 0, .prop = "foo" },
|
|
};
|
|
struct test *t;
|
|
|
|
ARRAY_FOR_EACH(tests, t) {
|
|
struct input_absinfo abs;
|
|
uint32_t mask;
|
|
|
|
mask = parse_ev_abs_prop(t->prop, &abs);
|
|
ck_assert_int_eq(mask, t->which);
|
|
|
|
if (t->which & MIN)
|
|
ck_assert_int_eq(abs.minimum, t->min);
|
|
if (t->which & MAX)
|
|
ck_assert_int_eq(abs.maximum, t->max);
|
|
if (t->which & RES)
|
|
ck_assert_int_eq(abs.resolution, t->res);
|
|
if (t->which & FUZZ)
|
|
ck_assert_int_eq(abs.fuzz, t->fuzz);
|
|
if (t->which & FLAT)
|
|
ck_assert_int_eq(abs.flat, t->flat);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
int main(int argc, char **argv) {
|
|
|
|
SRunner *sr = srunner_create(NULL);
|
|
Suite *s = suite_create("fuzz-override");
|
|
TCase *tc = tcase_create("parser");
|
|
int nfailed;
|
|
|
|
tcase_add_test(tc, test_parse_ev_abs);
|
|
suite_add_tcase(s, tc);
|
|
srunner_add_suite(sr, s);
|
|
|
|
srunner_run_all(sr, CK_NORMAL);
|
|
nfailed = srunner_ntests_failed(sr);
|
|
srunner_free(sr);
|
|
|
|
return nfailed;
|
|
}
|