1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include "qemu/osdep.h"
26#include "vnc.h"
27#include "vnc-jobs.h"
28
29static 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
72err_end:
73 inflateEnd(&stream);
74err:
75 g_free(out);
76 return NULL;
77}
78
79static 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
124err_end:
125 deflateEnd(&stream);
126err:
127 g_free(out);
128 return NULL;
129}
130
131static 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)));
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
148static 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));
183 vnc_write_u32(vs, flags);
184 vnc_write(vs, zbuf, zsize);
185 vnc_unlock_output(vs);
186 vnc_flush(vs);
187}
188
189static void vnc_clipboard_update_info(VncState *vs, QemuClipboardInfo *info)
190{
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
221static 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;
230 case QEMU_CLIPBOARD_RESET_SERIAL:
231
232 return;
233 }
234}
235
236static 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
253void vnc_client_cut_text_ext(VncState *vs, int32_t len, uint32_t flags, uint8_t *data)
254{
255 if (flags & VNC_CLIPBOARD_CAPS) {
256
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
303void 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
313void 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
329 if (!vs->cbpeer.notifier.notify) {
330 vs->cbpeer.name = "vnc";
331 vs->cbpeer.notifier.notify = vnc_clipboard_notify;
332 vs->cbpeer.request = vnc_clipboard_request;
333 qemu_clipboard_peer_register(&vs->cbpeer);
334 }
335}
336
