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/units.h"
   7 #include "trace.h"
   8
   9 #include "qapi/qapi-types-char.h"
  10
  11 #include "spice/vd_agent.h"
  12
  13 #define VDAGENT_BUFFER_LIMIT (1 * MiB)
  14
  15 struct VDAgentChardev {
  16     Chardev parent;
  17
  18     /* guest vdagent */
  19     uint32_t caps;
  20     VDIChunkHeader chunk;
  21     uint32_t chunksize;
  22     uint8_t *msgbuf;
  23     uint32_t msgsize;
  24     uint8_t *xbuf;
  25     uint32_t xoff, xsize;
  26     Buffer outbuf;
  27 };
  28 typedef struct VDAgentChardev VDAgentChardev;
  29
  30 #define TYPE_CHARDEV_QEMU_VDAGENT "chardev-qemu-vdagent"
  31
  32 DECLARE_INSTANCE_CHECKER(VDAgentChardev, QEMU_VDAGENT_CHARDEV,
  33                          TYPE_CHARDEV_QEMU_VDAGENT);
  34
  35 /* ------------------------------------------------------------------ */
  36 /* names, for debug logging                                           */
  37
  38 static const char *cap_name[] = {
  39     [VD_AGENT_CAP_MOUSE_STATE]                    = "mouse-state",
  40     [VD_AGENT_CAP_MONITORS_CONFIG]                = "monitors-config",
  41     [VD_AGENT_CAP_REPLY]                          = "reply",
  42     [VD_AGENT_CAP_CLIPBOARD]                      = "clipboard",
  43     [VD_AGENT_CAP_DISPLAY_CONFIG]                 = "display-config",
  44     [VD_AGENT_CAP_CLIPBOARD_BY_DEMAND]            = "clipboard-by-demand",
  45     [VD_AGENT_CAP_CLIPBOARD_SELECTION]            = "clipboard-selection",
  46     [VD_AGENT_CAP_SPARSE_MONITORS_CONFIG]         = "sparse-monitors-config",
  47     [VD_AGENT_CAP_GUEST_LINEEND_LF]               = "guest-lineend-lf",
  48     [VD_AGENT_CAP_GUEST_LINEEND_CRLF]             = "guest-lineend-crlf",
  49     [VD_AGENT_CAP_MAX_CLIPBOARD]                  = "max-clipboard",
  50     [VD_AGENT_CAP_AUDIO_VOLUME_SYNC]              = "audio-volume-sync",
  51     [VD_AGENT_CAP_MONITORS_CONFIG_POSITION]       = "monitors-config-position",
  52     [VD_AGENT_CAP_FILE_XFER_DISABLED]             = "file-xfer-disabled",
  53     [VD_AGENT_CAP_FILE_XFER_DETAILED_ERRORS]      = "file-xfer-detailed-errors",
  54 #if 0
  55     [VD_AGENT_CAP_GRAPHICS_DEVICE_INFO]           = "graphics-device-info",
  56     [VD_AGENT_CAP_CLIPBOARD_NO_RELEASE_ON_REGRAB] = "clipboard-no-release-on-regrab",
  57     [VD_AGENT_CAP_CLIPBOARD_GRAB_SERIAL]          = "clipboard-grab-serial",
  58 #endif
  59 };
  60
  61 static const char *msg_name[] = {
  62     [VD_AGENT_MOUSE_STATE]           = "mouse-state",
  63     [VD_AGENT_MONITORS_CONFIG]       = "monitors-config",
  64     [VD_AGENT_REPLY]                 = "reply",
  65     [VD_AGENT_CLIPBOARD]             = "clipboard",
  66     [VD_AGENT_DISPLAY_CONFIG]        = "display-config",
  67     [VD_AGENT_ANNOUNCE_CAPABILITIES] = "announce-capabilities",
  68     [VD_AGENT_CLIPBOARD_GRAB]        = "clipboard-grab",
  69     [VD_AGENT_CLIPBOARD_REQUEST]     = "clipboard-request",
  70     [VD_AGENT_CLIPBOARD_RELEASE]     = "clipboard-release",
  71     [VD_AGENT_FILE_XFER_START]       = "file-xfer-start",
  72     [VD_AGENT_FILE_XFER_STATUS]      = "file-xfer-status",
  73     [VD_AGENT_FILE_XFER_DATA]        = "file-xfer-data",
  74     [VD_AGENT_CLIENT_DISCONNECTED]   = "client-disconnected",
  75     [VD_AGENT_MAX_CLIPBOARD]         = "max-clipboard",
  76     [VD_AGENT_AUDIO_VOLUME_SYNC]     = "audio-volume-sync",
  77 #if 0
  78     [VD_AGENT_GRAPHICS_DEVICE_INFO]  = "graphics-device-info",
  79 #endif
  80 };
  81
  82 #define GET_NAME(_m, _v) \
  83     (((_v) < ARRAY_SIZE(_m) && (_m[_v])) ? (_m[_v]) : "???")
  84
  85 /* ------------------------------------------------------------------ */
  86 /* send messages                                                      */
  87
  88 static void vdagent_send_buf(VDAgentChardev *vd)
  89 {
  90     uint32_t len;
  91
  92     while (!buffer_empty(&vd->outbuf)) {
  93         len = qemu_chr_be_can_write(CHARDEV(vd));
  94         if (len == 0) {
  95             return;
  96         }
  97         if (len > vd->outbuf.offset) {
  98             len = vd->outbuf.offset;
  99         }
 100         qemu_chr_be_write(CHARDEV(vd), vd->outbuf.buffer, len);
 101         buffer_advance(&vd->outbuf, len);
 102     }
 103 }
 104
 105 static void vdagent_send_msg(VDAgentChardev *vd, VDAgentMessage *msg)
 106 {
 107     uint8_t *msgbuf = (void *)msg;
 108     uint32_t msgsize = sizeof(VDAgentMessage) + msg->size;
 109     uint32_t msgoff = 0;
 110     VDIChunkHeader chunk;
 111
 112     trace_vdagent_send(GET_NAME(msg_name, msg->type));
 113
 114     msg->protocol = VD_AGENT_PROTOCOL;
 115
 116     if (vd->outbuf.offset + msgsize > VDAGENT_BUFFER_LIMIT) {
 117         error_report("buffer full, dropping message");
 118         return;
 119     }
 120
 121     while (msgoff < msgsize) {
 122         chunk.port = VDP_CLIENT_PORT;
 123         chunk.size = msgsize - msgoff;
 124         if (chunk.size > 1024) {
 125             chunk.size = 1024;
 126         }
 127         buffer_reserve(&vd->outbuf, sizeof(chunk) + chunk.size);
 128         buffer_append(&vd->outbuf, &chunk, sizeof(chunk));
 129         buffer_append(&vd->outbuf, msgbuf + msgoff, chunk.size);
 130         msgoff += chunk.size;
 131     }
 132     vdagent_send_buf(vd);
 133 }
 134
 135 static void vdagent_send_caps(VDAgentChardev *vd)
 136 {
 137     g_autofree VDAgentMessage *msg = g_malloc0(sizeof(VDAgentMessage) +
 138                                                sizeof(VDAgentAnnounceCapabilities) +
 139                                                sizeof(uint32_t));
 140
 141     msg->type = VD_AGENT_ANNOUNCE_CAPABILITIES;
 142     msg->size = sizeof(VDAgentAnnounceCapabilities) + sizeof(uint32_t);
 143
 144     vdagent_send_msg(vd, msg);
 145 }
 146
 147 /* ------------------------------------------------------------------ */
 148 /* chardev backend                                                    */
 149
 150 static void vdagent_chr_open(Chardev *chr,
 151                              ChardevBackend *backend,
 152                              bool *be_opened,
 153                              Error **errp)
 154 {
 155 #if defined(HOST_WORDS_BIGENDIAN)
 156     /*
 157      * TODO: vdagent protocol is defined to be LE,
 158      * so we have to byteswap everything on BE hosts.
 159      */
 160     error_setg(errp, "vdagent is not supported on bigendian hosts");
 161     return;
 162 #endif
 163
 164     *be_opened = true;
 165 }
 166
 167 static void vdagent_chr_recv_caps(VDAgentChardev *vd, VDAgentMessage *msg)
 168 {
 169     VDAgentAnnounceCapabilities *caps = (void *)msg->data;
 170     int i;
 171
 172     if (msg->size < (sizeof(VDAgentAnnounceCapabilities) +
 173                      sizeof(uint32_t))) {
 174         return;
 175     }
 176
 177     for (i = 0; i < ARRAY_SIZE(cap_name); i++) {
 178         if (caps->caps[0] & (1 << i)) {
 179             trace_vdagent_peer_cap(GET_NAME(cap_name, i));
 180         }
 181     }
 182
 183     vd->caps = caps->caps[0];
 184     if (caps->request) {
 185         vdagent_send_caps(vd);
 186     }
 187 }
 188
 189 static void vdagent_chr_recv_msg(VDAgentChardev *vd, VDAgentMessage *msg)
 190 {
 191     trace_vdagent_recv_msg(GET_NAME(msg_name, msg->type), msg->size);
 192
 193     switch (msg->type) {
 194     case VD_AGENT_ANNOUNCE_CAPABILITIES:
 195         vdagent_chr_recv_caps(vd, msg);
 196         break;
 197     default:
 198         break;
 199     }
 200 }
 201
 202 static void vdagent_reset_xbuf(VDAgentChardev *vd)
 203 {
 204     g_clear_pointer(&vd->xbuf, g_free);
 205     vd->xoff = 0;
 206     vd->xsize = 0;
 207 }
 208
 209 static void vdagent_chr_recv_chunk(VDAgentChardev *vd)
 210 {
 211     VDAgentMessage *msg = (void *)vd->msgbuf;
 212
 213     if (!vd->xsize) {
 214         if (vd->msgsize < sizeof(*msg)) {
 215             error_report("%s: message too small: %d < %zd", __func__,
 216                          vd->msgsize, sizeof(*msg));
 217             return;
 218         }
 219         if (vd->msgsize == msg->size + sizeof(*msg)) {
 220             vdagent_chr_recv_msg(vd, msg);
 221             return;
 222         }
 223     }
 224
 225     if (!vd->xsize) {
 226         vd->xsize = msg->size + sizeof(*msg);
 227         vd->xbuf = g_malloc0(vd->xsize);
 228     }
 229
 230     if (vd->xoff + vd->msgsize > vd->xsize) {
 231         error_report("%s: Oops: %d+%d > %d", __func__,
 232                      vd->xoff, vd->msgsize, vd->xsize);
 233         vdagent_reset_xbuf(vd);
 234         return;
 235     }
 236
 237     memcpy(vd->xbuf + vd->xoff, vd->msgbuf, vd->msgsize);
 238     vd->xoff += vd->msgsize;
 239     if (vd->xoff < vd->xsize) {
 240         return;
 241     }
 242
 243     msg = (void *)vd->xbuf;
 244     vdagent_chr_recv_msg(vd, msg);
 245     vdagent_reset_xbuf(vd);
 246 }
 247
 248 static void vdagent_reset_bufs(VDAgentChardev *vd)
 249 {
 250     memset(&vd->chunk, 0, sizeof(vd->chunk));
 251     vd->chunksize = 0;
 252     g_free(vd->msgbuf);
 253     vd->msgbuf = NULL;
 254     vd->msgsize = 0;
 255 }
 256
 257 static int vdagent_chr_write(Chardev *chr, const uint8_t *buf, int len)
 258 {
 259     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 260     uint32_t copy, ret = len;
 261
 262     while (len) {
 263         if (vd->chunksize < sizeof(vd->chunk)) {
 264             copy = sizeof(vd->chunk) - vd->chunksize;
 265             if (copy > len) {
 266                 copy = len;
 267             }
 268             memcpy((void *)(&vd->chunk) + vd->chunksize, buf, copy);
 269             vd->chunksize += copy;
 270             buf += copy;
 271             len -= copy;
 272             if (vd->chunksize < sizeof(vd->chunk)) {
 273                 break;
 274             }
 275
 276             assert(vd->msgbuf == NULL);
 277             vd->msgbuf = g_malloc0(vd->chunk.size);
 278         }
 279
 280         copy = vd->chunk.size - vd->msgsize;
 281         if (copy > len) {
 282             copy = len;
 283         }
 284         memcpy(vd->msgbuf + vd->msgsize, buf, copy);
 285         vd->msgsize += copy;
 286         buf += copy;
 287         len -= copy;
 288
 289         if (vd->msgsize == vd->chunk.size) {
 290             trace_vdagent_recv_chunk(vd->chunk.size);
 291             vdagent_chr_recv_chunk(vd);
 292             vdagent_reset_bufs(vd);
 293         }
 294     }
 295
 296     return ret;
 297 }
 298
 299 static void vdagent_chr_accept_input(Chardev *chr)
 300 {
 301     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 302
 303     vdagent_send_buf(vd);
 304 }
 305
 306 static void vdagent_chr_set_fe_open(struct Chardev *chr, int fe_open)
 307 {
 308     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(chr);
 309
 310     if (!fe_open) {
 311         trace_vdagent_close();
 312         /* reset state */
 313         vdagent_reset_bufs(vd);
 314         vd->caps = 0;
 315         return;
 316     }
 317
 318     trace_vdagent_open();
 319 }
 320
 321 /* ------------------------------------------------------------------ */
 322
 323 static void vdagent_chr_class_init(ObjectClass *oc, void *data)
 324 {
 325     ChardevClass *cc = CHARDEV_CLASS(oc);
 326
 327     cc->open             = vdagent_chr_open;
 328     cc->chr_write        = vdagent_chr_write;
 329     cc->chr_set_fe_open  = vdagent_chr_set_fe_open;
 330     cc->chr_accept_input = vdagent_chr_accept_input;
 331 }
 332
 333 static void vdagent_chr_init(Object *obj)
 334 {
 335     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(obj);
 336
 337     buffer_init(&vd->outbuf, "vdagent-outbuf");
 338 }
 339
 340 static void vdagent_chr_fini(Object *obj)
 341 {
 342     VDAgentChardev *vd = QEMU_VDAGENT_CHARDEV(obj);
 343
 344     buffer_free(&vd->outbuf);
 345 }
 346
 347 static const TypeInfo vdagent_chr_type_info = {
 348     .name = TYPE_CHARDEV_QEMU_VDAGENT,
 349     .parent = TYPE_CHARDEV,
 350     .instance_size = sizeof(VDAgentChardev),
 351     .instance_init = vdagent_chr_init,
 352     .instance_finalize = vdagent_chr_fini,
 353     .class_init = vdagent_chr_class_init,
 354 };
 355
 356 static void register_types(void)
 357 {
 358     type_register_static(&vdagent_chr_type_info);
 359 }
 360
 361 type_init(register_types);