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"
26 #include "vnc.h"
27 #include "vnc-jobs.h"
28
inflate_buffer(uint8_t * in,uint32_t in_len,uint32_t * size)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:
53 break;
54 case Z_STREAM_END:
55 *size = stream.total_out;
56 inflateEnd(&stream);
57 return out;
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
72 *size = stream.total_out;
73 inflateEnd(&stream);
74
75 return out;
76
77 err_end:
78 inflateEnd(&stream);
79 err:
80 g_free(out);
81 return NULL;
82 }
83
deflate_buffer(uint8_t * in,uint32_t in_len,uint32_t * size)84 static uint8_t *deflate_buffer(uint8_t *in, uint32_t in_len, uint32_t *size)
85 {
86 z_stream stream = {
87 .next_in = in,
88 .avail_in = in_len,
89 .zalloc = Z_NULL,
90 .zfree = Z_NULL,
91 };
92 uint32_t out_len = 8;
93 uint8_t *out = g_malloc(out_len);
94 int ret;
95
96 stream.next_out = out + stream.total_out;
97 stream.avail_out = out_len - stream.total_out;
98
99 ret = deflateInit(&stream, Z_DEFAULT_COMPRESSION);
100 if (ret != Z_OK) {
101 goto err;
102 }
103
104 while (ret != Z_STREAM_END) {
105 ret = deflate(&stream, Z_FINISH);
106 switch (ret) {
107 case Z_OK:
108 case Z_STREAM_END:
109 break;
110 case Z_BUF_ERROR:
111 out_len <<= 1;
112 if (out_len > (1 << 20)) {
113 goto err_end;
114 }
115 out = g_realloc(out, out_len);
116 stream.next_out = out + stream.total_out;
117 stream.avail_out = out_len - stream.total_out;
118 break;
119 default:
120 goto err_end;
121 }
122 }
123
124 *size = stream.total_out;
125 deflateEnd(&stream);
126
127 return out;
128
129 err_end:
130 deflateEnd(&stream);
131 err:
132 g_free(out);
133 return NULL;
134 }
135
vnc_clipboard_send(VncState * vs,uint32_t count,uint32_t * dwords)136 static void vnc_clipboard_send(VncState *vs, uint32_t count, uint32_t *dwords)
137 {
138 int i;
139
140 vnc_lock_output(vs);
141 vnc_write_u8(vs, VNC_MSG_SERVER_CUT_TEXT);
142 vnc_write_u8(vs, 0);
143 vnc_write_u8(vs, 0);
144 vnc_write_u8(vs, 0);
145 vnc_write_s32(vs, -(count * sizeof(uint32_t))); /* -(message length) */
146 for (i = 0; i < count; i++) {
147 vnc_write_u32(vs, dwords[i]);
148 }
149 vnc_unlock_output(vs);
150 vnc_flush(vs);
151 }
152
vnc_clipboard_provide(VncState * vs,QemuClipboardInfo * info,QemuClipboardType type)153 static void vnc_clipboard_provide(VncState *vs,
154 QemuClipboardInfo *info,
155 QemuClipboardType type)
156 {
157 uint32_t flags = 0;
158 g_autofree uint8_t *buf = NULL;
159 g_autofree void *zbuf = NULL;
160 uint32_t zsize;
161
162 switch (type) {
163 case QEMU_CLIPBOARD_TYPE_TEXT:
164 flags |= VNC_CLIPBOARD_TEXT;
165 break;
166 default:
167 return;
168 }
169 flags |= VNC_CLIPBOARD_PROVIDE;
170
171 buf = g_malloc(info->types[type].size + 4);
172 buf[0] = (info->types[type].size >> 24) & 0xff;
173 buf[1] = (info->types[type].size >> 16) & 0xff;
174 buf[2] = (info->types[type].size >> 8) & 0xff;
175 buf[3] = (info->types[type].size >> 0) & 0xff;
176 memcpy(buf + 4, info->types[type].data, info->types[type].size);
177 zbuf = deflate_buffer(buf, info->types[type].size + 4, &zsize);
178 if (!zbuf) {
179 return;
180 }
181
182 vnc_lock_output(vs);
183 vnc_write_u8(vs, VNC_MSG_SERVER_CUT_TEXT);
184 vnc_write_u8(vs, 0);
185 vnc_write_u8(vs, 0);
186 vnc_write_u8(vs, 0);
187 vnc_write_s32(vs, -(sizeof(uint32_t) + zsize)); /* -(message length) */
188 vnc_write_u32(vs, flags);
189 vnc_write(vs, zbuf, zsize);
190 vnc_unlock_output(vs);
191 vnc_flush(vs);
192 }
193
vnc_clipboard_update_info(VncState * vs,QemuClipboardInfo * info)194 static void vnc_clipboard_update_info(VncState *vs, QemuClipboardInfo *info)
195 {
196 QemuClipboardType type;
197 bool self_update = info->owner == &vs->cbpeer;
198 uint32_t flags = 0;
199
200 if (info != vs->cbinfo) {
201 qemu_clipboard_info_unref(vs->cbinfo);
202 vs->cbinfo = qemu_clipboard_info_ref(info);
203 vs->cbpending = 0;
204 if (!self_update) {
205 if (info->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
206 flags |= VNC_CLIPBOARD_TEXT;
207 }
208 flags |= VNC_CLIPBOARD_NOTIFY;
209 vnc_clipboard_send(vs, 1, &flags);
210 }
211 return;
212 }
213
214 if (self_update) {
215 return;
216 }
217
218 for (type = 0; type < QEMU_CLIPBOARD_TYPE__COUNT; type++) {
219 if (vs->cbpending & (1 << type)) {
220 vs->cbpending &= ~(1 << type);
221 vnc_clipboard_provide(vs, info, type);
222 }
223 }
224 }
225
vnc_clipboard_notify(Notifier * notifier,void * data)226 static void vnc_clipboard_notify(Notifier *notifier, void *data)
227 {
228 VncState *vs = container_of(notifier, VncState, cbpeer.notifier);
229 QemuClipboardNotify *notify = data;
230
231 switch (notify->type) {
232 case QEMU_CLIPBOARD_UPDATE_INFO:
233 vnc_clipboard_update_info(vs, notify->info);
234 return;
235 case QEMU_CLIPBOARD_RESET_SERIAL:
236 /* ignore */
237 return;
238 }
239 }
240
vnc_clipboard_request(QemuClipboardInfo * info,QemuClipboardType type)241 static void vnc_clipboard_request(QemuClipboardInfo *info,
242 QemuClipboardType type)
243 {
244 VncState *vs = container_of(info->owner, VncState, cbpeer);
245 uint32_t flags = 0;
246
247 if (type == QEMU_CLIPBOARD_TYPE_TEXT) {
248 flags |= VNC_CLIPBOARD_TEXT;
249 }
250 if (!flags) {
251 return;
252 }
253 flags |= VNC_CLIPBOARD_REQUEST;
254
255 vnc_clipboard_send(vs, 1, &flags);
256 }
257
vnc_client_cut_text_ext(VncState * vs,int32_t len,uint32_t flags,uint8_t * data)258 void vnc_client_cut_text_ext(VncState *vs, int32_t len, uint32_t flags, uint8_t *data)
259 {
260 if (flags & VNC_CLIPBOARD_CAPS) {
261 /* need store caps somewhere ? */
262 return;
263 }
264
265 if (flags & VNC_CLIPBOARD_NOTIFY) {
266 QemuClipboardInfo *info =
267 qemu_clipboard_info_new(&vs->cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD);
268 if (flags & VNC_CLIPBOARD_TEXT) {
269 info->types[QEMU_CLIPBOARD_TYPE_TEXT].available = true;
270 }
271 qemu_clipboard_update(info);
272 qemu_clipboard_info_unref(info);
273 return;
274 }
275
276 if (flags & VNC_CLIPBOARD_PROVIDE &&
277 vs->cbinfo &&
278 vs->cbinfo->owner == &vs->cbpeer) {
279 uint32_t size = 0;
280 g_autofree uint8_t *buf = inflate_buffer(data, len - 4, &size);
281 if ((flags & VNC_CLIPBOARD_TEXT) &&
282 buf && size >= 4) {
283 uint32_t tsize = read_u32(buf, 0);
284 uint8_t *tbuf = buf + 4;
285 if (tsize < size) {
286 qemu_clipboard_set_data(&vs->cbpeer, vs->cbinfo,
287 QEMU_CLIPBOARD_TYPE_TEXT,
288 tsize, tbuf, true);
289 }
290 }
291 }
292
293 if (flags & VNC_CLIPBOARD_REQUEST &&
294 vs->cbinfo &&
295 vs->cbinfo->owner != &vs->cbpeer) {
296 if ((flags & VNC_CLIPBOARD_TEXT) &&
297 vs->cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].available) {
298 if (vs->cbinfo->types[QEMU_CLIPBOARD_TYPE_TEXT].data) {
299 vnc_clipboard_provide(vs, vs->cbinfo, QEMU_CLIPBOARD_TYPE_TEXT);
300 } else {
301 vs->cbpending |= (1 << QEMU_CLIPBOARD_TYPE_TEXT);
302 qemu_clipboard_request(vs->cbinfo, QEMU_CLIPBOARD_TYPE_TEXT);
303 }
304 }
305 }
306 }
307
vnc_client_cut_text(VncState * vs,size_t len,uint8_t * text)308 void vnc_client_cut_text(VncState *vs, size_t len, uint8_t *text)
309 {
310 QemuClipboardInfo *info =
311 qemu_clipboard_info_new(&vs->cbpeer, QEMU_CLIPBOARD_SELECTION_CLIPBOARD);
312
313 qemu_clipboard_set_data(&vs->cbpeer, info, QEMU_CLIPBOARD_TYPE_TEXT,
314 len, text, true);
315 qemu_clipboard_info_unref(info);
316 }
317
vnc_server_cut_text_caps(VncState * vs)318 void vnc_server_cut_text_caps(VncState *vs)
319 {
320 uint32_t caps[2];
321
322 if (!vnc_has_feature(vs, VNC_FEATURE_CLIPBOARD_EXT)) {
323 return;
324 }
325
326 caps[0] = (VNC_CLIPBOARD_PROVIDE |
327 VNC_CLIPBOARD_NOTIFY |
328 VNC_CLIPBOARD_REQUEST |
329 VNC_CLIPBOARD_CAPS |
330 VNC_CLIPBOARD_TEXT);
331 caps[1] = 0;
332 vnc_clipboard_send(vs, 2, caps);
333
334 if (!vs->cbpeer.notifier.notify) {
335 vs->cbpeer.name = "vnc";
336 vs->cbpeer.notifier.notify = vnc_clipboard_notify;
337 vs->cbpeer.request = vnc_clipboard_request;
338 qemu_clipboard_peer_register(&vs->cbpeer);
339 }
340 }
341