xref: /openbmc/qemu/ui/input-barrier.c (revision 6f9ff551) 
1 /*
2  * SPDX-License-Identifier: GPL-2.0-or-later
3  *
4  * This work is licensed under the terms of the GNU GPL, version 2 or later.
5  * See the COPYING file in the top-level directory.
6  */
7 
8 #include "qemu/osdep.h"
9 #include "sysemu/sysemu.h"
10 #include "qemu/main-loop.h"
11 #include "qemu/sockets.h"
12 #include "qapi/error.h"
13 #include "qom/object_interfaces.h"
14 #include "io/channel-socket.h"
15 #include "ui/input.h"
16 #include "qom/object.h"
17 #include "ui/vnc_keysym.h" /* use name2keysym from VNC as we use X11 values */
18 #include "qemu/cutils.h"
19 #include "qapi/qmp/qerror.h"
20 #include "input-barrier.h"
21 
22 #define TYPE_INPUT_BARRIER "input-barrier"
23 OBJECT_DECLARE_SIMPLE_TYPE(InputBarrier, input_barrier,
24                            INPUT_BARRIER, ObjectClass)
25 
26 
27 #define MAX_HELLO_LENGTH 1024
28 
29 struct InputBarrier {
30     Object parent;
31 
32     QIOChannelSocket *sioc;
33     guint ioc_tag;
34 
35     /* display properties */
36     gchar *name;
37     int16_t x_origin, y_origin;
38     int16_t width, height;
39 
40     /* keyboard/mouse server */
41 
42     SocketAddress saddr;
43 
44     char buffer[MAX_HELLO_LENGTH];
45 };
46 
47 
48 static const char *cmd_names[] = {
49     [barrierCmdCNoop]          = "CNOP",
50     [barrierCmdCClose]         = "CBYE",
51     [barrierCmdCEnter]         = "CINN",
52     [barrierCmdCLeave]         = "COUT",
53     [barrierCmdCClipboard]     = "CCLP",
54     [barrierCmdCScreenSaver]   = "CSEC",
55     [barrierCmdCResetOptions]  = "CROP",
56     [barrierCmdCInfoAck]       = "CIAK",
57     [barrierCmdCKeepAlive]     = "CALV",
58     [barrierCmdDKeyDown]       = "DKDN",
59     [barrierCmdDKeyRepeat]     = "DKRP",
60     [barrierCmdDKeyUp]         = "DKUP",
61     [barrierCmdDMouseDown]     = "DMDN",
62     [barrierCmdDMouseUp]       = "DMUP",
63     [barrierCmdDMouseMove]     = "DMMV",
64     [barrierCmdDMouseRelMove]  = "DMRM",
65     [barrierCmdDMouseWheel]    = "DMWM",
66     [barrierCmdDClipboard]     = "DCLP",
67     [barrierCmdDInfo]          = "DINF",
68     [barrierCmdDSetOptions]    = "DSOP",
69     [barrierCmdDFileTransfer]  = "DFTR",
70     [barrierCmdDDragInfo]      = "DDRG",
71     [barrierCmdQInfo]          = "QINF",
72     [barrierCmdEIncompatible]  = "EICV",
73     [barrierCmdEBusy]          = "EBSY",
74     [barrierCmdEUnknown]       = "EUNK",
75     [barrierCmdEBad]           = "EBAD",
76     [barrierCmdHello]          = "Barrier",
77     [barrierCmdHelloBack]      = "Barrier",
78 };
79 
80 static kbd_layout_t *kbd_layout;
81 
82 static int input_barrier_to_qcode(uint16_t keyid, uint16_t keycode)
83 {
84     /* keycode is optional, if it is not provided use keyid */
85     if (keycode && keycode <= qemu_input_map_xorgkbd_to_qcode_len) {
86         return qemu_input_map_xorgkbd_to_qcode[keycode];
87     }
88 
89     if (keyid >= 0xE000 && keyid <= 0xEFFF) {
90         keyid += 0x1000;
91     }
92 
93     /* keyid is the X11 key id */
94     if (kbd_layout) {
95         keycode = keysym2scancode(kbd_layout, keyid, NULL, false);
96 
97         return qemu_input_key_number_to_qcode(keycode);
98     }
99 
100     return qemu_input_map_x11_to_qcode[keyid];
101 }
102 
103 static int input_barrier_to_mouse(uint8_t buttonid)
104 {
105     switch (buttonid) {
106     case barrierButtonLeft:
107         return INPUT_BUTTON_LEFT;
108     case barrierButtonMiddle:
109         return INPUT_BUTTON_MIDDLE;
110     case barrierButtonRight:
111         return INPUT_BUTTON_RIGHT;
112     case barrierButtonExtra0:
113         return INPUT_BUTTON_SIDE;
114     }
115     return buttonid;
116 }
117 
118 #define read_char(x, p, l)           \
119 do {                                 \
120     int size = sizeof(char);         \
121     if (l < size) {                  \
122         return G_SOURCE_REMOVE;      \
123     }                                \
124     x = *(char *)p;                  \
125     p += size;                       \
126     l -= size;                       \
127 } while (0)
128 
129 #define read_short(x, p, l)          \
130 do {                                 \
131     int size = sizeof(short);        \
132     if (l < size) {                  \
133         return G_SOURCE_REMOVE;      \
134     }                                \
135     x = ntohs(*(short *)p);          \
136     p += size;                       \
137     l -= size;                       \
138 } while (0)
139 
140 #define write_short(p, x, l)         \
141 do {                                 \
142     int size = sizeof(short);        \
143     if (l < size) {                  \
144         return G_SOURCE_REMOVE;      \
145     }                                \
146     *(short *)p = htons(x);          \
147     p += size;                       \
148     l -= size;                       \
149 } while (0)
150 
151 #define read_int(x, p, l)            \
152 do {                                 \
153     int size = sizeof(int);          \
154     if (l < size) {                  \
155         return G_SOURCE_REMOVE;      \
156     }                                \
157     x = ntohl(*(int *)p);            \
158     p += size;                       \
159     l -= size;                       \
160 } while (0)
161 
162 #define write_int(p, x, l)           \
163 do {                                 \
164     int size = sizeof(int);          \
165     if (l < size) {                  \
166         return G_SOURCE_REMOVE;      \
167     }                                \
168     *(int *)p = htonl(x);            \
169     p += size;                       \
170     l -= size;                       \
171 } while (0)
172 
173 #define write_cmd(p, c, l)           \
174 do {                                 \
175     int size = strlen(cmd_names[c]); \
176     if (l < size) {                  \
177         return G_SOURCE_REMOVE;      \
178     }                                \
179     memcpy(p, cmd_names[c], size);   \
180     p += size;                       \
181     l -= size;                       \
182 } while (0)
183 
184 #define write_string(p, s, l)        \
185 do {                                 \
186     int size = strlen(s);            \
187     if (l < size + sizeof(int)) {    \
188         return G_SOURCE_REMOVE;      \
189     }                                \
190     *(int *)p = htonl(size);         \
191     p += sizeof(size);               \
192     l -= sizeof(size);               \
193     memcpy(p, s, size);              \
194     p += size;                       \
195     l -= size;                       \
196 } while (0)
197 
198 static gboolean readcmd(InputBarrier *ib, struct barrierMsg *msg)
199 {
200     int ret, len, i;
201     enum barrierCmd cmd;
202     char *p;
203 
204     ret = qio_channel_read(QIO_CHANNEL(ib->sioc), (char *)&len, sizeof(len),
205                            NULL);
206     if (ret < 0) {
207         return G_SOURCE_REMOVE;
208     }
209 
210     len = ntohl(len);
211     if (len > MAX_HELLO_LENGTH) {
212         return G_SOURCE_REMOVE;
213     }
214 
215     ret = qio_channel_read(QIO_CHANNEL(ib->sioc), ib->buffer, len, NULL);
216     if (ret < 0) {
217         return G_SOURCE_REMOVE;
218     }
219 
220     p = ib->buffer;
221     if (len >= strlen(cmd_names[barrierCmdHello]) &&
222         memcmp(p, cmd_names[barrierCmdHello],
223                strlen(cmd_names[barrierCmdHello])) == 0) {
224         cmd = barrierCmdHello;
225         p += strlen(cmd_names[barrierCmdHello]);
226         len -= strlen(cmd_names[barrierCmdHello]);
227     } else {
228         for (cmd = 0; cmd < barrierCmdHello; cmd++) {
229             if (memcmp(ib->buffer, cmd_names[cmd], 4) == 0) {
230                 break;
231             }
232         }
233 
234         if (cmd == barrierCmdHello) {
235             return G_SOURCE_REMOVE;
236         }
237         p += 4;
238         len -= 4;
239     }
240 
241     msg->cmd = cmd;
242     switch (cmd) {
243     /* connection */
244     case barrierCmdHello:
245         read_short(msg->version.major, p, len);
246         read_short(msg->version.minor, p, len);
247         break;
248     case barrierCmdDSetOptions:
249         read_int(msg->set.nb, p, len);
250         msg->set.nb /= 2;
251         if (msg->set.nb > BARRIER_MAX_OPTIONS) {
252             msg->set.nb = BARRIER_MAX_OPTIONS;
253         }
254         i = 0;
255         while (len && i < msg->set.nb) {
256             read_int(msg->set.option[i].id, p, len);
257             /* it's a string, restore endianness */
258             msg->set.option[i].id = htonl(msg->set.option[i].id);
259             msg->set.option[i].nul = 0;
260             read_int(msg->set.option[i].value, p, len);
261             i++;
262         }
263         break;
264     case barrierCmdQInfo:
265         break;
266 
267     /* mouse */
268     case barrierCmdDMouseMove:
269     case barrierCmdDMouseRelMove:
270         read_short(msg->mousepos.x, p, len);
271         read_short(msg->mousepos.y, p, len);
272         break;
273     case barrierCmdDMouseDown:
274     case barrierCmdDMouseUp:
275         read_char(msg->mousebutton.buttonid, p, len);
276         break;
277     case barrierCmdDMouseWheel:
278         read_short(msg->mousepos.y, p, len);
279         msg->mousepos.x = 0;
280         if (len) {
281             msg->mousepos.x = msg->mousepos.y;
282             read_short(msg->mousepos.y, p, len);
283         }
284         break;
285 
286     /* keyboard */
287     case barrierCmdDKeyDown:
288     case barrierCmdDKeyUp:
289         read_short(msg->key.keyid, p, len);
290         read_short(msg->key.modifier, p, len);
291         msg->key.button = 0;
292         if (len) {
293             read_short(msg->key.button, p, len);
294         }
295         break;
296     case barrierCmdDKeyRepeat:
297         read_short(msg->repeat.keyid, p, len);
298         read_short(msg->repeat.modifier, p, len);
299         read_short(msg->repeat.repeat, p, len);
300         msg->repeat.button = 0;
301         if (len) {
302             read_short(msg->repeat.button, p, len);
303         }
304         break;
305     case barrierCmdCInfoAck:
306     case barrierCmdCResetOptions:
307     case barrierCmdCEnter:
308     case barrierCmdDClipboard:
309     case barrierCmdCKeepAlive:
310     case barrierCmdCLeave:
311     case barrierCmdCClose:
312         break;
313 
314     /* Invalid from the server */
315     case barrierCmdHelloBack:
316     case barrierCmdCNoop:
317     case barrierCmdDInfo:
318         break;
319 
320     /* Error codes */
321     case barrierCmdEIncompatible:
322         read_short(msg->version.major, p, len);
323         read_short(msg->version.minor, p, len);
324         break;
325     case barrierCmdEBusy:
326     case barrierCmdEUnknown:
327     case barrierCmdEBad:
328         break;
329     default:
330         return G_SOURCE_REMOVE;
331     }
332 
333     return G_SOURCE_CONTINUE;
334 }
335 
336 static gboolean writecmd(InputBarrier *ib, struct barrierMsg *msg)
337 {
338     char *p;
339     int ret, i;
340     int avail, len;
341 
342     p = ib->buffer;
343     avail = MAX_HELLO_LENGTH;
344 
345     /* reserve space to store the length */
346     p += sizeof(int);
347     avail -= sizeof(int);
348 
349     switch (msg->cmd) {
350     case barrierCmdHello:
351         if (msg->version.major < BARRIER_VERSION_MAJOR ||
352             (msg->version.major == BARRIER_VERSION_MAJOR &&
353              msg->version.minor < BARRIER_VERSION_MINOR)) {
354             ib->ioc_tag = 0;
355             return G_SOURCE_REMOVE;
356         }
357         write_cmd(p, barrierCmdHelloBack, avail);
358         write_short(p, BARRIER_VERSION_MAJOR, avail);
359         write_short(p, BARRIER_VERSION_MINOR, avail);
360         write_string(p, ib->name, avail);
361         break;
362     case barrierCmdCClose:
363         ib->ioc_tag = 0;
364         return G_SOURCE_REMOVE;
365     case barrierCmdQInfo:
366         write_cmd(p, barrierCmdDInfo, avail);
367         write_short(p, ib->x_origin, avail);
368         write_short(p, ib->y_origin, avail);
369         write_short(p, ib->width, avail);
370         write_short(p, ib->height, avail);
371         write_short(p, 0, avail);    /* warpsize (obsolete) */
372         write_short(p, 0, avail);    /* mouse x */
373         write_short(p, 0, avail);    /* mouse y */
374         break;
375     case barrierCmdCInfoAck:
376         break;
377     case barrierCmdCResetOptions:
378         /* TODO: reset options */
379         break;
380     case barrierCmdDSetOptions:
381         /* TODO: set options */
382         break;
383     case barrierCmdCEnter:
384         break;
385     case barrierCmdDClipboard:
386         break;
387     case barrierCmdCKeepAlive:
388         write_cmd(p, barrierCmdCKeepAlive, avail);
389         break;
390     case barrierCmdCLeave:
391         break;
392 
393     /* mouse */
394     case barrierCmdDMouseMove:
395         qemu_input_queue_abs(NULL, INPUT_AXIS_X, msg->mousepos.x,
396                              ib->x_origin, ib->width);
397         qemu_input_queue_abs(NULL, INPUT_AXIS_Y, msg->mousepos.y,
398                              ib->y_origin, ib->height);
399         qemu_input_event_sync();
400         break;
401     case barrierCmdDMouseRelMove:
402         qemu_input_queue_rel(NULL, INPUT_AXIS_X, msg->mousepos.x);
403         qemu_input_queue_rel(NULL, INPUT_AXIS_Y, msg->mousepos.y);
404         qemu_input_event_sync();
405         break;
406     case barrierCmdDMouseDown:
407         qemu_input_queue_btn(NULL,
408                              input_barrier_to_mouse(msg->mousebutton.buttonid),
409                              true);
410         qemu_input_event_sync();
411         break;
412     case barrierCmdDMouseUp:
413         qemu_input_queue_btn(NULL,
414                              input_barrier_to_mouse(msg->mousebutton.buttonid),
415                              false);
416         qemu_input_event_sync();
417         break;
418     case barrierCmdDMouseWheel:
419         qemu_input_queue_btn(NULL, (msg->mousepos.y > 0) ? INPUT_BUTTON_WHEEL_UP
420                              : INPUT_BUTTON_WHEEL_DOWN, true);
421         qemu_input_event_sync();
422         qemu_input_queue_btn(NULL, (msg->mousepos.y > 0) ? INPUT_BUTTON_WHEEL_UP
423                              : INPUT_BUTTON_WHEEL_DOWN, false);
424         qemu_input_event_sync();
425         break;
426 
427     /* keyboard */
428     case barrierCmdDKeyDown:
429         qemu_input_event_send_key_qcode(NULL,
430                         input_barrier_to_qcode(msg->key.keyid, msg->key.button),
431                                         true);
432         break;
433     case barrierCmdDKeyRepeat:
434         for (i = 0; i < msg->repeat.repeat; i++) {
435             qemu_input_event_send_key_qcode(NULL,
436                   input_barrier_to_qcode(msg->repeat.keyid, msg->repeat.button),
437                                             false);
438             qemu_input_event_send_key_qcode(NULL,
439                   input_barrier_to_qcode(msg->repeat.keyid, msg->repeat.button),
440                                             true);
441         }
442         break;
443     case barrierCmdDKeyUp:
444         qemu_input_event_send_key_qcode(NULL,
445                         input_barrier_to_qcode(msg->key.keyid, msg->key.button),
446                                         false);
447         break;
448     default:
449         write_cmd(p, barrierCmdEUnknown, avail);
450         break;
451     }
452 
453     len = MAX_HELLO_LENGTH - avail - sizeof(int);
454     if (len) {
455         p = ib->buffer;
456         avail = sizeof(len);
457         write_int(p, len, avail);
458         ret = qio_channel_write(QIO_CHANNEL(ib->sioc), ib->buffer,
459                                 len + sizeof(len), NULL);
460         if (ret < 0) {
461             ib->ioc_tag = 0;
462             return G_SOURCE_REMOVE;
463         }
464     }
465 
466     return G_SOURCE_CONTINUE;
467 }
468 
469 static gboolean input_barrier_event(QIOChannel *ioc G_GNUC_UNUSED,
470                                     GIOCondition condition, void *opaque)
471 {
472     InputBarrier *ib = opaque;
473     int ret;
474     struct barrierMsg msg;
475 
476     ret = readcmd(ib, &msg);
477     if (ret == G_SOURCE_REMOVE) {
478         ib->ioc_tag = 0;
479         return G_SOURCE_REMOVE;
480     }
481 
482     return writecmd(ib, &msg);
483 }
484 
485 static void input_barrier_complete(UserCreatable *uc, Error **errp)
486 {
487     InputBarrier *ib = INPUT_BARRIER(uc);
488     Error *local_err = NULL;
489 
490     if (!ib->name) {
491         error_setg(errp, QERR_MISSING_PARAMETER, "name");
492         return;
493     }
494 
495     /*
496      * Connect to the primary
497      * Primary is the server where the keyboard and the mouse
498      * are connected and forwarded to the secondary (the client)
499      */
500 
501     ib->sioc = qio_channel_socket_new();
502     qio_channel_set_name(QIO_CHANNEL(ib->sioc), "barrier-client");
503 
504     qio_channel_socket_connect_sync(ib->sioc, &ib->saddr, &local_err);
505     if (local_err) {
506         error_propagate(errp, local_err);
507         return;
508     }
509 
510     qio_channel_set_delay(QIO_CHANNEL(ib->sioc), false);
511 
512     ib->ioc_tag = qio_channel_add_watch(QIO_CHANNEL(ib->sioc), G_IO_IN,
513                                         input_barrier_event, ib, NULL);
514 }
515 
516 static void input_barrier_instance_finalize(Object *obj)
517 {
518     InputBarrier *ib = INPUT_BARRIER(obj);
519 
520     if (ib->ioc_tag) {
521         g_source_remove(ib->ioc_tag);
522         ib->ioc_tag = 0;
523     }
524 
525     if (ib->sioc) {
526         qio_channel_close(QIO_CHANNEL(ib->sioc), NULL);
527         object_unref(OBJECT(ib->sioc));
528     }
529     g_free(ib->name);
530     g_free(ib->saddr.u.inet.host);
531     g_free(ib->saddr.u.inet.port);
532 }
533 
534 static char *input_barrier_get_name(Object *obj, Error **errp)
535 {
536     InputBarrier *ib = INPUT_BARRIER(obj);
537 
538     return g_strdup(ib->name);
539 }
540 
541 static void input_barrier_set_name(Object *obj, const char *value,
542                                   Error **errp)
543 {
544     InputBarrier *ib = INPUT_BARRIER(obj);
545 
546     if (ib->name) {
547         error_setg(errp, "name property already set");
548         return;
549     }
550     ib->name = g_strdup(value);
551 }
552 
553 static char *input_barrier_get_server(Object *obj, Error **errp)
554 {
555     InputBarrier *ib = INPUT_BARRIER(obj);
556 
557     return g_strdup(ib->saddr.u.inet.host);
558 }
559 
560 static void input_barrier_set_server(Object *obj, const char *value,
561                                      Error **errp)
562 {
563     InputBarrier *ib = INPUT_BARRIER(obj);
564 
565     g_free(ib->saddr.u.inet.host);
566     ib->saddr.u.inet.host = g_strdup(value);
567 }
568 
569 static char *input_barrier_get_port(Object *obj, Error **errp)
570 {
571     InputBarrier *ib = INPUT_BARRIER(obj);
572 
573     return g_strdup(ib->saddr.u.inet.port);
574 }
575 
576 static void input_barrier_set_port(Object *obj, const char *value,
577                                      Error **errp)
578 {
579     InputBarrier *ib = INPUT_BARRIER(obj);
580 
581     g_free(ib->saddr.u.inet.port);
582     ib->saddr.u.inet.port = g_strdup(value);
583 }
584 
585 static void input_barrier_set_x_origin(Object *obj, const char *value,
586                                        Error **errp)
587 {
588     InputBarrier *ib = INPUT_BARRIER(obj);
589     int result, err;
590 
591     err = qemu_strtoi(value, NULL, 0, &result);
592     if (err < 0 || result < 0 || result > SHRT_MAX) {
593         error_setg(errp,
594                    "x-origin property must be in the range [0..%d]", SHRT_MAX);
595         return;
596     }
597     ib->x_origin = result;
598 }
599 
600 static char *input_barrier_get_x_origin(Object *obj, Error **errp)
601 {
602     InputBarrier *ib = INPUT_BARRIER(obj);
603 
604     return g_strdup_printf("%d", ib->x_origin);
605 }
606 
607 static void input_barrier_set_y_origin(Object *obj, const char *value,
608                                        Error **errp)
609 {
610     InputBarrier *ib = INPUT_BARRIER(obj);
611     int result, err;
612 
613     err = qemu_strtoi(value, NULL, 0, &result);
614     if (err < 0 || result < 0 || result > SHRT_MAX) {
615         error_setg(errp,
616                    "y-origin property must be in the range [0..%d]", SHRT_MAX);
617         return;
618     }
619     ib->y_origin = result;
620 }
621 
622 static char *input_barrier_get_y_origin(Object *obj, Error **errp)
623 {
624     InputBarrier *ib = INPUT_BARRIER(obj);
625 
626     return g_strdup_printf("%d", ib->y_origin);
627 }
628 
629 static void input_barrier_set_width(Object *obj, const char *value,
630                                        Error **errp)
631 {
632     InputBarrier *ib = INPUT_BARRIER(obj);
633     int result, err;
634 
635     err = qemu_strtoi(value, NULL, 0, &result);
636     if (err < 0 || result < 0 || result > SHRT_MAX) {
637         error_setg(errp,
638                    "width property must be in the range [0..%d]", SHRT_MAX);
639         return;
640     }
641     ib->width = result;
642 }
643 
644 static char *input_barrier_get_width(Object *obj, Error **errp)
645 {
646     InputBarrier *ib = INPUT_BARRIER(obj);
647 
648     return g_strdup_printf("%d", ib->width);
649 }
650 
651 static void input_barrier_set_height(Object *obj, const char *value,
652                                        Error **errp)
653 {
654     InputBarrier *ib = INPUT_BARRIER(obj);
655     int result, err;
656 
657     err = qemu_strtoi(value, NULL, 0, &result);
658     if (err < 0 || result < 0 || result > SHRT_MAX) {
659         error_setg(errp,
660                    "height property must be in the range [0..%d]", SHRT_MAX);
661         return;
662     }
663     ib->height = result;
664 }
665 
666 static char *input_barrier_get_height(Object *obj, Error **errp)
667 {
668     InputBarrier *ib = INPUT_BARRIER(obj);
669 
670     return g_strdup_printf("%d", ib->height);
671 }
672 
673 static void input_barrier_instance_init(Object *obj)
674 {
675     InputBarrier *ib = INPUT_BARRIER(obj);
676 
677     /* always use generic keymaps */
678     if (keyboard_layout && !kbd_layout) {
679         /* We use X11 key id, so use VNC name2keysym */
680         kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout,
681                                           &error_fatal);
682     }
683 
684     ib->saddr.type = SOCKET_ADDRESS_TYPE_INET;
685     ib->saddr.u.inet.host = g_strdup("localhost");
686     ib->saddr.u.inet.port = g_strdup("24800");
687 
688     ib->x_origin = 0;
689     ib->y_origin = 0;
690     ib->width = 1920;
691     ib->height = 1080;
692 
693     object_property_add_str(obj, "name",
694                             input_barrier_get_name,
695                             input_barrier_set_name);
696     object_property_add_str(obj, "server",
697                             input_barrier_get_server,
698                             input_barrier_set_server);
699     object_property_add_str(obj, "port",
700                             input_barrier_get_port,
701                             input_barrier_set_port);
702     object_property_add_str(obj, "x-origin",
703                             input_barrier_get_x_origin,
704                             input_barrier_set_x_origin);
705     object_property_add_str(obj, "y-origin",
706                             input_barrier_get_y_origin,
707                             input_barrier_set_y_origin);
708     object_property_add_str(obj, "width",
709                             input_barrier_get_width,
710                             input_barrier_set_width);
711     object_property_add_str(obj, "height",
712                             input_barrier_get_height,
713                             input_barrier_set_height);
714 }
715 
716 static void input_barrier_class_init(ObjectClass *oc, void *data)
717 {
718     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
719 
720     ucc->complete = input_barrier_complete;
721 }
722 
723 static const TypeInfo input_barrier_info = {
724     .name = TYPE_INPUT_BARRIER,
725     .parent = TYPE_OBJECT,
726     .class_size = sizeof(InputBarrierClass),
727     .class_init = input_barrier_class_init,
728     .instance_size = sizeof(InputBarrier),
729     .instance_init = input_barrier_instance_init,
730     .instance_finalize = input_barrier_instance_finalize,
731     .interfaces = (InterfaceInfo[]) {
732         { TYPE_USER_CREATABLE },
733         { }
734     }
735 };
736 
737 static void register_types(void)
738 {
739     type_register_static(&input_barrier_info);
740 }
741 
742 type_init(register_types);
743