ui/vdagent.c

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