VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/VBoxClient/clipboard.cpp@ 81369

Last change on this file since 81369 was 81369, checked in by vboxsync, 5 years ago

*: doxygen fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 10.6 KB
Line 
1/** $Id: clipboard.cpp 81369 2019-10-18 21:13:03Z vboxsync $ */
2/** @file
3 * Guest Additions - X11 Shared Clipboard.
4 */
5
6/*
7 * Copyright (C) 2007-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#include <iprt/alloc.h>
23#include <iprt/asm.h>
24#include <iprt/assert.h>
25#include <iprt/initterm.h>
26#include <iprt/mem.h>
27#include <iprt/string.h>
28#include <iprt/process.h>
29#include <iprt/semaphore.h>
30
31#include <VBox/log.h>
32#include <VBox/VBoxGuestLib.h>
33#include <VBox/HostServices/VBoxClipboardSvc.h>
34#include <VBox/GuestHost/SharedClipboard.h>
35
36#include "VBoxClient.h"
37
38
39/*********************************************************************************************************************************
40* Global Variables *
41*********************************************************************************************************************************/
42
43/**
44 * Global clipboard context information.
45 */
46struct _SHCLCONTEXT
47{
48 /** Client ID for the clipboard subsystem */
49 uint32_t client;
50
51 /** Pointer to the X11 clipboard backend */
52 CLIPBACKEND *pBackend;
53};
54
55/** Only one client is supported. There seems to be no need for more clients. */
56static SHCLCONTEXT g_ctx;
57
58
59/**
60 * Transfer clipboard data from the guest to the host.
61 *
62 * @returns VBox result code
63 * @param u32Format The format of the data being sent
64 * @param pv Pointer to the data being sent
65 * @param cb Size of the data being sent in bytes
66 */
67static int vboxClipboardSendData(uint32_t u32Format, void *pv, uint32_t cb)
68{
69 int rc;
70 LogFlowFunc(("u32Format=%d, pv=%p, cb=%d\n", u32Format, pv, cb));
71 rc = VbglR3ClipboardWriteData(g_ctx.client, u32Format, pv, cb);
72 LogFlowFuncLeaveRC(rc);
73 return rc;
74}
75
76
77/**
78 * Get clipboard data from the host.
79 *
80 * @returns VBox result code
81 * @param pCtx Our context information
82 * @param u32Format The format of the data being requested
83 * @param ppv On success and if pcb > 0, this will point to a buffer
84 * to be freed with RTMemFree containing the data read.
85 * @param pcb On success, this contains the number of bytes of data
86 * returned
87 */
88DECLCALLBACK(int) ClipRequestDataForX11Callback(SHCLCONTEXT *pCtx, uint32_t u32Format, void **ppv, uint32_t *pcb)
89{
90 RT_NOREF(pCtx);
91 int rc = VINF_SUCCESS;
92 uint32_t cb = 1024;
93 void *pv = RTMemAlloc(cb);
94
95 *ppv = 0;
96 LogFlowFunc(("u32Format=%u\n", u32Format));
97 if (RT_UNLIKELY(!pv))
98 rc = VERR_NO_MEMORY;
99 if (RT_SUCCESS(rc))
100 rc = VbglR3ClipboardReadData(g_ctx.client, u32Format, pv, cb, pcb);
101 if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
102 *ppv = pv;
103 /* A return value of VINF_BUFFER_OVERFLOW tells us to try again with a
104 * larger buffer. The size of the buffer needed is placed in *pcb.
105 * So we start all over again. */
106 if (rc == VINF_BUFFER_OVERFLOW)
107 {
108 cb = *pcb;
109 RTMemFree(pv);
110 pv = RTMemAlloc(cb);
111 if (RT_UNLIKELY(!pv))
112 rc = VERR_NO_MEMORY;
113 if (RT_SUCCESS(rc))
114 rc = VbglR3ClipboardReadData(g_ctx.client, u32Format, pv, cb, pcb);
115 if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
116 *ppv = pv;
117 }
118 /* Catch other errors. This also catches the case in which the buffer was
119 * too small a second time, possibly because the clipboard contents
120 * changed half-way through the operation. Since we can't say whether or
121 * not this is actually an error, we just return size 0.
122 */
123 if (RT_FAILURE(rc) || (VINF_BUFFER_OVERFLOW == rc))
124 {
125 *pcb = 0;
126 if (pv != NULL)
127 RTMemFree(pv);
128 }
129 LogFlowFuncLeaveRC(rc);
130 if (RT_SUCCESS(rc))
131 LogFlow((" *pcb=%d\n", *pcb));
132 return rc;
133}
134
135/** Opaque data structure describing a request from the host for clipboard
136 * data, passed in when the request is forwarded to the X11 backend so that
137 * it can be completed correctly. */
138struct _CLIPREADCBREQ
139{
140 /** The data format that was requested. */
141 uint32_t u32Format;
142};
143
144/**
145 * Tell the host that new clipboard formats are available.
146 *
147 * @param pCtx Our context information.
148 * @param u32Formats The formats to report.
149 */
150DECLCALLBACK(void) ClipReportX11FormatsCallback(SHCLCONTEXT *pCtx, uint32_t u32Formats)
151{
152 RT_NOREF(pCtx);
153
154 LogFlowFunc(("u32Formats=%RU32\n", u32Formats));
155
156 int rc = VbglR3ClipboardFormatsReport(g_ctx.client, u32Formats);
157 RT_NOREF(rc);
158
159 LogFlowFuncLeaveRC(rc);
160}
161
162/** This is called by the backend to tell us that a request for data from
163 * X11 has completed.
164 * @param pCtx Our context information
165 * @param rc the iprt result code of the request
166 * @param pReq the request structure that we passed in when we started
167 * the request. We RTMemFree() this in this function.
168 * @param pv the clipboard data returned from X11 if the request
169 * succeeded (see @a rc)
170 * @param cb the size of the data in @a pv
171 */
172DECLCALLBACK(void) ClipRequestFromX11CompleteCallback(SHCLCONTEXT *pCtx, int rc, CLIPREADCBREQ *pReq, void *pv, uint32_t cb)
173{
174 RT_NOREF(pCtx);
175 if (RT_SUCCESS(rc))
176 vboxClipboardSendData(pReq->u32Format, pv, cb);
177 else
178 vboxClipboardSendData(0, NULL, 0);
179 RTMemFree(pReq);
180}
181
182/**
183 * Connect the guest clipboard to the host.
184 *
185 * @returns VBox status code
186 */
187static int vboxClipboardConnect(void)
188{
189 LogFlowFuncEnter();
190
191 /* Sanity */
192 AssertReturn(g_ctx.client == 0, VERR_WRONG_ORDER);
193 AssertReturn(g_ctx.pBackend == NULL, VERR_WRONG_ORDER);
194
195 int rc;
196
197 g_ctx.pBackend = ClipConstructX11(&g_ctx, false);
198 if (g_ctx.pBackend)
199 {
200 rc = ClipStartX11(g_ctx.pBackend, false /* grab */);
201 if (RT_SUCCESS(rc))
202 {
203 rc = VbglR3ClipboardConnect(&g_ctx.client);
204 if (RT_SUCCESS(rc))
205 {
206 Assert(g_ctx.client);
207 }
208 else
209 VBClLogError("Error connecting to host, rc=%Rrc\n", rc);
210 }
211 }
212 else
213 rc = VERR_NO_MEMORY;
214
215 if (rc != VINF_SUCCESS && g_ctx.pBackend)
216 ClipDestructX11(g_ctx.pBackend);
217
218 LogFlowFuncLeaveRC(rc);
219 return rc;
220}
221
222/**
223 * The main loop of our clipboard reader.
224 */
225int vboxClipboardMain(void)
226{
227 int rc;
228 LogFlowFunc(("Starting guest clipboard service\n"));
229 bool fExiting = false;
230
231 while (!fExiting)
232 {
233 uint32_t Msg;
234 uint32_t fFormats;
235 rc = VbglR3ClipboardGetHostMsgOld(g_ctx.client, &Msg, &fFormats);
236 if (RT_SUCCESS(rc))
237 {
238 switch (Msg)
239 {
240 case VBOX_SHCL_HOST_MSG_FORMATS_REPORT:
241 {
242 /* The host has announced available clipboard formats.
243 * Save the information so that it is available for
244 * future requests from guest applications.
245 */
246 LogFlowFunc(("VBOX_SHCL_HOST_MSG_FORMATS_WRITE fFormats=%x\n", fFormats));
247 ClipAnnounceFormatToX11(g_ctx.pBackend, fFormats);
248 break;
249 }
250
251 case VBOX_SHCL_HOST_MSG_READ_DATA:
252 {
253 /* The host needs data in the specified format. */
254 LogFlowFunc(("VBOX_SHCL_HOST_MSG_READ_DATA fFormats=%x\n", fFormats));
255 CLIPREADCBREQ *pReq;
256 pReq = (CLIPREADCBREQ *)RTMemAllocZ(sizeof(*pReq));
257 if (!pReq)
258 {
259 rc = VERR_NO_MEMORY;
260 fExiting = true;
261 }
262 else
263 {
264 pReq->u32Format = fFormats;
265 ClipRequestDataFromX11(g_ctx.pBackend, fFormats,
266 pReq);
267 }
268 break;
269 }
270
271 case VBOX_SHCL_HOST_MSG_QUIT:
272 {
273 /* The host is terminating. */
274 LogFlowFunc(("VBOX_SHCL_HOST_MSG_QUIT\n"));
275 if (RT_SUCCESS(ClipStopX11(g_ctx.pBackend)))
276 ClipDestructX11(g_ctx.pBackend);
277 fExiting = true;
278 break;
279 }
280
281 default:
282 {
283 VBClLogInfo("Unsupported message from host (%RU32)\n", Msg);
284 break;
285 }
286 }
287 }
288
289 LogFlow(("processed host event rc = %d\n", rc));
290 }
291 LogFlowFuncLeaveRC(rc);
292 return rc;
293}
294
295static const char *getName()
296{
297 return "Shared Clipboard";
298}
299
300static const char *getPidFilePath()
301{
302 return ".vboxclient-clipboard.pid";
303}
304
305static int run(struct VBCLSERVICE **ppInterface, bool fDaemonised)
306{
307 RT_NOREF(ppInterface, fDaemonised);
308
309 /* Initialise the guest library. */
310 int rc = vboxClipboardConnect();
311 if (RT_SUCCESS(rc))
312 {
313 rc = vboxClipboardMain();
314 }
315
316 if (RT_FAILURE(rc))
317 VBClLogError("Service terminated abnormally with %Rrc\n", rc);
318
319 if (rc == VERR_HGCM_SERVICE_NOT_FOUND)
320 rc = VINF_SUCCESS; /* Prevent automatic restart by daemon script if host service not available. */
321
322 return rc;
323}
324
325static void cleanup(struct VBCLSERVICE **ppInterface)
326{
327 RT_NOREF(ppInterface);
328 VbglR3Term();
329}
330
331struct VBCLSERVICE vbclClipboardInterface =
332{
333 getName,
334 getPidFilePath,
335 VBClServiceDefaultHandler, /* init */
336 run,
337 cleanup
338};
339
340struct CLIPBOARDSERVICE
341{
342 struct VBCLSERVICE *pInterface;
343};
344
345struct VBCLSERVICE **VBClGetClipboardService()
346{
347 struct CLIPBOARDSERVICE *pService =
348 (struct CLIPBOARDSERVICE *)RTMemAlloc(sizeof(*pService));
349
350 if (!pService)
351 VBClLogFatalError("Out of memory\n");
352 pService->pInterface = &vbclClipboardInterface;
353 return &pService->pInterface;
354}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette