You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
451 lines
11 KiB
451 lines
11 KiB
/*
|
|
* Copyright (c) 2015 Etienne Gemsa <etienne.gemsa@lse.epita.fr>
|
|
* Copyright (c) 2015-2016 Dmitry V. Levin <ldv@altlinux.org>
|
|
* Copyright (c) 2015-2018 The strace developers.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "defs.h"
|
|
|
|
#include "xlat/evdev_abs.h"
|
|
#include "xlat/evdev_ev.h"
|
|
|
|
#ifdef HAVE_LINUX_INPUT_H
|
|
|
|
# include <linux/ioctl.h>
|
|
# include <linux/input.h>
|
|
|
|
# include "xlat/evdev_autorepeat.h"
|
|
# include "xlat/evdev_ff_status.h"
|
|
# include "xlat/evdev_ff_types.h"
|
|
# include "xlat/evdev_keycode.h"
|
|
# include "xlat/evdev_leds.h"
|
|
# include "xlat/evdev_misc.h"
|
|
# include "xlat/evdev_mtslots.h"
|
|
# include "xlat/evdev_prop.h"
|
|
# include "xlat/evdev_relative_axes.h"
|
|
# include "xlat/evdev_snd.h"
|
|
# include "xlat/evdev_switch.h"
|
|
|
|
# ifndef SYN_MAX
|
|
# define SYN_MAX 0xf
|
|
# endif
|
|
|
|
const size_t evdev_abs_size = ARRAY_SIZE(evdev_abs) - 1;
|
|
|
|
static int
|
|
abs_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
|
|
{
|
|
tprints(", ");
|
|
|
|
struct input_absinfo absinfo;
|
|
|
|
if (!umove_or_printaddr(tcp, arg, &absinfo)) {
|
|
tprintf("{value=%u"
|
|
", minimum=%u, ",
|
|
absinfo.value,
|
|
absinfo.minimum);
|
|
|
|
if (!abbrev(tcp)) {
|
|
tprintf("maximum=%u"
|
|
", fuzz=%u"
|
|
", flat=%u",
|
|
absinfo.maximum,
|
|
absinfo.fuzz,
|
|
absinfo.flat);
|
|
# ifdef HAVE_STRUCT_INPUT_ABSINFO_RESOLUTION
|
|
tprintf(", resolution=%u",
|
|
absinfo.resolution);
|
|
# endif
|
|
} else {
|
|
tprints("...");
|
|
}
|
|
|
|
tprints("}");
|
|
}
|
|
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
|
|
static int
|
|
keycode_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
|
|
{
|
|
tprints(", ");
|
|
|
|
unsigned int keycode[2];
|
|
|
|
if (!umove_or_printaddr(tcp, arg, &keycode)) {
|
|
tprintf("[%u, ", keycode[0]);
|
|
printxval_index(evdev_keycode, keycode[1], "KEY_???");
|
|
tprints("]");
|
|
}
|
|
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
|
|
# ifdef EVIOCGKEYCODE_V2
|
|
static int
|
|
keycode_V2_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
|
|
{
|
|
tprints(", ");
|
|
|
|
struct input_keymap_entry ike;
|
|
|
|
if (umove_or_printaddr(tcp, arg, &ike))
|
|
return RVAL_IOCTL_DECODED;
|
|
|
|
tprintf("{flags=%" PRIu8
|
|
", len=%" PRIu8 ", ",
|
|
ike.flags,
|
|
ike.len);
|
|
|
|
if (!abbrev(tcp)) {
|
|
unsigned int i;
|
|
|
|
tprintf("index=%" PRIu16 ", keycode=", ike.index);
|
|
printxval_index(evdev_keycode, ike.keycode, "KEY_???");
|
|
tprints(", scancode=[");
|
|
for (i = 0; i < ARRAY_SIZE(ike.scancode); i++) {
|
|
if (i > 0)
|
|
tprints(", ");
|
|
tprintf("%" PRIx8, ike.scancode[i]);
|
|
}
|
|
tprints("]");
|
|
} else {
|
|
tprints("...");
|
|
}
|
|
|
|
tprints("}");
|
|
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
# endif /* EVIOCGKEYCODE_V2 */
|
|
|
|
static int
|
|
getid_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
|
|
{
|
|
tprints(", ");
|
|
|
|
struct input_id id;
|
|
|
|
if (!umove_or_printaddr(tcp, arg, &id))
|
|
tprintf("{ID_BUS=%" PRIu16
|
|
", ID_VENDOR=%" PRIu16
|
|
", ID_PRODUCT=%" PRIu16
|
|
", ID_VERSION=%" PRIu16 "}",
|
|
id.bustype,
|
|
id.vendor,
|
|
id.product,
|
|
id.version);
|
|
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
|
|
static int
|
|
decode_bitset_(struct tcb *const tcp, const kernel_ulong_t arg,
|
|
const struct xlat decode_nr[], const unsigned int max_nr,
|
|
const char *const dflt, size_t decode_nr_size, enum xlat_type xt)
|
|
{
|
|
tprints(", ");
|
|
|
|
unsigned int size;
|
|
if ((kernel_ulong_t) tcp->u_rval > max_nr / 8)
|
|
size = max_nr;
|
|
else
|
|
size = tcp->u_rval * 8;
|
|
char decoded_arg[size];
|
|
|
|
if (umove_or_printaddr(tcp, arg, &decoded_arg))
|
|
return RVAL_IOCTL_DECODED;
|
|
|
|
tprints("[");
|
|
|
|
int bit_displayed = 0;
|
|
int i = next_set_bit(decoded_arg, 0, size);
|
|
if (i < 0) {
|
|
tprints(" 0 ");
|
|
} else {
|
|
printxval_dispatch(decode_nr, decode_nr_size, i, dflt, xt);
|
|
|
|
while ((i = next_set_bit(decoded_arg, i + 1, size)) > 0) {
|
|
if (abbrev(tcp) && bit_displayed >= 3) {
|
|
tprints(", ...");
|
|
break;
|
|
}
|
|
tprints(", ");
|
|
printxval_dispatch(decode_nr, decode_nr_size, i, dflt,
|
|
xt);
|
|
bit_displayed++;
|
|
}
|
|
}
|
|
|
|
tprints("]");
|
|
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
|
|
#define decode_bitset(tcp_, arg_, decode_nr_, max_nr_, dflt_, xt_) \
|
|
decode_bitset_((tcp_), (arg_), (decode_nr_), (max_nr_), \
|
|
(dflt_), ARRAY_SIZE(decode_nr_), (xt_))
|
|
|
|
# ifdef EVIOCGMTSLOTS
|
|
static int
|
|
mtslots_ioctl(struct tcb *const tcp, const unsigned int code,
|
|
const kernel_ulong_t arg)
|
|
{
|
|
tprints(", ");
|
|
|
|
const size_t size = _IOC_SIZE(code) / sizeof(int);
|
|
if (!size) {
|
|
printaddr(arg);
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
|
|
int buffer[size];
|
|
|
|
if (umove_or_printaddr(tcp, arg, &buffer))
|
|
return RVAL_IOCTL_DECODED;
|
|
|
|
tprints("{code=");
|
|
printxval(evdev_mtslots, buffer[0], "ABS_MT_???");
|
|
|
|
tprints(", values=[");
|
|
|
|
unsigned int i;
|
|
for (i = 1; i < ARRAY_SIZE(buffer); i++)
|
|
tprintf("%s%d", i > 1 ? ", " : "", buffer[i]);
|
|
|
|
tprints("]}");
|
|
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
# endif /* EVIOCGMTSLOTS */
|
|
|
|
# if defined EVIOCGREP || defined EVIOCSREP
|
|
static int
|
|
repeat_ioctl(struct tcb *const tcp, const kernel_ulong_t arg)
|
|
{
|
|
tprints(", ");
|
|
printpair_int(tcp, arg, "%u");
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
# endif /* EVIOCGREP || EVIOCSREP */
|
|
|
|
static int
|
|
bit_ioctl(struct tcb *const tcp, const unsigned int ev_nr,
|
|
const kernel_ulong_t arg)
|
|
{
|
|
switch (ev_nr) {
|
|
case 0:
|
|
return decode_bitset(tcp, arg, evdev_ev,
|
|
EV_MAX, "EV_???", XT_SORTED);
|
|
case EV_KEY:
|
|
return decode_bitset(tcp, arg, evdev_keycode,
|
|
KEY_MAX, "KEY_???", XT_INDEXED);
|
|
case EV_REL:
|
|
return decode_bitset(tcp, arg, evdev_relative_axes,
|
|
REL_MAX, "REL_???", XT_INDEXED);
|
|
case EV_ABS:
|
|
return decode_bitset(tcp, arg, evdev_abs,
|
|
ABS_MAX, "ABS_???", XT_INDEXED);
|
|
case EV_MSC:
|
|
return decode_bitset(tcp, arg, evdev_misc,
|
|
MSC_MAX, "MSC_???", XT_INDEXED);
|
|
case EV_SW:
|
|
return decode_bitset(tcp, arg, evdev_switch,
|
|
SW_MAX, "SW_???", XT_INDEXED);
|
|
case EV_LED:
|
|
return decode_bitset(tcp, arg, evdev_leds,
|
|
LED_MAX, "LED_???", XT_INDEXED);
|
|
case EV_SND:
|
|
return decode_bitset(tcp, arg, evdev_snd,
|
|
SND_MAX, "SND_???", XT_INDEXED);
|
|
case EV_REP:
|
|
return decode_bitset(tcp, arg, evdev_autorepeat,
|
|
REP_MAX, "REP_???", XT_INDEXED);
|
|
case EV_FF:
|
|
return decode_bitset(tcp, arg, evdev_ff_types,
|
|
FF_MAX, "FF_???", XT_SORTED);
|
|
case EV_PWR:
|
|
tprints(", ");
|
|
printnum_int(tcp, arg, "%d");
|
|
return RVAL_IOCTL_DECODED;
|
|
case EV_FF_STATUS:
|
|
return decode_bitset(tcp, arg, evdev_ff_status,
|
|
FF_STATUS_MAX, "FF_STATUS_???",
|
|
XT_INDEXED);
|
|
default:
|
|
tprints(", ");
|
|
printaddr(arg);
|
|
return RVAL_IOCTL_DECODED;
|
|
}
|
|
}
|
|
|
|
static int
|
|
evdev_read_ioctl(struct tcb *const tcp, const unsigned int code,
|
|
const kernel_ulong_t arg)
|
|
{
|
|
/* fixed-number fixed-length commands */
|
|
switch (code) {
|
|
case EVIOCGVERSION:
|
|
tprints(", ");
|
|
printnum_int(tcp, arg, "%#x");
|
|
return RVAL_IOCTL_DECODED;
|
|
case EVIOCGEFFECTS:
|
|
tprints(", ");
|
|
printnum_int(tcp, arg, "%u");
|
|
return RVAL_IOCTL_DECODED;
|
|
case EVIOCGID:
|
|
return getid_ioctl(tcp, arg);
|
|
# ifdef EVIOCGREP
|
|
case EVIOCGREP:
|
|
return repeat_ioctl(tcp, arg);
|
|
# endif
|
|
case EVIOCGKEYCODE:
|
|
return keycode_ioctl(tcp, arg);
|
|
# ifdef EVIOCGKEYCODE_V2
|
|
case EVIOCGKEYCODE_V2:
|
|
return keycode_V2_ioctl(tcp, arg);
|
|
# endif
|
|
}
|
|
|
|
/* fixed-number variable-length commands */
|
|
switch (_IOC_NR(code)) {
|
|
# ifdef EVIOCGMTSLOTS
|
|
case _IOC_NR(EVIOCGMTSLOTS(0)):
|
|
return mtslots_ioctl(tcp, code, arg);
|
|
# endif
|
|
case _IOC_NR(EVIOCGNAME(0)):
|
|
case _IOC_NR(EVIOCGPHYS(0)):
|
|
case _IOC_NR(EVIOCGUNIQ(0)):
|
|
tprints(", ");
|
|
if (syserror(tcp))
|
|
printaddr(arg);
|
|
else
|
|
printstrn(tcp, arg, tcp->u_rval);
|
|
return RVAL_IOCTL_DECODED;
|
|
# ifdef EVIOCGPROP
|
|
case _IOC_NR(EVIOCGPROP(0)):
|
|
return decode_bitset(tcp, arg, evdev_prop,
|
|
INPUT_PROP_MAX, "PROP_???",
|
|
XT_INDEXED);
|
|
# endif
|
|
case _IOC_NR(EVIOCGSND(0)):
|
|
return decode_bitset(tcp, arg, evdev_snd,
|
|
SND_MAX, "SND_???", XT_INDEXED);
|
|
# ifdef EVIOCGSW
|
|
case _IOC_NR(EVIOCGSW(0)):
|
|
return decode_bitset(tcp, arg, evdev_switch,
|
|
SW_MAX, "SW_???", XT_INDEXED);
|
|
# endif
|
|
case _IOC_NR(EVIOCGKEY(0)):
|
|
return decode_bitset(tcp, arg, evdev_keycode,
|
|
KEY_MAX, "KEY_???", XT_INDEXED);
|
|
case _IOC_NR(EVIOCGLED(0)):
|
|
return decode_bitset(tcp, arg, evdev_leds,
|
|
LED_MAX, "LED_???", XT_INDEXED);
|
|
}
|
|
|
|
/* multi-number fixed-length commands */
|
|
if ((_IOC_NR(code) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0)))
|
|
return abs_ioctl(tcp, arg);
|
|
|
|
/* multi-number variable-length commands */
|
|
if ((_IOC_NR(code) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
|
|
return bit_ioctl(tcp, _IOC_NR(code) & EV_MAX, arg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
evdev_write_ioctl(struct tcb *const tcp, const unsigned int code,
|
|
const kernel_ulong_t arg)
|
|
{
|
|
/* fixed-number fixed-length commands */
|
|
switch (code) {
|
|
# ifdef EVIOCSREP
|
|
case EVIOCSREP:
|
|
return repeat_ioctl(tcp, arg);
|
|
# endif
|
|
case EVIOCSKEYCODE:
|
|
return keycode_ioctl(tcp, arg);
|
|
# ifdef EVIOCSKEYCODE_V2
|
|
case EVIOCSKEYCODE_V2:
|
|
return keycode_V2_ioctl(tcp, arg);
|
|
# endif
|
|
case EVIOCRMFF:
|
|
tprintf(", %d", (int) arg);
|
|
return RVAL_IOCTL_DECODED;
|
|
case EVIOCGRAB:
|
|
# ifdef EVIOCREVOKE
|
|
case EVIOCREVOKE:
|
|
# endif
|
|
tprintf(", %" PRI_klu, arg);
|
|
return RVAL_IOCTL_DECODED;
|
|
# ifdef EVIOCSCLOCKID
|
|
case EVIOCSCLOCKID:
|
|
tprints(", ");
|
|
printnum_int(tcp, arg, "%u");
|
|
return RVAL_IOCTL_DECODED;
|
|
# endif
|
|
default: {
|
|
int rc = evdev_write_ioctl_mpers(tcp, code, arg);
|
|
|
|
if (rc != RVAL_DECODED)
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
/* multi-number fixed-length commands */
|
|
if ((_IOC_NR(code) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0)))
|
|
return abs_ioctl(tcp, arg);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
print_evdev_ff_type(const kernel_ulong_t val)
|
|
{
|
|
printxval(evdev_ff_types, val, "FF_???");
|
|
}
|
|
|
|
int
|
|
evdev_ioctl(struct tcb *const tcp,
|
|
const unsigned int code, const kernel_ulong_t arg)
|
|
{
|
|
switch (_IOC_DIR(code)) {
|
|
case _IOC_READ:
|
|
if (entering(tcp))
|
|
return 0;
|
|
return evdev_read_ioctl(tcp, code, arg);
|
|
case _IOC_WRITE:
|
|
return evdev_write_ioctl(tcp, code, arg) | RVAL_DECODED;
|
|
default:
|
|
return RVAL_DECODED;
|
|
}
|
|
}
|
|
|
|
#endif /* HAVE_LINUX_INPUT_H */
|