]>
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 | ||
ebfbf394 FE |
72 | *size = stream.total_out; |
73 | inflateEnd(&stream); | |
74 | ||
75 | return out; | |
76 | ||
0bf41cab GH |
77 | err_end: |
78 | inflateEnd(&stream); | |
79 | err: | |
80 | g_free(out); | |
81 | return NULL; | |
82 | } | |
83 | ||
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 | ||
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 | ||
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 | ||
1b17f1e9 | 194 | static void vnc_clipboard_update_info(VncState *vs, QemuClipboardInfo *info) |
0bf41cab | 195 | { |
0bf41cab GH |
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 | ||
1b17f1e9 MAL |
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; | |
505dbf9b MAL |
235 | case QEMU_CLIPBOARD_RESET_SERIAL: |
236 | /* ignore */ | |
237 | return; | |
1b17f1e9 MAL |
238 | } |
239 | } | |
240 | ||
0bf41cab GH |
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 | ||
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 | ||
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 | ||
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 | ||
1b17f1e9 | 334 | if (!vs->cbpeer.notifier.notify) { |
2e572baf | 335 | vs->cbpeer.name = "vnc"; |
1b17f1e9 | 336 | vs->cbpeer.notifier.notify = vnc_clipboard_notify; |
2e572baf VSO |
337 | vs->cbpeer.request = vnc_clipboard_request; |
338 | qemu_clipboard_peer_register(&vs->cbpeer); | |
339 | } | |
0bf41cab | 340 | } |