Changeset 80283 in vbox for trunk/src/VBox/HostServices/SharedClipboard
- Timestamp:
- Aug 15, 2019 8:47:23 AM (6 years ago)
- svn:sync-xref-src-repo-rev:
- 132738
- Location:
- trunk/src/VBox/HostServices/SharedClipboard
- Files:
-
- 4 edited
-
VBoxSharedClipboardSvc-internal.h (modified) (1 diff)
-
VBoxSharedClipboardSvc-uri.cpp (modified) (52 diffs)
-
VBoxSharedClipboardSvc-utils.cpp (modified) (1 diff)
-
VBoxSharedClipboardSvc.cpp (modified) (4 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
r79631 r80283 222 222 PVBOXCLIPBOARDLISTENTRY pListEntry); 223 223 224 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const char *pszPath,225 P VBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj);224 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, 225 PSHAREDCLIPBOARDOBJHANDLE phObj); 226 226 int vboxSvcClipboardURIObjClose(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj); 227 227 int vboxSvcClipboardURIObjRead(PSHAREDCLIPBOARDPROVIDERCTX pCtx, SHAREDCLIPBOARDOBJHANDLE hObj, -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp
r79704 r80283 25 25 #include <VBox/err.h> 26 26 27 #include <VBox/GuestHost/clipboard-helper.h> 27 28 #include <VBox/HostServices/VBoxClipboardSvc.h> 28 29 #include <VBox/HostServices/VBoxClipboardExt.h> … … 49 50 * Prototypes * 50 51 *********************************************************************************************************************************/ 51 int VBoxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],52 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms);53 int VBoxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],54 SHAREDCLIPBOARDLISTHANDLE hList);52 static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 53 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms); 54 static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 55 SHAREDCLIPBOARDLISTHANDLE hList); 55 56 56 57 … … 75 76 } 76 77 77 DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, 78 char **ppapszRoots, uint32_t *pcRoots) 78 DECLCALLBACK(int) vboxSvcClipboardURIGetRoots(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDROOTLIST *ppRootList) 79 79 { 80 80 LogFlowFuncEnter(); … … 85 85 int rc; 86 86 87 size_t cbRootsRecv = 0; 88 89 char *pszRoots = NULL; 90 uint32_t cRoots = 0; 91 92 /* There might be more than one message needed for retrieving all root items. */ 93 for (;;) 94 { 95 PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOTS, 96 VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS); 97 if (pMsg) 98 { 99 HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */); 100 HGCMSvcSetU32(&pMsg->m_paParms[1], 0 /* fRoots */); 101 HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fMore */); 102 HGCMSvcSetU32(&pMsg->m_paParms[3], 0 /* cRoots */); 103 104 uint32_t cbData = _64K; 105 void *pvData = RTMemAlloc(cbData); 106 AssertPtrBreakStmt(pvData, rc = VERR_NO_MEMORY); 107 108 HGCMSvcSetU32(&pMsg->m_paParms[4], cbData); 109 HGCMSvcSetPv (&pMsg->m_paParms[5], pvData, cbData); 110 111 rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsg, true /* fAppend */); 112 if (RT_SUCCESS(rc)) 113 { 114 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, 115 SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS); 116 AssertRC(rc2); 117 118 vboxSvcClipboardClientWakeup(pClient); 119 } 120 } 121 else 122 rc = VERR_NO_MEMORY; 123 124 if (RT_SUCCESS(rc)) 125 { 126 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 127 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_GET_ROOTS, 128 30 * 1000 /* Timeout in ms */, &pPayload); 129 if (RT_SUCCESS(rc)) 130 { 131 PVBOXCLIPBOARDROOTS pRoots = (PVBOXCLIPBOARDROOTS)pPayload->pvData; 132 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDROOTS)); 133 134 LogFlowFunc(("cbRoots=%RU32, fRoots=%RU32, fMore=%RTbool\n", pRoots->cbRoots, pRoots->fRoots, pRoots->fMore)); 135 136 if (!pRoots->cbRoots) 137 break; 138 AssertPtr(pRoots->pszRoots); 139 140 if (pszRoots == NULL) 141 pszRoots = (char *)RTMemDup((void *)pRoots->pszRoots, pRoots->cbRoots); 142 else 143 pszRoots = (char *)RTMemRealloc(pszRoots, cbRootsRecv + pRoots->cbRoots); 144 145 AssertPtrBreakStmt(pszRoots, rc = VERR_NO_MEMORY); 146 147 cbRootsRecv += pRoots->cbRoots; 148 149 if (cbRootsRecv > _32M) /* Don't allow more than 32MB root entries for now. */ 87 PVBOXCLIPBOARDCLIENTMSG pMsgHdr = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ, 88 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ); 89 if (pMsgHdr) 90 { 91 uint16_t uEventHdrRead = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer); 92 93 HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEventHdrRead)); 94 HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */); 95 96 rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsgHdr, true /* fAppend */); 97 if (RT_SUCCESS(rc)) 98 { 99 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEventHdrRead); 100 AssertRC(rc2); 101 102 rc = vboxSvcClipboardClientWakeup(pClient); 103 if (RT_SUCCESS(rc)) 104 { 105 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayloadHdr; 106 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEventHdrRead, 107 pCtx->pTransfer->uTimeoutMs, &pPayloadHdr); 108 if (RT_SUCCESS(rc)) 150 109 { 151 rc = VERR_ALLOCATION_TOO_BIG; /** @todo Find a better rc. */ 152 break; 110 PVBOXCLIPBOARDROOTLISTHDR pSrcRootListHdr = (PVBOXCLIPBOARDROOTLISTHDR)pPayloadHdr->pvData; 111 Assert(pPayloadHdr->cbData == sizeof(VBOXCLIPBOARDROOTLISTHDR)); 112 113 LogFlowFunc(("cRoots=%RU32, fRoots=0x%x\n", pSrcRootListHdr->cRoots, pSrcRootListHdr->fRoots)); 114 115 PVBOXCLIPBOARDROOTLIST pRootList = SharedClipboardURIRootListAlloc(); 116 if (pRootList) 117 { 118 if (pSrcRootListHdr->cRoots) 119 { 120 pRootList->paEntries = 121 (PVBOXCLIPBOARDROOTLISTENTRY)RTMemAllocZ(pSrcRootListHdr->cRoots * sizeof(VBOXCLIPBOARDROOTLISTENTRY)); 122 123 if (pRootList->paEntries) 124 { 125 for (uint32_t i = 0; i < pSrcRootListHdr->cRoots; i++) 126 { 127 PVBOXCLIPBOARDCLIENTMSG pMsgEntry = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ, 128 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ); 129 130 uint16_t uEventEntryRead = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer); 131 132 HGCMSvcSetU32(&pMsgEntry->m_paParms[0], 133 VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEventEntryRead)); 134 HGCMSvcSetU32(&pMsgEntry->m_paParms[1], 0 /* fRoots */); 135 HGCMSvcSetU32(&pMsgEntry->m_paParms[2], i /* uIndex */); 136 137 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEventEntryRead); 138 AssertRC(rc2); 139 140 rc = vboxSvcClipboardMsgAdd(pClient->pData, pMsgEntry, true /* fAppend */); 141 if (RT_FAILURE(rc)) 142 break; 143 144 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayloadEntry; 145 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEventEntryRead, 146 pCtx->pTransfer->uTimeoutMs, &pPayloadEntry); 147 if (RT_FAILURE(rc)) 148 break; 149 150 PVBOXCLIPBOARDROOTLISTENTRY pSrcRootListEntry = (PVBOXCLIPBOARDROOTLISTENTRY)pPayloadEntry->pvData; 151 Assert(pPayloadEntry->cbData == sizeof(VBOXCLIPBOARDROOTLISTENTRY)); 152 153 rc = SharedClipboardURIListEntryCopy(&pRootList->paEntries[i], pSrcRootListEntry); 154 155 SharedClipboardURITransferPayloadFree(pPayloadEntry); 156 157 SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEventEntryRead); 158 159 if (RT_FAILURE(rc)) 160 break; 161 } 162 } 163 else 164 rc = VERR_NO_MEMORY; 165 } 166 167 if (RT_SUCCESS(rc)) 168 { 169 pRootList->Hdr.cRoots = pSrcRootListHdr->cRoots; 170 pRootList->Hdr.fRoots = 0; /** @todo Implement this. */ 171 172 *ppRootList = pRootList; 173 } 174 else 175 SharedClipboardURIRootListFree(pRootList); 176 177 SharedClipboardURITransferPayloadFree(pPayloadHdr); 178 } 179 else 180 rc = VERR_NO_MEMORY; 153 181 } 154 155 cRoots += pRoots->cRoots; 156 157 const bool fDone = !RT_BOOL(pRoots->fMore); /* More root entries to be retrieved? Otherwise bail out. */ 158 159 SharedClipboardURITransferPayloadFree(pPayload); 160 161 if (fDone) 162 break; 163 } 164 } 165 166 if (RT_FAILURE(rc)) 167 break; 168 } 169 170 if (RT_SUCCESS(rc)) 171 { 172 LogFlowFunc(("cRoots=%RU32\n", cRoots)); 173 174 *ppapszRoots = pszRoots; 175 *pcRoots = cRoots; 182 } 183 184 SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEventHdrRead); 185 } 176 186 } 177 187 else 178 { 179 RTMemFree(pszRoots); 180 pszRoots = NULL; 181 } 188 rc = VERR_NO_MEMORY; 182 189 183 190 LogFlowFuncLeave(); … … 199 206 if (pMsg) 200 207 { 201 rc = VBoxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, pOpenParms);208 rc = vboxSvcClipboardURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, pOpenParms); 202 209 if (RT_SUCCESS(rc)) 203 210 { … … 205 212 if (RT_SUCCESS(rc)) 206 213 { 207 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN); 214 uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer); 215 216 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent); 208 217 AssertRC(rc2); 209 218 210 vboxSvcClipboardClientWakeup(pClient); 219 rc = vboxSvcClipboardClientWakeup(pClient); 220 if (RT_SUCCESS(rc)) 221 { 222 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 223 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); 224 if (RT_SUCCESS(rc)) 225 { 226 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY)); 227 228 PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData; 229 AssertPtr(pReply); 230 231 Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN); 232 233 *phList = pReply->u.ListOpen.uHandle; 234 235 SharedClipboardURITransferPayloadFree(pPayload); 236 } 237 } 238 239 SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEvent); 211 240 } 212 241 } … … 214 243 else 215 244 rc = VERR_NO_MEMORY; 216 217 if (RT_SUCCESS(rc))218 {219 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;220 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN,221 30 * 1000 /* Timeout in ms */, &pPayload);222 if (RT_SUCCESS(rc))223 {224 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDREPLY));225 226 PVBOXCLIPBOARDREPLY pReply = (PVBOXCLIPBOARDREPLY)pPayload->pvData;227 AssertPtr(pReply);228 229 Assert(pReply->uType == VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN);230 231 *phList = pReply->u.ListOpen.uHandle;232 233 SharedClipboardURITransferPayloadFree(pPayload);234 }235 }236 245 237 246 LogFlowFuncLeaveRC(rc); … … 252 261 if (pMsg) 253 262 { 254 rc = VBoxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, hList);263 rc = vboxSvcClipboardURISetListClose(pMsg->m_cParms, pMsg->m_paParms, hList); 255 264 if (RT_SUCCESS(rc)) 256 265 { … … 258 267 if (RT_SUCCESS(rc)) 259 268 { 260 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE); 269 uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer); 270 271 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent); 261 272 AssertRC(rc2); 262 273 263 vboxSvcClipboardClientWakeup(pClient); 274 rc = vboxSvcClipboardClientWakeup(pClient); 275 if (RT_SUCCESS(rc)) 276 { 277 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 278 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); 279 if (RT_SUCCESS(rc)) 280 SharedClipboardURITransferPayloadFree(pPayload); 281 } 282 283 SharedClipboardURITransferEventUnregister(pCtx->pTransfer, uEvent); 264 284 } 265 285 } … … 267 287 else 268 288 rc = VERR_NO_MEMORY; 269 270 if (RT_SUCCESS(rc))271 {272 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;273 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE,274 30 * 1000 /* Timeout in ms */, &pPayload);275 if (RT_SUCCESS(rc))276 SharedClipboardURITransferPayloadFree(pPayload);277 }278 289 279 290 LogFlowFuncLeaveRC(rc); … … 302 313 if (RT_SUCCESS(rc)) 303 314 { 304 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE); 315 uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer); 316 317 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent); 305 318 AssertRC(rc2); 306 319 307 vboxSvcClipboardClientWakeup(pClient); 320 rc = vboxSvcClipboardClientWakeup(pClient); 321 if (RT_SUCCESS(rc)) 322 { 323 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 324 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, 325 pCtx->pTransfer->uTimeoutMs, &pPayload); 326 if (RT_SUCCESS(rc)) 327 { 328 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR)); 329 330 *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData; 331 332 SharedClipboardURITransferPayloadFree(pPayload); 333 } 334 } 308 335 } 309 336 } … … 311 338 rc = VERR_NO_MEMORY; 312 339 313 if (RT_SUCCESS(rc))314 {315 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;316 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE,317 30 * 1000 /* Timeout in ms */, &pPayload);318 if (RT_SUCCESS(rc))319 {320 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTHDR));321 322 *pListHdr = *(PVBOXCLIPBOARDLISTHDR)pPayload->pvData;323 324 SharedClipboardURITransferPayloadFree(pPayload);325 }326 }327 328 340 LogFlowFuncLeaveRC(rc); 329 341 return rc; … … 351 363 352 364 PVBOXCLIPBOARDCLIENTMSG pMsg = vboxSvcClipboardMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_ENTRY_READ, 353 VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ _REQ);365 VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY_READ); 354 366 if (pMsg) 355 367 { 356 HGCMSvcSetU32(&pMsg->m_paParms[0], 0 /* uContextID */); 368 uint16_t uEvent = SharedClipboardURITransferEventIDGenerate(pCtx->pTransfer); 369 370 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 357 371 HGCMSvcSetU64(&pMsg->m_paParms[1], hList); 358 372 HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */); … … 361 375 if (RT_SUCCESS(rc)) 362 376 { 363 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE); 364 if (rc2 == VERR_ALREADY_EXISTS) 365 rc2 = VINF_SUCCESS; 377 int rc2 = SharedClipboardURITransferEventRegister(pCtx->pTransfer, uEvent); 366 378 AssertRC(rc2); 367 379 368 vboxSvcClipboardClientWakeup(pClient); 380 rc = vboxSvcClipboardClientWakeup(pClient); 381 if (RT_SUCCESS(rc)) 382 { 383 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 384 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, uEvent, pCtx->pTransfer->uTimeoutMs, &pPayload); 385 if (RT_SUCCESS(rc)) 386 { 387 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY)); 388 389 rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData); 390 391 SharedClipboardURITransferPayloadFree(pPayload); 392 } 393 } 369 394 } 370 395 } … … 372 397 rc = VERR_NO_MEMORY; 373 398 374 if (RT_SUCCESS(rc))375 {376 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload;377 rc = SharedClipboardURITransferEventWait(pCtx->pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE,378 30 * 1000 /* Timeout in ms */, &pPayload);379 if (RT_SUCCESS(rc))380 {381 Assert(pPayload->cbData == sizeof(VBOXCLIPBOARDLISTENTRY));382 383 rc = SharedClipboardURIListEntryCopy(pListEntry, (PVBOXCLIPBOARDLISTENTRY)pPayload->pvData);384 385 SharedClipboardURITransferPayloadFree(pPayload);386 }387 }388 389 399 LogFlowFuncLeaveRC(rc); 390 400 return rc; … … 401 411 } 402 412 403 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, const char *pszPath,404 P VBOXCLIPBOARDCREATEPARMS pCreateParms, PSHAREDCLIPBOARDOBJHANDLE phObj)405 { 406 RT_NOREF(pCtx, p szPath, pCreateParms, phObj);413 int vboxSvcClipboardURIObjOpen(PSHAREDCLIPBOARDPROVIDERCTX pCtx, PVBOXCLIPBOARDOBJOPENCREATEPARMS pCreateParms, 414 PSHAREDCLIPBOARDOBJHANDLE phObj) 415 { 416 RT_NOREF(pCtx, pCreateParms, phObj); 407 417 408 418 LogFlowFuncEnter(); … … 413 423 AssertPtr(pThisCtx); 414 424 425 RT_NOREF(pThisCtx); 426 415 427 LogFlowFuncLeaveRC(rc); 416 428 return rc; … … 427 439 PVBOXCLIPBOARDCONTEXT pThisCtx = (PVBOXCLIPBOARDCONTEXT)pCtx->pvUser; 428 440 AssertPtr(pThisCtx); 441 442 RT_NOREF(pThisCtx); 429 443 430 444 LogFlowFuncLeaveRC(rc); … … 509 523 * @param pReply Where to store the reply. 510 524 */ 511 int VBoxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[],512 PVBOXCLIPBOARDREPLY pReply)525 static int vboxSvcClipboardURIGetReply(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 526 PVBOXCLIPBOARDREPLY pReply) 513 527 { 514 528 int rc; … … 518 532 uint32_t cbPayload = 0; 519 533 520 /* Note: Context ID (paParms[0]) not used yet. */521 534 rc = HGCMSvcGetU32(&paParms[1], &pReply->uType); 522 535 if (RT_SUCCESS(rc)) … … 569 582 570 583 /** 571 * Gets the URI root entriesfrom HGCM service parameters.584 * Gets an URI root list header from HGCM service parameters. 572 585 * 573 586 * @returns VBox status code. 574 587 * @param cParms Number of HGCM parameters supplied in \a paParms. 575 588 * @param paParms Array of HGCM parameters. 576 * @param pRoot s Where to store the URI root entrieson success.577 */ 578 int VBoxSvcClipboardURIGetRoots(uint32_t cParms, VBOXHGCMSVCPARM paParms[],579 PVBOXCLIPBOARDROOTS pRoots)589 * @param pRootLstHdr Where to store the URI root list header on success. 590 */ 591 static int vboxSvcClipboardURIGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 592 PVBOXCLIPBOARDROOTLISTHDR pRootLstHdr) 580 593 { 581 594 int rc; 582 595 583 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOTS) 584 { 585 /* Note: Context ID (paParms[0]) not used yet. */ 586 rc = HGCMSvcGetU32(&paParms[1], &pRoots->fRoots); 587 if (RT_SUCCESS(rc)) 588 { 589 uint32_t fMore; 590 rc = HGCMSvcGetU32(&paParms[2], &fMore); 591 if (RT_SUCCESS(rc)) 592 pRoots->fMore = RT_BOOL(fMore); 593 } 594 if (RT_SUCCESS(rc)) 595 rc = HGCMSvcGetU32(&paParms[3], &pRoots->cRoots); 596 if (RT_SUCCESS(rc)) 597 { 598 uint32_t cbRoots; 599 rc = HGCMSvcGetU32(&paParms[4], &cbRoots); 600 if (RT_SUCCESS(rc)) 601 rc = HGCMSvcGetPv(&paParms[5], (void **)&pRoots->pszRoots, &pRoots->cbRoots); 602 603 AssertReturn(cbRoots == pRoots->cbRoots, VERR_INVALID_PARAMETER); 596 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR) 597 { 598 rc = HGCMSvcGetU32(&paParms[1], &pRootLstHdr->fRoots); 599 if (RT_SUCCESS(rc)) 600 rc = HGCMSvcGetU32(&paParms[2], &pRootLstHdr->cRoots); 601 } 602 else 603 rc = VERR_INVALID_PARAMETER; 604 605 LogFlowFuncLeaveRC(rc); 606 return rc; 607 } 608 609 /** 610 * Gets an URI root list entry from HGCM service parameters. 611 * 612 * @returns VBox status code. 613 * @param cParms Number of HGCM parameters supplied in \a paParms. 614 * @param paParms Array of HGCM parameters. 615 * @param pListEntry Where to store the root list entry. 616 */ 617 static int vboxSvcClipboardURIGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 618 PVBOXCLIPBOARDROOTLISTENTRY pListEntry) 619 { 620 int rc; 621 622 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY) 623 { 624 rc = HGCMSvcGetU32(&paParms[1], &pListEntry->fInfo); 625 /* Note: paParms[2] contains the entry index, currently being ignored. */ 626 if (RT_SUCCESS(rc)) 627 rc = HGCMSvcGetPv(&paParms[3], (void **)&pListEntry->pszName, &pListEntry->cbName); 628 if (RT_SUCCESS(rc)) 629 { 630 uint32_t cbInfo; 631 rc = HGCMSvcGetU32(&paParms[4], &cbInfo); 632 if (RT_SUCCESS(rc)) 633 { 634 rc = HGCMSvcGetPv(&paParms[5], &pListEntry->pvInfo, &pListEntry->cbInfo); 635 AssertReturn(cbInfo == pListEntry->cbInfo, VERR_INVALID_PARAMETER); 636 } 604 637 } 605 638 } … … 619 652 * @param pOpenParms Where to store the open parameters of the request. 620 653 */ 621 int VBoxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],622 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)654 static int vboxSvcClipboardURIGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 655 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms) 623 656 { 624 657 int rc; … … 629 662 uint32_t cbFilter = 0; 630 663 631 /* Note: Context ID (paParms[0]) not used yet. */632 664 rc = HGCMSvcGetU32(&paParms[1], &pOpenParms->fList); 633 665 if (RT_SUCCESS(rc)) … … 666 698 * @param pOpenParms List open parameters to set. 667 699 */ 668 int VBoxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[],669 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms)700 static int vboxSvcClipboardURISetListOpen(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 701 PVBOXCLIPBOARDLISTOPENPARMS pOpenParms) 670 702 { 671 703 int rc; … … 698 730 * @param hList Handle of list to close. 699 731 */ 700 int VBoxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[],701 SHAREDCLIPBOARDLISTHANDLE hList)732 static int vboxSvcClipboardURISetListClose(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 733 SHAREDCLIPBOARDLISTHANDLE hList) 702 734 { 703 735 int rc; … … 726 758 * @param pListHdr Where to store the list header. 727 759 */ 728 int VBoxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[],729 PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr)760 static int vboxSvcClipboardURIGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 761 PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTHDR pListHdr) 730 762 { 731 763 int rc; … … 733 765 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR) 734 766 { 735 /* Note: Context ID (paParms[0]) not used yet. */736 767 rc = HGCMSvcGetU64(&paParms[1], phList); 737 768 /* Note: Flags (paParms[2]) not used here. */ … … 768 799 * @param pListHdr Pointer to data to set to the HGCM parameters. 769 800 */ 770 int VBoxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHDR pListHdr)801 static int vboxSvcClipboardURISetListHdr(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTHDR pListHdr) 771 802 { 772 803 int rc; … … 804 835 * @param pListEntry Where to store the list entry. 805 836 */ 806 int VBoxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[],807 PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry)837 static int vboxSvcClipboardURIGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], 838 PSHAREDCLIPBOARDLISTHANDLE phList, PVBOXCLIPBOARDLISTENTRY pListEntry) 808 839 { 809 840 int rc; … … 811 842 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY) 812 843 { 813 /* Note: Context ID (paParms[0]) not used yet. */814 844 rc = HGCMSvcGetU64(&paParms[1], phList); 815 845 if (RT_SUCCESS(rc)) … … 849 879 * @param pListEntry Pointer to data to set to the HGCM parameters. 850 880 */ 851 int VBoxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTENTRY pListEntry)881 static int vboxSvcClipboardURISetListEntry(uint32_t cParms, VBOXHGCMSVCPARM paParms[], PVBOXCLIPBOARDLISTENTRY pListEntry) 852 882 { 853 883 int rc; … … 879 909 * @param pRc Where to store the received error code. 880 910 */ 881 int VBoxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc)911 static int vboxSvcClipboardURIGetError(uint32_t cParms, VBOXHGCMSVCPARM paParms[], int *pRc) 882 912 { 883 913 AssertPtrReturn(paParms, VERR_INVALID_PARAMETER); … … 888 918 if (cParms == VBOX_SHARED_CLIPBOARD_CPARMS_ERROR) 889 919 { 890 /* Note: Context ID (paParms[0]) not used yet. */891 920 rc = HGCMSvcGetU32(&paParms[1], (uint32_t *)pRc); /** @todo int vs. uint32_t !!! */ 892 921 } … … 907 936 * @param paParms Array function parameters supplied. 908 937 */ 909 int VBoxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer,910 uint32_t cParms, VBOXHGCMSVCPARM paParms[])938 static int vboxSvcClipboardURITransferHandleReply(PVBOXCLIPBOARDCLIENT pClient, PSHAREDCLIPBOARDURITRANSFER pTransfer, 939 uint32_t cParms, VBOXHGCMSVCPARM paParms[]) 911 940 { 912 941 RT_NOREF(pClient); … … 918 947 if (pReply) 919 948 { 920 rc = VBoxSvcClipboardURIGetReply(cParms, paParms, pReply);949 rc = vboxSvcClipboardURIGetReply(cParms, paParms, pReply); 921 950 if (RT_SUCCESS(rc)) 922 951 { … … 931 960 { 932 961 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_OPEN: 933 { 934 rc = SharedClipboardURITransferEventSignal(pTransfer, 935 SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_OPEN, pPayload); 936 break; 937 } 938 962 RT_FALL_THROUGH(); 939 963 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_LIST_CLOSE: 940 { 941 rc = SharedClipboardURITransferEventSignal(pTransfer, 942 SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_CLOSE, pPayload); 943 break; 944 } 945 964 RT_FALL_THROUGH(); 946 965 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_OPEN: 947 { 948 rc = SharedClipboardURITransferEventSignal(pTransfer, 949 SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_OPEN, pPayload); 950 break; 951 } 952 966 RT_FALL_THROUGH(); 953 967 case VBOX_SHAREDCLIPBOARD_REPLYMSGTYPE_OBJ_CLOSE: 954 968 { 955 rc = SharedClipboardURITransferEventSignal(pTransfer, 956 SHAREDCLIPBOARDURITRANSFEREVENTTYPE_OBJ_CLOSE, pPayload); 969 uint32_t uCID; 970 rc = HGCMSvcGetU32(&paParms[0], &uCID); 971 if (RT_SUCCESS(rc)) 972 { 973 const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 974 rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload); 975 } 957 976 break; 958 977 } … … 1007 1026 1008 1027 LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_pfnExtension=%p\n", 1009 pClient->uClientID, u32Function, VBox SvcClipboardGuestMsgToStr(u32Function), cParms, g_pfnExtension));1028 pClient->uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_pfnExtension)); 1010 1029 1011 1030 const PVBOXCLIPBOARDCLIENTDATA pClientData = pClient->pData; … … 1193 1212 case VBOX_SHARED_CLIPBOARD_GUEST_FN_REPLY: 1194 1213 { 1195 rc = VBoxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms); 1196 break; 1197 } 1198 1199 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOTS: 1200 { 1201 VBOXCLIPBOARDROOTS Roots; 1202 rc = VBoxSvcClipboardURIGetRoots(cParms, paParms, &Roots); 1203 if (RT_SUCCESS(rc)) 1204 { 1205 void *pvData = SharedClipboardURIRootsDup(&Roots); 1206 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTS); 1214 rc = vboxSvcClipboardURITransferHandleReply(pClient, pTransfer, cParms, paParms); 1215 break; 1216 } 1217 1218 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_READ: 1219 { 1220 break; 1221 } 1222 1223 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_HDR_WRITE: 1224 { 1225 VBOXCLIPBOARDROOTLISTHDR lstHdr; 1226 rc = vboxSvcClipboardURIGetRootListHdr(cParms, paParms, &lstHdr); 1227 if (RT_SUCCESS(rc)) 1228 { 1229 void *pvData = SharedClipboardURIRootListHdrDup(&lstHdr); 1230 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTHDR); 1231 1232 uint32_t uCID; 1233 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1234 if (RT_SUCCESS(rc)) 1235 { 1236 const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1237 1238 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1239 rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1240 if (RT_SUCCESS(rc)) 1241 rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload); 1242 } 1243 } 1244 break; 1245 } 1246 1247 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ: 1248 { 1249 #if 0 1250 VBOXCLIPBOARDROOTLISTENTRY lstEntry; 1251 rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); 1252 if (RT_SUCCESS(rc)) 1253 { 1254 void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); 1255 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY); 1207 1256 1208 1257 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1209 rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ GET_ROOTS,1258 rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, 1210 1259 pvData, cbData, &pPayload); 1211 1260 if (RT_SUCCESS(rc)) 1212 rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ GET_ROOTS,1261 rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, 1213 1262 pPayload); 1214 1263 } 1215 1264 break; 1265 #endif 1266 } 1267 1268 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE: 1269 { 1270 VBOXCLIPBOARDROOTLISTENTRY lstEntry; 1271 rc = vboxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); 1272 if (RT_SUCCESS(rc)) 1273 { 1274 void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); 1275 uint32_t cbData = sizeof(VBOXCLIPBOARDROOTLISTENTRY); 1276 1277 uint32_t uCID; 1278 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1279 if (RT_SUCCESS(rc)) 1280 { 1281 const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1282 1283 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1284 rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1285 if (RT_SUCCESS(rc)) 1286 rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload); 1287 } 1288 } 1289 break; 1216 1290 } 1217 1291 … … 1219 1293 { 1220 1294 VBOXCLIPBOARDLISTOPENPARMS listOpenParms; 1221 rc = VBoxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms);1295 rc = vboxSvcClipboardURIGetListOpen(cParms, paParms, &listOpenParms); 1222 1296 if (RT_SUCCESS(rc)) 1223 1297 { … … 1239 1313 1240 1314 SHAREDCLIPBOARDLISTHANDLE hList; 1241 /* Note: Context ID (paParms[0]) not used yet. */1242 1315 rc = HGCMSvcGetU64(&paParms[1], &hList); 1243 1316 if (RT_SUCCESS(rc)) … … 1254 1327 1255 1328 SHAREDCLIPBOARDLISTHANDLE hList; 1256 /* Note: Context ID (paParms[0]) not used yet. */1257 1329 rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */ 1258 1330 if (RT_SUCCESS(rc)) … … 1261 1333 rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList); 1262 1334 if (RT_SUCCESS(rc)) 1263 rc = VBoxSvcClipboardURISetListHdr(cParms, paParms, &hdrList);1335 rc = vboxSvcClipboardURISetListHdr(cParms, paParms, &hdrList); 1264 1336 } 1265 1337 break; … … 1273 1345 { 1274 1346 SHAREDCLIPBOARDLISTHANDLE hList; 1275 rc = VBoxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList);1347 rc = vboxSvcClipboardURIGetListHdr(cParms, paParms, &hList, &hdrList); 1276 1348 if (RT_SUCCESS(rc)) 1277 1349 { … … 1279 1351 uint32_t cbData = sizeof(VBOXCLIPBOARDLISTHDR); 1280 1352 1281 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1282 rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE, 1283 pvData, cbData, &pPayload); 1353 uint32_t uCID; 1354 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1284 1355 if (RT_SUCCESS(rc)) 1285 1356 { 1286 rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_HDR_WRITE, 1287 pPayload); 1357 const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1358 1359 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1360 rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1361 if (RT_SUCCESS(rc)) 1362 rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload); 1288 1363 } 1289 1364 } … … 1298 1373 1299 1374 SHAREDCLIPBOARDLISTHANDLE hList; 1300 /* Note: Context ID (paParms[0]) not used yet. */1301 1375 rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */ 1302 1376 if (RT_SUCCESS(rc)) … … 1315 1389 { 1316 1390 SHAREDCLIPBOARDLISTHANDLE hList; 1317 rc = VBoxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList);1391 rc = vboxSvcClipboardURIGetListEntry(cParms, paParms, &hList, &entryList); 1318 1392 if (RT_SUCCESS(rc)) 1319 1393 { … … 1321 1395 uint32_t cbData = sizeof(VBOXCLIPBOARDLISTENTRY); 1322 1396 1323 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1324 rc = SharedClipboardURITransferPayloadAlloc(SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE, 1325 pvData, cbData, &pPayload); 1397 uint32_t uCID; 1398 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1326 1399 if (RT_SUCCESS(rc)) 1327 1400 { 1328 rc = SharedClipboardURITransferEventSignal(pTransfer, SHAREDCLIPBOARDURITRANSFEREVENTTYPE_LIST_ENTRY_WRITE, 1329 pPayload); 1401 const uint16_t uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1402 1403 PSHAREDCLIPBOARDURITRANSFERPAYLOAD pPayload; 1404 rc = SharedClipboardURITransferPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1405 if (RT_SUCCESS(rc)) 1406 rc = SharedClipboardURITransferEventSignal(pTransfer, uEvent, pPayload); 1330 1407 } 1331 1332 1408 } 1333 1409 } … … 1514 1590 { 1515 1591 int rcGuest; 1516 rc = VBoxSvcClipboardURIGetError(cParms,paParms, &rcGuest);1592 rc = vboxSvcClipboardURIGetError(cParms,paParms, &rcGuest); 1517 1593 if (RT_SUCCESS(rc)) 1518 1594 LogRel(("Shared Clipboard: Transfer error: %Rrc\n", rcGuest)); … … 1581 1657 int vboxSvcClipboardURIAreaRegister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) 1582 1658 { 1659 RT_NOREF(pClientState); 1660 1583 1661 LogFlowFuncEnter(); 1584 1662 … … 1628 1706 int vboxSvcClipboardURIAreaUnregister(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) 1629 1707 { 1708 RT_NOREF(pClientState); 1709 1630 1710 LogFlowFuncEnter(); 1631 1711 … … 1675 1755 SHAREDCLIPBOARDAREAID uID) 1676 1756 { 1757 RT_NOREF(pClientState); 1758 1677 1759 LogFlowFuncEnter(); 1678 1760 … … 1720 1802 int vboxSvcClipboardURIAreaDetach(PVBOXCLIPBOARDCLIENTSTATE pClientState, PSHAREDCLIPBOARDURITRANSFER pTransfer) 1721 1803 { 1804 RT_NOREF(pClientState); 1805 1722 1806 LogFlowFuncEnter(); 1723 1807 -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-utils.cpp
r79630 r80283 143 143 } 144 144 145 #if 1 146 int rc = 0; 147 #else 148 /* Sanity. */ 149 Assert(pTransfer->State.enmDir == SHAREDCLIPBOARDURITRANSFERDIR_READ); 150 151 int rc; 152 153 /* Note: Message priority / order is taken into account here. */ 154 if (pTransfer->State.pHeader) 155 { 156 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_HDR\n")); 157 rc = VBoxSvcClipboardURIWriteListHdr(cParms, paParms, pTransfer->State.pHeader); 158 if (RT_SUCCESS(rc)) 159 { 160 /* We're done witht the data header, destroy it. */ 161 SharedClipboardURIListHdrFree(pTransfer->State.pHeader); 162 pTransfer->State.pHeader = NULL; 163 164 fHandled = true; 165 } 166 } 167 else if (pTransfer->State.pMeta) 168 { 169 LogFlowFunc(("VBOX_SHARED_CLIPBOARD_GUEST_FN_READ_DATA_CHUNK\n")); 170 171 uint32_t cbBuf = _64K; 172 uint8_t pvBuf[_64K]; /** @todo Improve */ 173 174 uint32_t cbRead; 175 rc = SharedClipboardMetaDataRead(pTransfer->State.pMeta, pvBuf, cbBuf, &cbRead); 176 if (RT_SUCCESS(rc)) 177 { 178 Assert(cbRead <= cbBuf); 179 180 VBOXCLIPBOARDListEntry ListEntry; 181 RT_ZERO(ListEntry); 182 ListEntry.pvData = pvBuf; 183 ListEntry.cbData = cbRead; 184 185 rc = VBoxSvcClipboardURIWriteListEntry(cParms, paParms, &ListEntry); 186 } 187 188 /* Has all meta data been read? */ 189 if (RT_SUCCESS(rc)) 190 { 191 if (SharedClipboardMetaDataGetUsed(pTransfer->State.pMeta) == 0) 192 { 193 SharedClipboardMetaDataFree(pTransfer->State.pMeta); 194 pTransfer->State.pMeta = NULL; 195 } 196 197 fHandled = true; 198 } 199 } 200 else if (pTransfer->pURIList) 201 { 202 PSHAREDCLIPBOARDCLIENTURIOBJCTX pObjCtx = SharedClipboardURITransferGetCurrentObjCtx(pTransfer); 203 if (!SharedClipboardURIObjCtxIsValid(pObjCtx)) 204 { 205 if (!pTransfer->pURIList->IsEmpty()) 206 pObjCtx->pObj = pTransfer->pURIList->First(); 207 } 208 209 if ( pObjCtx 210 && pObjCtx->pObj) 211 { 212 switch (pObjCtx->pObj->GetType()) 213 { 214 case SharedClipboardURIObject::Type_Directory: 215 { 216 rc = VBoxSvcClipboardURIWriteDir(cParms, paParms, &ListEntry); 217 break; 218 } 219 } 220 } 221 222 if (0) 223 { 224 delete pTransfer->pURIList; 225 pTransfer->pURIList = NULL; 226 } 227 228 fHandled = true; 229 } 230 else 231 rc = VERR_WRONG_ORDER; 232 #endif 233 234 LogFlowFunc(("rc=%Rrc, fHandled=%RTbool\n", rc, fHandled)); 145 LogFlowFunc(("fHandled=%RTbool\n", fHandled)); 235 146 return fHandled; 236 147 } -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
r79705 r80283 177 177 178 178 #include <VBox/AssertGuest.h> 179 #include <VBox/GuestHost/clipboard-helper.h> 179 180 #include <VBox/HostServices/Service.h> 180 181 #include <VBox/HostServices/VBoxClipboardSvc.h> … … 471 472 vboxSvcClipboardMsgSetPeekReturn(pFirstMsg, paParms, cParms); 472 473 LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n", 473 pClient->uClientID, pFirstMsg->m_uMsg, VBox SvcClipboardHostMsgToStr(pFirstMsg->m_uMsg),474 pClient->uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), 474 475 pFirstMsg->m_cParms)); 475 476 return VINF_SUCCESS; … … 535 536 { 536 537 LogFlowFunc(("First message is: %RU32 %s (%RU32 parms)\n", 537 pFirstMsg->m_uMsg, VBox SvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));538 pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms)); 538 539 539 540 ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_uMsg == idMsgExpected || idMsgExpected == UINT32_MAX, 540 541 ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n", 541 pFirstMsg->m_uMsg, VBox SvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,542 idMsgExpected, VBox SvcClipboardHostMsgToStr(idMsgExpected), cParms),542 pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms, 543 idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms), 543 544 VERR_MISMATCH); 544 545 ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_cParms == cParms, 545 546 ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n", 546 pFirstMsg->m_uMsg, VBox SvcClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,547 idMsgExpected, VBox SvcClipboardHostMsgToStr(idMsgExpected), cParms),547 pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms, 548 idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms), 548 549 VERR_WRONG_PARAMETER_COUNT); 549 550 … … 552 553 ASSERT_GUEST_MSG_RETURN(pFirstMsg->m_paParms[i].type == paParms[i].type, 553 554 ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->m_paParms[i].type, 554 paParms[i].type, pFirstMsg->m_uMsg, VBox SvcClipboardHostMsgToStr(pFirstMsg->m_uMsg)),555 paParms[i].type, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg)), 555 556 VERR_WRONG_PARAMETER_TYPE); 556 557 /*
Note:
See TracChangeset
for help on using the changeset viewer.
