ui/input-barrier.c

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