Changeset 79347 in vbox for trunk/src/VBox/HostServices/SharedClipboard
- Timestamp:
- Jun 26, 2019 9:15:29 AM (6 years ago)
- svn:sync-xref-src-repo-rev:
- 131579
- Location:
- trunk
- Files:
-
- 8 edited
-
. (modified) (1 prop)
-
src/VBox/HostServices/SharedClipboard/Makefile.kmk (modified) (1 diff)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h (modified) (5 diffs)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp (modified) (32 diffs)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h (modified) (2 diffs)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp (modified) (1 diff)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp (modified) (14 diffs)
-
src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp (modified) (10 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk
- Property svn:mergeinfo
-
old new 9 9 /branches/VBox-5.1:112367,115992,116543,116550,116568,116573 10 10 /branches/VBox-5.2:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124260,124263,124271,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812 11 /branches/VBox-6.0:130474-130475,130477,130479 11 /branches/VBox-6.0:130474-130475,130477,130479,131352 12 12 /branches/aeichner/vbox-chromium-cleanup:129816,129818-129851,129853-129861,129871-129872,129876,129880,129882,130013-130015,130036,130094-130095 13 13 /branches/andy/draganddrop:90781-91268
-
- Property svn:mergeinfo
-
trunk/src/VBox/HostServices/SharedClipboard/Makefile.kmk
r79270 r79347 51 51 $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardMetaData.cpp \ 52 52 $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardPath.cpp \ 53 $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider.cpp \54 $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardProvider-HostService.cpp \55 53 $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIList.cpp \ 56 54 $(PATH_ROOT)/src/VBox/GuestHost/SharedClipboard/ClipboardURIObject.cpp \ -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
r79120 r79347 82 82 uint32_t u32ClientID; 83 83 84 SHAREDCLIPBOARDSOURCE enmSource; 85 84 86 /** The guest is waiting for a message. */ 85 87 bool fAsync; … … 95 97 struct { 96 98 VBOXHGCMCALLHANDLE callHandle; 99 uint32_t cParms; 97 100 VBOXHGCMSVCPARM *paParms; 98 101 } async; … … 100 103 struct { 101 104 VBOXHGCMCALLHANDLE callHandle; 105 uint32_t cParms; 102 106 VBOXHGCMSVCPARM *paParms; 103 107 } asyncRead; … … 129 133 * The service functions. Locking is between the service thread and the platform-dependent (window) thread. 130 134 */ 135 int vboxSvcClipboardCompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual); 131 136 uint32_t vboxSvcClipboardGetMode(void); 132 137 int vboxSvcClipboardReportMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t uMsg, uint32_t uFormats); 133 int vboxSvcClipboard CompleteReadData(PVBOXCLIPBOARDCLIENTDATA pClientData, int rc, uint32_t cbActual);138 int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource); 134 139 135 140 # ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST … … 157 162 158 163 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 159 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData); 160 int VBoxClipboardSvcImplURIWriteDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData); 161 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr); 162 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr); 163 int VBoxClipboardSvcImplURIReadFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData); 164 int VBoxClipboardSvcImplURIWriteFileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData); 164 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer); 165 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer); 166 167 int VBoxClipboardSvcImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr); 168 int VBoxClipboardSvcImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr); 169 int VBoxClipboardSvcImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead); 170 int VBoxClipboardSvcImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten); 171 172 int VBoxClipboardSvcImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData); 173 int VBoxClipboardSvcImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData); 174 175 int VBoxClipboardSvcImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr); 176 int VBoxClipboardSvcImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr); 177 int VBoxClipboardSvcImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead); 178 int VBoxClipboardSvcImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten); 165 179 #endif 166 180 -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp
r79299 r79347 43 43 44 44 45 /** 46 * Reads an URI data header from HGCM service parameters. 45 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, 46 PVBOXCLIPBOARDDATAHDR *ppDataHdr) 47 { 48 RT_NOREF(pCtx, ppDataHdr); 49 return VERR_NOT_IMPLEMENTED; 50 } 51 52 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadObjHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, 53 PVBOXCLIPBOARDDATAHDR *ppDataHdr) 54 { 55 RT_NOREF(pCtx, ppDataHdr); 56 return VERR_NOT_IMPLEMENTED; 57 } 58 59 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, 60 PVBOXCLIPBOARDDIRDATA *ppDirData) 61 { 62 RT_NOREF(pCtx, ppDirData); 63 return VERR_NOT_IMPLEMENTED; 64 } 65 66 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, 67 PVBOXCLIPBOARDFILEHDR *ppFileHdr) 68 { 69 RT_NOREF(pCtx, ppFileHdr); 70 return VERR_NOT_IMPLEMENTED; 71 } 72 73 static DECLCALLBACK(int) vboxSvcClipboardURIProviderImplReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtX, 74 void *pvData, uint32_t cbData, uint32_t fFlags, 75 uint32_t *pcbRead) 76 { 77 #if 0 78 const PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser; 79 80 return pObjCtx->pObj->Read(pvBuf, cbBuf, pcbWritten); 81 #endif 82 83 RT_NOREF(pCtX, pvData, cbData, fFlags, pcbRead); 84 return VERR_NOT_IMPLEMENTED; 85 } 86 87 #if 0 88 int vboxSvcClipboardURIAnnounce(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) 89 { 90 Provider.pfnReadDataHdr = vboxSvcClipboardURIProviderImplReadDataHdr; 91 Provider.pfnReadDataChunk = vboxSvcClipboardURIProviderImplReadDataChunk; 92 Provider.pfnReadDir = vboxSvcClipboardURIProviderImplReadDir; 93 Provider.pfnReadFileHdr = vboxSvcClipboardURIProviderImplReadFileHdr; 94 Provider.pfnReadFileData = vboxSvcClipboardURIProviderImplReadFileData; 95 96 Provider.pvUser = 97 98 SharedClipboardURITransferSetProvider(&Provider); 99 100 return rc; 101 } 102 #endif 103 104 /** 105 * Gets an URI data header from HGCM service parameters. 47 106 * 48 107 * @returns VBox status code. … … 51 110 * @param pDataHdr Where to store the result. 52 111 */ 53 int VBoxSvcClipboardURI ReadDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)112 int VBoxSvcClipboardURIGetDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr) 54 113 { 55 114 int rc; … … 97 156 98 157 /** 99 * Reads an URI data header fromHGCM service parameters.158 * Sets an URI data header to HGCM service parameters. 100 159 * 101 160 * @returns VBox status code. 102 161 * @param cParms Number of HGCM parameters supplied in \a paParms. 103 162 * @param paParms Array of HGCM parameters. 104 * @param pDataHdr Pointer to data to write thethe HGCM parameters.105 */ 106 int VBoxSvcClipboardURI WriteDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr)163 * @param pDataHdr Pointer to data to set to the HGCM parameters. 164 */ 165 int VBoxSvcClipboardURISetDataHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATAHDR pDataHdr) 107 166 { 108 167 int rc; … … 139 198 140 199 /** 141 * Reads an URI data chunk from HGCM service parameters.200 * Gets an URI data chunk from HGCM service parameters. 142 201 * 143 202 * @returns VBox status code. … … 146 205 * @param pDataChunk Where to store the result. 147 206 */ 148 int VBoxSvcClipboardURI ReadDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)207 int VBoxSvcClipboardURIGetDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk) 149 208 { 150 209 int rc; … … 175 234 176 235 /** 177 * Writes an URI data chunk to HGCM service parameters.236 * Sets an URI data chunk to HGCM service parameters. 178 237 * 179 238 * @returns VBox status code. 180 239 * @param cParms Number of HGCM parameters supplied in \a paParms. 181 240 * @param paParms Array of HGCM parameters. 182 * @param pDataChunk Pointer to data to write thethe HGCM parameters.183 */ 184 int VBoxSvcClipboardURI WriteDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk)241 * @param pDataChunk Pointer to data to set to the HGCM parameters. 242 */ 243 int VBoxSvcClipboardURISetDataChunk(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDATACHUNK pDataChunk) 185 244 { 186 245 int rc; … … 206 265 207 266 /** 208 * Reads an URI directory entry from HGCM service parameters.267 * Gets an URI directory entry from HGCM service parameters. 209 268 * 210 269 * @returns VBox status code. … … 213 272 * @param pDirData Where to store the result. 214 273 */ 215 int VBoxSvcClipboardURI ReadDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)274 int VBoxSvcClipboardURIGetDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData) 216 275 { 217 276 int rc; … … 242 301 243 302 /** 244 * Writes an URI directory entry to HGCM service parameters.303 * Sets an URI directory entry to HGCM service parameters. 245 304 * 246 305 * @returns VBox status code. 247 306 * @param cParms Number of HGCM parameters supplied in \a paParms. 248 307 * @param paParms Array of HGCM parameters. 249 * @param pDirData Pointer to data to write thethe HGCM parameters.250 */ 251 int VBoxSvcClipboardURI WriteDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData)308 * @param pDirData Pointer to data to set to the HGCM parameters. 309 */ 310 int VBoxSvcClipboardURISetDir(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDDIRDATA pDirData) 252 311 { 253 312 int rc; … … 277 336 * @param pFileHdr Where to store the result. 278 337 */ 279 int VBoxSvcClipboardURI ReadFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)338 int VBoxSvcClipboardURIGetFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr) 280 339 { 281 340 int rc; … … 305 364 306 365 /** 307 * Writes an URI file header to HGCM service parameters.366 * Sets an URI file header to HGCM service parameters. 308 367 * 309 368 * @returns VBox status code. 310 369 * @param cParms Number of HGCM parameters supplied in \a paParms. 311 370 * @param paParms Array of HGCM parameters. 312 * @param pFileHdr Pointer to data to write thethe HGCM parameters.313 */ 314 int VBoxSvcClipboardURI WriteFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr)371 * @param pFileHdr Pointer to data to set to the HGCM parameters. 372 */ 373 int VBoxSvcClipboardURISetFileHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEHDR pFileHdr) 315 374 { 316 375 int rc; … … 335 394 336 395 /** 337 * Reads an URI file data chunk from HGCM service parameters.396 * Gets an URI file data chunk from HGCM service parameters. 338 397 * 339 398 * @returns VBox status code. … … 342 401 * @param pFileData Where to store the result. 343 402 */ 344 int VBoxSvcClipboardURI ReadFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)403 int VBoxSvcClipboardURIGetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData) 345 404 { 346 405 int rc; … … 367 426 368 427 /** 369 * Writes an URI file data chunk to HGCM service parameters.428 * Sets an URI file data chunk to HGCM service parameters. 370 429 * 371 430 * @returns VBox status code. 372 431 * @param cParms Number of HGCM parameters supplied in \a paParms. 373 432 * @param paParms Array of HGCM parameters. 374 * @param pFileData Pointer to data to write thethe HGCM parameters.375 */ 376 int VBoxSvcClipboardURI WriteFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData)433 * @param pFileData Pointer to data to set to the HGCM parameters. 434 */ 435 int VBoxSvcClipboardURISetFileData(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDFILEDATA pFileData) 377 436 { 378 437 int rc; … … 438 497 } 439 498 440 if (!SharedClipboardURICtxGet ActiveTransfers(&pClientData->URI))441 { 442 LogFunc(("No activetransfers found\n"));499 if (!SharedClipboardURICtxGetRunningTransfers(&pClientData->URI)) 500 { 501 LogFunc(("No running transfers found\n")); 443 502 return VERR_WRONG_ORDER; 444 503 } … … 462 521 { 463 522 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n")); 523 524 VBOXCLIPBOARDDATAHDR dataHdr; 525 rc = VBoxSvcClipboardURISetDataHdr(cParms, paParms, &dataHdr); 464 526 break; 465 527 } … … 472 534 rc = SharedClipboardURIDataHdrInit(&dataHdr); 473 535 if (RT_SUCCESS(rc)) 474 rc = VBoxSvcClipboardURIReadDataHdr(cParms, paParms, &dataHdr); 475 if (RT_SUCCESS(rc)) 476 { 477 AssertBreakStmt(pTransfer->State.pHeader == NULL, rc = VERR_WRONG_ORDER); 478 pTransfer->State.pHeader = SharedClipboardURIDataHdrDup(&dataHdr); 479 if (pTransfer->State.pHeader) 480 { 481 LogFlowFunc(("Meta data size is %RU32\n", pTransfer->State.pHeader->cbMeta)); 482 } 483 else 484 rc = VERR_NO_MEMORY; 485 } 536 rc = VBoxSvcClipboardURIGetDataHdr(cParms, paParms, &dataHdr); 537 /*if (RT_SUCCESS(rc)) 538 rc = SharedClipboardURITransferSetDataHeader(&dataHdr);*/ 486 539 break; 487 540 } … … 500 553 rc = SharedClipboardURIDataChunkInit(&dataChunk); 501 554 if (RT_SUCCESS(rc)) 502 rc = VBoxSvcClipboardURIReadDataChunk(cParms, paParms, &dataChunk); 555 rc = VBoxSvcClipboardURIGetDataChunk(cParms, paParms, &dataChunk); 556 #if 0 503 557 if (RT_SUCCESS(rc)) 504 558 { 505 AssertPtrBreakStmt(pTransfer->State.pHeader, rc = VERR_WRONG_ORDER); 506 507 rc = SharedClipboardURITransferMetaDataAdd(pTransfer, dataChunk.pvData, dataChunk.cbData); 508 if ( RT_SUCCESS(rc) 509 && SharedClipboardURITransferMetaDataIsComplete(pTransfer)) /* Meta data transfer complete? */ 510 { 511 rc = SharedClipboardURITransferPrepare(pTransfer); 512 } 559 VBOXCLIPBOARDTRANSFEREVENT Event = { &dataChunk, sizeof(dataChunk) }; 560 rc = SharedClipboardURITransferSendEvent(WRITE_DATA_CHUNK, &Event); 513 561 } 514 562 #endif 515 563 break; 516 564 } … … 519 567 { 520 568 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DIR\n")); 521 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_DIR) 522 { 523 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI)) 524 { 525 rc = VERR_WRONG_ORDER; 526 break; 527 } 528 529 VBOXCLIPBOARDDIRDATA data; 530 rc = VBoxClipboardSvcImplURIReadDir(pClientData, &data); 531 if (RT_SUCCESS(rc)) 532 { 533 /* Note: Context ID (paParms[0]) not used yet. */ 534 HGCMSvcSetPv (&paParms[1], data.pszPath, data.cbPath); 535 HGCMSvcSetU32(&paParms[2], data.cbPath); 536 HGCMSvcSetU32(&paParms[3], data.fMode); 537 538 SharedClipboardURIDirDataDestroy(&data); 539 } 540 } 569 570 VBOXCLIPBOARDDIRDATA data; 571 rc = VBoxSvcClipboardURISetDir(cParms, paParms, &data); 541 572 break; 542 573 } … … 547 578 548 579 VBOXCLIPBOARDDIRDATA dirData; 549 rc = VBoxSvcClipboardURI ReadDir(cParms, paParms, &dirData);580 rc = VBoxSvcClipboardURIGetDir(cParms, paParms, &dirData); 550 581 if (RT_SUCCESS(rc)) 551 582 { … … 562 593 if (RT_SUCCESS(rc)) 563 594 { 564 /* Add for having a proper rollback. */565 int rc2 = pArea->Add Dir(pszDir);595 SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_DIR, SHAREDCLIPBOARDAREAOBJSTATE_COMPLETE }; 596 int rc2 = pArea->AddObject(pszDir, Obj); 566 597 AssertRC(rc2); 567 598 } … … 578 609 { 579 610 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_FILE_HDR\n")); 580 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_HDR) 581 { 582 VBOXCLIPBOARDFILEHDR hdr; 583 rc = VBoxClipboardSvcImplURIReadFileHdr(pClientData, &hdr); 584 if (RT_SUCCESS(rc)) 585 { 586 /* Note: Context ID (paParms[0]) not used yet. */ 587 HGCMSvcSetPv (&paParms[1], hdr.pszFilePath, hdr.cbFilePath); 588 HGCMSvcSetU32(&paParms[2], hdr.cbFilePath); 589 HGCMSvcSetU32(&paParms[3], hdr.fFlags); 590 HGCMSvcSetU32(&paParms[4], hdr.fMode); 591 HGCMSvcSetU64(&paParms[5], hdr.cbSize); 592 593 SharedClipboardURIFileHdrDestroy(&hdr); 594 } 595 } 611 612 VBOXCLIPBOARDFILEHDR fileHdr; 613 rc = VBoxSvcClipboardURISetFileHdr(cParms, paParms, &fileHdr); 596 614 break; 597 615 } … … 603 621 if (!SharedClipboardURIObjCtxIsValid(SharedClipboardURITransferGetCurrentObjCtx(pTransfer))) 604 622 { 605 pTransfer-> ObjCtx.pObj = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File);606 if (pTransfer-> ObjCtx.pObj) /** @todo Can this throw? */623 pTransfer->State.ObjCtx.pObj = new SharedClipboardURIObject(SharedClipboardURIObject::Type_File); 624 if (pTransfer->State.ObjCtx.pObj) /** @todo Can this throw? */ 607 625 { 608 626 rc = VINF_SUCCESS; … … 618 636 619 637 VBOXCLIPBOARDFILEHDR fileHdr; 620 rc = VBoxSvcClipboardURI ReadFileHdr(cParms, paParms, &fileHdr);638 rc = VBoxSvcClipboardURIGetFileHdr(cParms, paParms, &fileHdr); 621 639 if (RT_SUCCESS(rc)) 622 640 { … … 659 677 pObj->GetDestPathAbs().c_str())); 660 678 661 SharedClipboardURIObjCtxDestroy(&pTransfer-> ObjCtx);679 SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx); 662 680 } 663 681 664 /* Add for having a proper rollback. */665 int rc2 = pArea->Add File(pszPathAbs);682 SHAREDCLIPBOARDAREAOBJ Obj = { SHAREDCLIPBOARDAREAOBJTYPE_FILE, SHAREDCLIPBOARDAREAOBJSTATE_NONE }; 683 int rc2 = pArea->AddObject(pszPathAbs, Obj); 666 684 AssertRC(rc2); 667 685 } … … 677 695 { 678 696 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_READ_FILE_DATA\n")); 679 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_READ_FILE_DATA) 680 { 681 if (!SharedClipboardURICtxGetActiveTransfers(&pClientData->URI)) 682 { 683 rc = VERR_WRONG_ORDER; 684 break; 685 } 686 687 VBOXCLIPBOARDFILEDATA data; 688 rc = VBoxClipboardSvcImplURIReadFileData(pClientData, &data); 689 if (RT_SUCCESS(rc)) 690 { 691 /* Note: Context ID (paParms[0]) not used yet. */ 692 HGCMSvcSetPv (&paParms[1], data.pvData, data.cbData); 693 HGCMSvcSetU32(&paParms[2], data.cbData); 694 HGCMSvcSetPv (&paParms[3], data.pvChecksum, data.cbChecksum); 695 HGCMSvcSetU32(&paParms[4], data.cbChecksum); 696 697 SharedClipboardURIFileDataDestroy(&data); 698 } 699 } 697 698 VBOXCLIPBOARDFILEDATA fileData; 699 rc = VBoxSvcClipboardURISetFileData(cParms, paParms, &fileData); 700 700 break; 701 701 } … … 705 705 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_FN_WRITE_FILE_DATA\n")); 706 706 707 if (!SharedClipboardURIObjCtxIsValid(&pTransfer-> ObjCtx))707 if (!SharedClipboardURIObjCtxIsValid(&pTransfer->State.ObjCtx)) 708 708 { 709 709 rc = VERR_WRONG_ORDER; … … 712 712 713 713 VBOXCLIPBOARDFILEDATA fileData; 714 rc = VBoxSvcClipboardURI ReadFileData(cParms, paParms, &fileData);714 rc = VBoxSvcClipboardURIGetFileData(cParms, paParms, &fileData); 715 715 if (RT_SUCCESS(rc)) 716 716 { … … 734 734 if ( pObj->IsComplete() 735 735 || RT_FAILURE(rc)) 736 SharedClipboardURIObjCtxDestroy(&pTransfer-> ObjCtx);736 SharedClipboardURIObjCtxDestroy(&pTransfer->State.ObjCtx); 737 737 } 738 738 else … … 771 771 writeParms.u.HostService.paParms = paParms; 772 772 773 rc = pTransfer->pProvider->OnWrite(&writeParms);773 //rc = pTransfer->pProvider->OnWrite(&writeParms); 774 774 } 775 775 } … … 919 919 * @param pClientState Client state to use. 920 920 * @param pTransfer URI transfer to attach a clipboard area to. 921 */ 922 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) 921 * @param uID ID of clipboard area to to attach to. Specify 0 to attach to the most recent one. 922 */ 923 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer, 924 SHAREDCLIPBOARDAREAID uID) 923 925 { 924 926 LogFlowFuncEnter(); … … 938 940 RT_ZERO(parms); 939 941 940 parms.uID = 0; /* 0 means most recent clipboard area. */942 parms.uID = uID; /* 0 means most recent clipboard area. */ 941 943 942 944 /* The client now needs to attach to the most recent clipboard area -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.h
r79174 r79347 22 22 #endif 23 23 24 //int vboxSvcClipboardURIAnnounce(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); 25 24 26 int vboxSvcClipboardURIHandler(uint32_t u32ClientID, void *pvClient, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival, bool *pfAsync); 25 27 int vboxSvcClipboardURIHostHandler(uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[]); … … 27 29 int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer); 28 30 int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer); 29 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer );31 int vboxSvcClipboardURIAreaAttach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer, SHAREDCLIPBOARDAREAID uID); 30 32 int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer); 31 32 DECLCALLBACK(int) vboxClipboardSvcReadDataHdrCallback(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData);33 33 34 34 #endif /* !VBOX_INCLUDED_SRC_SharedClipboard_VBoxSharedClipboardSvc_uri_h */ -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp
r79267 r79347 158 158 bool fHandled = false; 159 159 160 #if 0 160 /* For now we only support one transfer at a time. */ 161 161 PSHAREDCLIPBOARDURITRANSFER pTransfer = SharedClipboardURICtxGetTransfer(&pClientData->URI, 0 /* Index */); 162 if (pTransfer) 163 { 164 if ( !s_fReqHdr 165 && !pTransfer->State.pHeader) 166 { 167 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA\n")); 168 169 HGCMSvcSetU32(&paParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA); 170 HGCMSvcSetU32(&paParms[1], VBOX_SHARED_CLIPBOARD_FMT_URI_LIST /* fFormats */); 162 if (!pTransfer) 163 return fHandled; 164 165 #if 1 166 int rc = 0; 167 #else 168 /* Sanity. */ 169 Assert(pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ); 170 171 int rc; 172 173 /* Note: Message priority / order is taken into account here. */ 174 if (pTransfer->State.pHeader) 175 { 176 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n")); 177 rc = VBoxSvcClipboardURIWriteDataHdr(cParms, paParms, pTransfer->State.pHeader); 178 if (RT_SUCCESS(rc)) 179 { 180 /* We're done witht the data header, destroy it. */ 181 SharedClipboardURIDataHdrFree(pTransfer->State.pHeader); 182 pTransfer->State.pHeader = NULL; 183 171 184 fHandled = true; 172 173 s_fReqHdr = true; 174 } 175 else 176 { 177 } 178 } 185 } 186 } 187 else if (pTransfer->State.pMeta) 188 { 189 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK\n")); 190 191 uint32_t cbBuf = _64K; 192 uint8_t pvBuf[_64K]; /** @todo Improve */ 193 194 uint32_t cbRead; 195 rc = SharedClipboardMetaDataRead(pTransfer->State.pMeta, pvBuf, cbBuf, &cbRead); 196 if (RT_SUCCESS(rc)) 197 { 198 Assert(cbRead <= cbBuf); 199 200 VBOXCLIPBOARDDATACHUNK dataChunk; 201 RT_ZERO(dataChunk); 202 dataChunk.pvData = pvBuf; 203 dataChunk.cbData = cbRead; 204 205 rc = VBoxSvcClipboardURIWriteDataChunk(cParms, paParms, &dataChunk); 206 } 207 208 /* Has all meta data been read? */ 209 if (RT_SUCCESS(rc)) 210 { 211 if (SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta) == 0) 212 { 213 SharedClipboardMetaDataFree(pTransfer->State.pMeta); 214 pTransfer->State.pMeta = NULL; 215 } 216 217 fHandled = true; 218 } 219 } 220 else if (pTransfer->pURIList) 221 { 222 PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer); 223 if (!SharedClipboardURIObjCtxIsValid(pObjCtx)) 224 { 225 if (!pTransfer->pURIList->IsEmpty()) 226 pObjCtx->pObj = pTransfer->pURIList->First(); 227 } 228 229 if ( pObjCtx 230 && pObjCtx->pObj) 231 { 232 switch (pObjCtx->pObj->GetType()) 233 { 234 case SharedClipboardURIObject::Type_Directory: 235 { 236 rc = VBoxSvcClipboardURIWriteDir(cParms, paParms, &dataChunk); 237 break; 238 } 239 } 240 } 241 242 if (0) 243 { 244 delete pTransfer->pURIList; 245 pTransfer->pURIList = NULL; 246 } 247 248 fHandled = true; 249 } 250 else 251 rc = VERR_WRONG_ORDER; 179 252 #endif 180 253 181 LogFlowFunc((" fHandled=%RTbool\n", fHandled));254 LogFlowFunc(("rc=%Rrc, fHandled=%RTbool\n", rc, fHandled)); 182 255 return fHandled; 183 256 } -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
r79299 r79347 56 56 * Internal Functions * 57 57 *********************************************************************************************************************************/ 58 static int vboxClipboard WinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx);58 static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx); 59 59 60 60 struct _VBOXCLIPBOARDCONTEXT … … 131 131 * Specify 0 if no waiting is required. 132 132 */ 133 static int vboxClipboard WinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat,134 RTMSINTERVAL uTimeoutMs)135 { 136 Assert (pCtx->pClientData);133 static int vboxClipboardSvcWinRequestData(PVBOXCLIPBOARDCONTEXT pCtx, VBOXCLIPBOARDFORMAT fFormat, 134 RTMSINTERVAL uTimeoutMs) 135 { 136 AssertPtr(pCtx->pClientData); 137 137 Assert(pCtx->hRenderEvent); 138 138 Assert(pCtx->pClientData->State.data.pv == NULL && pCtx->pClientData->State.data.cb == 0 && pCtx->pClientData->State.data.u32Format == 0); … … 151 151 } 152 152 153 static LRESULT CALLBACK vboxClipboard WinWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)153 static LRESULT CALLBACK vboxClipboardSvcWinWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) 154 154 { 155 155 LRESULT lresultRc = 0; … … 169 169 170 170 /* Clipboard was updated by another application, retrieve formats and report back. */ 171 int rc = vboxClipboard WinSyncInternal(pCtx);171 int rc = vboxClipboardSvcWinSyncInternal(pCtx); 172 172 AssertRC(rc); 173 174 vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL); 173 175 } 174 176 } break; … … 187 189 { 188 190 /* Clipboard was updated by another application, retrieve formats and report back. */ 189 int vboxrc = vboxClipboardWinSyncInternal(pCtx); 190 AssertRC(vboxrc); 191 int rc = vboxClipboardSvcWinSyncInternal(pCtx); 192 if (RT_SUCCESS(rc)) 193 vboxSvcClipboardSetSource(pCtx->pClientData, SHAREDCLIPBOARDSOURCE_LOCAL); 191 194 } 192 195 … … 221 224 else 222 225 { 223 int rc = vboxClipboard WinRequestData(pCtx, fFormat, 30 * 1000 /* 30s timeout */);226 int rc = vboxClipboardSvcWinRequestData(pCtx, fFormat, 30 * 1000 /* 30s timeout */); 224 227 225 228 LogFunc(("vboxClipboardReadDataFromClient rc = %Rrc, pv %p, cb %d, u32Format %d\n", … … 328 331 if (pTransfer) 329 332 { 330 rc = VBoxClipboardWinURI Announce(pWinCtx, &pCtx->pClientData->URI, pTransfer);333 rc = VBoxClipboardWinURITransferCreate(pWinCtx, pTransfer); 331 334 332 335 /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation … … 336 339 AssertFailedStmt(rc = VERR_NOT_FOUND); 337 340 338 /* Note: VBoxClipboardWinURI Announce() takes care of closing the clipboard. */341 /* Note: VBoxClipboardWinURITransferCreate() takes care of closing the clipboard. */ 339 342 } 340 343 else … … 376 379 } 377 380 378 DECLCALLBACK(int) vboxClipboard WinThread(RTTHREAD hThreadSelf, void *pvUser)381 DECLCALLBACK(int) vboxClipboardSvcWinThread(RTTHREAD hThreadSelf, void *pvUser) 379 382 { 380 383 RT_NOREF(hThreadSelf, pvUser); … … 395 398 396 399 wc.style = CS_NOCLOSE; 397 wc.lpfnWndProc = vboxClipboard WinWndProc;400 wc.lpfnWndProc = vboxClipboardSvcWinWndProc; 398 401 wc.hInstance = hInstance; 399 402 wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND + 1); … … 485 488 * @param pCtx Clipboard context to synchronize. 486 489 */ 487 static int vboxClipboard WinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx)490 static int vboxClipboardSvcWinSyncInternal(PVBOXCLIPBOARDCONTEXT pCtx) 488 491 { 489 492 AssertPtrReturn(pCtx, VERR_INVALID_POINTER); … … 521 524 if (RT_SUCCESS(rc)) 522 525 { 523 rc = RTThreadCreate(&g_ctx.hThread, vboxClipboard WinThread, NULL, _64K /* Stack size */,526 rc = RTThreadCreate(&g_ctx.hThread, vboxClipboardSvcWinThread, NULL, _64K /* Stack size */, 524 527 RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP"); 525 528 } … … 577 580 { 578 581 /* Sync the host clipboard content with the client. */ 579 return vboxClipboard WinSyncInternal(pClientData->State.pCtx);582 return vboxClipboardSvcWinSyncInternal(pClientData->State.pCtx); 580 583 } 581 584 … … 767 770 768 771 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 769 int VBoxClipboardSvcImplURIReadDir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData) 770 { 771 RT_NOREF(pClientData, pDirData); 772 DECLCALLBACK(void) vboxClipboardSvcWinURITransferPrepareCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData) 773 { 774 LogFlowFuncEnter(); 775 776 AssertPtrReturnVoid(pData); 777 778 PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser; 779 AssertPtrReturnVoid(pClientData); 780 781 /* Tell the guest that it can start sending URI data. */ 782 int rc2 = vboxSvcClipboardReportMsg(pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA, 783 VBOX_SHARED_CLIPBOARD_FMT_URI_LIST); 784 AssertRC(rc2); 785 } 786 787 DECLCALLBACK(void) vboxClipboardSvcWinURIDataCompleteCallback(PSHAREDCLIPBOARDURITRANSFERCALLBACKDATA pData) 788 { 789 LogFlowFuncEnter(); 790 791 AssertPtrReturnVoid(pData); 792 793 PSHAREDCLIPBOARDURITRANSFER pTransfer = pData->pTransfer; 794 AssertPtrReturnVoid(pTransfer); 795 796 SharedClipboardWinURITransferCtx *pTransferCtx = (SharedClipboardWinURITransferCtx *)pTransfer->pvUser; 797 AssertPtrReturnVoid(pTransferCtx); 798 799 /* Notify the Windows implementation's data object that the meta data has been read successfully. */ 800 if (pTransferCtx->pDataObj) 801 pTransferCtx->pDataObj->OnMetaDataComplete(pTransfer); 802 } 803 804 int VBoxClipboardSvcImplURITransferCreate(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer) 805 { 806 LogFlowFuncEnter(); 807 808 /* Register needed callbacks so that we can wait for the meta data to arrive here. */ 809 SHAREDCLIPBOARDURITRANSFERCALLBACKS Callbacks; 810 RT_ZERO(Callbacks); 811 812 Callbacks.pvUser = pClientData; 813 Callbacks.pfnTransferPrepare = vboxClipboardSvcWinURITransferPrepareCallback; 814 815 SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks); 816 817 return VINF_SUCCESS; 818 } 819 820 int VBoxClipboardSvcImplURITransferDestroy(PVBOXCLIPBOARDCLIENTDATA pClientData, PSHAREDCLIPBOARDURITRANSFER pTransfer) 821 { 822 LogFlowFuncEnter(); 823 824 VBoxClipboardWinURITransferDestroy(&pClientData->State.pCtx->Win, pTransfer); 825 826 return VINF_SUCCESS; 827 } 828 829 int VBoxClipboardSvcImplURIReadDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDATAHDR *ppDataHdr) 830 { 831 RT_NOREF(ppDataHdr); 832 833 LogFlowFuncEnter(); 834 835 PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pCtx->pvUser; 836 AssertPtr(pClientData); 837 838 772 839 return VERR_NOT_IMPLEMENTED; 773 840 } 774 841 775 int VBoxClipboardSvcImplURIWriteD ir(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDDIRDATA pDirData)776 { 777 RT_NOREF(pC lientData, pDirData);842 int VBoxClipboardSvcImplURIWriteDataHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr) 843 { 844 RT_NOREF(pCtx, pDataHdr); 778 845 return VERR_NOT_IMPLEMENTED; 779 846 } 780 847 781 int VBoxClipboardSvcImplURIReadFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr) 782 { 783 RT_NOREF(pClientData, pFileHdr); 848 int VBoxClipboardSvcImplURIReadDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, 849 void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbRead) 850 { 851 RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbRead); 784 852 return VERR_NOT_IMPLEMENTED; 785 853 } 786 854 787 int VBoxClipboardSvcImplURIWriteFileHdr(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEHDR pFileHdr) 788 { 789 RT_NOREF(pClientData, pFileHdr); 855 int VBoxClipboardSvcImplURIWriteDataChunk(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDATAHDR pDataHdr, 856 const void *pvChunk, uint32_t cbChunk, uint32_t fFlags, uint32_t *pcbWritten) 857 { 858 RT_NOREF(pCtx, pDataHdr, pvChunk, cbChunk, fFlags, pcbWritten); 790 859 return VERR_NOT_IMPLEMENTED; 791 860 } 792 861 793 int VBoxClipboardSvcImplURIRead FileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)794 { 795 RT_NOREF(pC lientData, pFileData);862 int VBoxClipboardSvcImplURIReadDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDDIRDATA *ppDirData) 863 { 864 RT_NOREF(pCtx, ppDirData); 796 865 return VERR_NOT_IMPLEMENTED; 797 866 } 798 867 799 int VBoxClipboardSvcImplURIWrite FileData(PVBOXCLIPBOARDCLIENTDATA pClientData, PVBOXCLIPBOARDFILEDATA pFileData)800 { 801 RT_NOREF(pC lientData, pFileData);868 int VBoxClipboardSvcImplURIWriteDir(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDDIRDATA pDirData) 869 { 870 RT_NOREF(pCtx, pDirData); 802 871 return VERR_NOT_IMPLEMENTED; 803 872 } 873 874 int VBoxClipboardSvcImplURIReadFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDFILEHDR *ppFileHdr) 875 { 876 RT_NOREF(pCtx, ppFileHdr); 877 return VERR_NOT_IMPLEMENTED; 878 } 879 880 int VBoxClipboardSvcImplURIWriteFileHdr(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const PVBOXCLIPBOARDFILEHDR pFileHdr) 881 { 882 RT_NOREF(pCtx, pFileHdr); 883 return VERR_NOT_IMPLEMENTED; 884 } 885 886 int VBoxClipboardSvcImplURIReadFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, 887 uint32_t *pcbRead) 888 { 889 RT_NOREF(pCtx, pvData, cbData, fFlags, pcbRead); 890 return VERR_NOT_IMPLEMENTED; 891 } 892 893 int VBoxClipboardSvcImplURIWriteFileData(PSHAREDCLIPBOARDPROVIDERCTX pCtx, void *pvData, uint32_t cbData, uint32_t fFlags, 894 uint32_t *pcbWritten) 895 { 896 RT_NOREF(pCtx, pvData, cbData, fFlags, pcbWritten); 897 return VERR_NOT_IMPLEMENTED; 898 } 804 899 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ 805 900 -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
r79299 r79347 259 259 static bool vboxSvcClipboardReturnMsg(PVBOXCLIPBOARDCLIENTDATA pClientData, uint32_t cParms, VBOXHGCMSVCPARM paParms[]) 260 260 { 261 RT_NOREF(cParms); 261 /** @todo r=andy The client at the moment supplies two parameters, which we can 262 * use by filling in the next message type sent by the host service. 263 * Make this more flexible later, as I don't want to break the existing protocol right now. */ 264 if (cParms < 2) 265 { 266 AssertFailed(); /* Should never happen. */ 267 return false; 268 } 262 269 263 270 /* Message priority is taken into account. */ … … 385 392 { 386 393 /* The client waits for a response. */ 387 bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData, 0 /* cParms, fix */, 394 bool fMessageReturned = vboxSvcClipboardReturnMsg(pClientData, 395 pClientData->State.async.cParms, 388 396 pClientData->State.async.paParms); 389 397 … … 410 418 else 411 419 VBoxSvcClipboardUnlock(); 420 } 421 422 LogFlowFuncLeaveRC(rc); 423 return rc; 424 } 425 426 427 int vboxSvcClipboardSetSource(PVBOXCLIPBOARDCLIENTDATA pClientData, SHAREDCLIPBOARDSOURCE enmSource) 428 { 429 if (!pClientData) /* If no client connected (anymore), bail out. */ 430 return VINF_SUCCESS; 431 432 int rc = VINF_SUCCESS; 433 434 if (VBoxSvcClipboardLock()) 435 { 436 pClientData->State.enmSource = enmSource; 437 438 LogFlowFunc(("Source of client %RU32 is now %RU32\n", pClientData->State.u32ClientID, pClientData->State.enmSource)); 439 440 VBoxSvcClipboardUnlock(); 412 441 } 413 442 … … 585 614 pClientData->State.fAsync = true; 586 615 pClientData->State.async.callHandle = callHandle; 616 pClientData->State.async.cParms = cParms; 587 617 pClientData->State.async.paParms = paParms; 588 618 } … … 623 653 else 624 654 { 655 rc = vboxSvcClipboardSetSource(pClientData, SHAREDCLIPBOARDSOURCE_REMOTE); 656 625 657 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 626 658 if ( RT_SUCCESS(rc) 627 659 && (u32Formats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST)) 628 660 { 629 if (!SharedClipboardURICtx MaximumTransfersReached(&pClientData->URI))661 if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI)) 630 662 { 663 SharedClipboardURICtxTransfersCleanup(&pClientData->URI); 664 631 665 PSHAREDCLIPBOARDURITRANSFER pTransfer; 632 rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ, &pTransfer); 666 rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_READ, 667 SHAREDCLIPBOARDSOURCE_REMOTE, &pTransfer); 633 668 if (RT_SUCCESS(rc)) 634 669 { … … 638 673 SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx; 639 674 RT_ZERO(creationCtx); 640 creationCtx.enmSource = SHAREDCLIPBOARDURIPROVIDERSOURCE_HOSTSERVICE; 641 creationCtx.enmDir = SHAREDCLIPBOARDURITRANSFERDIR_READ; 675 676 creationCtx.enmSource = pClientData->State.enmSource; 677 678 RT_ZERO(creationCtx.Interface); 679 creationCtx.Interface.pfnReadDataHdr = VBoxClipboardSvcImplURIReadDataHdr; 680 creationCtx.Interface.pfnReadDataChunk = VBoxClipboardSvcImplURIReadDataChunk; 681 creationCtx.Interface.pfnReadDirectory = VBoxClipboardSvcImplURIReadDir; 682 creationCtx.Interface.pfnReadFileHdr = VBoxClipboardSvcImplURIReadFileHdr; 683 creationCtx.Interface.pfnReadFileData = VBoxClipboardSvcImplURIReadFileData; 684 685 creationCtx.Interface.pfnWriteDataHdr = VBoxClipboardSvcImplURIWriteDataHdr; 686 creationCtx.Interface.pfnWriteDataChunk = VBoxClipboardSvcImplURIWriteDataChunk; 687 creationCtx.Interface.pfnWriteDirectory = VBoxClipboardSvcImplURIWriteDir; 688 creationCtx.Interface.pfnWriteFileHdr = VBoxClipboardSvcImplURIWriteFileHdr; 689 creationCtx.Interface.pfnWriteFileData = VBoxClipboardSvcImplURIWriteFileData; 690 691 creationCtx.pvUser = pClientData; 692 642 693 creationCtx.u.HostService.pArea = pTransfer->pArea; 643 694 … … 645 696 if (RT_SUCCESS(rc)) 646 697 rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer); 698 } 699 700 if (RT_SUCCESS(rc)) 701 { 702 rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer); 703 } 704 else 705 { 706 VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer); 707 SharedClipboardURITransferDestroy(pTransfer); 647 708 } 648 709 } … … 650 711 else 651 712 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED; 713 714 LogFunc(("VBOX_SHARED_CLIPBOARD_FMT_URI_LIST: %Rrc\n", rc)); 715 716 if (RT_FAILURE(rc)) 717 LogRel(("Shared Clipboard: Initializing URI guest to host read transfer failed with %Rrc\n", rc)); 652 718 } 653 719 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ … … 689 755 else 690 756 { 757 if ( vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST 758 && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) 759 { 760 rc = VERR_ACCESS_DENIED; 761 break; 762 } 763 691 764 uint32_t u32Format; 692 void *pv;693 uint32_t cb;694 695 765 rc = HGCMSvcGetU32(&paParms[0], &u32Format); 696 766 if (RT_SUCCESS(rc)) 697 767 { 698 rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb); 699 700 if (RT_SUCCESS (rc)) 768 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 769 if (u32Format == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) 701 770 { 702 if ( vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_HOST_TO_GUEST 703 && vboxSvcClipboardGetMode() != VBOX_SHARED_CLIPBOARD_MODE_BIDIRECTIONAL) 771 if (!SharedClipboardURICtxTransfersMaximumReached(&pClientData->URI)) 704 772 { 705 rc = VERR_NOT_SUPPORTED; 706 break; 707 } 708 709 uint32_t cbActual = 0; 710 711 if (g_pfnExtension) 712 { 713 VBOXCLIPBOARDEXTPARMS parms; 714 RT_ZERO(parms); 715 716 parms.u32Format = u32Format; 717 parms.u.pvData = pv; 718 parms.cbData = cb; 719 720 g_fReadingData = true; 721 722 rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof (parms)); 723 LogFlowFunc(("DATA: g_fDelayedAnnouncement = %d, g_u32DelayedFormats = 0x%x\n", g_fDelayedAnnouncement, g_u32DelayedFormats)); 724 725 if (g_fDelayedAnnouncement) 773 SharedClipboardURICtxTransfersCleanup(&pClientData->URI); 774 775 PSHAREDCLIPBOARDURITRANSFER pTransfer; 776 rc = SharedClipboardURITransferCreate(SHAREDCLIPBOARDURITRANSFERDIR_WRITE, 777 pClientData->State.enmSource, 778 &pTransfer); 779 if (RT_SUCCESS(rc)) 726 780 { 727 vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats); 728 g_fDelayedAnnouncement = false; 729 g_u32DelayedFormats = 0; 730 } 731 732 g_fReadingData = false; 733 734 if (RT_SUCCESS (rc)) 735 { 736 cbActual = parms.cbData; 781 /* Attach to the most recent clipboard area. */ 782 rc = vboxSvcClipboardURIAreaAttach(&pClientData->State, pTransfer, 0 /* Area ID */); 783 if (RT_SUCCESS(rc)) 784 { 785 SHAREDCLIPBOARDPROVIDERCREATIONCTX creationCtx; 786 RT_ZERO(creationCtx); 787 788 creationCtx.enmSource = SharedClipboardURITransferGetSource(pTransfer); 789 790 RT_ZERO(creationCtx.Interface); 791 792 creationCtx.Interface.pfnReadDataHdr = VBoxClipboardSvcImplURIReadDataHdr; 793 creationCtx.Interface.pfnReadDataChunk = VBoxClipboardSvcImplURIReadDataChunk; 794 creationCtx.Interface.pfnReadDirectory = VBoxClipboardSvcImplURIReadDir; 795 creationCtx.Interface.pfnReadFileHdr = VBoxClipboardSvcImplURIReadFileHdr; 796 creationCtx.Interface.pfnReadFileData = VBoxClipboardSvcImplURIReadFileData; 797 798 creationCtx.Interface.pfnWriteDataHdr = VBoxClipboardSvcImplURIWriteDataHdr; 799 creationCtx.Interface.pfnWriteDataChunk = VBoxClipboardSvcImplURIWriteDataChunk; 800 creationCtx.Interface.pfnWriteDirectory = VBoxClipboardSvcImplURIWriteDir; 801 creationCtx.Interface.pfnWriteFileHdr = VBoxClipboardSvcImplURIWriteFileHdr; 802 creationCtx.Interface.pfnWriteFileData = VBoxClipboardSvcImplURIWriteFileData; 803 804 creationCtx.pvUser = pClientData; 805 806 creationCtx.u.HostService.pArea = pTransfer->pArea; 807 808 rc = SharedClipboardURITransferProviderCreate(pTransfer, &creationCtx); 809 if (RT_SUCCESS(rc)) 810 rc = SharedClipboardURICtxTransferAdd(&pClientData->URI, pTransfer); 811 } 812 813 if (RT_SUCCESS(rc)) 814 { 815 rc = VBoxClipboardSvcImplURITransferCreate(pClientData, pTransfer); 816 } 817 else 818 { 819 VBoxClipboardSvcImplURITransferDestroy(pClientData, pTransfer); 820 SharedClipboardURITransferDestroy(pTransfer); 821 } 737 822 } 738 823 } 739 740 /* Release any other pending read, as we only 741 * support one pending read at one time. */ 742 rc = vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0); 824 else 825 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED; 826 827 if (RT_FAILURE(rc)) 828 LogRel(("Shared Clipboard: Initializing URI host to guest write transfer failed with %Rrc\n", rc)); 829 } 830 else 831 { 832 #endif 833 void *pv; 834 uint32_t cb; 835 rc = VBoxHGCMParmPtrGet(&paParms[1], &pv, &cb); 743 836 if (RT_SUCCESS(rc)) 744 rc = VBoxClipboardSvcImplReadData(pClientData, u32Format, pv, cb, &cbActual);745 746 /* Remember our read request until it is completed.747 * See the protocol description above for more748 * information. */749 if (rc == VINF_HGCM_ASYNC_EXECUTE)750 837 { 751 if (VBoxSvcClipboardLock()) 838 uint32_t cbActual = 0; 839 840 if (g_pfnExtension) 752 841 { 753 pClientData->State.asyncRead.callHandle = callHandle; 754 pClientData->State.asyncRead.paParms = paParms; 755 pClientData->State.fReadPending = true; 756 fAsynchronousProcessing = true; 757 VBoxSvcClipboardUnlock(); 842 VBOXCLIPBOARDEXTPARMS parms; 843 RT_ZERO(parms); 844 845 parms.u32Format = u32Format; 846 parms.u.pvData = pv; 847 parms.cbData = cb; 848 849 g_fReadingData = true; 850 851 rc = g_pfnExtension(g_pvExtension, VBOX_CLIPBOARD_EXT_FN_DATA_READ, &parms, sizeof (parms)); 852 LogFlowFunc(("DATA: g_fDelayedAnnouncement = %d, g_u32DelayedFormats = 0x%x\n", g_fDelayedAnnouncement, g_u32DelayedFormats)); 853 854 if (g_fDelayedAnnouncement) 855 { 856 vboxSvcClipboardReportMsg(g_pClientData, VBOX_SHARED_CLIPBOARD_HOST_MSG_REPORT_FORMATS, g_u32DelayedFormats); 857 g_fDelayedAnnouncement = false; 858 g_u32DelayedFormats = 0; 859 } 860 861 g_fReadingData = false; 862 863 if (RT_SUCCESS (rc)) 864 { 865 cbActual = parms.cbData; 866 } 758 867 } 759 else 760 rc = VERR_NOT_SUPPORTED; 868 869 /* Release any other pending read, as we only 870 * support one pending read at one time. */ 871 rc = vboxSvcClipboardCompleteReadData(pClientData, VERR_NO_DATA, 0); 872 if (RT_SUCCESS(rc)) 873 rc = VBoxClipboardSvcImplReadData(pClientData, u32Format, pv, cb, &cbActual); 874 875 /* Remember our read request until it is completed. 876 * See the protocol description above for more 877 * information. */ 878 if (rc == VINF_HGCM_ASYNC_EXECUTE) 879 { 880 if (VBoxSvcClipboardLock()) 881 { 882 pClientData->State.asyncRead.callHandle = callHandle; 883 pClientData->State.asyncRead.cParms = cParms; 884 pClientData->State.asyncRead.paParms = paParms; 885 pClientData->State.fReadPending = true; 886 fAsynchronousProcessing = true; 887 VBoxSvcClipboardUnlock(); 888 } 889 else 890 rc = VERR_NOT_SUPPORTED; 891 } 892 else if (RT_SUCCESS (rc)) 893 { 894 HGCMSvcSetU32(&paParms[2], cbActual); 895 } 761 896 } 762 else if (RT_SUCCESS (rc)) 763 { 764 HGCMSvcSetU32(&paParms[2], cbActual); 765 } 897 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 766 898 } 899 #endif 767 900 } 768 901 } … … 986 1119 return rc; 987 1120 } 988 989 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST990 DECLCALLBACK(int) vboxClipboardSvcReadDataHdrCallback(PSHAREDCLIPBOARDPROVIDERCALLBACKDATA pData)991 {992 LogFlowFuncEnter();993 994 PVBOXCLIPBOARDCLIENTDATA pClientData = (PVBOXCLIPBOARDCLIENTDATA)pData->pvUser;995 996 int rc = vboxSvcClipboardReportMsg(pClientData,997 VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_READ_DATA_HDR, VBOX_SHARED_CLIPBOARD_FMT_URI_LIST);998 LogFlowFuncLeaveRC(rc);999 return rc;1000 }1001 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */1002 1121 1003 1122 #ifndef UNIT_TEST
Note:
See TracChangeset
for help on using the changeset viewer.
