ui/vdagent.c

   1 #include "qemu/osdep.h"
   2 #include "qapi/error.h"
   3 #include "include/qemu-common.h"
   4 #include "chardev/char.h"
   5 #include "qemu/buffer.h"
   6 #include "qemu/option.h"
   7 #include "qemu/units.h"
   8 #include "hw/qdev-core.h"
   9 #include "ui/clipboard.h"
  10 #include "ui/console.h"
  11 #include "ui/input.h"
  12 #include "trace.h"
  13
  14 #include "qapi/qapi-types-char.h"
  15 #include "qapi/qapi-types-ui.h"
  16
  17 #include "spice/vd_agent.h"
  18
  19 #define VDAGENT_BUFFER_LIMIT (1 * MiB)
  20 #define VDAGENT_MOUSE_DEFAULT true
  21 #define VDAGENT_CLIPBOARD_DEFAULT false
  22
  23 struct VDAgentChardev {
  24     Chardev parent;
  25
  26     /* config */
  27     bool mouse;
  28     bool clipboard;
  29
  30     /* guest vdagent */
  31     uint32_t caps;
  32     VDIChunkHeader chunk;
  33     uint32_t chunksize;
  34     uint8_t *msgbuf;
  35     uint32_t msgsize;
  36     uint8_t *xbuf;
  37     uint32_t xoff, xsize;
  38     Buffer outbuf;
  39
  40     /* mouse */
  41     DeviceState mouse_dev;
  42     uint32_t mouse_x;
  43     uint32_t mouse_y;
  44     uint32_t mouse_btn;
  45     uint32_t mouse_display;
  46     QemuInputHandlerState *mouse_hs;
  47
  48     /* clipboard */
  49     QemuClipboardPeer cbpeer;
  50     QemuClipboardInfo *cbinfo[QEMU_CLIPBOARD_SELECTION__COUNT];
  51     uint32_t cbpending[QEMU_CLIPBOARD_SELECTION__COUNT];
  52 };
  53 typedef struct VDAgentChardev VDAgentChardev;
  54
  55 #define TYPE_CHARDEV_QEMU_VDAGENT "chardev-qemu-vdagent"
  56
  57 DECLARE_INSTANCE_CHECKER(VDAgentChardev, QEMU_VDAGENT_CHARDEV,
  58                          TYPE_CHARDEV_QEMU_VDAGENT);
  59
  60 /* ------------------------------------------------------------------ */
  61 /* names, for debug logging                                           */
  62
  63 static const char *cap_name[] = {
  64     [VD_AGENT_CAP_MOUSE_STATE]                    = "mouse-state",
  65     [VD_AGENT_CAP_MONITORS_CONFIG]                = "monitors-config",
  66     [VD_AGENT_CAP_REPLY]                          = "reply",
  67     [VD_AGENT_CAP_CLIPBOARD]                      = "clipboard",
  68     [VD_AGENT_CAP_DISPLAY_CONFIG]                 = "display-config",
  69     [VD_AGENT_CAP_CLIPBOARD_BY_DEMAND]            = "clipboard-by-demand",
  70     [VD_AGENT_CAP_CLIPBOARD_SELECTION]            = "clipboard-selection",
  71     [VD_AGENT_CAP_SPARSE_MONITORS_CONFIG]         = "sparse-monitors-config",
  72     [VD_AGENT_CAP_GUEST_LINEEND_LF]               = "guest-lineend-lf",
  73     [VD_AGENT_CAP_GUEST_LINEEND_CRLF]             = "guest-lineend-crlf",
  74     [VD_AGENT_CAP_MAX_CLIPBOARD]                  = "max-clipboard",
  75     [VD_AGENT_CAP_AUDIO_VOLUME_SYNC]              = "audio-volume-sync",
  76     [VD_AGENT_CAP_MONITORS_CONFIG_POSITION]       = "monitors-config-position",
  77     [VD_AGENT_CAP_FILE_XFER_DISABLED]             = "file-xfer-disabled",
  78     [VD_AGENT_CAP_FILE_XFER_DETAILED_ERRORS]      = "file-xfer-detailed-errors",
  79 #if 0
  80     [VD_AGENT_CAP_GRAPHICS_DEVICE_INFO]           = "graphics-device-info",
  81     [VD_AGENT_CAP_CLIPBOARD_NO_RELEASE_ON_REGRAB] = "clipboard-no-release-on-regrab",
  82     [VD_AGENT_CAP_CLIPBOARD_GRAB_SERIAL]          = "clipboard-grab-serial",
  83 #endif
  84 };
  85
  86 static const char *msg_name[] = {
  87     [VD_AGENT_MOUSE_STATE]           = "mouse-state",
  88     [VD_AGENT_MONITORS_CONFIG]       = "monitors-config",
  89     [VD_AGENT_REPLY]                 = "reply",
  90     [VD_AGENT_CLIPBOARD]             = "clipboard",
  91     [VD_AGENT_DISPLAY_CONFIG]        = "display-config",
  92     [VD_AGENT_ANNOUNCE_CAPABILITIES] = "announce-capabilities",
  93     [VD_AGENT_CLIPBOARD_GRAB]        = "clipboard-grab",
  94     [VD_AGENT_CLIPBOARD_REQUEST]     = "clipboard-request",
  95     [VD_AGENT_CLIPBOARD_RELEASE]     = "clipboard-release",
  96     [VD_AGENT_FILE_XFER_START]       = "file-xfer-start",
  97     [VD_AGENT_FILE_XFER_STATUS]      = "file-xfer-status",
  98     [VD_AGENT_FILE_XFER_DATA]        = "file-xfer-data",
  99     [VD_AGENT_CLIENT_DISCONNECTED]   = "client-disconnected",
 100     [VD_AGENT_MAX_CLIPBOARD]         = "max-clipboard",
 101     [VD_AGENT_AUDIO_VOLUME_SYNC]     = "audio-volume-sync",
 102 #if 0
 103     [VD_AGENT_GRAPHICS_DEVICE_INFO]  = "graphics-device-info",
 104 #endif
 105 };
 106
 107 static const char *sel_name[] = {
 108     [VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD] = "clipboard",
 109     [VD_AGENT_CLIPBOARD_SELECTION_PRIMARY]   = "primary",
 110     [VD_AGENT_CLIPBOARD_SELECTION_SECONDARY] = "secondary",
 111 };
 112
 113 static const char *type_name[] = {
 114     [VD_AGENT_CLIPBOARD_NONE]       = "none",
 115     [VD_AGENT_CLIPBOARD_UTF8_TEXT]  = "text",
 116     [VD_AGENT_CLIPBOARD_IMAGE_PNG]  = "png",
 117     [VD_AGENT_CLIPBOARD_IMAGE_BMP]  = "bmp",
 118     [VD_AGENT_CLIPBOARD_IMAGE_TIFF] = "tiff",
 119     [VD_AGENT_CLIPBOARD_IMAGE_JPG]  = "jpg",
 120 #if 0
 121     [VD_AGENT_CLIPBOARD_FILE_LIST]  = "files",
 122 #endif
 123 };
 124
 125 #define GET_NAME(_m, _v) \
 126     (((_v) < ARRAY_SIZE(_m) && (_m[_v])) ? (_m[_v]) : "???")
 127
 128 /* ------------------------------------------------------------------ */
 129 /* send messages                                                      */
 130
 131 static void vdagent_send_buf(VDAgentChardev *vd)
 132 {
 133     uint32_t len;
 134
 135     while (!buffer_empty(&vd->outbuf)) {
 136         len = qemu_chr_be_can_write(CHARDEV(vd));
 137         if (len == 0) {
 138             return;
 139         }
 140         if (len > vd->outbuf.offset) {
 141             len = vd->outbuf.offset;
 142         }
 143         qemu_chr_be_write(CHARDEV(vd), vd->outbuf.buffer, len);
 144         buffer_advance(&vd->outbuf, len);
 145     }
 146 }
 147
 148 static void vdagent_send_msg(VDAgentChardev *vd, VDAgentMessage *msg)
 149 {
 150     uint8_t *msgbuf = (void *)msg;
 151     uint32_t msgsize = sizeof(VDAgentMessage) + msg->size;
 152     uint32_t msgoff = 0;
 153     VDIChunkHeader chunk;
 154
 155     trace_vdagent_send(GET_NAME(msg_name, msg->type));
 156
 157     msg->protocol = VD_AGENT_PROTOCOL;
 158
 159     if (vd->outbuf.offset + msgsize > VDAGENT_BUFFER_LIMIT) {
 160         error_report("buffer full, dropping message");
 161         return;
 162     }
 163
 164     while (msgoff < msgsize) {
 165         chunk.port = VDP_CLIENT_PORT;
 166         chunk.size = msgsize - msgoff;
 167         if (chunk.size > 1024) {
 168             chunk.size = 1024;
 169         }
 170         buffer_reserve(&vd->outbuf, sizeof(chunk) + chunk.size);
 171         buffer_append(&vd->outbuf, &chunk, sizeof(chunk));
 172         buffer_append(&vd->outbuf, msgbuf + msgoff, chunk.size);
 173         msgoff += chunk.size;
 174     }
 175     vdagent_send_buf(vd);
 176 }
 177
 178 static void vdagent_send_caps(VDAgentChardev *vd)
 179 {
 180     g_autofree VDAgentMessage *msg = g_malloc0(sizeof(VDAgentMessage) +
 181                                                sizeof(VDAgentAnnounceCapabilities) +
 182                                                sizeof(uint32_t));
 183     VDAgentAnnounceCapabilities *caps = (void *)msg->data;
 184
 185     msg->type = VD_AGENT_ANNOUNCE_CAPABILITIES;
 186     msg->size = sizeof(VDAgentAnnounceCapabilities) + sizeof(uint32_t);
 187     if (vd->mouse) {
 188         caps->caps[0] |= (1 << VD_AGENT_CAP_MOUSE_STATE);
 189     }
 190     if (vd->clipboard) {
 191         caps->caps[0] |= (1 << VD_AGENT_CAP_CLIPBOARD_BY_DEMAND);
 192         caps->caps[0] |= (1 << VD_AGENT_CAP_CLIPBOARD_SELECTION);
 193     }
 194
 195     vdagent_send_msg(vd, msg);
 196 }
 197
 198 /* ------------------------------------------------------------------ */
 199 /* mouse events                                                       */
 200
 201 static bool have_mouse(VDAgentChardev *vd)
 202 {
 203     return vd->mouse &&
 204         (vd->caps & (1 << VD_AGENT_CAP_MOUSE_STATE));
 205 }
 206
 207 static void vdagent_send_mouse(VDAgentChardev *vd)
 208 {
 209     g_autofree VDAgentMessage *msg = g_malloc0(sizeof(VDAgentMessage) +
 210                                                sizeof(VDAgentMouseState));
 211     VDAgentMouseState *mouse = (void *)msg->data;
 212
 213     msg->type = VD_AGENT_MOUSE_STATE;
 214     msg->size = sizeof(VDAgentMouseState);
 215
 216     mouse->x          = vd->mouse_x;
 217     mouse->y          = vd->mouse_y;
 218     mouse->buttons    = vd->mouse_btn;
 219     mouse->display_id = vd->mouse_display;
 220
 221     vdagent_send_msg(vd, msg);
 222 }
 223
 224 static void vdagent_pointer_event(DeviceState *dev, QemuConsole *src,
 225                                   InputEvent *evt)
 226 {
 227     static const int bmap[INPUT_BUTTON__MAX] = {
 228         [INPUT_BUTTON_LEFT]        = VD_AGENT_LBUTTON_MASK,
 229         [INPUT_BUTTON_RIGHT]       = VD_AGENT_RBUTTON_MASK,
 230         [INPUT_BUTTON_MIDDLE]      = VD_AGENT_MBUTTON_MASK,
 231         [INPUT_BUTTON_WHEEL_UP]    = VD_AGENT_UBUTTON_MASK,
 232         [INPUT_BUTTON_WHEEL_DOWN]  = VD_AGENT_DBUTTON_MASK,
 233 #ifdef VD_AGENT_EBUTTON_MASK
 234         [INPUT_BUTTON_SIDE]        = VD_AGENT_SBUTTON_MASK,
 235         [INPUT_BUTTON_EXTRA]       = VD_AGENT_EBUTTON_MASK,
 236 #endif
 237     };
 238
 239     VDAgentChardev *vd = container_of(dev, struct VDAgentChardev, mouse_dev);
 240     InputMoveEvent *move;
 241     InputBtnEvent *btn;
 242     uint32_t xres, yres;
 243
 244     switch (evt->type) {
 245     case INPUT_EVENT_KIND_ABS:
 246         move = evt->u.abs.data;
 247         xres = qemu_console_get_width(src, 1024);
 248         yres = qemu_console_get_height(src, 768);
 249         if (move->axis == INPUT_AXIS_X) {
 250             vd->mouse_x = qemu_input_scale_axis(move->value,
 251                                                 INPUT_EVENT_ABS_MIN,
 252                                                 INPUT_EVENT_ABS_MAX,
 253                                                 0, xres);
 254         } else if (move->axis == INPUT_AXIS_Y) {
 255             vd->mouse_y = qemu_input_scale_axis(move->value,
 256                                                 INPUT_EVENT_ABS_MIN,
 257                                                 INPUT_EVENT_ABS_MAX,
 258                                                 0, yres);
 259         }
 260         vd->mouse_display = qemu_console_get_index(src);
 261         break;
 262
 263     case INPUT_EVENT_KIND_BTN:
 264         btn = evt->u.btn.data;
 265         if (btn->down) {
 266             vd->mouse_btn |= bmap[btn->button];
 267         } else {
 268             vd->mouse_btn &= ~bmap[btn->button];
 269         }
 270         break;
 271
 272     default:
 273         /* keep gcc happy */
 274         break;
 275     }
 276 }
 277
 278 static void vdagent_pointer_sync(DeviceState *dev)
 279 {
 280     VDAgentChardev *vd = container_of(dev, struct VDAgentChardev, mouse_dev);
 281
 282     if (vd->caps & (1 << VD_AGENT_CAP_MOUSE_STATE)) {
 283         vdagent_send_mouse(vd);
 284     }
 285 }
 286
 287 static QemuInputHandler vdagent_mouse_handler = {
 288     .name  = "vdagent mouse",
 289     .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_ABS,
 290     .event = vdagent_pointer_event,
 291     .sync  = vdagent_pointer_sync,
 292 };
 293
 294 /* ------------------------------------------------------------------ */
 295 /* clipboard                                                          */
 296
 297 static bool have_clipboard(VDAgentChardev *vd)
 298 {
 299     return vd->clipboard &&
 300         (vd->caps & (1 << VD_AGENT_CAP_CLIPBOARD_BY_DEMAND));
 301 }
 302
 303 static bool have_selection(VDAgentChardev *vd)
 304 {
 305     return vd->caps & (1 << VD_AGENT_CAP_CLIPBOARD_SELECTION);
 306 }
 307
 308 static uint32_t type_qemu_to_vdagent(enum QemuClipboardType type)
 309 {
 310     switch (type) {
 311     case QEMU_CLIPBOARD_TYPE_TEXT:
 312         return VD_AGENT_CLIPBOARD_UTF8_TEXT;
 313     default:
 314         return VD_AGENT_CLIPBOARD_NONE;
 315     }
 316 }
 317
 318 static void vdagent_send_clipboard_grab(VDAgentChardev *vd,
 319                                         QemuClipboardInfo *info)
 320 {
 321     g_autofree VDAgentMessage *msg =
 322         g_malloc0(sizeof(VDAgentMessage) +
 323                   sizeof(uint32_t) * (QEMU_CLIPBOARD_TYPE__COUNT + 1));
 324     uint8_t *s = msg->data;
 325     uint32_t *data = (uint32_t *)msg->data;
 326     uint32_t q, type;
 327
 328     if (have_selection(vd)) {
 329         *s = info->selection;
 330         data++;
 331         msg->size += sizeof(uint32_t);
 332     } else if (info->selection != QEMU_CLIPBOARD_SELECTION_CLIPBOARD) {
 333         return;
 334     }
 335
 336     for (q = 0; q < QEMU_CLIPBOARD_TYPE__COUNT; q++) {
 337         type = type_qemu_to_vdagent(q);
 338         if (type != VD_AGENT_CLIPBOARD_NONE && info->types[q].available) {
 339             *data = type;
 340             data++;
 341             msg->size += sizeof(uint32_t);
 342         }
 343     }
 344
 345     msg->type = VD_AGENT_CLIPBOARD_GRAB;
 346     vdagent_send_msg(vd, msg);
 347 }
 348
 349 static void vdagent_send_clipboard_data(VDAgentChardev *vd,
 350                                         QemuClipboardInfo *info,
 351                                         QemuClipboardType type)
 352 {
 353     g_autofree VDAgentMessage *msg = g_malloc0(sizeof(VDAgentMessage) +
 354                                                sizeof(uint32_t) * 2 +
 355                                                info->types[type].size);
 356
 357     uint8_t *s = msg->data;
 358     uint32_t *data = (uint32_t *)msg->data;
 359
 360     if (have_selection(vd)) {
 361         *s = info->selection;
 362         data++;
 363         msg->size += sizeof(uint32_t);
 364     } else if (info->selection != QEMU_CLIPBOARD_SELECTION_CLIPBOARD) {
 365         return;
 366     }
 367
 368     *data = type_qemu_to_vdagent(type);
 369     data++;
 370     msg->size += sizeof(uint32_t);
 371
 372     memcpy(data, info->types[type].data, info->types[type].size);
 373     msg->size += info->types[type].size;
 374
 375     msg->type = VD_AGENT_CLIPBOARD;
 376     vdagent_send_msg(vd, msg);
 377 }
 378
 379 static void vdagent_clipboard_notify(Notifier *notifier, void *data)
 380 {
 381     VDAgentChardev *vd = container_of(notifier, VDAgentChardev, cbpeer.update);
 382     QemuClipboardInfo *info = data;
 383     QemuClipboardSelection s = info->selection;
 384     QemuClipboardType type;
 385     bool self_update = info->owner == &vd->cbpeer;
 386
 387     if (info != vd->cbinfo[s]) {
 388         qemu_clipboard_info_unref(vd->cbinfo[s]);
 389         vd->cbinfo[s] = qemu_clipboard_info_ref(info);
 390         vd->cbpending[s] = 0;
 391         if (!self_update) {
 392             vdagent_send_clipboard_grab(vd, info);
 393         }
 394         return;
 395     }
 396
 397     if (self_update) {
 398         return;
 399     }
 400
 401     for (type = 0; type < QEMU_CLIPBOARD_TYPE__COUNT; type++) {
 402         if (vd->cbpending[s] & (1 << type)) {
 403             vd->cbpending[s] &= ~(1 << type);
 404             vdagent_send_clipboard_data(vd, info, type);
 405         }
 406     }
 407 }
 408
 409 static void vdagent_clipboard_request(QemuClipboardInfo *info,
 410                                       QemuClipboardType qtype)
 411 {
 412     VDAgentChardev *vd = container_of(info->owner, VDAgentChardev, cbpeer);
 413     g_autofree VDAgentMessage *msg = g_malloc0(sizeof(VDAgentMessage) +
 414                                                sizeof(uint32_t) * 2);
 415     uint32_t type = type_qemu_to_vdagent(qtype);
 416     uint8_t *s = msg->data;
 417     uint32_t *data = (uint32_t *)msg->data;
 418
 419     if (type == VD_AGENT_CLIPBOARD_NONE) {
 420         return;
 421     }
 422
 423     if (have_selection(vd)) {
 424         *s = info->selection;
 425         data++;
 426         msg->size += sizeof(uint32_t);
 427     }
 428
 429     *data = type;
 430     msg->size += sizeof(uint32_t);
 431
 432     msg->type = VD_AGENT_CLIPBOARD_REQUEST;
 433     vdagent_send_msg(vd, msg);
 434 }
 435
 436 static void vdagent_clipboard_recv_grab(VDAgentChardev *vd, uint8_t s, uint32_t size, void *data)
 437 {
 438     g_autoptr(QemuClipboardInfo) info = NULL;
 439
 440     trace_vdagent_cb_grab_selection(GET_NAME(sel_name, s));
 441     info = qemu_clipboard_info_new(&vd->cbpeer, s);
 442     if (size > sizeof(uint32_t) * 10) {
 443         /*
 444          * spice has 6 types as of 2021. Limiting to 10 entries
 445          * so we we have some wiggle room.
 446          */
 447         return;
 448     }
 449     while (size >= sizeof(uint32_t)) {
 450         trace_vdagent_cb_grab_type(GET_NAME(type_name, *(uint32_t *)data));
 451         switch (*(uint32_t *)data) {
 452         case VD_AGENT_CLIPBOARD_UTF8_TEXT:
 453             info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
 454             break;
 455         default:
 456             break;
 457         }
 458         data += sizeof(uint32_t);
 459         size -= sizeof(uint32_t);
 460     }
 461     qemu_clipboard_update(info);
 462 }
 463
 464 static void vdagent_clipboard_recv_request(VDAgentChardev *vd, uint8_t s, uint32_t size, void *data)
 465 {
 466     QemuClipboardType type;
 467
 468     if (size < sizeof(uint32_t)) {
 469         return;
 470     }
 471     switch (*(uint32_t *)data) {
 472     case VD_AGENT_CLIPBOARD_UTF8_TEXT:
 473         type = QEMU_CLIPBOARD_TYPE_TEXT;
 474         break;
 475     default:
 476         return;
 477     }
 478     if (vd->cbinfo[s] && vd->cbinfo[s]->types[type].available &&
 479         vd->cbinfo[s]->owner != &vd->cbpeer) {
 480         if (vd->cbinfo[s]->types[type].data) {
 481             vdagent_send_clipboard_data(vd, vd->cbinfo[s], type);
 482         } else {
 483             vd->cbpending[s] |= (1 << type);
 484             qemu_clipboard_request(vd->cbinfo[s], type);
 485         }
 486     }
 487 }
 488
 489 static void vdagent_clipboard_recv_data(VDAgentChardev *vd, uint8_t s, uint32_t size, void *data)
 490 {
 491     QemuClipboardType type;
 492
 493     if (size < sizeof(uint32_t)) {
 494         return;
 495     }
 496     switch (*(uint32_t *)data) {
 497     case VD_AGENT_CLIPBOARD_UTF8_TEXT:
 498         type = QEMU_CLIPBOARD_TYPE_TEXT;
 499         break;
 500     default:
 501         return;
 502     }
 503     data += 4;
 504     size -= 4;
 505     qemu_clipboard_set_data(&vd->cbpeer, vd->cbinfo[s], type, size, data, true);
 506 }
 507
 508 static void vdagent_clipboard_recv_release(VDAgentChardev *vd, uint8_t s)
 509 {
 510     g_autoptr(QemuClipboardInfo) info = NULL;
 511
 512     if (vd->cbinfo[s] && vd->cbinfo[s]->owner == &vd->cbpeer) {
 513         /* set empty clipboard info */
 514         info = qemu_clipboard_info_new(NULL, s);
 515         qemu_clipboard_update(info);
 516     }
 517 }
 518
 519 static void vdagent_chr_recv_clipboard(VDAgentChardev *vd, VDAgentMessage *msg)
 520 {
 521     uint8_t s = VD_AGENT_CLIPBOARD_SELECTION_CLIPBOARD;
 522     uint32_t size = msg->size;
 523     void *data = msg->data;
 524
 525     if (have_selection(vd)) {
 526         if (size < 4) {
 527             return;
 528         }
 529         s = *(uint8_t *)data;
 530         if (s >= QEMU_CLIPBOARD_SELECTION__COUNT) {
 531             return;
 532         }
 533         data += 4;
 534         size -= 4;
 535     }
 536
 537     switch (msg->type) {
 538     case VD_AGENT_CLIPBOARD_GRAB:
 539         return vdagent_clipboard_recv_grab(vd, s, size, data);
 540     case VD_AGENT_CLIPBOARD_REQUEST:
 541         return vdagent_clipboard_recv_request(vd, s, size, data);
 542     case VD_AGENT_CLIPBOARD: /* data */
 543         return vdagent_clipboard_recv_data(vd, s, size, data);
 544     case VD_AGENT_CLIPBOARD_RELEASE:
 545         return vdagent_clipboard_recv_release(vd, s);
 546     default:
 547         g_assert_not_reached();
 548     }
 549 }
 550
 551 /* ------------------------------------------------------------------ */
 552 /* chardev backend                                                    */
 553
 554 static void vdagent_chr_open(Chardev *chr,
 555                              ChardevBackend *backend,
 556                              bool *be_opened,
 557                              Error **errp)
 558 {
 559     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 560     ChardevQemuVDAgent *cfg = backend->u.qemu_vdagent.data;
 561
 562 #if defined(HOST_WORDS_BIGENDIAN)
 563     /*
 564      * TODO: vdagent protocol is defined to be LE,
 565      * so we have to byteswap everything on BE hosts.
 566      */
 567     error_setg(errp, "vdagent is not supported on bigendian hosts");
 568     return;
 569 #endif
 570
 571     vd->mouse = VDAGENT_MOUSE_DEFAULT;
 572     if (cfg->has_mouse) {
 573         vd->mouse = cfg->mouse;
 574     }
 575
 576     vd->clipboard = VDAGENT_CLIPBOARD_DEFAULT;
 577     if (cfg->has_clipboard) {
 578         vd->clipboard = cfg->clipboard;
 579     }
 580
 581     if (vd->mouse) {
 582         vd->mouse_hs = qemu_input_handler_register(&vd->mouse_dev,
 583                                                    &vdagent_mouse_handler);
 584     }
 585
 586     *be_opened = true;
 587 }
 588
 589 static void vdagent_chr_recv_caps(VDAgentChardev *vd, VDAgentMessage *msg)
 590 {
 591     VDAgentAnnounceCapabilities *caps = (void *)msg->data;
 592     int i;
 593
 594     if (msg->size < (sizeof(VDAgentAnnounceCapabilities) +
 595                      sizeof(uint32_t))) {
 596         return;
 597     }
 598
 599     for (i = 0; i < ARRAY_SIZE(cap_name); i++) {
 600         if (caps->caps[0] & (1 << i)) {
 601             trace_vdagent_peer_cap(GET_NAME(cap_name, i));
 602         }
 603     }
 604
 605     vd->caps = caps->caps[0];
 606     if (caps->request) {
 607         vdagent_send_caps(vd);
 608     }
 609     if (have_mouse(vd) && vd->mouse_hs) {
 610         qemu_input_handler_activate(vd->mouse_hs);
 611     }
 612     if (have_clipboard(vd) && vd->cbpeer.update.notify == NULL) {
 613         vd->cbpeer.name = "vdagent";
 614         vd->cbpeer.update.notify = vdagent_clipboard_notify;
 615         vd->cbpeer.request = vdagent_clipboard_request;
 616         qemu_clipboard_peer_register(&vd->cbpeer);
 617     }
 618 }
 619
 620 static void vdagent_chr_recv_msg(VDAgentChardev *vd, VDAgentMessage *msg)
 621 {
 622     trace_vdagent_recv_msg(GET_NAME(msg_name, msg->type), msg->size);
 623
 624     switch (msg->type) {
 625     case VD_AGENT_ANNOUNCE_CAPABILITIES:
 626         vdagent_chr_recv_caps(vd, msg);
 627         break;
 628     case VD_AGENT_CLIPBOARD:
 629     case VD_AGENT_CLIPBOARD_GRAB:
 630     case VD_AGENT_CLIPBOARD_REQUEST:
 631     case VD_AGENT_CLIPBOARD_RELEASE:
 632         if (have_clipboard(vd)) {
 633             vdagent_chr_recv_clipboard(vd, msg);
 634         }
 635         break;
 636     default:
 637         break;
 638     }
 639 }
 640
 641 static void vdagent_reset_xbuf(VDAgentChardev *vd)
 642 {
 643     g_clear_pointer(&vd->xbuf, g_free);
 644     vd->xoff = 0;
 645     vd->xsize = 0;
 646 }
 647
 648 static void vdagent_chr_recv_chunk(VDAgentChardev *vd)
 649 {
 650     VDAgentMessage *msg = (void *)vd->msgbuf;
 651
 652     if (!vd->xsize) {
 653         if (vd->msgsize < sizeof(*msg)) {
 654             error_report("%s: message too small: %d < %zd", __func__,
 655                          vd->msgsize, sizeof(*msg));
 656             return;
 657         }
 658         if (vd->msgsize == msg->size + sizeof(*msg)) {
 659             vdagent_chr_recv_msg(vd, msg);
 660             return;
 661         }
 662     }
 663
 664     if (!vd->xsize) {
 665         vd->xsize = msg->size + sizeof(*msg);
 666         vd->xbuf = g_malloc0(vd->xsize);
 667     }
 668
 669     if (vd->xoff + vd->msgsize > vd->xsize) {
 670         error_report("%s: Oops: %d+%d > %d", __func__,
 671                      vd->xoff, vd->msgsize, vd->xsize);
 672         vdagent_reset_xbuf(vd);
 673         return;
 674     }
 675
 676     memcpy(vd->xbuf + vd->xoff, vd->msgbuf, vd->msgsize);
 677     vd->xoff += vd->msgsize;
 678     if (vd->xoff < vd->xsize) {
 679         return;
 680     }
 681
 682     msg = (void *)vd->xbuf;
 683     vdagent_chr_recv_msg(vd, msg);
 684     vdagent_reset_xbuf(vd);
 685 }
 686
 687 static void vdagent_reset_bufs(VDAgentChardev *vd)
 688 {
 689     memset(&vd->chunk, 0, sizeof(vd->chunk));
 690     vd->chunksize = 0;
 691     g_free(vd->msgbuf);
 692     vd->msgbuf = NULL;
 693     vd->msgsize = 0;
 694 }
 695
 696 static int vdagent_chr_write(Chardev *chr, const uint8_t *buf, int len)
 697 {
 698     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 699     uint32_t copy, ret = len;
 700
 701     while (len) {
 702         if (vd->chunksize < sizeof(vd->chunk)) {
 703             copy = sizeof(vd->chunk) - vd->chunksize;
 704             if (copy > len) {
 705                 copy = len;
 706             }
 707             memcpy((void *)(&vd->chunk) + vd->chunksize, buf, copy);
 708             vd->chunksize += copy;
 709             buf += copy;
 710             len -= copy;
 711             if (vd->chunksize < sizeof(vd->chunk)) {
 712                 break;
 713             }
 714
 715             assert(vd->msgbuf == NULL);
 716             vd->msgbuf = g_malloc0(vd->chunk.size);
 717         }
 718
 719         copy = vd->chunk.size - vd->msgsize;
 720         if (copy > len) {
 721             copy = len;
 722         }
 723         memcpy(vd->msgbuf + vd->msgsize, buf, copy);
 724         vd->msgsize += copy;
 725         buf += copy;
 726         len -= copy;
 727
 728         if (vd->msgsize == vd->chunk.size) {
 729             trace_vdagent_recv_chunk(vd->chunk.size);
 730             vdagent_chr_recv_chunk(vd);
 731             vdagent_reset_bufs(vd);
 732         }
 733     }
 734
 735     return ret;
 736 }
 737
 738 static void vdagent_chr_accept_input(Chardev *chr)
 739 {
 740     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 741
 742     vdagent_send_buf(vd);
 743 }
 744
 745 static void vdagent_disconnect(VDAgentChardev *vd)
 746 {
 747     buffer_reset(&vd->outbuf);
 748     vdagent_reset_bufs(vd);
 749     vd->caps = 0;
 750     if (vd->mouse_hs) {
 751         qemu_input_handler_deactivate(vd->mouse_hs);
 752     }
 753     if (vd->cbpeer.update.notify) {
 754         qemu_clipboard_peer_unregister(&vd->cbpeer);
 755         memset(&vd->cbpeer, 0, sizeof(vd->cbpeer));
 756     }
 757 }
 758
 759 static void vdagent_chr_set_fe_open(struct Chardev *chr, int fe_open)
 760 {
 761     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 762
 763     if (!fe_open) {
 764         trace_vdagent_close();
 765         vdagent_disconnect(vd);
 766         return;
 767     }
 768
 769     trace_vdagent_open();
 770 }
 771
 772 static void vdagent_chr_parse(QemuOpts *opts, ChardevBackend *backend,
 773                               Error **errp)
 774 {
 775     ChardevQemuVDAgent *cfg;
 776
 777     backend->type = CHARDEV_BACKEND_KIND_QEMU_VDAGENT;
 778     cfg = backend->u.qemu_vdagent.data = g_new0(ChardevQemuVDAgent, 1);
 779     qemu_chr_parse_common(opts, qapi_ChardevQemuVDAgent_base(cfg));
 780     cfg->has_mouse = true;
 781     cfg->mouse = qemu_opt_get_bool(opts, "mouse", VDAGENT_MOUSE_DEFAULT);
 782     cfg->has_clipboard = true;
 783     cfg->clipboard = qemu_opt_get_bool(opts, "clipboard", VDAGENT_CLIPBOARD_DEFAULT);
 784 }
 785
 786 /* ------------------------------------------------------------------ */
 787
 788 static void vdagent_chr_class_init(ObjectClass *oc, void *data)
 789 {
 790     ChardevClass *cc = CHARDEV_CLASS(oc);
 791
 792     cc->parse            = vdagent_chr_parse;
 793     cc->open             = vdagent_chr_open;
 794     cc->chr_write        = vdagent_chr_write;
 795     cc->chr_set_fe_open  = vdagent_chr_set_fe_open;
 796     cc->chr_accept_input = vdagent_chr_accept_input;
 797 }
 798
 799 static void vdagent_chr_init(Object *obj)
 800 {
 801     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(obj);
 802
 803     buffer_init(&vd->outbuf, "vdagent-outbuf");
 804 }
 805
 806 static void vdagent_chr_fini(Object *obj)
 807 {
 808     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(obj);
 809
 810     vdagent_disconnect(vd);
 811     buffer_free(&vd->outbuf);
 812 }
 813
 814 static const TypeInfo vdagent_chr_type_info = {
 815     .name = TYPE_CHARDEV_QEMU_VDAGENT,
 816     .parent = TYPE_CHARDEV,
 817     .instance_size = sizeof(VDAgentChardev),
 818     .instance_init = vdagent_chr_init,
 819     .instance_finalize = vdagent_chr_fini,
 820     .class_init = vdagent_chr_class_init,
 821 };
 822
 823 static void register_types(void)
 824 {
 825     type_register_static(&vdagent_chr_type_info);
 826 }
 827
 828 type_init(register_types);