Changeset 80845 in vbox for trunk/src/VBox/HostServices
- Timestamp:
- Sep 17, 2019 9:05:21 AM (6 years ago)
- svn:sync-xref-src-repo-rev:
- 133415
- Location:
- trunk/src/VBox/HostServices/SharedClipboard
- Files:
-
- 4 edited
-
VBoxSharedClipboardSvc-internal.h (modified) (4 diffs)
-
VBoxSharedClipboardSvc-uri.cpp (modified) (31 diffs)
-
VBoxSharedClipboardSvc-win.cpp (modified) (10 diffs)
-
VBoxSharedClipboardSvc.cpp (modified) (36 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-internal.h
r80664 r80845 58 58 { 59 59 /** Stored message type. */ 60 uint32_t m_uMsg;60 uint32_t uMsg; 61 61 /** Number of stored HGCM parameters. */ 62 uint32_t m_cParms;62 uint32_t cParms; 63 63 /** Stored HGCM parameters. */ 64 PVBOXHGCMSVCPARM m_paParms;64 PVBOXHGCMSVCPARM paParms; 65 65 /** Message context. */ 66 SHCLMSGCTX m_Ctx;66 SHCLMSGCTX Ctx; 67 67 } SHCLCLIENTMSG, *PSHCLCLIENTMSG; 68 68 … … 84 84 SHCLCONTEXT *pCtx; 85 85 86 /** The client's HGCM ID. */ 87 uint32_t u32ClientID; 86 /** The client's HGCM ID. Not related to the session ID below! */ 87 uint32_t uClientID; 88 /** The client's session ID. */ 89 uint32_t uSessionID; 88 90 /** Optional protocol version the client uses. Set to 0 by default. */ 89 uint32_t 91 uint32_t uProtocolVer; 90 92 /** Maximum chunk size to use for data transfers. Set to _64K by default. */ 91 uint32_t 92 SHCLSOURCE enmSource;93 uint32_t cbChunkSize; 94 SHCLSOURCE enmSource; 93 95 /** The client's URI state. */ 94 96 SHCLCLIENTURISTATE URI; … … 97 99 typedef struct _SHCLCLIENTCMDCTX 98 100 { 99 uint32_t 101 uint32_t uContextID; 100 102 } SHCLCLIENTCMDCTX, *PSHCLCLIENTCMDCTX; 101 103 102 104 typedef struct _SHCLCLIENT 103 105 { 104 /** The client's HGCM client ID. */105 uint32_t uClientID;106 106 /** General client state data. */ 107 107 SHCLCLIENTSTATE State; 108 108 /** The client's message queue (FIFO). */ 109 109 RTCList<SHCLCLIENTMSG *> queueMsg; 110 /** The client's own event source. */ 111 SHCLEVENTSOURCE Events; 110 /** The client's own event source. 111 * Needed for events which are not bound to a specific transfer. */ 112 SHCLEVENTSOURCE Events; 112 113 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 113 114 /** URI context data. */ 114 SHCLURICTX URI;115 SHCLURICTX URI; 115 116 #endif 116 117 /** Structure for keeping the client's pending (deferred return) state. … … 226 227 int sharedClipboardSvcURIGetRoots(PSHCLPROVIDERCTX pCtx, PSHCLROOTLIST *ppRootList); 227 228 228 int sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx, 229 PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList); 229 int sharedClipboardSvcURIListOpen(PSHCLPROVIDERCTX pCtx, PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList); 230 230 int sharedClipboardSvcURIListClose(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList); 231 int sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, 232 PSHCLLISTHDR pListHdr); 233 int sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, 234 PSHCLLISTHDR pListHdr); 235 int sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, 236 PSHCLLISTENTRY pListEntry); 237 int sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, 238 PSHCLLISTENTRY pListEntry); 231 int sharedClipboardSvcURIListHdrRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr); 232 int sharedClipboardSvcURIListHdrWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr); 233 int sharedClipboardSvcURIListEntryRead(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry); 234 int sharedClipboardSvcURIListEntryWrite(PSHCLPROVIDERCTX pCtx, SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry); 239 235 240 236 int sharedClipboardSvcURIObjOpen(PSHCLPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, 241 PSHCLOBJHANDLE phObj);237 PSHCLOBJHANDLE phObj); 242 238 int sharedClipboardSvcURIObjClose(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj); 243 239 int sharedClipboardSvcURIObjRead(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, 244 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead);240 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbRead); 245 241 int sharedClipboardSvcURIObjWrite(PSHCLPROVIDERCTX pCtx, SHCLOBJHANDLE hObj, 246 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten);242 void *pvData, uint32_t cbData, uint32_t fFlags, uint32_t *pcbWritten); 247 243 248 244 DECLCALLBACK(void) VBoxSvcClipboardURITransferPrepareCallback(PSHCLURITRANSFERCALLBACKDATA pData); -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-uri.cpp
r80664 r80845 84 84 85 85 PSHCLCLIENTMSG pMsgHdr = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_HDR_READ, 86 86 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_HDR_READ); 87 87 if (pMsgHdr) 88 88 { 89 89 SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 90 90 91 HGCMSvcSetU32(&pMsgHdr->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 92 HGCMSvcSetU32(&pMsgHdr->m_paParms[1], 0 /* fRoots */); 91 HGCMSvcSetU32(&pMsgHdr->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 92 pCtx->pTransfer->State.uID, uEvent)); 93 HGCMSvcSetU32(&pMsgHdr->paParms[1], 0 /* fRoots */); 93 94 94 95 rc = sharedClipboardSvcMsgAdd(pClient, pMsgHdr, true /* fAppend */); … … 124 125 { 125 126 PSHCLCLIENTMSG pMsgEntry = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_ROOT_LIST_ENTRY_READ, 126 127 VBOX_SHARED_CLIPBOARD_CPARMS_ROOT_LIST_ENTRY_READ_REQ); 127 128 128 129 uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 129 130 130 HGCMSvcSetU32(&pMsgEntry->m_paParms[0], 131 VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 132 HGCMSvcSetU32(&pMsgEntry->m_paParms[1], 0 /* fRoots */); 133 HGCMSvcSetU32(&pMsgEntry->m_paParms[2], i /* uIndex */); 131 HGCMSvcSetU32(&pMsgEntry->paParms[0], 132 VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uClientID, 133 pCtx->pTransfer->State.uID, uEvent)); 134 HGCMSvcSetU32(&pMsgEntry->paParms[1], 0 /* fRoots */); 135 HGCMSvcSetU32(&pMsgEntry->paParms[2], i /* uIndex */); 134 136 135 137 rc2 = SharedClipboardEventRegister(&pCtx->pTransfer->Events, uEvent); … … 206 208 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 207 209 208 pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent); 209 210 rc = sharedClipboardSvcURISetListOpen(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, pOpenParms); 210 pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID, 211 uEvent); 212 213 rc = sharedClipboardSvcURISetListOpen(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, pOpenParms); 211 214 if (RT_SUCCESS(rc)) 212 215 { … … 258 261 259 262 PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_LIST_CLOSE, 260 263 VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE); 261 264 if (pMsg) 262 265 { 263 266 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 264 267 265 pMsg->m_Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent); 266 267 rc = sharedClipboardSvcURISetListClose(pMsg->m_cParms, pMsg->m_paParms, &pMsg->m_Ctx, hList); 268 pMsg->Ctx.uContextID = VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID, 269 uEvent); 270 271 rc = sharedClipboardSvcURISetListClose(pMsg->cParms, pMsg->paParms, &pMsg->Ctx, hList); 268 272 if (RT_SUCCESS(rc)) 269 273 { … … 310 314 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 311 315 312 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 313 HGCMSvcSetU64(&pMsg->m_paParms[1], hList); 314 HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */); 316 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 317 pCtx->pTransfer->State.uID, uEvent)); 318 HGCMSvcSetU64(&pMsg->paParms[1], hList); 319 HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */); 315 320 316 321 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 370 375 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 371 376 372 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 373 HGCMSvcSetU64(&pMsg->m_paParms[1], hList); 374 HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fInfo */); 377 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 378 pCtx->pTransfer->State.uID, uEvent)); 379 HGCMSvcSetU64(&pMsg->paParms[1], hList); 380 HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fInfo */); 375 381 376 382 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 433 439 const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */ 434 440 435 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 436 HGCMSvcSetU64(&pMsg->m_paParms[1], 0); /* uHandle */ 437 HGCMSvcSetU32(&pMsg->m_paParms[2], cbPath); 438 HGCMSvcSetPv (&pMsg->m_paParms[3], pCreateParms->pszPath, cbPath); 439 HGCMSvcSetU32(&pMsg->m_paParms[4], pCreateParms->fCreate); 441 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 442 pCtx->pTransfer->State.uID, uEvent)); 443 HGCMSvcSetU64(&pMsg->paParms[1], 0); /* uHandle */ 444 HGCMSvcSetU32(&pMsg->paParms[2], cbPath); 445 HGCMSvcSetPv (&pMsg->paParms[3], pCreateParms->pszPath, cbPath); 446 HGCMSvcSetU32(&pMsg->paParms[4], pCreateParms->fCreate); 440 447 441 448 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 483 490 484 491 PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_CLOSE, 485 492 VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_CLOSE); 486 493 if (pMsg) 487 494 { 488 495 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 489 496 490 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 491 HGCMSvcSetU64(&pMsg->m_paParms[1], hObj); 497 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 498 pCtx->pTransfer->State.uID, uEvent)); 499 HGCMSvcSetU64(&pMsg->paParms[1], hObj); 492 500 493 501 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 536 544 537 545 PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_READ, 538 546 VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_READ_REQ); 539 547 if (pMsg) 540 548 { 541 549 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 542 550 543 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 544 HGCMSvcSetU64(&pMsg->m_paParms[1], hObj); 545 HGCMSvcSetU32(&pMsg->m_paParms[2], cbData); 546 HGCMSvcSetU32(&pMsg->m_paParms[3], fFlags); 551 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 552 pCtx->pTransfer->State.uID, uEvent)); 553 HGCMSvcSetU64(&pMsg->paParms[1], hObj); 554 HGCMSvcSetU32(&pMsg->paParms[2], cbData); 555 HGCMSvcSetU32(&pMsg->paParms[3], fFlags); 547 556 548 557 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 594 603 595 604 PSHCLCLIENTMSG pMsg = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_OBJ_WRITE, 596 605 VBOX_SHARED_CLIPBOARD_CPARMS_OBJ_WRITE); 597 606 if (pMsg) 598 607 { 599 608 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pCtx->pTransfer->Events); 600 609 601 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pCtx->pTransfer->State.uID, uEvent)); 602 HGCMSvcSetU64(&pMsg->m_paParms[1], hObj); 603 HGCMSvcSetU64(&pMsg->m_paParms[2], cbData); 604 HGCMSvcSetU64(&pMsg->m_paParms[3], fFlags); 610 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 611 pCtx->pTransfer->State.uID, uEvent)); 612 HGCMSvcSetU64(&pMsg->paParms[1], hObj); 613 HGCMSvcSetU64(&pMsg->paParms[2], cbData); 614 HGCMSvcSetU64(&pMsg->paParms[3], fFlags); 605 615 606 616 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 697 707 uint32_t cbPayload = 0; 698 708 709 /* paParms[0] has the context ID. */ 699 710 rc = HGCMSvcGetU32(&paParms[1], &pReply->uType); 700 711 if (RT_SUCCESS(rc)) … … 714 725 switch (pReply->uType) 715 726 { 727 case VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS: 728 { 729 if (cParms >= 6) 730 rc = HGCMSvcGetU32(&paParms[5], &pReply->u.TransferStatus.uStatus); 731 break; 732 } 733 716 734 case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN: 717 735 { … … 1151 1169 int rc; 1152 1170 1153 uint32_t 1171 uint32_t cbReply = sizeof(SHCLREPLY); 1154 1172 PSHCLREPLY pReply = (PSHCLREPLY)RTMemAlloc(cbReply); 1155 1173 if (pReply) … … 1167 1185 switch (pReply->uType) 1168 1186 { 1187 case VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS: 1188 RT_FALL_THROUGH(); 1169 1189 case VBOX_SHCL_REPLYMSGTYPE_LIST_OPEN: 1170 1190 RT_FALL_THROUGH(); … … 1237 1257 1238 1258 LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n", 1239 pClient->uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension)); 1240 1259 pClient->State.uClientID, u32Function, VBoxClipboardGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension)); 1260 1261 #if 0 1241 1262 /* Check if we've the right mode set. */ 1242 1263 if (!sharedClipboardSvcURIMsgIsAllowed(sharedClipboardSvcGetMode(), u32Function)) … … 1245 1266 return VERR_ACCESS_DENIED; 1246 1267 } 1268 #endif 1247 1269 1248 1270 /* A (valid) service extension is needed because VBoxSVC needs to keep track of the … … 1257 1279 } 1258 1280 1259 int rc = V INF_SUCCESS;1281 int rc = VERR_INVALID_PARAMETER; /* Play safe by default. */ 1260 1282 1261 1283 /* 1262 1284 * Pre-check: For certain messages we need to make sure that a (right) transfer is present. 1263 1285 */ 1286 uint32_t uCID = 0; /* Context ID */ 1264 1287 PSHCLURITRANSFER pTransfer = NULL; 1288 1265 1289 switch (u32Function) 1266 1290 { … … 1272 1296 { 1273 1297 LogFunc(("No transfers found\n")); 1274 rc = VERR_ WRONG_ORDER;1298 rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND; 1275 1299 break; 1276 1300 } 1277 1301 1278 const uint32_t uTransferID = 0; /* Only one transfer per client is supported at the moment. */ 1302 if (cParms < 1) 1303 break; 1304 1305 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1306 if (RT_FAILURE(rc)) 1307 break; 1308 1309 const SHCLURITRANSFERID uTransferID = VBO_SHARED_CLIPBOARD_CONTEXTID_GET_TRANSFER(uCID); 1279 1310 1280 1311 pTransfer = SharedClipboardURICtxGetTransfer(&pClient->URI, uTransferID); … … 1282 1313 { 1283 1314 LogFunc(("Transfer with ID %RU32 not found\n", uTransferID)); 1284 rc = VERR_ WRONG_ORDER;1315 rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND; 1285 1316 } 1286 1317 break; … … 1292 1323 1293 1324 rc = VERR_INVALID_PARAMETER; /* Play safe. */ 1325 1326 bool fDoCallComplete = true; 1294 1327 1295 1328 switch (u32Function) … … 1399 1432 { 1400 1433 rc = sharedClipboardSvcURITransferHandleReply(pClient, pTransfer, cParms, paParms); 1434 1435 /* This message does not need any completion, as it can happen at any time from the guest side. */ 1436 fDoCallComplete = false; 1401 1437 break; 1402 1438 } … … 1416 1452 uint32_t cbData = sizeof(SHCLROOTLISTHDR); 1417 1453 1418 uint32_t uCID; 1419 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1454 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1455 1456 PSHCLEVENTPAYLOAD pPayload; 1457 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1420 1458 if (RT_SUCCESS(rc)) 1421 1459 { 1460 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload); 1461 if (RT_FAILURE(rc)) 1462 SharedClipboardPayloadFree(pPayload); 1463 } 1464 } 1465 break; 1466 } 1467 1468 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ: 1469 { 1470 #if 0 1471 SHCLROOTLISTENTRY lstEntry; 1472 rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); 1473 if (RT_SUCCESS(rc)) 1474 { 1475 void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); 1476 uint32_t cbData = sizeof(SHCLROOTLISTENTRY); 1477 1478 PSHCLURITRANSFERPAYLOAD pPayload; 1479 rc = SharedClipboardURITransferPayloadAlloc(SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, 1480 pvData, cbData, &pPayload); 1481 if (RT_SUCCESS(rc)) 1482 rc = SharedClipboardURITransferEventSignal(pTransfer, SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, 1483 pPayload); 1484 } 1485 break; 1486 #endif 1487 } 1488 1489 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE: 1490 { 1491 SHCLROOTLISTENTRY lstEntry; 1492 rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry); 1493 if (RT_SUCCESS(rc)) 1494 { 1495 void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); 1496 uint32_t cbData = sizeof(SHCLROOTLISTENTRY); 1497 1498 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1499 1500 PSHCLEVENTPAYLOAD pPayload; 1501 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1502 if (RT_SUCCESS(rc)) 1503 { 1504 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload); 1505 if (RT_FAILURE(rc)) 1506 SharedClipboardPayloadFree(pPayload); 1507 } 1508 } 1509 break; 1510 } 1511 1512 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN: 1513 { 1514 SHCLLISTOPENPARMS listOpenParms; 1515 rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms); 1516 if (RT_SUCCESS(rc)) 1517 { 1518 SHCLLISTHANDLE hList; 1519 rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList); 1520 if (RT_SUCCESS(rc)) 1521 { 1522 /* Return list handle. */ 1523 HGCMSvcSetU32(&paParms[1], hList); 1524 } 1525 } 1526 break; 1527 } 1528 1529 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE: 1530 { 1531 if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE) 1532 break; 1533 1534 SHCLLISTHANDLE hList; 1535 rc = HGCMSvcGetU64(&paParms[1], &hList); 1536 if (RT_SUCCESS(rc)) 1537 { 1538 rc = SharedClipboardURITransferListClose(pTransfer, hList); 1539 } 1540 break; 1541 } 1542 1543 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ: 1544 { 1545 if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR) 1546 break; 1547 1548 SHCLLISTHANDLE hList; 1549 rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */ 1550 if (RT_SUCCESS(rc)) 1551 { 1552 SHCLLISTHDR hdrList; 1553 rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList); 1554 /*if (RT_SUCCESS(rc)) 1555 rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/ 1556 } 1557 break; 1558 } 1559 1560 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE: 1561 { 1562 SHCLLISTHDR hdrList; 1563 rc = SharedClipboardURIListHdrInit(&hdrList); 1564 if (RT_SUCCESS(rc)) 1565 { 1566 SHCLLISTHANDLE hList; 1567 rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList); 1568 if (RT_SUCCESS(rc)) 1569 { 1570 void *pvData = SharedClipboardURIListHdrDup(&hdrList); 1571 uint32_t cbData = sizeof(SHCLLISTHDR); 1572 1422 1573 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1423 1574 … … 1435 1586 } 1436 1587 1437 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_READ: 1438 { 1439 #if 0 1440 SHCLROOTLISTENTRY lstEntry; 1441 rc = VBoxSvcClipboardURIGetRootListEntry(cParms, paParms, &lstEntry); 1442 if (RT_SUCCESS(rc)) 1443 { 1444 void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); 1445 uint32_t cbData = sizeof(SHCLROOTLISTENTRY); 1446 1447 PSHCLURITRANSFERPAYLOAD pPayload; 1448 rc = SharedClipboardURITransferPayloadAlloc(SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, 1449 pvData, cbData, &pPayload); 1588 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ: 1589 { 1590 if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY) 1591 break; 1592 1593 SHCLLISTHANDLE hList; 1594 rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */ 1595 if (RT_SUCCESS(rc)) 1596 { 1597 SHCLLISTENTRY entryList; 1598 rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList); 1599 } 1600 break; 1601 } 1602 1603 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE: 1604 { 1605 SHCLLISTENTRY entryList; 1606 rc = SharedClipboardURIListEntryInit(&entryList); 1607 if (RT_SUCCESS(rc)) 1608 { 1609 SHCLLISTHANDLE hList; 1610 rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList); 1450 1611 if (RT_SUCCESS(rc)) 1451 rc = SharedClipboardURITransferEventSignal(pTransfer, SHCLURITRANSFEREVENTTYPE_ROOT_LIST_HDR_READ, 1452 pPayload); 1453 } 1454 break; 1455 #endif 1456 } 1457 1458 case VBOX_SHARED_CLIPBOARD_GUEST_FN_ROOT_LIST_ENTRY_WRITE: 1459 { 1460 SHCLROOTLISTENTRY lstEntry; 1461 rc = sharedClipboardSvcURIGetRootListEntry(cParms, paParms, &lstEntry); 1462 if (RT_SUCCESS(rc)) 1463 { 1464 void *pvData = SharedClipboardURIRootListEntryDup(&lstEntry); 1465 uint32_t cbData = sizeof(SHCLROOTLISTENTRY); 1466 1467 uint32_t uCID; 1468 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1469 if (RT_SUCCESS(rc)) 1470 { 1612 { 1613 void *pvData = SharedClipboardURIListEntryDup(&entryList); 1614 uint32_t cbData = sizeof(SHCLLISTENTRY); 1615 1471 1616 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1472 1617 … … 1484 1629 } 1485 1630 1486 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_OPEN:1487 {1488 SHCLLISTOPENPARMS listOpenParms;1489 rc = sharedClipboardSvcURIGetListOpen(cParms, paParms, &listOpenParms);1490 if (RT_SUCCESS(rc))1491 {1492 SHCLLISTHANDLE hList;1493 rc = SharedClipboardURITransferListOpen(pTransfer, &listOpenParms, &hList);1494 if (RT_SUCCESS(rc))1495 {1496 /* Return list handle. */1497 HGCMSvcSetU32(&paParms[1], hList);1498 }1499 }1500 break;1501 }1502 1503 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_CLOSE:1504 {1505 if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_CLOSE)1506 break;1507 1508 SHCLLISTHANDLE hList;1509 rc = HGCMSvcGetU64(&paParms[1], &hList);1510 if (RT_SUCCESS(rc))1511 {1512 rc = SharedClipboardURITransferListClose(pTransfer, hList);1513 }1514 break;1515 }1516 1517 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_READ:1518 {1519 if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_HDR)1520 break;1521 1522 SHCLLISTHANDLE hList;1523 rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */1524 if (RT_SUCCESS(rc))1525 {1526 SHCLLISTHDR hdrList;1527 rc = SharedClipboardURITransferListGetHeader(pTransfer, hList, &hdrList);1528 /*if (RT_SUCCESS(rc))1529 rc = sharedClipboardSvcURISetListHdr(cParms, paParms, &hdrList);*/1530 }1531 break;1532 }1533 1534 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_HDR_WRITE:1535 {1536 SHCLLISTHDR hdrList;1537 rc = SharedClipboardURIListHdrInit(&hdrList);1538 if (RT_SUCCESS(rc))1539 {1540 SHCLLISTHANDLE hList;1541 rc = sharedClipboardSvcURIGetListHdr(cParms, paParms, &hList, &hdrList);1542 if (RT_SUCCESS(rc))1543 {1544 void *pvData = SharedClipboardURIListHdrDup(&hdrList);1545 uint32_t cbData = sizeof(SHCLLISTHDR);1546 1547 uint32_t uCID;1548 rc = HGCMSvcGetU32(&paParms[0], &uCID);1549 if (RT_SUCCESS(rc))1550 {1551 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);1552 1553 PSHCLEVENTPAYLOAD pPayload;1554 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);1555 if (RT_SUCCESS(rc))1556 {1557 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);1558 if (RT_FAILURE(rc))1559 SharedClipboardPayloadFree(pPayload);1560 }1561 }1562 }1563 }1564 break;1565 }1566 1567 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_READ:1568 {1569 if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_LIST_ENTRY)1570 break;1571 1572 SHCLLISTHANDLE hList;1573 rc = HGCMSvcGetU64(&paParms[1], &hList); /* Get list handle. */1574 if (RT_SUCCESS(rc))1575 {1576 SHCLLISTENTRY entryList;1577 rc = SharedClipboardURITransferListRead(pTransfer, hList, &entryList);1578 }1579 break;1580 }1581 1582 case VBOX_SHARED_CLIPBOARD_GUEST_FN_LIST_ENTRY_WRITE:1583 {1584 SHCLLISTENTRY entryList;1585 rc = SharedClipboardURIListEntryInit(&entryList);1586 if (RT_SUCCESS(rc))1587 {1588 SHCLLISTHANDLE hList;1589 rc = sharedClipboardSvcURIGetListEntry(cParms, paParms, &hList, &entryList);1590 if (RT_SUCCESS(rc))1591 {1592 void *pvData = SharedClipboardURIListEntryDup(&entryList);1593 uint32_t cbData = sizeof(SHCLLISTENTRY);1594 1595 uint32_t uCID;1596 rc = HGCMSvcGetU32(&paParms[0], &uCID);1597 if (RT_SUCCESS(rc))1598 {1599 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID);1600 1601 PSHCLEVENTPAYLOAD pPayload;1602 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload);1603 if (RT_SUCCESS(rc))1604 {1605 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload);1606 if (RT_FAILURE(rc))1607 SharedClipboardPayloadFree(pPayload);1608 }1609 }1610 }1611 }1612 break;1613 }1614 1615 1631 #if 0 1616 1632 case VBOX_SHARED_CLIPBOARD_GUEST_FN_OBJ_OPEN: … … 1639 1655 uint32_t cbData = sizeof(SHCLOBJDATACHUNK); 1640 1656 1641 uint32_t uCID; 1642 rc = HGCMSvcGetU32(&paParms[0], &uCID); 1657 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1658 1659 PSHCLEVENTPAYLOAD pPayload; 1660 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1643 1661 if (RT_SUCCESS(rc)) 1644 1662 { 1645 const SHCLEVENTID uEvent = VBOX_SHARED_CLIPBOARD_CONTEXTID_GET_EVENT(uCID); 1646 1647 PSHCLEVENTPAYLOAD pPayload; 1648 rc = SharedClipboardPayloadAlloc(uEvent, pvData, cbData, &pPayload); 1649 if (RT_SUCCESS(rc)) 1650 { 1651 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload); 1652 if (RT_FAILURE(rc)) 1653 SharedClipboardPayloadFree(pPayload); 1654 } 1663 rc = SharedClipboardEventSignal(&pTransfer->Events, uEvent, pPayload); 1664 if (RT_FAILURE(rc)) 1665 SharedClipboardPayloadFree(pPayload); 1655 1666 } 1656 1667 } … … 1849 1860 } 1850 1861 1851 if ( rc != VINF_HGCM_ASYNC_EXECUTE)1862 if (fDoCallComplete) 1852 1863 { 1853 1864 /* Tell the client that the call is complete (unblocks waiting). */ 1854 LogFlowFunc(("[Client %RU32] Calling pfnCallComplete w/ rc=%Rrc\n", pClient-> uClientID, rc));1865 LogFlowFunc(("[Client %RU32] Calling pfnCallComplete w/ rc=%Rrc\n", pClient->State.uClientID, rc)); 1855 1866 AssertPtr(g_pHelpers); 1856 1867 g_pHelpers->pfnCallComplete(callHandle, rc); 1857 1868 } 1858 1869 1859 LogFlowFunc(("[Client %RU32] Returning rc=%Rrc\n", pClient-> uClientID, rc));1870 LogFlowFunc(("[Client %RU32] Returning rc=%Rrc\n", pClient->State.uClientID, rc)); 1860 1871 return rc; 1861 1872 } … … 1934 1945 1935 1946 LogFlowFunc(("Registered new clipboard area (%RU32) by client %RU32 with rc=%Rrc\n", 1936 parms.uID, pClientState->u 32ClientID, rc));1947 parms.uID, pClientState->uClientID, rc)); 1937 1948 } 1938 1949 else … … 1980 1991 1981 1992 LogFlowFunc(("Unregistered clipboard area (%RU32) by client %RU32 with rc=%Rrc\n", 1982 parms.uID, pClientState->u 32ClientID, rc));1993 parms.uID, pClientState->uClientID, rc)); 1983 1994 } 1984 1995 … … 2030 2041 2031 2042 LogFlowFunc(("Attached client %RU32 to clipboard area %RU32 with rc=%Rrc\n", 2032 pClientState->u 32ClientID, parms.uID, rc));2043 pClientState->uClientID, parms.uID, rc)); 2033 2044 } 2034 2045 else … … 2068 2079 2069 2080 LogFlowFunc(("Detached client %RU32 from clipboard area %RU32 with rc=%Rrc\n", 2070 pClientState->u 32ClientID, uAreaID, rc));2081 pClientState->uClientID, uAreaID, rc)); 2071 2082 } 2072 2083 … … 2078 2089 } 2079 2090 2091 /** 2092 * Reports a transfer status to the guest. 2093 * 2094 * @returns VBox status code. 2095 * @param pClient Client that owns the transfer. 2096 * @param pTransfer Transfer to report status for. 2097 * @param uStatus Status to report. 2098 * @param rcTransfer Result code to report. Optional and depending on status. 2099 * @param puEvent Where to store the created wait event. Optional. 2100 */ 2101 int sharedClipboardSvcURITransferSendStatus(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer, SHCLURITRANSFERSTATUS uStatus, 2102 int rcTransfer, PSHCLEVENTID puEvent) 2103 { 2104 AssertPtrReturn(pClient, VERR_INVALID_POINTER); 2105 AssertPtrReturn(pTransfer, VERR_INVALID_POINTER); 2106 /* puEvent is optional. */ 2107 2108 PSHCLCLIENTMSG pMsgReadData = sharedClipboardSvcMsgAlloc(VBOX_SHARED_CLIPBOARD_HOST_MSG_URI_TRANSFER_STATUS, 2109 VBOX_SHARED_CLIPBOARD_CPARMS_TRANSFER_STATUS); 2110 if (!pMsgReadData) 2111 return VERR_NO_MEMORY; 2112 2113 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pTransfer->Events); 2114 2115 HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 2116 pTransfer->State.uID, uEvent)); 2117 HGCMSvcSetU32(&pMsgReadData->paParms[1], pTransfer->State.enmDir); 2118 HGCMSvcSetU32(&pMsgReadData->paParms[2], uStatus); 2119 HGCMSvcSetU32(&pMsgReadData->paParms[3], (uint32_t)rcTransfer); /** @todo uint32_t vs. int. */ 2120 HGCMSvcSetU32(&pMsgReadData->paParms[4], 0 /* fFlags, unused */); 2121 2122 int rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */); 2123 if (RT_SUCCESS(rc)) 2124 { 2125 rc = SharedClipboardEventRegister(&pTransfer->Events, uEvent); 2126 if (RT_SUCCESS(rc)) 2127 { 2128 rc = sharedClipboardSvcClientWakeup(pClient); 2129 if (RT_SUCCESS(rc)) 2130 { 2131 LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU32 to guest\n", 2132 VBoxClipboardTransferStatusToStr(uStatus), rcTransfer, pTransfer->State.uID)); 2133 2134 if (puEvent) 2135 *puEvent = uEvent; 2136 } 2137 else 2138 SharedClipboardEventUnregister(&pTransfer->Events, uEvent); 2139 } 2140 } 2141 2142 LogFlowFuncLeaveRC(rc); 2143 return rc; 2144 } 2145 2146 /** 2147 * Starts a new transfer, waiting for acknowledgement by the guest side. 2148 * 2149 * @returns VBox status code. 2150 * @param pClient Client that owns the transfer. 2151 * @param enmDir Transfer direction to start. 2152 * @param enmSource Transfer source to start. 2153 * @param ppTransfer Where to return the created transfer on success. Optional. 2154 */ 2155 int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient, 2156 SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource, 2157 PSHCLURITRANSFER *ppTransfer) 2158 { 2159 AssertPtrReturn(pClient, VERR_INVALID_POINTER); 2160 /* ppTransfer is optional. */ 2161 2162 LogFlowFuncEnter(); 2163 2164 SharedClipboardURICtxTransfersCleanup(&pClient->URI); 2165 2166 int rc; 2167 2168 if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI)) 2169 { 2170 LogRel2(("Shared Clipboard: Starting %s transfer ...\n", enmDir == SHCLURITRANSFERDIR_READ ? "read" : "write")); 2171 2172 PSHCLURITRANSFER pTransfer; 2173 rc = SharedClipboardURITransferCreate(&pTransfer); 2174 if (RT_SUCCESS(rc)) 2175 { 2176 SHCLPROVIDERCREATIONCTX creationCtx; 2177 RT_ZERO(creationCtx); 2178 2179 if (enmDir == SHCLURITRANSFERDIR_READ) 2180 { 2181 rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer); 2182 if (RT_SUCCESS(rc)) 2183 { 2184 creationCtx.Interface.pfnTransferOpen = sharedClipboardSvcURITransferOpen; 2185 creationCtx.Interface.pfnTransferClose = sharedClipboardSvcURITransferClose; 2186 creationCtx.Interface.pfnListOpen = sharedClipboardSvcURIListOpen; 2187 creationCtx.Interface.pfnListClose = sharedClipboardSvcURIListClose; 2188 creationCtx.Interface.pfnObjOpen = sharedClipboardSvcURIObjOpen; 2189 creationCtx.Interface.pfnObjClose = sharedClipboardSvcURIObjClose; 2190 2191 creationCtx.Interface.pfnGetRoots = sharedClipboardSvcURIGetRoots; 2192 creationCtx.Interface.pfnListHdrRead = sharedClipboardSvcURIListHdrRead; 2193 creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcURIListEntryRead; 2194 creationCtx.Interface.pfnObjRead = sharedClipboardSvcURIObjRead; 2195 } 2196 } 2197 else if (enmDir == SHCLURITRANSFERDIR_WRITE) 2198 { 2199 creationCtx.Interface.pfnListHdrWrite = sharedClipboardSvcURIListHdrWrite; 2200 creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcURIListEntryWrite; 2201 creationCtx.Interface.pfnObjWrite = sharedClipboardSvcURIObjWrite; 2202 } 2203 else 2204 AssertFailed(); 2205 2206 creationCtx.enmSource = pClient->State.enmSource; 2207 creationCtx.pvUser = pClient; 2208 2209 /* Register needed callbacks so that we can wait for the meta data to arrive here. */ 2210 SHCLURITRANSFERCALLBACKS Callbacks; 2211 RT_ZERO(Callbacks); 2212 2213 Callbacks.pvUser = pClient; 2214 2215 Callbacks.pfnTransferPrepare = VBoxSvcClipboardURITransferPrepareCallback; 2216 Callbacks.pfnTransferComplete = VBoxSvcClipboardURITransferCompleteCallback; 2217 Callbacks.pfnTransferCanceled = VBoxSvcClipboardURITransferCanceledCallback; 2218 Callbacks.pfnTransferError = VBoxSvcClipboardURITransferErrorCallback; 2219 2220 SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks); 2221 2222 uint32_t uTransferID = 0; 2223 2224 rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx); 2225 if (RT_SUCCESS(rc)) 2226 { 2227 rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer); 2228 if (RT_SUCCESS(rc)) 2229 { 2230 rc = SharedClipboardURICtxTransferRegister(&pClient->URI, pTransfer, &uTransferID); 2231 if (RT_SUCCESS(rc)) 2232 { 2233 rc = SharedClipboardURITransferInit(pTransfer, uTransferID, enmDir, enmSource); 2234 if (RT_SUCCESS(rc)) 2235 { 2236 SHCLEVENTID uEvent; 2237 rc = sharedClipboardSvcURITransferSendStatus(pClient, pTransfer, 2238 SHCLURITRANSFERSTATUS_READY, VINF_SUCCESS, 2239 &uEvent); 2240 if (RT_SUCCESS(rc)) 2241 { 2242 LogRel2(("Shared Clipboard: Waiting for start of transfer %RU32 on guest ...\n", 2243 pTransfer->State.uID)); 2244 2245 PSHCLEVENTPAYLOAD pPayload; 2246 rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, &pPayload); 2247 if (RT_SUCCESS(rc)) 2248 { 2249 Assert(pPayload->cbData == sizeof(SHCLREPLY)); 2250 PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData; 2251 AssertPtr(pReply); 2252 2253 Assert(pReply->uType == VBOX_SHCL_REPLYMSGTYPE_TRANSFER_STATUS); 2254 2255 if (pReply->u.TransferStatus.uStatus) 2256 { 2257 LogRel2(("Shared Clipboard: Started transfer %RU32 on guest\n", pTransfer->State.uID)); 2258 } 2259 else 2260 LogRel(("Shared Clipboard: Guest reported status %s (error %Rrc) while starting transfer %RU32\n", 2261 VBoxClipboardTransferStatusToStr(pReply->u.TransferStatus.uStatus), 2262 pReply->rc, pTransfer->State.uID)); 2263 } 2264 else 2265 LogRel(("Shared Clipboard: Unable to start transfer %RU32 on guest, rc=%Rrc\n", 2266 pTransfer->State.uID, rc)); 2267 } 2268 } 2269 } 2270 } 2271 } 2272 2273 if (RT_FAILURE(rc)) 2274 { 2275 SharedClipboardURICtxTransferUnregister(&pClient->URI, uTransferID); 2276 2277 SharedClipboardURITransferDestroy(pTransfer); 2278 2279 RTMemFree(pTransfer); 2280 pTransfer = NULL; 2281 } 2282 else 2283 { 2284 if (ppTransfer) 2285 *ppTransfer = pTransfer; 2286 } 2287 } 2288 2289 if (RT_FAILURE(rc)) 2290 LogRel(("Shared Clipboard: Starting transfer failed with %Rrc\n", rc)); 2291 } 2292 else 2293 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED; 2294 2295 LogFlowFuncLeaveRC(rc); 2296 return rc; 2297 } 2298 2299 /** 2300 * Stops a transfer, communicating the status to the guest side. 2301 * 2302 * @returns VBox status code. 2303 * @param pClient Client that owns the transfer. 2304 * @param pTransfer Transfer to stop. 2305 */ 2306 int sharedClipboardSvcURITransferStop(PSHCLCLIENT pClient, PSHCLURITRANSFER pTransfer) 2307 { 2308 int rc = SharedClipboardURITransferClose(pTransfer); 2309 if (RT_SUCCESS(rc)) 2310 { 2311 SHCLEVENTID uEvent; 2312 rc = sharedClipboardSvcURITransferSendStatus(pClient, pTransfer, 2313 SHCLURITRANSFERSTATUS_STOPPED, VINF_SUCCESS, 2314 &uEvent); 2315 if (RT_SUCCESS(rc)) 2316 { 2317 LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU32 on guest ...\n", pTransfer->State.uID)); 2318 2319 rc = SharedClipboardEventWait(&pTransfer->Events, uEvent, pTransfer->uTimeoutMs, NULL); 2320 if (RT_SUCCESS(rc)) 2321 { 2322 rc = SharedClipboardURICtxTransferUnregister(&pClient->URI, SharedClipboardURITransferGetID(pTransfer)); 2323 2324 LogRel2(("Shared Clipboard: Stopped transfer %RU32 on guest\n", pTransfer->State.uID)); 2325 } 2326 else 2327 LogRel(("Shared Clipboard: Unable to stop transfer %RU32 on guest, rc=%Rrc\n", 2328 pTransfer->State.uID, rc)); 2329 } 2330 } 2331 2332 LogFlowFuncLeaveRC(rc); 2333 return rc; 2334 } 2335 -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-win.cpp
r80664 r80845 58 58 { 59 59 /** Handle for window message handling thread. */ 60 RTTHREAD 60 RTTHREAD hThread; 61 61 /** Structure for keeping and communicating with service client. */ 62 PSHCLCLIENT 62 PSHCLCLIENT pClient; 63 63 /** Windows-specific context data. */ 64 SHCLWINCTX 64 SHCLWINCTX Win; 65 65 }; 66 66 … … 213 213 case WM_CLIPBOARDUPDATE: 214 214 { 215 const HWND hWndClipboardOwner = GetClipboardOwner(); 216 if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner) 217 { 215 LogFunc(("WM_CLIPBOARDUPDATE: Waiting ...\n")); 216 217 int rc = RTCritSectEnter(&pWinCtx->CritSect); 218 if (RT_SUCCESS(rc)) 219 { 220 const HWND hWndClipboardOwner = GetClipboardOwner(); 221 218 222 LogFunc(("WM_CLIPBOARDUPDATE: hWndClipboardOwnerUs=%p, hWndNewClipboardOwner=%p\n", 219 223 pWinCtx->hWndClipboardOwnerUs, hWndClipboardOwner)); 220 224 221 /* Clipboard was updated by another application, retrieve formats and report back. */ 222 int rc = vboxClipboardSvcWinSyncInternal(pCtx); 223 if (RT_SUCCESS(rc)) 224 sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); 225 } 225 if (pWinCtx->hWndClipboardOwnerUs != hWndClipboardOwner) 226 { 227 int rc2 = RTCritSectLeave(&pWinCtx->CritSect); 228 AssertRC(rc2); 229 230 /* Clipboard was updated by another application, retrieve formats and report back. */ 231 rc = vboxClipboardSvcWinSyncInternal(pCtx); 232 if (RT_SUCCESS(rc)) 233 rc = sharedClipboardSvcSetSource(pCtx->pClient, SHCLSOURCE_LOCAL); 234 } 235 else 236 { 237 int rc2 = RTCritSectLeave(&pWinCtx->CritSect); 238 AssertRC(rc2); 239 } 240 } 241 242 if (RT_FAILURE(rc)) 243 LogRel(("Shared Clipboard: WM_CLIPBOARDUPDATE failed with %Rrc\n", rc)); 226 244 227 245 break; … … 311 329 case SHCL_WIN_WM_REPORT_FORMATS: 312 330 { 313 LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS\n")); 314 315 /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT. */ 331 /* Announce available formats. Do not insert data -- will be inserted in WM_RENDERFORMAT (or via IDataObject). */ 316 332 SHCLFORMATS fFormats = (uint32_t)lParam; 317 if (fFormats != VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */ 318 { 333 LogFunc(("SHCL_WIN_WM_REPORT_FORMATS: fFormats=0x%x\n", fFormats)); 334 335 if (fFormats == VBOX_SHARED_CLIPBOARD_FMT_NONE) /* Could arrive with some older GA versions. */ 336 break; 337 338 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 339 if (fFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) 340 { 341 PSHCLURITRANSFER pTransfer; 342 int rc = sharedClipboardSvcURITransferStart(pCtx->pClient, 343 SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE, 344 &pTransfer); 345 if (RT_SUCCESS(rc)) 346 { 347 /* Create the IDataObject implementation the host OS needs and assign 348 * the newly created transfer to this object. */ 349 rc = SharedClipboardWinURITransferCreate(&pCtx->Win, pTransfer); 350 351 /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation 352 (ClipboardDataObjectImpl::GetData()). */ 353 } 354 else 355 LogRel(("Shared Clipboard: Initializing read transfer failed with %Rrc\n", rc)); 356 } 357 else 358 { 359 #endif 319 360 int rc = SharedClipboardWinOpen(hWnd); 320 361 if (RT_SUCCESS(rc)) … … 326 367 SharedClipboardWinClose(); 327 368 } 328 329 LogFunc(("VBOX_CLIPBOARD_WM_REPORT_FORMATS: fFormats=0x%x, lastErr=%ld\n", fFormats, GetLastError()));330 } 331 369 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 370 } 371 #endif 372 LogFunc(("SHCL_WIN_WM_REPORT_FORMATS: lastErr=%ld\n", GetLastError())); 332 373 break; 333 374 } … … 457 498 if (FAILED(hr)) 458 499 { 459 LogRel((" Clipboard: Initializing OLE failed (%Rhrc) -- file transfers unavailable\n"));500 LogRel(("Shared Clipboard: Initializing window thread OLE failed (%Rhrc) -- file transfers unavailable\n", hr)); 460 501 /* Not critical, the rest of the clipboard might work. */ 461 502 } 462 503 else 463 LogRel(("Clipboard: Initialized OLE\n")); 464 } 465 #endif 466 504 LogRel(("Shared Clipboard: Initialized window thread OLE\n")); 505 } 506 #endif 467 507 int rc2 = RTThreadUserSignal(hThreadSelf); 468 508 AssertRC(rc2); … … 550 590 int SharedClipboardSvcImplInit(void) 551 591 { 552 /* Initialization is done in SharedClipboardSvcImplConnect(). */ 592 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 593 HRESULT hr = OleInitialize(NULL); 594 if (FAILED(hr)) 595 { 596 LogRel(("Shared Clipboard: Initializing OLE failed (%Rhrc) -- file transfers unavailable\n", hr)); 597 /* Not critical, the rest of the clipboard might work. */ 598 } 599 else 600 LogRel(("Shared Clipboard: Initialized OLE\n")); 601 #endif 602 553 603 return VINF_SUCCESS; 554 604 } … … 556 606 void SharedClipboardSvcImplDestroy(void) 557 607 { 558 /* Destruction is done in SharedClipboardSvcImplDisconnect(). */ 608 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 609 OleSetClipboard(NULL); /* Make sure to flush the clipboard on destruction. */ 610 OleUninitialize(); 611 #endif 559 612 } 560 613 … … 570 623 if (pCtx) 571 624 { 572 /* Check that new Clipboard API is available. */ 573 rc = SharedClipboardWinCheckAndInitNewAPI(&pCtx->Win.newAPI); 625 rc = SharedClipboardWinCtxInit(&pCtx->Win); 574 626 if (RT_SUCCESS(rc)) 575 627 { … … 628 680 } 629 681 682 SharedClipboardWinCtxDestroy(&pCtx->Win); 683 630 684 if (RT_SUCCESS(rc)) 631 685 { … … 654 708 LogFlowFunc(("uFormats=0x%x, hWnd=%p\n", pFormats->uFormats, pCtx->Win.hWnd)); 655 709 656 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 657 if (pFormats->uFormats & VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) 658 { 659 PSHCLURITRANSFER pTransfer; 660 rc = sharedClipboardSvcURITransferStart(pClient, 661 SHCLURITRANSFERDIR_READ, SHCLSOURCE_REMOTE, 662 &pTransfer); 663 if (RT_SUCCESS(rc)) 664 { 665 /* Create the IDataObject implementation the host OS needs and assign 666 * the newly created transfer to this object. */ 667 rc = SharedClipboardWinURITransferCreate(&pCtx->Win, pTransfer); 668 669 /* Note: The actual requesting + retrieving of data will be done in the IDataObject implementation 670 (ClipboardDataObjectImpl::GetData()). */ 671 } 672 } 673 else 674 { 675 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ 676 677 /* 678 * The guest announced formats. Forward to the window thread. 679 */ 680 PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_REPORT_FORMATS, 681 0 /* wParam */, pFormats->uFormats /* lParam */); 682 683 rc = VINF_SUCCESS; 684 685 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST 686 } 687 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */ 710 /* 711 * The guest announced formats. Forward to the window thread. 712 */ 713 PostMessage(pCtx->Win.hWnd, SHCL_WIN_WM_REPORT_FORMATS, 714 0 /* wParam */, pFormats->uFormats /* lParam */); 715 716 rc = VINF_SUCCESS; 688 717 689 718 LogFlowFuncLeaveRC(rc); -
trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc.cpp
r80664 r80845 246 246 ClipboardClientMap g_mapClients; 247 247 248 /** Global map of all registered event sources. */249 ClipboardEventSourceMap g_mapEventSources;250 251 248 /** Global list of all clients which are queued up (deferred return) and ready 252 249 * to process new commands. The key is the (unique) client ID. */ 253 250 ClipboardClientQueue g_listClientsDeferred; 254 251 255 256 /**257 * Creates a (unique) event source ID.258 *259 * @returns VBox status code, or VERR_NOT_FOUND on error.260 * @param puID Where to store the created event source ID on success.261 */262 int sharedClipboardSvcEventSourceCreateID(PSHCLEVENTSOURCEID puID)263 {264 AssertPtrReturn(puID, VERR_INVALID_POINTER);265 266 for (uint32_t i = 0; i < 32; i++) /* Don't try too hard. */267 {268 SHCLEVENTSOURCEID uID = RTRandU32() % VBOX_SHARED_CLIPBOARD_MAX_EVENT_SOURCES;269 if (g_mapEventSources.find(uID) == g_mapEventSources.end())270 {271 *puID = uID;272 return VINF_SUCCESS;273 }274 }275 276 return VERR_NOT_FOUND;277 }278 252 279 253 uint32_t sharedClipboardSvcGetMode(void) … … 366 340 if (pMsg) 367 341 { 368 pMsg-> m_paParms = (PVBOXHGCMSVCPARM)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * cParms);369 if (pMsg-> m_paParms)370 { 371 pMsg-> m_cParms = cParms;372 pMsg-> m_uMsg = uMsg;342 pMsg->paParms = (PVBOXHGCMSVCPARM)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * cParms); 343 if (pMsg->paParms) 344 { 345 pMsg->cParms = cParms; 346 pMsg->uMsg = uMsg; 373 347 374 348 return pMsg; … … 391 365 return; 392 366 393 if (pMsg-> m_paParms)394 RTMemFree(pMsg-> m_paParms);367 if (pMsg->paParms) 368 RTMemFree(pMsg->paParms); 395 369 396 370 RTMemFree(pMsg); … … 411 385 Assert(cDstParms >= 2); 412 386 if (paDstParms[0].type == VBOX_HGCM_SVC_PARM_32BIT) 413 paDstParms[0].u.uint32 = pMsg-> m_uMsg;387 paDstParms[0].u.uint32 = pMsg->uMsg; 414 388 else 415 paDstParms[0].u.uint64 = pMsg-> m_uMsg;416 paDstParms[1].u.uint32 = pMsg-> m_cParms;417 418 uint32_t i = RT_MIN(cDstParms, pMsg-> m_cParms + 2);389 paDstParms[0].u.uint64 = pMsg->uMsg; 390 paDstParms[1].u.uint32 = pMsg->cParms; 391 392 uint32_t i = RT_MIN(cDstParms, pMsg->cParms + 2); 419 393 while (i-- > 2) 420 switch (pMsg-> m_paParms[i - 2].type)394 switch (pMsg->paParms[i - 2].type) 421 395 { 422 396 case VBOX_HGCM_SVC_PARM_32BIT: paDstParms[i].u.uint32 = ~(uint32_t)sizeof(uint32_t); break; 423 397 case VBOX_HGCM_SVC_PARM_64BIT: paDstParms[i].u.uint32 = ~(uint32_t)sizeof(uint64_t); break; 424 case VBOX_HGCM_SVC_PARM_PTR: paDstParms[i].u.uint32 = pMsg-> m_paParms[i - 2].u.pointer.size; break;398 case VBOX_HGCM_SVC_PARM_PTR: paDstParms[i].u.uint32 = pMsg->paParms[i - 2].u.pointer.size; break; 425 399 } 426 400 } … … 445 419 int rc = VINF_SUCCESS; 446 420 447 switch (pMsg-> m_uMsg)421 switch (pMsg->uMsg) 448 422 { 449 423 case VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT: … … 457 431 { 458 432 HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_READ_DATA); 459 AssertBreakStmt(pMsg-> m_cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */433 AssertBreakStmt(pMsg->cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */ 460 434 uint32_t uFmt; 461 rc = HGCMSvcGetU32(&pMsg-> m_paParms[1] /* uFormat */, &uFmt);435 rc = HGCMSvcGetU32(&pMsg->paParms[1] /* uFormat */, &uFmt); 462 436 if (RT_SUCCESS(rc)) 463 437 HGCMSvcSetU32(&paDstParms[1], uFmt); … … 468 442 { 469 443 HGCMSvcSetU32(&paDstParms[0], VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS_REPORT); 470 AssertBreakStmt(pMsg-> m_cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */444 AssertBreakStmt(pMsg->cParms >= 2, rc = VERR_INVALID_PARAMETER); /* Paranoia. */ 471 445 uint32_t uFmts; 472 rc = HGCMSvcGetU32(&pMsg-> m_paParms[1] /* uFormats */, &uFmts);446 rc = HGCMSvcGetU32(&pMsg->paParms[1] /* uFormats */, &uFmts); 473 447 if (RT_SUCCESS(rc)) 474 448 HGCMSvcSetU32(&paDstParms[1], uFmts); … … 499 473 500 474 LogFlowFunc(("uMsg=%RU32 (%s), cParms=%RU32, fAppend=%RTbool\n", 501 pMsg-> m_uMsg, VBoxClipboardHostMsgToStr(pMsg->m_uMsg), pMsg->m_cParms, fAppend));475 pMsg->uMsg, VBoxClipboardHostMsgToStr(pMsg->uMsg), pMsg->cParms, fAppend)); 502 476 503 477 if (fAppend) … … 560 534 paParms[0].u.uint64 = idRestore; 561 535 LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VERR_VM_RESTORED (%#RX64 -> %#RX64)\n", 562 pClient-> uClientID, idRestoreCheck, idRestore));536 pClient->State.uClientID, idRestoreCheck, idRestore)); 563 537 return VERR_VM_RESTORED; 564 538 } … … 576 550 sharedClipboardSvcMsgSetPeekReturn(pFirstMsg, paParms, cParms); 577 551 LogFlowFunc(("[Client %RU32] VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_XXX -> VINF_SUCCESS (idMsg=%u (%s), cParms=%u)\n", 578 pClient-> uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),579 pFirstMsg-> m_cParms));552 pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), 553 pFirstMsg->cParms)); 580 554 return VINF_SUCCESS; 581 555 } … … 587 561 if (!fWait) 588 562 { 589 LogFlowFunc(("[Client %RU32] GUEST_MSG_PEEK_NOWAIT -> VERR_TRY_AGAIN\n", pClient-> uClientID));563 LogFlowFunc(("[Client %RU32] GUEST_MSG_PEEK_NOWAIT -> VERR_TRY_AGAIN\n", pClient->State.uClientID)); 590 564 return VERR_TRY_AGAIN; 591 565 } … … 595 569 */ 596 570 ASSERT_GUEST_MSG_RETURN(pClient->Pending.uType == 0, ("Already pending! (idClient=%RU32)\n", 597 pClient-> uClientID), VERR_RESOURCE_BUSY);571 pClient->State.uClientID), VERR_RESOURCE_BUSY); 598 572 pClient->Pending.hHandle = hCall; 599 573 pClient->Pending.cParms = cParms; 600 574 pClient->Pending.paParms = paParms; 601 575 pClient->Pending.uType = VBOX_SHARED_CLIPBOARD_GUEST_FN_MSG_PEEK_WAIT; 602 LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient-> uClientID));576 LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient->State.uClientID)); 603 577 return VINF_HGCM_ASYNC_EXECUTE; 604 578 } … … 637 611 638 612 LogFlowFunc(("[Client %RU32] uMsg=%RU32 (%s), cParms=%RU32\n", 639 pClient-> uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),640 pFirstMsg-> m_cParms));613 pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), 614 pFirstMsg->cParms)); 641 615 642 616 rc = sharedClipboardSvcMsgSetGetHostMsgOldReturn(pFirstMsg, paParms, cParms); … … 657 631 { 658 632 ASSERT_GUEST_MSG_RETURN(pClient->Pending.uType == 0, ("Already pending! (idClient=%RU32)\n", 659 pClient-> uClientID), VERR_RESOURCE_BUSY);633 pClient->State.uClientID), VERR_RESOURCE_BUSY); 660 634 661 635 pClient->Pending.hHandle = hCall; … … 666 640 rc = VINF_HGCM_ASYNC_EXECUTE; /* The caller must not complete it. */ 667 641 668 LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient-> uClientID));669 } 670 } 671 672 LogFlowFunc(("[Client %RU32] rc=%Rrc\n", pClient-> uClientID, rc));642 LogFlowFunc(("[Client %RU32] Is now in pending mode...\n", pClient->State.uClientID)); 643 } 644 } 645 646 LogFlowFunc(("[Client %RU32] rc=%Rrc\n", pClient->State.uClientID, rc)); 673 647 return rc; 674 648 } … … 710 684 { 711 685 LogFlowFunc(("First message is: %RU32 (%s), cParms=%RU32\n", 712 pFirstMsg-> m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms));713 714 ASSERT_GUEST_MSG_RETURN(pFirstMsg-> m_uMsg == idMsgExpected || idMsgExpected == UINT32_MAX,686 pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms)); 687 688 ASSERT_GUEST_MSG_RETURN(pFirstMsg->uMsg == idMsgExpected || idMsgExpected == UINT32_MAX, 715 689 ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n", 716 pFirstMsg-> m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,690 pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms, 717 691 idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms), 718 692 VERR_MISMATCH); 719 ASSERT_GUEST_MSG_RETURN(pFirstMsg-> m_cParms == cParms,693 ASSERT_GUEST_MSG_RETURN(pFirstMsg->cParms == cParms, 720 694 ("idMsg=%u (%s) cParms=%u, caller expected %u (%s) and %u\n", 721 pFirstMsg-> m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg), pFirstMsg->m_cParms,695 pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), pFirstMsg->cParms, 722 696 idMsgExpected, VBoxClipboardHostMsgToStr(idMsgExpected), cParms), 723 697 VERR_WRONG_PARAMETER_COUNT); … … 725 699 /* Check the parameter types. */ 726 700 for (uint32_t i = 0; i < cParms; i++) 727 ASSERT_GUEST_MSG_RETURN(pFirstMsg-> m_paParms[i].type == paParms[i].type,728 ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg-> m_paParms[i].type,729 paParms[i].type, pFirstMsg-> m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg)),701 ASSERT_GUEST_MSG_RETURN(pFirstMsg->paParms[i].type == paParms[i].type, 702 ("param #%u: type %u, caller expected %u (idMsg=%u %s)\n", i, pFirstMsg->paParms[i].type, 703 paParms[i].type, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg)), 730 704 VERR_WRONG_PARAMETER_TYPE); 731 705 /* … … 737 711 int rc = VINF_SUCCESS; 738 712 for (uint32_t i = 0; i < cParms; i++) 739 switch (pFirstMsg-> m_paParms[i].type)713 switch (pFirstMsg->paParms[i].type) 740 714 { 741 715 case VBOX_HGCM_SVC_PARM_32BIT: 742 paParms[i].u.uint32 = pFirstMsg-> m_paParms[i].u.uint32;716 paParms[i].u.uint32 = pFirstMsg->paParms[i].u.uint32; 743 717 break; 744 718 745 719 case VBOX_HGCM_SVC_PARM_64BIT: 746 paParms[i].u.uint64 = pFirstMsg-> m_paParms[i].u.uint64;720 paParms[i].u.uint64 = pFirstMsg->paParms[i].u.uint64; 747 721 break; 748 722 749 723 case VBOX_HGCM_SVC_PARM_PTR: 750 724 { 751 uint32_t const cbSrc = pFirstMsg-> m_paParms[i].u.pointer.size;725 uint32_t const cbSrc = pFirstMsg->paParms[i].u.pointer.size; 752 726 uint32_t const cbDst = paParms[i].u.pointer.size; 753 727 paParms[i].u.pointer.size = cbSrc; /** @todo Check if this is safe in other layers... 754 728 * Update: Safe, yes, but VMMDevHGCM doesn't pass it along. */ 755 729 if (cbSrc <= cbDst) 756 memcpy(paParms[i].u.pointer.addr, pFirstMsg-> m_paParms[i].u.pointer.addr, cbSrc);730 memcpy(paParms[i].u.pointer.addr, pFirstMsg->paParms[i].u.pointer.addr, cbSrc); 757 731 else 758 732 { … … 764 738 765 739 default: 766 AssertMsgFailed(("#%u: %u\n", i, pFirstMsg-> m_paParms[i].type));740 AssertMsgFailed(("#%u: %u\n", i, pFirstMsg->paParms[i].type)); 767 741 rc = VERR_INTERNAL_ERROR; 768 742 break; … … 777 751 rc = g_pHelpers->pfnCallComplete(hCall, rc); 778 752 779 LogFlowFunc(("[Client %RU32] pfnCallComplete -> %Rrc\n", pClient-> uClientID, rc));753 LogFlowFunc(("[Client %RU32] pfnCallComplete -> %Rrc\n", pClient->State.uClientID, rc)); 780 754 781 755 if (rc != VERR_CANCELLED) … … 788 762 } 789 763 790 LogFlowFunc(("[Client %RU32] Returning %Rrc\n", pClient-> uClientID, rc));764 LogFlowFunc(("[Client %RU32] Returning %Rrc\n", pClient->State.uClientID, rc)); 791 765 return rc; 792 766 } … … 795 769 paParms[0].u.uint32 = 0; 796 770 paParms[1].u.uint32 = 0; 797 LogFlowFunc(("[Client %RU32] -> VERR_TRY_AGAIN\n", pClient-> uClientID));771 LogFlowFunc(("[Client %RU32] -> VERR_TRY_AGAIN\n", pClient->State.uClientID)); 798 772 return VERR_TRY_AGAIN; 799 773 } … … 813 787 if (pClient->Pending.uType) 814 788 { 815 LogFunc(("[Client %RU32] Waking up ...\n", pClient-> uClientID));789 LogFunc(("[Client %RU32] Waking up ...\n", pClient->State.uClientID)); 816 790 817 791 rc = VINF_SUCCESS; … … 823 797 { 824 798 LogFunc(("[Client %RU32] Current host message is %RU32 (%s), cParms=%RU32\n", 825 pClient-> uClientID, pFirstMsg->m_uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->m_uMsg),826 pFirstMsg-> m_cParms));799 pClient->State.uClientID, pFirstMsg->uMsg, VBoxClipboardHostMsgToStr(pFirstMsg->uMsg), 800 pFirstMsg->cParms)); 827 801 828 802 bool fDonePending = false; … … 861 835 } 862 836 else 863 AssertMsgFailed(("Waking up client ID=%RU32 with no host message in queue is a bad idea\n", pClient-> uClientID));837 AssertMsgFailed(("Waking up client ID=%RU32 with no host message in queue is a bad idea\n", pClient->State.uClientID)); 864 838 865 839 return rc; 866 840 } 867 841 else 868 LogFunc(("[Client %RU32] Not in pending state, skipping wakeup\n", pClient-> uClientID));842 LogFunc(("[Client %RU32] Not in pending state, skipping wakeup\n", pClient->State.uClientID)); 869 843 870 844 return VINF_NO_CHANGE; … … 894 868 const SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); 895 869 896 HGCMSvcSetU32(&pMsgReadData->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent)); 897 HGCMSvcSetU32(&pMsgReadData->m_paParms[1], pDataReq->uFmt); 898 HGCMSvcSetU32(&pMsgReadData->m_paParms[2], pClient->State.cbChunkSize); 870 HGCMSvcSetU32(&pMsgReadData->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 871 pClient->Events.uID, uEvent)); 872 HGCMSvcSetU32(&pMsgReadData->paParms[1], pDataReq->uFmt); 873 HGCMSvcSetU32(&pMsgReadData->paParms[2], pClient->State.cbChunkSize); 899 874 900 875 rc = sharedClipboardSvcMsgAdd(pClient, pMsgReadData, true /* fAppend */); … … 964 939 SHCLEVENTID uEvent = SharedClipboardEventIDGenerate(&pClient->Events); 965 940 966 HGCMSvcSetU32(&pMsg->m_paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->Events.uID, uEvent)); 967 HGCMSvcSetU32(&pMsg->m_paParms[1], pFormats->uFormats); 968 HGCMSvcSetU32(&pMsg->m_paParms[2], 0 /* fFlags */); 941 HGCMSvcSetU32(&pMsg->paParms[0], VBOX_SHARED_CLIPBOARD_CONTEXTID_MAKE(pClient->State.uSessionID, 942 pClient->Events.uID, uEvent)); 943 HGCMSvcSetU32(&pMsg->paParms[1], pFormats->uFormats); 944 HGCMSvcSetU32(&pMsg->paParms[2], 0 /* fFlags */); 969 945 970 946 rc = sharedClipboardSvcMsgAdd(pClient, pMsg, true /* fAppend */); … … 1072 1048 pClient->State.enmSource = enmSource; 1073 1049 1074 LogFlowFunc(("Source of client %RU32 is now %RU32\n", pClient->State.u 32ClientID, pClient->State.enmSource));1050 LogFlowFunc(("Source of client %RU32 is now %RU32\n", pClient->State.uClientID, pClient->State.enmSource)); 1075 1051 1076 1052 VBoxSvcClipboardUnlock(); … … 1080 1056 return rc; 1081 1057 } 1082 1083 #ifdef VBOX_WITH_SHARED_CLIPBOARD_URI_LIST1084 int sharedClipboardSvcURITransferStart(PSHCLCLIENT pClient,1085 SHCLURITRANSFERDIR enmDir, SHCLSOURCE enmSource,1086 PSHCLURITRANSFER *ppTransfer)1087 {1088 LogFlowFuncEnter();1089 1090 SharedClipboardURICtxTransfersCleanup(&pClient->URI);1091 1092 int rc;1093 1094 if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI))1095 {1096 PSHCLURITRANSFER pTransfer;1097 rc = SharedClipboardURITransferCreate(enmDir, enmSource, &pTransfer);1098 if (RT_SUCCESS(rc))1099 {1100 SHCLPROVIDERCREATIONCTX creationCtx;1101 RT_ZERO(creationCtx);1102 1103 if (enmDir == SHCLURITRANSFERDIR_READ)1104 {1105 rc = sharedClipboardSvcURIAreaRegister(&pClient->State, pTransfer);1106 if (RT_SUCCESS(rc))1107 {1108 creationCtx.enmSource = pClient->State.enmSource;1109 1110 creationCtx.Interface.pfnTransferOpen = sharedClipboardSvcURITransferOpen;1111 creationCtx.Interface.pfnTransferClose = sharedClipboardSvcURITransferClose;1112 creationCtx.Interface.pfnListOpen = sharedClipboardSvcURIListOpen;1113 creationCtx.Interface.pfnListClose = sharedClipboardSvcURIListClose;1114 creationCtx.Interface.pfnObjOpen = sharedClipboardSvcURIObjOpen;1115 creationCtx.Interface.pfnObjClose = sharedClipboardSvcURIObjClose;1116 1117 creationCtx.Interface.pfnGetRoots = sharedClipboardSvcURIGetRoots;1118 creationCtx.Interface.pfnListHdrRead = sharedClipboardSvcURIListHdrRead;1119 creationCtx.Interface.pfnListEntryRead = sharedClipboardSvcURIListEntryRead;1120 creationCtx.Interface.pfnObjRead = sharedClipboardSvcURIObjRead;1121 1122 creationCtx.pvUser = pClient;1123 }1124 }1125 else if (enmDir == SHCLURITRANSFERDIR_WRITE)1126 {1127 AssertFailed(); /** @todo Implement this. */1128 }1129 1130 /* Register needed callbacks so that we can wait for the meta data to arrive here. */1131 SHCLURITRANSFERCALLBACKS Callbacks;1132 RT_ZERO(Callbacks);1133 1134 Callbacks.pvUser = pClient;1135 1136 Callbacks.pfnTransferPrepare = VBoxSvcClipboardURITransferPrepareCallback;1137 Callbacks.pfnTransferComplete = VBoxSvcClipboardURITransferCompleteCallback;1138 Callbacks.pfnTransferCanceled = VBoxSvcClipboardURITransferCanceledCallback;1139 Callbacks.pfnTransferError = VBoxSvcClipboardURITransferErrorCallback;1140 1141 SharedClipboardURITransferSetCallbacks(pTransfer, &Callbacks);1142 1143 rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx);1144 if (RT_SUCCESS(rc))1145 {1146 rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer);1147 if (RT_SUCCESS(rc))1148 rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer);1149 1150 if (RT_FAILURE(rc))1151 SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer);1152 }1153 1154 if (RT_FAILURE(rc))1155 {1156 SharedClipboardURITransferDestroy(pTransfer);1157 pTransfer = NULL;1158 }1159 else1160 {1161 *ppTransfer = pTransfer;1162 }1163 }1164 }1165 else1166 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;1167 1168 LogFlowFuncLeaveRC(rc);1169 return rc;1170 }1171 #endif /* VBOX_WITH_SHARED_CLIPBOARD_URI_LIST */1172 1058 1173 1059 static int svcInit(void) … … 1247 1133 1248 1134 /* Assign the client ID. */ 1249 pClient-> uClientID = u32ClientID;1135 pClient->State.uClientID = u32ClientID; 1250 1136 1251 1137 /* Create the client's own event source. */ 1252 SHCLEVENTSOURCEID uEventSourceID; 1253 int rc = sharedClipboardSvcEventSourceCreateID(&uEventSourceID); 1254 if (RT_SUCCESS(rc)) 1255 rc = SharedClipboardEventSourceCreate(&pClient->Events, uEventSourceID); 1138 int rc = SharedClipboardEventSourceCreate(&pClient->Events, 0 /* ID, ignored */); 1256 1139 if (RT_SUCCESS(rc)) 1257 1140 { … … 1495 1378 if (uFormat == VBOX_SHARED_CLIPBOARD_FMT_URI_LIST) 1496 1379 { 1497 if (!SharedClipboardURICtxTransfersMaximumReached(&pClient->URI)) 1498 { 1499 SharedClipboardURICtxTransfersCleanup(&pClient->URI); 1500 1501 PSHCLURITRANSFER pTransfer; 1502 rc = SharedClipboardURITransferCreate(SHCLURITRANSFERDIR_WRITE, 1503 pClient->State.enmSource, 1504 &pTransfer); 1505 if (RT_SUCCESS(rc)) 1506 { 1507 /* Attach to the most recent clipboard area. */ 1508 rc = sharedClipboardSvcURIAreaAttach(&pClient->State, pTransfer, 0 /* Area ID */); 1509 if (RT_SUCCESS(rc)) 1510 { 1511 SHCLPROVIDERCREATIONCTX creationCtx; 1512 RT_ZERO(creationCtx); 1513 1514 creationCtx.enmSource = SharedClipboardURITransferGetSource(pTransfer); 1515 1516 RT_ZERO(creationCtx.Interface); 1517 1518 creationCtx.Interface.pfnListHdrWrite = sharedClipboardSvcURIListHdrWrite; 1519 creationCtx.Interface.pfnListEntryWrite = sharedClipboardSvcURIListEntryWrite; 1520 creationCtx.Interface.pfnObjWrite = sharedClipboardSvcURIObjWrite; 1521 1522 creationCtx.pvUser = pClient; 1523 1524 rc = SharedClipboardURITransferSetInterface(pTransfer, &creationCtx); 1525 if (RT_SUCCESS(rc)) 1526 rc = SharedClipboardURICtxTransferAdd(&pClient->URI, pTransfer); 1527 } 1528 1529 if (RT_SUCCESS(rc)) 1530 { 1531 rc = SharedClipboardSvcImplURITransferCreate(pClient, pTransfer); 1532 } 1533 else 1534 { 1535 SharedClipboardSvcImplURITransferDestroy(pClient, pTransfer); 1536 SharedClipboardURITransferDestroy(pTransfer); 1537 } 1538 } 1539 } 1540 else 1541 rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED; 1542 1380 rc = sharedClipboardSvcURITransferStart(pClient, SHCLURITRANSFERDIR_WRITE, SHCLSOURCE_LOCAL, 1381 NULL /* pTransfer */); 1543 1382 if (RT_FAILURE(rc)) 1544 LogRel(("Shared Clipboard: Initializing URI host to guest write transfer failed with %Rrc\n", rc));1383 LogRel(("Shared Clipboard: Initializing host write transfer failed with %Rrc\n", rc)); 1545 1384 } 1546 1385 else … … 1645 1484 } 1646 1485 1647 LogFlowFunc(("u32ClientID=%RU32, fDoCallComplete=%RTbool, rc=%Rrc\n", pClient-> uClientID, fDoCallComplete, rc));1486 LogFlowFunc(("u32ClientID=%RU32, fDoCallComplete=%RTbool, rc=%Rrc\n", pClient->State.uClientID, fDoCallComplete, rc)); 1648 1487 1649 1488 if (fDoCallComplete) … … 1668 1507 /* Register the client. 1669 1508 * Note: Do *not* memset the struct, as it contains classes (for caching). */ 1670 pClientState->u 32ClientID = uClientID;1671 pClientState->uProtocolVer 1509 pClientState->uClientID = uClientID; 1510 pClientState->uProtocolVer = 0; 1672 1511 1673 1512 return VINF_SUCCESS; … … 1799 1638 static SSMFIELD const s_aShClSSMClientMsgHdr[] = 1800 1639 { 1801 SSMFIELD_ENTRY(SHCLCLIENTMSG, m_uMsg),1802 SSMFIELD_ENTRY(SHCLCLIENTMSG, m_cParms),1640 SSMFIELD_ENTRY(SHCLCLIENTMSG, uMsg), 1641 SSMFIELD_ENTRY(SHCLCLIENTMSG, cParms), 1803 1642 SSMFIELD_ENTRY_TERM() 1804 1643 }; … … 1851 1690 AssertRCReturn(rc, rc); 1852 1691 1853 rc = SSMR3PutStructEx(pSSM, &pMsg-> m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);1692 rc = SSMR3PutStructEx(pSSM, &pMsg->Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL); 1854 1693 AssertRCReturn(rc, rc); 1855 1694 1856 for (uint32_t p = 0; p < pMsg-> m_cParms; p++)1857 { 1858 rc = HGCMSvcSSMR3Put(&pMsg-> m_paParms[p], pSSM);1695 for (uint32_t p = 0; p < pMsg->cParms; p++) 1696 { 1697 rc = HGCMSvcSSMR3Put(&pMsg->paParms[p], pSSM); 1859 1698 AssertRCReturn(rc, rc); 1860 1699 } … … 1941 1780 AssertRCReturn(rc, rc); 1942 1781 1943 rc = SSMR3GetStructEx(pSSM, &pMsg-> m_Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL);1782 rc = SSMR3GetStructEx(pSSM, &pMsg->Ctx, sizeof(SHCLMSGCTX), 0 /*fFlags*/, &s_aShClSSMClientMsgCtx[0], NULL); 1944 1783 AssertRCReturn(rc, rc); 1945 1784 1946 pMsg-> m_paParms = (PVBOXHGCMSVCPARM)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * pMsg->m_cParms);1947 AssertPtrReturn(pMsg-> m_paParms, VERR_NO_MEMORY);1948 1949 for (uint32_t p = 0; p < pMsg-> m_cParms; p++)1950 { 1951 rc = HGCMSvcSSMR3Get(&pMsg-> m_paParms[p], pSSM);1785 pMsg->paParms = (PVBOXHGCMSVCPARM)RTMemAllocZ(sizeof(VBOXHGCMSVCPARM) * pMsg->cParms); 1786 AssertPtrReturn(pMsg->paParms, VERR_NO_MEMORY); 1787 1788 for (uint32_t p = 0; p < pMsg->cParms; p++) 1789 { 1790 rc = HGCMSvcSSMR3Get(&pMsg->paParms[p], pSSM); 1952 1791 AssertRCReturn(rc, rc); 1953 1792 }
Note:
See TracChangeset
for help on using the changeset viewer.
