[mirror_qemu.git] / ui / vnc-clipboard.c

/*
 * QEMU VNC display driver -- clipboard support
 *
 * Copyright (C) 2021 Gerd Hoffmann <kraxel@redhat.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"
#include "vnc.h"
#include "vnc-jobs.h"

static uint8_t *inflate_buffer(uint8_t *in, uint32_t in_len, uint32_t *size)
{
    z_stream stream = {
        .next_in  = in,
        .avail_in = in_len,
        .zalloc   = Z_NULL,
        .zfree    = Z_NULL,
    };
    uint32_t out_len = 8;
    uint8_t *out = g_malloc(out_len);
    int ret;

    stream.next_out = out + stream.total_out;
    stream.avail_out = out_len - stream.total_out;

    ret = inflateInit(&stream);
    if (ret != Z_OK) {
        goto err;
    }

    while (stream.avail_in) {
        ret = inflate(&stream, Z_FINISH);
        switch (ret) {
        case Z_OK:
            break;
        case Z_STREAM_END:
            *size = stream.total_out;
            inflateEnd(&stream);
            return out;
        case Z_BUF_ERROR:
            out_len <<= 1;
            if (out_len > (1 << 20)) {
                goto err_end;
            }
            out = g_realloc(out, out_len);
            stream.next_out = out + stream.total_out;
            stream.avail_out = out_len - stream.total_out;
            break;
        default:
            goto err_end;
        }
    }

err_end:
    inflateEnd(&stream);
err:
    g_free(out);
    return NULL;
}

static uint8_t *deflate_buffer(uint8_t *in, uint32_t in_len, uint32_t *size)
{
    z_stream stream = {
        .next_in  = in,
        .avail_in = in_len,
        .zalloc   = Z_NULL,
        .zfree    = Z_NULL,
    };
    uint32_t out_len = 8;
    uint8_t *out = g_malloc(out_len);
    int ret;

    stream.next_out = out + stream.total_out;
    stream.avail_out = out_len - stream.total_out;

    ret = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
    if (ret != Z_OK) {
        goto err;
    }

    while (ret != Z_STREAM_END) {
        ret = deflate(&stream, Z_FINISH);
        switch (ret) {
        case Z_OK:
        case Z_STREAM_END:
            break;
        case Z_BUF_ERROR:
            out_len <<= 1;
            if (out_len > (1 << 20)) {
                goto err_end;
            }
            out = g_realloc(out, out_len);
            stream.next_out = out + stream.total_out;
            stream.avail_out = out_len - stream.total_out;
            break;
        default:
            goto err_end;
        }
    }

    *size = stream.total_out;
    deflateEnd(&stream);

    return out;

err_end:
    deflateEnd(&stream);
err:
    g_free(out);
    return NULL;
}

static void vnc_clipboard_send(VncState *vs, uint32_t count, uint32_t *dwords)
{
    int i;

    vnc_lock_output(vs);
    vnc_write_u8(vs, VNC_MSG_SERVER_CUT_TEXT);
    vnc_write_u8(vs, 0);
    vnc_write_u8(vs, 0);
    vnc_write_u8(vs, 0);
    vnc_write_s32(vs, -(count * sizeof(uint32_t)));  /* -(message length) */
    for (i = 0; i < count; i++) {
        vnc_write_u32(vs, dwords[i]);
    }
    vnc_unlock_output(vs);
    vnc_flush(vs);
}

static void vnc_clipboard_provide(VncState *vs,
                                  QemuClipboardInfo *info,
                                  QemuClipboardType type)
{
    uint32_t flags = 0;
    g_autofree uint8_t *buf = NULL;
    g_autofree void *zbuf = NULL;
    uint32_t zsize;

    switch (type) {
    case QEMU_CLIPBOARD_TYPE_TEXT:
        flags |= VNC_CLIPBOARD_TEXT;
        break;
    default:
        return;
    }
    flags |= VNC_CLIPBOARD_PROVIDE;

    buf = g_malloc(info->types[type].size + 4);
    buf[0] = (info->types[type].size >> 24) & 0xff;
    buf[1] = (info->types[type].size >> 16) & 0xff;
    buf[2] = (info->types[type].size >>  8) & 0xff;
    buf[3] = (info->types[type].size >>  0) & 0xff;
    memcpy(buf + 4, info->types[type].data, info->types[type].size);
    zbuf = deflate_buffer(buf, info->types[type].size + 4, &zsize);
    if (!zbuf) {
        return;
    }

    vnc_lock_output(vs);
    vnc_write_u8(vs, VNC_MSG_SERVER_CUT_TEXT);
    vnc_write_u8(vs, 0);
    vnc_write_u8(vs, 0);
    vnc_write_u8(vs, 0);
    vnc_write_s32(vs, -(sizeof(uint32_t) + zsize));  /* -(message length) */
    vnc_write_u32(vs, flags);
    vnc_write(vs, zbuf, zsize);
    vnc_unlock_output(vs);
    vnc_flush(vs);
}

static void vnc_clipboard_update_info(VncState *vs, QemuClipboardInfo *info)
{
    QemuClipboardType type;
    bool self_update = info->owner == &vs->cbpeer;
    uint32_t flags = 0;

    if (info != vs->cbinfo) {
        qemu_clipboard_info_unref(vs->cbinfo);
        vs->cbinfo = qemu_clipboard_info_ref(info);
        vs->cbpending = 0;
        if (!self_update) {
            if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
                flags |= VNC_CLIPBOARD_TEXT;
            }
            flags |= VNC_CLIPBOARD_NOTIFY;
            vnc_clipboard_send(vs, 1, &flags);
        }
        return;
    }

    if (self_update) {
        return;
    }

    for (type = 0; type < QEMU_CLIPBOARD_TYPE__COUNT; type++) {
        if (vs->cbpending & (1 << type)) {
            vs->cbpending &= ~(1 << type);
            vnc_clipboard_provide(vs, info, type);
        }
    }
}

static void vnc_clipboard_notify(Notifier *notifier, void *data)
{
    VncState *vs = container_of(notifier, VncState, cbpeer.notifier);
    QemuClipboardNotify *notify = data;

    switch (notify->type) {
    case QEMU_CLIPBOARD_UPDATE_INFO:
        vnc_clipboard_update_info(vs, notify->info);
        return;
    case QEMU_CLIPBOARD_RESET_SERIAL:
        /* ignore */
        return;
    }
}

static void vnc_clipboard_request(QemuClipboardInfo *info,
                                  QemuClipboardType type)
{
    VncState *vs = container_of(info->owner, VncState, cbpeer);
    uint32_t flags = 0;

    if (type == QEMU_CLIPBOARD_TYPE_TEXT) {
        flags |= VNC_CLIPBOARD_TEXT;
    }
    if (!flags) {
        return;
    }
    flags |= VNC_CLIPBOARD_REQUEST;

    vnc_clipboard_send(vs, 1, &flags);
}

void vnc_client_cut_text_ext(VncState *vs, int32_t len, uint32_t flags, uint8_t *data)
{
    if (flags & VNC_CLIPBOARD_CAPS) {
        /* need store caps somewhere ? */
        return;
    }

    if (flags & VNC_CLIPBOARD_NOTIFY) {
        QemuClipboardInfo *info =
            qemu_clipboard_info_new(&vs->cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD);
        if (flags & VNC_CLIPBOARD_TEXT) {
            info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
        }
        qemu_clipboard_update(info);
        qemu_clipboard_info_unref(info);
        return;
    }

    if (flags & VNC_CLIPBOARD_PROVIDE &&
        vs->cbinfo &&
        vs->cbinfo->owner == &vs->cbpeer) {
        uint32_t size = 0;
        g_autofree uint8_t *buf = inflate_buffer(data, len - 4, &size);
        if ((flags & VNC_CLIPBOARD_TEXT) &&
            buf && size >= 4) {
            uint32_t tsize = read_u32(buf, 0);
            uint8_t *tbuf = buf + 4;
            if (tsize < size) {
                qemu_clipboard_set_data(&vs->cbpeer, vs->cbinfo,
                                        QEMU_CLIPBOARD_TYPE_TEXT,
                                        tsize, tbuf, true);
            }
        }
    }

    if (flags & VNC_CLIPBOARD_REQUEST &&
        vs->cbinfo &&
        vs->cbinfo->owner != &vs->cbpeer) {
        if ((flags & VNC_CLIPBOARD_TEXT) &&
            vs->cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
            if (vs->cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].data) {
                vnc_clipboard_provide(vs, vs->cbinfo, QEMU_CLIPBOARD_TYPE_TEXT);
            } else {
                vs->cbpending |= (1 << QEMU_CLIPBOARD_TYPE_TEXT);
                qemu_clipboard_request(vs->cbinfo, QEMU_CLIPBOARD_TYPE_TEXT);
            }
        }
    }
}

void vnc_client_cut_text(VncState *vs, size_t len, uint8_t *text)
{
    QemuClipboardInfo *info =
        qemu_clipboard_info_new(&vs->cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD);

    qemu_clipboard_set_data(&vs->cbpeer, info, QEMU_CLIPBOARD_TYPE_TEXT,
                            len, text, true);
    qemu_clipboard_info_unref(info);
}

void vnc_server_cut_text_caps(VncState *vs)
{
    uint32_t caps[2];

    if (!vnc_has_feature(vs, VNC_FEATURE_CLIPBOARD_EXT)) {
        return;
    }

    caps[0] = (VNC_CLIPBOARD_PROVIDE |
               VNC_CLIPBOARD_NOTIFY  |
               VNC_CLIPBOARD_REQUEST |
               VNC_CLIPBOARD_CAPS    |
               VNC_CLIPBOARD_TEXT);
    caps[1] = 0;
    vnc_clipboard_send(vs, 2, caps);

    if (!vs->cbpeer.notifier.notify) {
        vs->cbpeer.name = "vnc";
        vs->cbpeer.notifier.notify = vnc_clipboard_notify;
        vs->cbpeer.request = vnc_clipboard_request;
        qemu_clipboard_peer_register(&vs->cbpeer);
    }
}
Commit	Line	Data
0bf41cab GH	1	/*
	2	* QEMU VNC display driver -- clipboard support
	3	*
	4	* Copyright (C) 2021 Gerd Hoffmann <kraxel@redhat.com>
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
	25	#include "qemu/osdep.h"
0bf41cab GH	26	#include "vnc.h"
	27	#include "vnc-jobs.h"
	28
	29	static uint8_t inflate_buffer(uint8_t in, uint32_t in_len, uint32_t *size)
	30	{
	31	z_stream stream = {
	32	.next_in = in,
	33	.avail_in = in_len,
	34	.zalloc = Z_NULL,
	35	.zfree = Z_NULL,
	36	};
	37	uint32_t out_len = 8;
	38	uint8_t *out = g_malloc(out_len);
	39	int ret;
	40
	41	stream.next_out = out + stream.total_out;
	42	stream.avail_out = out_len - stream.total_out;
	43
	44	ret = inflateInit(&stream);
	45	if (ret != Z_OK) {
	46	goto err;
	47	}
	48
	49	while (stream.avail_in) {
	50	ret = inflate(&stream, Z_FINISH);
	51	switch (ret) {
	52	case Z_OK:
0bf41cab	53	break;
d921fea3 MMC	54	case Z_STREAM_END:
	55	*size = stream.total_out;
	56	inflateEnd(&stream);
	57	return out;
0bf41cab GH	58	case Z_BUF_ERROR:
	59	out_len <<= 1;
	60	if (out_len > (1 << 20)) {
	61	goto err_end;
	62	}
	63	out = g_realloc(out, out_len);
	64	stream.next_out = out + stream.total_out;
	65	stream.avail_out = out_len - stream.total_out;
	66	break;
	67	default:
	68	goto err_end;
	69	}
	70	}
	71
0bf41cab GH	72	err_end:
	73	inflateEnd(&stream);
	74	err:
	75	g_free(out);
	76	return NULL;
	77	}
	78
	79	static uint8_t deflate_buffer(uint8_t in, uint32_t in_len, uint32_t *size)
	80	{
	81	z_stream stream = {
	82	.next_in = in,
	83	.avail_in = in_len,
	84	.zalloc = Z_NULL,
	85	.zfree = Z_NULL,
	86	};
	87	uint32_t out_len = 8;
	88	uint8_t *out = g_malloc(out_len);
	89	int ret;
	90
	91	stream.next_out = out + stream.total_out;
	92	stream.avail_out = out_len - stream.total_out;
	93
	94	ret = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
	95	if (ret != Z_OK) {
	96	goto err;
	97	}
	98
	99	while (ret != Z_STREAM_END) {
	100	ret = deflate(&stream, Z_FINISH);
	101	switch (ret) {
	102	case Z_OK:
	103	case Z_STREAM_END:
	104	break;
	105	case Z_BUF_ERROR:
	106	out_len <<= 1;
	107	if (out_len > (1 << 20)) {
	108	goto err_end;
	109	}
	110	out = g_realloc(out, out_len);
	111	stream.next_out = out + stream.total_out;
	112	stream.avail_out = out_len - stream.total_out;
	113	break;
	114	default:
	115	goto err_end;
	116	}
	117	}
	118
	119	*size = stream.total_out;
	120	deflateEnd(&stream);
	121
	122	return out;
	123
	124	err_end:
	125	deflateEnd(&stream);
	126	err:
	127	g_free(out);
	128	return NULL;
	129	}
	130
	131	static void vnc_clipboard_send(VncState vs, uint32_t count, uint32_t dwords)
	132	{
	133	int i;
	134
	135	vnc_lock_output(vs);
136	vnc_write_u8(vs, VNC_MSG_SERVER_CUT_TEXT);
137	vnc_write_u8(vs, 0);
138	vnc_write_u8(vs, 0);
139	vnc_write_u8(vs, 0);
140	vnc_write_s32(vs, -(count * sizeof(uint32_t))); /* -(message length) */
141	for (i = 0; i < count; i++) {
142	vnc_write_u32(vs, dwords[i]);
143	}
144	vnc_unlock_output(vs);
145	vnc_flush(vs);
146	}
147
148	static void vnc_clipboard_provide(VncState *vs,
149	QemuClipboardInfo *info,
150	QemuClipboardType type)
151	{
152	uint32_t flags = 0;
153	g_autofree uint8_t *buf = NULL;
154	g_autofree void *zbuf = NULL;
155	uint32_t zsize;
156
157	switch (type) {
158	case QEMU_CLIPBOARD_TYPE_TEXT:
159	flags \|= VNC_CLIPBOARD_TEXT;
160	break;
161	default:
162	return;
163	}
164	flags \|= VNC_CLIPBOARD_PROVIDE;
165
166	buf = g_malloc(info->types[type].size + 4);
167	buf[0] = (info->types[type].size >> 24) & 0xff;
168	buf[1] = (info->types[type].size >> 16) & 0xff;
169	buf[2] = (info->types[type].size >> 8) & 0xff;
170	buf[3] = (info->types[type].size >> 0) & 0xff;
171	memcpy(buf + 4, info->types[type].data, info->types[type].size);
172	zbuf = deflate_buffer(buf, info->types[type].size + 4, &zsize);
173	if (!zbuf) {
174	return;
175	}
176
177	vnc_lock_output(vs);
178	vnc_write_u8(vs, VNC_MSG_SERVER_CUT_TEXT);
179	vnc_write_u8(vs, 0);
180	vnc_write_u8(vs, 0);
181	vnc_write_u8(vs, 0);
182	vnc_write_s32(vs, -(sizeof(uint32_t) + zsize)); /* -(message length) */
183	vnc_write_u32(vs, flags);
184	vnc_write(vs, zbuf, zsize);
185	vnc_unlock_output(vs);
186	vnc_flush(vs);
187	}
188
1b17f1e9	189	static void vnc_clipboard_update_info(VncState vs, QemuClipboardInfo info)
0bf41cab	190	{
0bf41cab GH	191	QemuClipboardType type;
	192	bool self_update = info->owner == &vs->cbpeer;
	193	uint32_t flags = 0;
	194
	195	if (info != vs->cbinfo) {
	196	qemu_clipboard_info_unref(vs->cbinfo);
	197	vs->cbinfo = qemu_clipboard_info_ref(info);
	198	vs->cbpending = 0;
	199	if (!self_update) {
	200	if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
	201	flags \|= VNC_CLIPBOARD_TEXT;
	202	}
	203	flags \|= VNC_CLIPBOARD_NOTIFY;
	204	vnc_clipboard_send(vs, 1, &flags);
	205	}
	206	return;
	207	}
	208
	209	if (self_update) {
	210	return;
	211	}
	212
	213	for (type = 0; type < QEMU_CLIPBOARD_TYPE__COUNT; type++) {
	214	if (vs->cbpending & (1 << type)) {
	215	vs->cbpending &= ~(1 << type);
	216	vnc_clipboard_provide(vs, info, type);
	217	}
	218	}
	219	}
	220
1b17f1e9 MAL	221	static void vnc_clipboard_notify(Notifier notifier, void data)
	222	{
	223	VncState *vs = container_of(notifier, VncState, cbpeer.notifier);
	224	QemuClipboardNotify *notify = data;
	225
	226	switch (notify->type) {
	227	case QEMU_CLIPBOARD_UPDATE_INFO:
	228	vnc_clipboard_update_info(vs, notify->info);
	229	return;
505dbf9b MAL	230	case QEMU_CLIPBOARD_RESET_SERIAL:
	231	/* ignore */
	232	return;
1b17f1e9 MAL	233	}
	234	}
	235
0bf41cab GH	236	static void vnc_clipboard_request(QemuClipboardInfo *info,
	237	QemuClipboardType type)
	238	{
	239	VncState *vs = container_of(info->owner, VncState, cbpeer);
	240	uint32_t flags = 0;
	241
	242	if (type == QEMU_CLIPBOARD_TYPE_TEXT) {
	243	flags \|= VNC_CLIPBOARD_TEXT;
	244	}
	245	if (!flags) {
	246	return;
	247	}
	248	flags \|= VNC_CLIPBOARD_REQUEST;
	249
	250	vnc_clipboard_send(vs, 1, &flags);
	251	}
	252
	253	void vnc_client_cut_text_ext(VncState vs, int32_t len, uint32_t flags, uint8_t data)
	254	{
	255	if (flags & VNC_CLIPBOARD_CAPS) {
	256	/* need store caps somewhere ? */
	257	return;
	258	}
	259
	260	if (flags & VNC_CLIPBOARD_NOTIFY) {
	261	QemuClipboardInfo *info =
	262	qemu_clipboard_info_new(&vs->cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD);
	263	if (flags & VNC_CLIPBOARD_TEXT) {
	264	info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
	265	}
	266	qemu_clipboard_update(info);
	267	qemu_clipboard_info_unref(info);
	268	return;
	269	}
	270
	271	if (flags & VNC_CLIPBOARD_PROVIDE &&
	272	vs->cbinfo &&
	273	vs->cbinfo->owner == &vs->cbpeer) {
	274	uint32_t size = 0;
	275	g_autofree uint8_t *buf = inflate_buffer(data, len - 4, &size);
	276	if ((flags & VNC_CLIPBOARD_TEXT) &&
	277	buf && size >= 4) {
	278	uint32_t tsize = read_u32(buf, 0);
	279	uint8_t *tbuf = buf + 4;
	280	if (tsize < size) {
	281	qemu_clipboard_set_data(&vs->cbpeer, vs->cbinfo,
	282	QEMU_CLIPBOARD_TYPE_TEXT,
	283	tsize, tbuf, true);
	284	}
	285	}
	286	}
	287
	288	if (flags & VNC_CLIPBOARD_REQUEST &&
	289	vs->cbinfo &&
	290	vs->cbinfo->owner != &vs->cbpeer) {
	291	if ((flags & VNC_CLIPBOARD_TEXT) &&
	292	vs->cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
	293	if (vs->cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].data) {
	294	vnc_clipboard_provide(vs, vs->cbinfo, QEMU_CLIPBOARD_TYPE_TEXT);
	295	} else {
	296	vs->cbpending \|= (1 << QEMU_CLIPBOARD_TYPE_TEXT);
	297	qemu_clipboard_request(vs->cbinfo, QEMU_CLIPBOARD_TYPE_TEXT);
	298	}
	299	}
300	}
301	}
302
303	void vnc_client_cut_text(VncState vs, size_t len, uint8_t text)
304	{
305	QemuClipboardInfo *info =
306	qemu_clipboard_info_new(&vs->cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD);
307
308	qemu_clipboard_set_data(&vs->cbpeer, info, QEMU_CLIPBOARD_TYPE_TEXT,
309	len, text, true);
310	qemu_clipboard_info_unref(info);
311	}
312
313	void vnc_server_cut_text_caps(VncState *vs)
314	{
315	uint32_t caps[2];
316
317	if (!vnc_has_feature(vs, VNC_FEATURE_CLIPBOARD_EXT)) {
318	return;
319	}
320
321	caps[0] = (VNC_CLIPBOARD_PROVIDE \|
322	VNC_CLIPBOARD_NOTIFY \|
323	VNC_CLIPBOARD_REQUEST \|
324	VNC_CLIPBOARD_CAPS \|
325	VNC_CLIPBOARD_TEXT);
326	caps[1] = 0;
327	vnc_clipboard_send(vs, 2, caps);
328
1b17f1e9	329	if (!vs->cbpeer.notifier.notify) {
2e572baf	330	vs->cbpeer.name = "vnc";
1b17f1e9	331	vs->cbpeer.notifier.notify = vnc_clipboard_notify;
2e572baf VSO	332	vs->cbpeer.request = vnc_clipboard_request;
	333	qemu_clipboard_peer_register(&vs->cbpeer);
	334	}
0bf41cab	335	}