xref: /linux/Documentation/input/uinput.rst (revision 547f574fd9d5e3925d47fd44decbf6ab6df94b0e) 
1=============
2uinput module
3=============
4
5Introduction
6============
7
8uinput is a kernel module that makes it possible to emulate input devices
9from userspace. By writing to /dev/uinput (or /dev/input/uinput) device, a
10process can create a virtual input device with specific capabilities. Once
11this virtual device is created, the process can send events through it,
12that will be delivered to userspace and in-kernel consumers.
13
14Interface
15=========
16
17::
18
19  linux/uinput.h
20
21The uinput header defines ioctls to create, set up, and destroy virtual
22devices.
23
24libevdev
25========
26
27libevdev is a wrapper library for evdev devices that provides interfaces to
28create uinput devices and send events. libevdev is less error-prone than
29accessing uinput directly, and should be considered for new software.
30
31For examples and more information about libevdev:
32https://www.freedesktop.org/software/libevdev/doc/latest/
33
34Examples
35========
36
37Keyboard events
38---------------
39
40This first example shows how to create a new virtual device, and how to
41send a key event. All default imports and error handlers were removed for
42the sake of simplicity.
43
44.. code-block:: c
45
46   #include <linux/uinput.h>
47
48   void emit(int fd, int type, int code, int val)
49   {
50      struct input_event ie;
51
52      ie.type = type;
53      ie.code = code;
54      ie.value = val;
55      /* timestamp values below are ignored */
56      ie.time.tv_sec = 0;
57      ie.time.tv_usec = 0;
58
59      write(fd, &ie, sizeof(ie));
60   }
61
62   int main(void)
63   {
64      struct uinput_setup usetup;
65
66      int fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
67
68
69      /*
70       * The ioctls below will enable the device that is about to be
71       * created, to pass key events, in this case the space key.
72       */
73      ioctl(fd, UI_SET_EVBIT, EV_KEY);
74      ioctl(fd, UI_SET_KEYBIT, KEY_SPACE);
75
76      memset(&usetup, 0, sizeof(usetup));
77      usetup.id.bustype = BUS_USB;
78      usetup.id.vendor = 0x1234; /* sample vendor */
79      usetup.id.product = 0x5678; /* sample product */
80      strcpy(usetup.name, "Example device");
81
82      ioctl(fd, UI_DEV_SETUP, &usetup);
83      ioctl(fd, UI_DEV_CREATE);
84
85      /*
86       * On UI_DEV_CREATE the kernel will create the device node for this
87       * device. We are inserting a pause here so that userspace has time
88       * to detect, initialize the new device, and can start listening to
89       * the event, otherwise it will not notice the event we are about
90       * to send. This pause is only needed in our example code!
91       */
92      sleep(1);
93
94      /* Key press, report the event, send key release, and report again */
95      emit(fd, EV_KEY, KEY_SPACE, 1);
96      emit(fd, EV_SYN, SYN_REPORT, 0);
97      emit(fd, EV_KEY, KEY_SPACE, 0);
98      emit(fd, EV_SYN, SYN_REPORT, 0);
99
100      /*
101       * Give userspace some time to read the events before we destroy the
102       * device with UI_DEV_DESTROY.
103       */
104      sleep(1);
105
106      ioctl(fd, UI_DEV_DESTROY);
107      close(fd);
108
109      return 0;
110   }
111
112Mouse movements
113---------------
114
115This example shows how to create a virtual device that behaves like a physical
116mouse.
117
118.. code-block:: c
119
120   #include <linux/uinput.h>
121
122   /* emit function is identical to of the first example */
123
124   int main(void)
125   {
126      struct uinput_setup usetup;
127      int i = 50;
128
129      int fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
130
131      /* enable mouse button left and relative events */
132      ioctl(fd, UI_SET_EVBIT, EV_KEY);
133      ioctl(fd, UI_SET_KEYBIT, BTN_LEFT);
134
135      ioctl(fd, UI_SET_EVBIT, EV_REL);
136      ioctl(fd, UI_SET_RELBIT, REL_X);
137      ioctl(fd, UI_SET_RELBIT, REL_Y);
138
139      memset(&usetup, 0, sizeof(usetup));
140      usetup.id.bustype = BUS_USB;
141      usetup.id.vendor = 0x1234; /* sample vendor */
142      usetup.id.product = 0x5678; /* sample product */
143      strcpy(usetup.name, "Example device");
144
145      ioctl(fd, UI_DEV_SETUP, &usetup);
146      ioctl(fd, UI_DEV_CREATE);
147
148      /*
149       * On UI_DEV_CREATE the kernel will create the device node for this
150       * device. We are inserting a pause here so that userspace has time
151       * to detect, initialize the new device, and can start listening to
152       * the event, otherwise it will not notice the event we are about
153       * to send. This pause is only needed in our example code!
154       */
155      sleep(1);
156
157      /* Move the mouse diagonally, 5 units per axis */
158      while (i--) {
159         emit(fd, EV_REL, REL_X, 5);
160         emit(fd, EV_REL, REL_Y, 5);
161         emit(fd, EV_SYN, SYN_REPORT, 0);
162         usleep(15000);
163      }
164
165      /*
166       * Give userspace some time to read the events before we destroy the
167       * device with UI_DEV_DESTROY.
168       */
169      sleep(1);
170
171      ioctl(fd, UI_DEV_DESTROY);
172      close(fd);
173
174      return 0;
175   }
176
177
178uinput old interface
179--------------------
180
181Before uinput version 5, there wasn't a dedicated ioctl to set up a virtual
182device. Programs supportinf older versions of uinput interface need to fill
183a uinput_user_dev structure and write it to the uinput file descriptor to
184configure the new uinput device. New code should not use the old interface
185but interact with uinput via ioctl calls, or use libevdev.
186
187.. code-block:: c
188
189   #include <linux/uinput.h>
190
191   /* emit function is identical to of the first example */
192
193   int main(void)
194   {
195      struct uinput_user_dev uud;
196      int version, rc, fd;
197
198      fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
199      rc = ioctl(fd, UI_GET_VERSION, &version);
200
201      if (rc == 0 && version >= 5) {
202         /* use UI_DEV_SETUP */
203         return 0;
204      }
205
206      /*
207       * The ioctls below will enable the device that is about to be
208       * created, to pass key events, in this case the space key.
209       */
210      ioctl(fd, UI_SET_EVBIT, EV_KEY);
211      ioctl(fd, UI_SET_KEYBIT, KEY_SPACE);
212
213      memset(&uud, 0, sizeof(uud));
214      snprintf(uud.name, UINPUT_MAX_NAME_SIZE, "uinput old interface");
215      write(fd, &uud, sizeof(uud));
216
217      ioctl(fd, UI_DEV_CREATE);
218
219      /*
220       * On UI_DEV_CREATE the kernel will create the device node for this
221       * device. We are inserting a pause here so that userspace has time
222       * to detect, initialize the new device, and can start listening to
223       * the event, otherwise it will not notice the event we are about
224       * to send. This pause is only needed in our example code!
225       */
226      sleep(1);
227
228      /* Key press, report the event, send key release, and report again */
229      emit(fd, EV_KEY, KEY_SPACE, 1);
230      emit(fd, EV_SYN, SYN_REPORT, 0);
231      emit(fd, EV_KEY, KEY_SPACE, 0);
232      emit(fd, EV_SYN, SYN_REPORT, 0);
233
234      /*
235       * Give userspace some time to read the events before we destroy the
236       * device with UI_DEV_DESTROY.
237       */
238      sleep(1);
239
240      ioctl(fd, UI_DEV_DESTROY);
241
242      close(fd);
243      return 0;
244   }
245
246