Changeset 78580 in vbox for trunk/src/VBox
- Timestamp:
- May 18, 2019 3:38:45 PM (6 years ago)
- Location:
- trunk/src/VBox/HostServices/SharedClipboard
- Files:
-
- 7 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/HostServices/SharedClipboard/VBoxClipboard.h
r78579 r78580 27 27 #include <VBox/GuestHost/SharedClipboard.h> 28 28 29 typedef struct _VBOXCLIPBOARD CLIENTDATA29 typedef struct _VBOXCLIPBOARDSVCCTX 30 30 { 31 struct _VBOXCLIPBOARD CLIENTDATA*pNext;32 struct _VBOXCLIPBOARD CLIENTDATA*pPrev;31 struct _VBOXCLIPBOARDSVCCTX *pNext; 32 struct _VBOXCLIPBOARDSVCCTX *pPrev; 33 33 34 34 VBOXCLIPBOARDCONTEXT *pCtx; -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-darwin.cpp
r78579 r78580 63 63 static int vboxClipboardChanged(VBOXCLIPBOARDCONTEXT *pCtx) 64 64 { 65 if (pCtx->p Client== NULL)65 if (pCtx->pSvcCtx == NULL) 66 66 return VINF_SUCCESS; 67 67 … … 72 72 if (RT_SUCCESS(rc) && fChanged) 73 73 { 74 vboxSvcClipboardReportMsg(pCtx->p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, fFormats);74 vboxSvcClipboardReportMsg(pCtx->pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, fFormats); 75 75 Log(("vboxClipboardChanged fFormats %02X\n", fFormats)); 76 76 } … … 157 157 destroyPasteboard(&g_ctx.pasteboard); 158 158 g_ctx.thread = NIL_RTTHREAD; 159 g_ctx.p Client= NULL;159 g_ctx.pSvcCtx = NULL; 160 160 } 161 161 … … 163 163 * Enable the shared clipboard - called by the hgcm clipboard subsystem. 164 164 * 165 * @param p ClientStructure containing context information about the guest system165 * @param pSvcCtx Structure containing context information about the guest system 166 166 * @param fHeadless Whether headless. 167 167 * @returns RT status code … … 170 170 { 171 171 NOREF(fHeadless); 172 if (g_ctx.p Client!= NULL)172 if (g_ctx.pSvcCtx != NULL) 173 173 { 174 174 /* One client only. */ … … 178 178 VBoxSvcClipboardLock(); 179 179 180 p Client->pCtx = &g_ctx;181 p Client->pCtx->pClient = pClient;180 pSvcCtx->pCtx = &g_ctx; 181 pSvcCtx->pCtx->pSvcCtx = pSvcCtx; 182 182 183 183 /* Initially sync the host clipboard content with the client. */ 184 int rc = VBoxClipboardSvcImplSync(p Client);184 int rc = VBoxClipboardSvcImplSync(pSvcCtx); 185 185 186 186 VBoxSvcClipboardUnlock(); … … 196 196 /* Sync the host clipboard content with the client. */ 197 197 VBoxSvcClipboardLock(); 198 int rc = vboxClipboardChanged(p Client->pCtx);198 int rc = vboxClipboardChanged(pSvcCtx->pCtx); 199 199 VBoxSvcClipboardUnlock(); 200 200 … … 210 210 211 211 VBoxSvcClipboardLock(); 212 p Client->pCtx->pClient= NULL;212 pSvcCtx->pCtx->pSvcCtx = NULL; 213 213 VBoxSvcClipboardUnlock(); 214 214 } … … 218 218 * subsystem. 219 219 * 220 * @param p ClientContext data for the guest system220 * @param pSvcCtx Context data for the guest system 221 221 * @param u32Formats Clipboard formats the guest is offering 222 222 */ … … 230 230 } 231 231 232 vboxSvcClipboardReportMsg(p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Formats);232 vboxSvcClipboardReportMsg(pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Formats); 233 233 } 234 234 … … 236 236 * Called by the HGCM clipboard subsystem when the guest wants to read the host clipboard. 237 237 * 238 * @param p ClientContext information about the guest VM238 * @param pSvcCtx Context information about the guest VM 239 239 * @param u32Format The format that the guest would like to receive the data in 240 240 * @param pv Where to write the data to … … 249 249 /* Default to no data available. */ 250 250 *pcbActual = 0; 251 int rc = readFromPasteboard(p Client->pCtx->pasteboard, u32Format, pv, cb, pcbActual);251 int rc = readFromPasteboard(pSvcCtx->pCtx->pasteboard, u32Format, pv, cb, pcbActual); 252 252 253 253 VBoxSvcClipboardUnlock(); … … 258 258 * Called by the HGCM clipboard subsystem when we have requested data and that data arrives. 259 259 * 260 * @param p ClientContext information about the guest VM260 * @param pSvcCtx Context information about the guest VM 261 261 * @param pv Buffer to which the data was written 262 262 * @param cb The size of the data written … … 267 267 VBoxSvcClipboardLock(); 268 268 269 writeToPasteboard(p Client->pCtx->pasteboard, pv, cb, u32Format);270 271 VBoxSvcClipboardUnlock(); 272 } 269 writeToPasteboard(pSvcCtx->pCtx->pasteboard, pv, cb, u32Format); 270 271 VBoxSvcClipboardUnlock(); 272 } -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
r78579 r78580 61 61 RTSEMEVENT hRenderEvent; 62 62 /** Structure for keeping and communicating with client data (from the guest). */ 63 PVBOXCLIPBOARDSVCCTX pClient;63 PVBOXCLIPBOARDSVCCTX pSvcCtx; 64 64 /** Windows-specific context data. */ 65 65 VBOXCLIPBOARDWINCTX Win; … … 160 160 static int vboxClipboardReadDataFromClient(VBOXCLIPBOARDCONTEXT *pCtx, VBOXCLIPBOARDFORMAT fFormat) 161 161 { 162 Assert(pCtx->p Client);162 Assert(pCtx->pSvcCtx); 163 163 Assert(pCtx->hRenderEvent); 164 Assert(pCtx->p Client->data.pv == NULL && pCtx->pClient->data.cb == 0 && pCtx->pClient->data.u32Format == 0);164 Assert(pCtx->pSvcCtx->data.pv == NULL && pCtx->pSvcCtx->data.cb == 0 && pCtx->pSvcCtx->data.u32Format == 0); 165 165 166 166 LogFlowFunc(("fFormat=%02X\n", fFormat)); 167 167 168 vboxSvcClipboardReportMsg(pCtx->p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat);168 vboxSvcClipboardReportMsg(pCtx->pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, fFormat); 169 169 170 170 return RTSemEventWait(pCtx->hRenderEvent, 30 * 1000 /* Timeout in ms */); … … 289 289 290 290 if ( fFormat == VBOX_SHARED_CLIPBOARD_FMT_NONE 291 || pCtx->p Client== NULL)291 || pCtx->pSvcCtx == NULL) 292 292 { 293 293 /* Unsupported clipboard format is requested. */ … … 300 300 301 301 LogFunc(("vboxClipboardReadDataFromClient rc = %Rrc, pv %p, cb %d, u32Format %d\n", 302 rc, pCtx->p Client->data.pv, pCtx->pClient->data.cb, pCtx->pClient->data.u32Format));302 rc, pCtx->pSvcCtx->data.pv, pCtx->pSvcCtx->data.cb, pCtx->pSvcCtx->data.u32Format)); 303 303 304 304 if ( RT_SUCCESS (rc) 305 && pCtx->p Client->data.pv != NULL306 && pCtx->p Client->data.cb > 0307 && pCtx->p Client->data.u32Format == fFormat)308 { 309 HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->p Client->data.cb);305 && pCtx->pSvcCtx->data.pv != NULL 306 && pCtx->pSvcCtx->data.cb > 0 307 && pCtx->pSvcCtx->data.u32Format == fFormat) 308 { 309 HANDLE hMem = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, pCtx->pSvcCtx->data.cb); 310 310 311 311 LogFunc(("hMem %p\n", hMem)); … … 321 321 LogFunc(("WM_RENDERFORMAT setting data\n")); 322 322 323 if (pCtx->p Client->data.pv)323 if (pCtx->pSvcCtx->data.pv) 324 324 { 325 memcpy(pMem, pCtx->p Client->data.pv, pCtx->pClient->data.cb);326 327 RTMemFree(pCtx->p Client->data.pv);328 pCtx->p Client->data.pv = NULL;325 memcpy(pMem, pCtx->pSvcCtx->data.pv, pCtx->pSvcCtx->data.cb); 326 327 RTMemFree(pCtx->pSvcCtx->data.pv); 328 pCtx->pSvcCtx->data.pv = NULL; 329 329 } 330 330 331 pCtx->p Client->data.cb = 0;332 pCtx->p Client->data.u32Format = 0;331 pCtx->pSvcCtx->data.cb = 0; 332 pCtx->pSvcCtx->data.u32Format = 0; 333 333 334 334 /* The memory must be unlocked before inserting to the Clipboard. */ … … 353 353 } 354 354 355 RTMemFree(pCtx->p Client->data.pv);356 pCtx->p Client->data.pv = NULL;357 pCtx->p Client->data.cb = 0;358 pCtx->p Client->data.u32Format = 0;355 RTMemFree(pCtx->pSvcCtx->data.pv); 356 pCtx->pSvcCtx->data.pv = NULL; 357 pCtx->pSvcCtx->data.cb = 0; 358 pCtx->pSvcCtx->data.u32Format = 0; 359 359 360 360 /* Something went wrong. */ … … 380 380 case VBOX_CLIPBOARD_WM_SET_FORMATS: 381 381 { 382 if ( pCtx->p Client== NULL383 || pCtx->p Client->fHostMsgFormats)382 if ( pCtx->pSvcCtx == NULL 383 || pCtx->pSvcCtx->fHostMsgFormats) 384 384 { 385 385 /* Host has pending formats message. Ignore the guest announcement, … … 545 545 int rc; 546 546 547 if (pCtx->p Client)547 if (pCtx->pSvcCtx) 548 548 { 549 549 uint32_t uFormats; 550 550 rc = VBoxClipboardWinGetFormats(&pCtx->Win, &uFormats); 551 551 if (RT_SUCCESS(rc)) 552 vboxSvcClipboardReportMsg(pCtx->p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, uFormats);552 vboxSvcClipboardReportMsg(pCtx->pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, uFormats); 553 553 } 554 554 else /* If we don't have any client data (yet), bail out. */ … … 608 608 LogFlowFuncEnter(); 609 609 610 if (g_ctx.p Client!= NULL)610 if (g_ctx.pSvcCtx != NULL) 611 611 { 612 612 /* One client only. */ … … 614 614 } 615 615 616 p Client->pCtx = &g_ctx;617 618 p Client->pCtx->pClient = pClient;616 pSvcCtx->pCtx = &g_ctx; 617 618 pSvcCtx->pCtx->pSvcCtx = pSvcCtx; 619 619 620 620 /* Sync the host clipboard content with the client. */ 621 VBoxClipboardSvcImplSync(p Client);621 VBoxClipboardSvcImplSync(pSvcCtx); 622 622 623 623 return VINF_SUCCESS; … … 627 627 { 628 628 /* Sync the host clipboard content with the client. */ 629 return vboxClipboardWinSyncInternal(p Client->pCtx);629 return vboxClipboardWinSyncInternal(pSvcCtx->pCtx); 630 630 } 631 631 632 632 void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx) 633 633 { 634 RT_NOREF(p Client);634 RT_NOREF(pSvcCtx); 635 635 636 636 LogFlowFuncEnter(); 637 637 638 g_ctx.p Client= NULL;638 g_ctx.pSvcCtx = NULL; 639 639 } 640 640 641 641 void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats) 642 642 { 643 AssertPtrReturnVoid(p Client);644 AssertPtrReturnVoid(p Client->pCtx);643 AssertPtrReturnVoid(pSvcCtx); 644 AssertPtrReturnVoid(pSvcCtx->pCtx); 645 645 646 646 /* 647 647 * The guest announces formats. Forward to the window thread. 648 648 */ 649 PostMessage(p Client->pCtx->Win.hWnd, WM_USER, 0, u32Formats);649 PostMessage(pSvcCtx->pCtx->Win.hWnd, WM_USER, 0, u32Formats); 650 650 } 651 651 … … 684 684 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Format, void *pv, uint32_t cb, uint32_t *pcbActual) 685 685 { 686 AssertPtrReturn(p Client, VERR_INVALID_POINTER);687 AssertPtrReturn(p Client->pCtx, VERR_INVALID_POINTER);686 AssertPtrReturn(pSvcCtx, VERR_INVALID_POINTER); 687 AssertPtrReturn(pSvcCtx->pCtx, VERR_INVALID_POINTER); 688 688 689 689 LogFlowFunc(("u32Format=%02X\n", u32Format)); … … 691 691 HANDLE hClip = NULL; 692 692 693 const PVBOXCLIPBOARDWINCTX pWinCtx = &p Client->pCtx->Win;693 const PVBOXCLIPBOARDWINCTX pWinCtx = &pSvcCtx->pCtx->Win; 694 694 695 695 /* … … 823 823 * The guest returns data that was requested in the WM_RENDERFORMAT handler. 824 824 */ 825 Assert(p Client->data.pv == NULL && pClient->data.cb == 0 && pClient->data.u32Format == 0);825 Assert(pSvcCtx->data.pv == NULL && pSvcCtx->data.cb == 0 && pSvcCtx->data.u32Format == 0); 826 826 827 827 vboxClipboardDump(pv, cb, u32Format); … … 841 841 if (pszResult != NULL && cbResult != 0) 842 842 { 843 p Client->data.pv = pszResult;844 p Client->data.cb = cbResult;845 p Client->data.u32Format = u32Format;843 pSvcCtx->data.pv = pszResult; 844 pSvcCtx->data.cb = cbResult; 845 pSvcCtx->data.u32Format = u32Format; 846 846 } 847 847 } … … 849 849 else 850 850 { 851 p Client->data.pv = RTMemDup(pv, cb);852 if (p Client->data.pv)853 { 854 p Client->data.cb = cb;855 p Client->data.u32Format = u32Format;856 } 857 } 858 } 859 860 AssertPtr(p Client->pCtx);861 int rc = RTSemEventSignal(p Client->pCtx->hRenderEvent);851 pSvcCtx->data.pv = RTMemDup(pv, cb); 852 if (pSvcCtx->data.pv) 853 { 854 pSvcCtx->data.cb = cb; 855 pSvcCtx->data.u32Format = u32Format; 856 } 857 } 858 } 859 860 AssertPtr(pSvcCtx->pCtx); 861 int rc = RTSemEventSignal(pSvcCtx->pCtx->hRenderEvent); 862 862 AssertRC(rc); 863 863 -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11-stubs.cpp
r78579 r78580 55 55 * Enable the shared clipboard - called by the hgcm clipboard subsystem. 56 56 * 57 * @param p ClientStructure containing context information about the guest system57 * @param pSvcCtx Structure containing context information about the guest system 58 58 * @param fHeadless Whether headless. 59 59 * @returns RT status code … … 61 61 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX pSvcCtx, bool fHeadless) 62 62 { 63 RT_NOREF(p Client, fHeadless);63 RT_NOREF(pSvcCtx, fHeadless); 64 64 LogFlowFunc(("called, returning VINF_SUCCESS.\n")); 65 65 return VINF_SUCCESS; … … 70 70 * after a save and restore of the guest. 71 71 */ 72 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX /* p Client*/)72 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX /* pSvcCtx */) 73 73 { 74 74 LogFlowFunc(("called, returning VINF_SUCCESS.\n")); … … 79 79 * Shut down the shared clipboard subsystem and "disconnect" the guest. 80 80 * 81 * @param p ClientStructure containing context information about the guest system81 * @param pSvcCtx Structure containing context information about the guest system 82 82 */ 83 83 void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX pSvcCtx) 84 84 { 85 RT_NOREF(p Client);85 RT_NOREF(pSvcCtx); 86 86 LogFlowFunc(("called, returning.\n")); 87 87 } … … 91 91 * subsystem. 92 92 * 93 * @param p ClientContext data for the guest system93 * @param pSvcCtx Context data for the guest system 94 94 * @param u32Formats Clipboard formats the guest is offering 95 95 */ 96 96 void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats) 97 97 { 98 RT_NOREF(p Client, u32Formats);98 RT_NOREF(pSvcCtx, u32Formats); 99 99 LogFlowFunc(("called, returning.\n")); 100 100 } … … 103 103 * Called by the HGCM clipboard subsystem when the guest wants to read the host clipboard. 104 104 * 105 * @param p ClientContext information about the guest VM105 * @param pSvcCtx Context information about the guest VM 106 106 * @param u32Format The format that the guest would like to receive the data in 107 107 * @param pv Where to write the data to … … 112 112 void *pv, uint32_t cb, uint32_t *pcbActual) 113 113 { 114 RT_NOREF(p Client, u32Format, pv, cb);114 RT_NOREF(pSvcCtx, u32Format, pv, cb); 115 115 LogFlowFunc(("called, returning VINF_SUCCESS.\n")); 116 116 /* No data available. */ … … 122 122 * Called by the HGCM clipboard subsystem when we have requested data and that data arrives. 123 123 * 124 * @param p ClientContext information about the guest VM124 * @param pSvcCtx Context information about the guest VM 125 125 * @param pv Buffer to which the data was written 126 126 * @param cb The size of the data written … … 130 130 uint32_t u32Format) 131 131 { 132 RT_NOREF(p Client, pv, cb, u32Format);132 RT_NOREF(pSvcCtx, pv, cb, u32Format); 133 133 LogFlowFunc(("called, returning.\n")); 134 134 } -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-x11.cpp
r78579 r78580 76 76 { 77 77 LogRelFlowFunc(("called. pCtx=%p, u32Formats=%02X\n", pCtx, u32Formats)); 78 vboxSvcClipboardReportMsg(pCtx->p Client,78 vboxSvcClipboardReportMsg(pCtx->pSvcCtx, 79 79 VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, 80 80 u32Formats); … … 123 123 { 124 124 pCtx->pBackend = pBackend; 125 p Client->pCtx = pCtx;126 pCtx->p Client = pClient;125 pSvcCtx->pCtx = pCtx; 126 pCtx->pSvcCtx = pSvcCtx; 127 127 rc = ClipStartX11(pBackend, true /* grab shared clipboard */); 128 128 } … … 149 149 * there is data in the host clipboard it will automatically be sent to 150 150 * the guest when the clipboard starts up. */ 151 vboxSvcClipboardReportMsg(p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, 0);151 vboxSvcClipboardReportMsg(pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, 0); 152 152 /** @todo r=andy Check rc code. */ 153 153 return VINF_SUCCESS; … … 163 163 164 164 LogRel(("Stopping the host clipboard service\n")); 165 VBOXCLIPBOARDCONTEXT *pCtx = p Client->pCtx;165 VBOXCLIPBOARDCONTEXT *pCtx = pSvcCtx->pCtx; 166 166 /* Drop the reference to the client, in case it is still there. This 167 167 * will cause any outstanding clipboard data requests from X11 to fail … … 169 169 pCtx->fShuttingDown = true; 170 170 /* If there is a currently pending request, release it immediately. */ 171 VBoxClipboardSvcImplWriteData(p Client, NULL, 0, 0);171 VBoxClipboardSvcImplWriteData(pSvcCtx, NULL, 0, 0); 172 172 int rc = ClipStopX11(pCtx->pBackend); 173 173 /** @todo handle this slightly more reasonably, or be really sure … … 185 185 * VBox is taking possession of the shared clipboard. 186 186 * 187 * @param p ClientContext data for the guest system187 * @param pSvcCtx Context data for the guest system 188 188 * @param u32Formats Clipboard formats the guest is offering 189 189 * @note Host glue code … … 191 191 void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Formats) 192 192 { 193 LogRelFlowFunc(("called. p Client=%p, u32Formats=%02X\n", pClient, u32Formats));194 195 ClipAnnounceFormatToX11(p Client->pCtx->pBackend, u32Formats);193 LogRelFlowFunc(("called. pSvcCtx=%p, u32Formats=%02X\n", pSvcCtx, u32Formats)); 194 195 ClipAnnounceFormatToX11(pSvcCtx->pCtx->pBackend, u32Formats); 196 196 } 197 197 … … 214 214 * asynchronously 215 215 * @returns iprt status code on failure 216 * @param p ClientContext information about the guest VM216 * @param pSvcCtx Context information about the guest VM 217 217 * @param u32Format The format that the guest would like to receive the data in 218 218 * @param pv Where to write the data to … … 229 229 uint32_t *pcbActual) 230 230 { 231 LogRelFlowFunc(("p Client=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p",232 p Client, u32Format, pv, cb, pcbActual));231 LogRelFlowFunc(("pSvcCtx=%p, u32Format=%02X, pv=%p, cb=%u, pcbActual=%p", 232 pSvcCtx, u32Format, pv, cb, pcbActual)); 233 233 234 234 int rc = VINF_SUCCESS; … … 241 241 pReq->cb = cb; 242 242 pReq->pcbActual = pcbActual; 243 rc = ClipRequestDataFromX11(p Client->pCtx->pBackend, u32Format, pReq);243 rc = ClipRequestDataFromX11(pSvcCtx->pCtx->pBackend, u32Format, pReq); 244 244 if (RT_SUCCESS(rc)) 245 245 rc = VINF_HGCM_ASYNC_EXECUTE; … … 269 269 RTMemFree(pReq); 270 270 271 vboxSvcClipboardCompleteReadData(pCtx->p Client, rc, cb);271 vboxSvcClipboardCompleteReadData(pCtx->pSvcCtx, rc, cb); 272 272 } 273 273 … … 295 295 296 296 /* Request data from VBox */ 297 vboxSvcClipboardReportMsg(pCtx->p Client,297 vboxSvcClipboardReportMsg(pCtx->pSvcCtx, 298 298 VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, 299 299 u32Format); … … 393 393 * Called when we have requested data from VBox and that data has arrived. 394 394 * 395 * @param p ClientContext information about the guest VM395 * @param pSvcCtx Context information about the guest VM 396 396 * @param pv Buffer to which the data was written 397 397 * @param cb The size of the data written … … 402 402 void *pv, uint32_t cb, uint32_t u32Format) 403 403 { 404 LogRelFlowFunc(("called. p Client=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n",405 p Client, pv, cb / 2, pv, cb, u32Format));406 407 VBOXCLIPBOARDCONTEXT *pCtx = p Client->pCtx;404 LogRelFlowFunc(("called. pSvcCtx=%p, pv=%p (%.*ls), cb=%u, u32Format=%02X\n", 405 pSvcCtx, pv, cb / 2, pv, cb, u32Format)); 406 407 VBOXCLIPBOARDCONTEXT *pCtx = pSvcCtx->pCtx; 408 408 409 409 /* Grab the mutex and check whether there is a pending request for data. */ … … 466 466 { 467 467 RT_NOREF(u32Formats); 468 CLIPBACKEND *pBackend = p Client->pCtx->pBackend;468 CLIPBACKEND *pBackend = pSvcCtx->pCtx->pBackend; 469 469 470 470 if ((u32Msg == VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA) 471 471 && !pBackend->writeData.timeout) 472 VBoxClipboardSvcImplWriteData(p Client, pBackend->writeData.pv,472 VBoxClipboardSvcImplWriteData(pSvcCtx, pBackend->writeData.pv, 473 473 pBackend->writeData.cb, 474 474 pBackend->writeData.format); … … 479 479 void vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDSVCCTX pSvcCtx, int rc, uint32_t cbActual) 480 480 { 481 CLIPBACKEND *pBackend = p Client->pCtx->pBackend;481 CLIPBACKEND *pBackend = pSvcCtx->pCtx->pBackend; 482 482 pBackend->completeRead.rc = rc; 483 483 pBackend->completeRead.cbActual = cbActual; -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
r78579 r78580 102 102 static void *g_pvExtension; 103 103 104 static PVBOXCLIPBOARDSVCCTX g_p Client;104 static PVBOXCLIPBOARDSVCCTX g_pSvcCtx; 105 105 106 106 /* Serialization of data reading and format announcements from the RDP client. */ … … 203 203 { 204 204 /* Message priority is taken into account. */ 205 if (p Client->fHostMsgQuit)205 if (pSvcCtx->fHostMsgQuit) 206 206 { 207 207 LogFlowFunc(("vboxSvcClipboardReturnMsg: Quit\n")); 208 208 VBoxHGCMParmUInt32Set(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT); 209 209 VBoxHGCMParmUInt32Set(&paParms[1], 0); 210 p Client->fHostMsgQuit = false;211 } 212 else if (p Client->fHostMsgReadData)210 pSvcCtx->fHostMsgQuit = false; 211 } 212 else if (pSvcCtx->fHostMsgReadData) 213 213 { 214 214 uint32_t fFormat = 0; 215 215 216 LogFlowFunc(("vboxSvcClipboardReturnMsg: ReadData %02X\n", p Client->u32RequestedFormat));217 if (p Client->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)216 LogFlowFunc(("vboxSvcClipboardReturnMsg: ReadData %02X\n", pSvcCtx->u32RequestedFormat)); 217 if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT) 218 218 fFormat = VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT; 219 else if (p Client->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)219 else if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_BITMAP) 220 220 fFormat = VBOX_SHARED_CLIPBOARD_FMT_BITMAP; 221 else if (p Client->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML)221 else if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_HTML) 222 222 fFormat = VBOX_SHARED_CLIPBOARD_FMT_HTML; 223 223 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 224 else if (p Client->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)224 else if (pSvcCtx->u32RequestedFormat & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) 225 225 fFormat = VBOX_SHARED_CLIPBOARD_FMT_URI_LIST; 226 226 #endif … … 228 228 { 229 229 LogRel2(("Clipboard: Unsupported format from guest (0x%x), skipping\n", fFormat)); 230 p Client->u32RequestedFormat = 0;230 pSvcCtx->u32RequestedFormat = 0; 231 231 } 232 p Client->u32RequestedFormat &= ~fFormat;232 pSvcCtx->u32RequestedFormat &= ~fFormat; 233 233 VBoxHGCMParmUInt32Set(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA); 234 234 VBoxHGCMParmUInt32Set(&paParms[1], fFormat); 235 if (p Client->u32RequestedFormat == 0)236 p Client->fHostMsgReadData = false;237 } 238 else if (p Client->fHostMsgFormats)239 { 240 LogFlowFunc(("vboxSvcClipboardReturnMsg: Formats %02X\n", p Client->u32AvailableFormats));235 if (pSvcCtx->u32RequestedFormat == 0) 236 pSvcCtx->fHostMsgReadData = false; 237 } 238 else if (pSvcCtx->fHostMsgFormats) 239 { 240 LogFlowFunc(("vboxSvcClipboardReturnMsg: Formats %02X\n", pSvcCtx->u32AvailableFormats)); 241 241 VBoxHGCMParmUInt32Set(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS); 242 VBoxHGCMParmUInt32Set(&paParms[1], p Client->u32AvailableFormats);243 p Client->fHostMsgFormats = false;242 VBoxHGCMParmUInt32Set(&paParms[1], pSvcCtx->u32AvailableFormats); 243 pSvcCtx->fHostMsgFormats = false; 244 244 } 245 245 else … … 256 256 void vboxSvcClipboardReportMsg(PVBOXCLIPBOARDSVCCTX pSvcCtx, uint32_t u32Msg, uint32_t u32Formats) 257 257 { 258 AssertPtrReturnVoid(p Client);258 AssertPtrReturnVoid(pSvcCtx); 259 259 260 260 if (VBoxSvcClipboardLock()) … … 265 265 { 266 266 LogFlowFunc(("Quit\n")); 267 p Client->fHostMsgQuit = true;267 pSvcCtx->fHostMsgQuit = true; 268 268 } break; 269 269 case VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA: … … 277 277 278 278 LogFlowFunc(("ReadData %02X\n", u32Formats)); 279 p Client->u32RequestedFormat = u32Formats;280 p Client->fHostMsgReadData = true;279 pSvcCtx->u32RequestedFormat = u32Formats; 280 pSvcCtx->fHostMsgReadData = true; 281 281 } break; 282 282 case VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS: … … 290 290 291 291 LogFlowFunc(("Formats %02X\n", u32Formats)); 292 p Client->u32AvailableFormats = u32Formats;293 p Client->fHostMsgFormats = true;292 pSvcCtx->u32AvailableFormats = u32Formats; 293 pSvcCtx->fHostMsgFormats = true; 294 294 } break; 295 295 default: … … 300 300 } 301 301 302 if (p Client->fAsync)302 if (pSvcCtx->fAsync) 303 303 { 304 304 /* The client waits for a response. */ 305 bool fMessageReturned = vboxSvcClipboardReturnMsg(p Client, pClient->async.paParms);305 bool fMessageReturned = vboxSvcClipboardReturnMsg(pSvcCtx, pSvcCtx->async.paParms); 306 306 307 307 /* Make a copy of the handle. */ 308 VBOXHGCMCALLHANDLE callHandle = p Client->async.callHandle;308 VBOXHGCMCALLHANDLE callHandle = pSvcCtx->async.callHandle; 309 309 310 310 if (fMessageReturned) 311 311 { 312 312 /* There is a response. */ 313 p Client->fAsync = false;313 pSvcCtx->fAsync = false; 314 314 } 315 315 … … 370 370 LogFunc(("u32ClientID = %d\n", u32ClientID)); 371 371 372 vboxSvcClipboardReportMsg(p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0);373 374 vboxSvcClipboardCompleteReadData(p Client, VERR_NO_DATA, 0);375 376 VBoxClipboardSvcImplDisconnect(p Client);377 378 memset(p Client, 0, sizeof(*pClient));379 380 g_p Client= NULL;372 vboxSvcClipboardReportMsg(pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT, 0); 373 374 vboxSvcClipboardCompleteReadData(pSvcCtx, VERR_NO_DATA, 0); 375 376 VBoxClipboardSvcImplDisconnect(pSvcCtx); 377 378 memset(pSvcCtx, 0, sizeof(*pSvcCtx)); 379 380 g_pSvcCtx = NULL; 381 381 382 382 return VINF_SUCCESS; … … 391 391 392 392 /* If there is already a client connected then we want to release it first. */ 393 if (g_p Client!= NULL)394 { 395 uint32_t u32OldClientID = g_p Client->u32ClientID;396 397 svcDisconnect(NULL, u32OldClientID, g_p Client);393 if (g_pSvcCtx != NULL) 394 { 395 uint32_t u32OldClientID = g_pSvcCtx->u32ClientID; 396 397 svcDisconnect(NULL, u32OldClientID, g_pSvcCtx); 398 398 /* And free the resources in the hgcm subsystem. */ 399 399 g_pHelpers->pfnDisconnectClient(g_pHelpers->pvInstance, u32OldClientID); … … 401 401 402 402 /* Register the client. */ 403 memset(p Client, 0, sizeof(*pClient));404 405 p Client->u32ClientID = u32ClientID;406 407 rc = VBoxClipboardSvcImplConnect(p Client, VBoxSvcClipboardGetHeadless());403 memset(pSvcCtx, 0, sizeof(*pSvcCtx)); 404 405 pSvcCtx->u32ClientID = u32ClientID; 406 407 rc = VBoxClipboardSvcImplConnect(pSvcCtx, VBoxSvcClipboardGetHeadless()); 408 408 409 409 if (RT_SUCCESS(rc)) 410 410 { 411 g_p Client = pClient;411 g_pSvcCtx = pSvcCtx; 412 412 } 413 413 … … 467 467 if (VBoxSvcClipboardLock()) 468 468 { 469 bool fMessageReturned = vboxSvcClipboardReturnMsg (p Client, paParms);469 bool fMessageReturned = vboxSvcClipboardReturnMsg (pSvcCtx, paParms); 470 470 471 471 if (fMessageReturned) 472 472 { 473 473 /* Just return to the caller. */ 474 p Client->fAsync = false;474 pSvcCtx->fAsync = false; 475 475 } 476 476 else … … 479 479 fAsynchronousProcessing = true; 480 480 481 p Client->fAsync = true;482 p Client->async.callHandle = callHandle;483 p Client->async.paParms = paParms;481 pSvcCtx->fAsync = true; 482 pSvcCtx->async.callHandle = callHandle; 483 pSvcCtx->async.paParms = paParms; 484 484 485 485 LogFunc(("async.\n")); … … 534 534 else 535 535 { 536 VBoxClipboardSvcImplFormatAnnounce (p Client, u32Formats);536 VBoxClipboardSvcImplFormatAnnounce (pSvcCtx, u32Formats); 537 537 } 538 538 } … … 592 592 if (g_fDelayedAnnouncement) 593 593 { 594 vboxSvcClipboardReportMsg (g_p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats);594 vboxSvcClipboardReportMsg (g_pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats); 595 595 g_fDelayedAnnouncement = false; 596 596 g_u32DelayedFormats = 0; … … 607 607 /* Release any other pending read, as we only 608 608 * support one pending read at one time. */ 609 vboxSvcClipboardCompleteReadData(p Client, VERR_NO_DATA, 0);610 rc = VBoxClipboardSvcImplReadData (p Client, u32Format, pv, cb, &cbActual);609 vboxSvcClipboardCompleteReadData(pSvcCtx, VERR_NO_DATA, 0); 610 rc = VBoxClipboardSvcImplReadData (pSvcCtx, u32Format, pv, cb, &cbActual); 611 611 } 612 612 … … 618 618 if (VBoxSvcClipboardLock()) 619 619 { 620 p Client->asyncRead.callHandle = callHandle;621 p Client->asyncRead.paParms = paParms;622 p Client->fReadPending = true;620 pSvcCtx->asyncRead.callHandle = callHandle; 621 pSvcCtx->asyncRead.paParms = paParms; 622 pSvcCtx->fReadPending = true; 623 623 fAsynchronousProcessing = true; 624 624 VBoxSvcClipboardUnlock(); … … 684 684 else 685 685 { 686 VBoxClipboardSvcImplWriteData (p Client, pv, cb, u32Format);686 VBoxClipboardSvcImplWriteData (pSvcCtx, pv, cb, u32Format); 687 687 } 688 688 } … … 720 720 if (VBoxSvcClipboardLock()) /* if not can we do anything useful? */ 721 721 { 722 callHandle = p Client->asyncRead.callHandle;723 paParms = p Client->asyncRead.paParms;724 fReadPending = p Client->fReadPending;725 p Client->fReadPending = false;722 callHandle = pSvcCtx->asyncRead.callHandle; 723 paParms = pSvcCtx->asyncRead.paParms; 724 fReadPending = pSvcCtx->fReadPending; 725 pSvcCtx->fReadPending = false; 726 726 VBoxSvcClipboardUnlock(); 727 727 } … … 831 831 with the high bit set. */ 832 832 SSMR3PutU32(pSSM, UINT32_C(0x80000002)); 833 int rc = SSMR3PutStructEx(pSSM, p Client, sizeof(*pClient), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);833 int rc = SSMR3PutStructEx(pSSM, pSvcCtx, sizeof(*pSvcCtx), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL); 834 834 AssertRCReturn(rc, rc); 835 835 … … 894 894 895 895 /* Existing client can not be in async state yet. */ 896 Assert(!p Client->fAsync);896 Assert(!pSvcCtx->fAsync); 897 897 898 898 /* Save the client ID for data validation. */ 899 899 /** @todo isn't this the same as u32ClientID? Playing safe for now... */ 900 uint32_t const u32ClientIDOld = p Client->u32ClientID;900 uint32_t const u32ClientIDOld = pSvcCtx->u32ClientID; 901 901 902 902 /* Restore the client data. */ … … 906 906 if (lenOrVer == UINT32_C(0x80000002)) 907 907 { 908 rc = SSMR3GetStructEx(pSSM, p Client, sizeof(*pClient), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL);908 rc = SSMR3GetStructEx(pSSM, pSvcCtx, sizeof(*pSvcCtx), 0 /*fFlags*/, &g_aClipboardClientDataFields[0], NULL); 909 909 AssertRCReturn(rc, rc); 910 910 } … … 937 937 AssertRCReturn(rc, rc); 938 938 939 p Client->fHostMsgQuit = savedState.fHostMsgQuit;940 p Client->fHostMsgReadData = savedState.fHostMsgReadData;941 p Client->fHostMsgFormats = savedState.fHostMsgFormats;942 p Client->u32RequestedFormat = savedState.u32RequestedFormat;939 pSvcCtx->fHostMsgQuit = savedState.fHostMsgQuit; 940 pSvcCtx->fHostMsgReadData = savedState.fHostMsgReadData; 941 pSvcCtx->fHostMsgFormats = savedState.fHostMsgFormats; 942 pSvcCtx->u32RequestedFormat = savedState.u32RequestedFormat; 943 943 } 944 944 else … … 949 949 950 950 /* Verify the client ID. */ 951 if (p Client->u32ClientID != u32ClientIDOld)952 { 953 LogFunc(("Client ID mismatch: expected %d, got %d\n", u32ClientIDOld, p Client->u32ClientID));954 p Client->u32ClientID = u32ClientIDOld;951 if (pSvcCtx->u32ClientID != u32ClientIDOld) 952 { 953 LogFunc(("Client ID mismatch: expected %d, got %d\n", u32ClientIDOld, pSvcCtx->u32ClientID)); 954 pSvcCtx->u32ClientID = u32ClientIDOld; 955 955 return VERR_SSM_DATA_UNIT_FORMAT_CHANGED; 956 956 } 957 957 958 958 /* Actual host data are to be reported to guest (SYNC). */ 959 VBoxClipboardSvcImplSync(p Client);959 VBoxClipboardSvcImplSync(pSvcCtx); 960 960 961 961 #else /* UNIT_TEST*/ … … 968 968 { 969 969 RT_NOREF2(pvData, cbData); 970 if (g_p Client!= NULL)970 if (g_pSvcCtx != NULL) 971 971 { 972 972 switch (u32Function) … … 982 982 else 983 983 { 984 vboxSvcClipboardReportMsg (g_p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Format);984 vboxSvcClipboardReportMsg (g_pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, u32Format); 985 985 } 986 986 } break; … … 988 988 case VBOX_CLIPBOARD_EXT_FN_DATA_READ: 989 989 { 990 vboxSvcClipboardReportMsg (g_p Client, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format);990 vboxSvcClipboardReportMsg (g_pSvcCtx, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, u32Format); 991 991 } break; 992 992 -
trunk/src/VBox/HostServices/SharedClipboard/testcase/tstClipboardServiceHost.cpp
r78579 r78580 275 275 int VBoxClipboardSvcImplInit() { return VINF_SUCCESS; } 276 276 void VBoxClipboardSvcImplDestroy() { } 277 void VBoxClipboardSvcImplDisconnect( _VBOXCLIPBOARDCLIENTDATA *) { AssertFailed(); }278 int VBoxClipboardSvcImplConnect( _VBOXCLIPBOARDCLIENTDATA *, bool)277 void VBoxClipboardSvcImplDisconnect(PVBOXCLIPBOARDSVCCTX) { AssertFailed(); } 278 int VBoxClipboardSvcImplConnect(PVBOXCLIPBOARDSVCCTX, bool) 279 279 { AssertFailed(); return VERR_WRONG_ORDER; } 280 void VBoxClipboardSvcImplFormatAnnounce( _VBOXCLIPBOARDCLIENTDATA *, unsigned int)280 void VBoxClipboardSvcImplFormatAnnounce(PVBOXCLIPBOARDSVCCTX, unsigned int) 281 281 { AssertFailed(); } 282 int VBoxClipboardSvcImplReadData( _VBOXCLIPBOARDCLIENTDATA *, unsigned int, void *, unsigned int, unsigned int *)282 int VBoxClipboardSvcImplReadData(PVBOXCLIPBOARDSVCCTX, unsigned int, void *, unsigned int, unsigned int *) 283 283 { AssertFailed(); return VERR_WRONG_ORDER; } 284 void VBoxClipboardSvcImplWriteData( _VBOXCLIPBOARDCLIENTDATA *, void *, unsigned int, unsigned int) { AssertFailed(); }285 int VBoxClipboardSvcImplSync( _VBOXCLIPBOARDCLIENTDATA *)284 void VBoxClipboardSvcImplWriteData(PVBOXCLIPBOARDSVCCTX, void *, unsigned int, unsigned int) { AssertFailed(); } 285 int VBoxClipboardSvcImplSync(PVBOXCLIPBOARDSVCCTX) 286 286 { AssertFailed(); return VERR_WRONG_ORDER; }
Note:
See TracChangeset
for help on using the changeset viewer.