VBoxSharedClipboardSvc-transfers.cpp@ 105745

Last change on this file since 105745 was 105635, checked in by vboxsync, 4 months ago
Shared Clipboard: Cleanup: Made a lot more functions static where possible and renamed the non-static ones to indicate its usage.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 86.9 KB

Line
1	/* $Id: VBoxSharedClipboardSvc-transfers.cpp 105635 2024-08-09 09:38:27Z vboxsync $ */
2	/** @file
3	* Shared Clipboard Service - Internal code for transfer (list) handling.
4	*/
5
6	/*
7	* Copyright (C) 2019-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_SHARED_CLIPBOARD
33	#include <VBox/log.h>
34
35	#include <VBox/err.h>
36
37	#include <VBox/GuestHost/clipboard-helper.h>
38	#include <VBox/HostServices/VBoxClipboardSvc.h>
39	#include <VBox/HostServices/VBoxClipboardExt.h>
40
41	#include <VBox/AssertGuest.h>
42	#include <iprt/dir.h>
43	#include <iprt/file.h>
44	#include <iprt/path.h>
45
46	#include <VBox/GuestHost/SharedClipboard-transfers.h>
47
48	#include "VBoxSharedClipboardSvc-internal.h"
49	#include "VBoxSharedClipboardSvc-transfers.h"
50
51
52	/*********************************************************************************************************************************
53	* Externals *
54	*********************************************************************************************************************************/
55	extern uint32_t g_fTransferMode;
56	extern SHCLEXTSTATE g_ExtState;
57	extern PVBOXHGCMSVCHELPERS g_pHelpers;
58	extern ClipboardClientMap g_mapClients;
59	extern ClipboardClientQueue g_listClientsDeferred;
60
61
62	/*********************************************************************************************************************************
63	* Prototypes *
64	*********************************************************************************************************************************/
65	static int shClSvcTransferSendStatusAsync(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS uStatus, int rcTransfer, PSHCLEVENT *ppEvent);
66	static int shClSvcTransferMsgSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM aParms[], uint64_t idCtx, PSHCLLISTOPENPARMS pOpenParms);
67	static int shClSvcTransferMsgSetListClose(uint32_t cParms, VBOXHGCMSVCPARM aParms[], uint64_t idCtx, SHCLLISTHANDLE hList);
68
69
70	/**
71	* Destroys all transfers of a Shared Clipboard client.
72	*
73	* @param pClient Client to destroy transfers for.
74	*/
75	void shClSvcTransferDestroyAll(PSHCLCLIENT pClient)
76	{
77	if (!pClient)
78	return;
79
80	LogFlowFuncEnter();
81
82	/* Unregister and destroy all transfers.
83	* Also make sure to let the backend know that all transfers are getting destroyed.
84	*
85	* Note: The index always will be 0, as the transfer gets unregistered. */
86	PSHCLTRANSFER pTransfer;
87	while ((pTransfer = ShClTransferCtxGetTransferByIndex(&pClient->Transfers.Ctx, 0 /* Index */)))
88	ShClSvcTransferDestroy(pClient, pTransfer);
89	}
90
91	/**
92	* Reads a root list header from the guest, asynchronous version.
93	*
94	* @returns VBox status code.
95	* @param pClient Client to read from.
96	* @param pTransfer Transfer to read root list header for.
97	* @param ppEvent Where to return the event to wait for.
98	* Must be released by the caller with ShClEventRelease().
99	*/
100	int ShClSvcTransferGHRootListReadHdrAsync(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, PSHCLEVENT *ppEvent)
101	{
102	LogFlowFuncEnter();
103
104	int rc;
105
106	PSHCLCLIENTMSG pMsgHdr = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_HDR_READ,
107	VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ_REQ);
108	if (pMsgHdr)
109	{
110	PSHCLEVENT pEvent;
111	rc = ShClEventSourceGenerateAndRegisterEvent(&pTransfer->Events, &pEvent);
112	if (RT_SUCCESS(rc))
113	{
114	HGCMSvcSetU64(&pMsgHdr->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
115	ShClTransferGetID(pTransfer), pEvent->idEvent));
116	HGCMSvcSetU32(&pMsgHdr->aParms[1], 0 /* fRoots */);
117
118	ShClSvcClientLock(pClient);
119
120	ShClSvcClientMsgAdd(pClient, pMsgHdr, true /* fAppend */);
121	rc = ShClSvcClientWakeup(pClient);
122
123	ShClSvcClientUnlock(pClient);
124
125	/* Remove event from list if caller did not request event handle or in case
126	* of failure (in this case caller should not release event). */
127	if ( RT_FAILURE(rc)
128	\|\| !ppEvent)
129	{
130	ShClEventRelease(pEvent);
131	pEvent = NULL;
132	}
133	else if (ppEvent)
134	*ppEvent = pEvent;
135	}
136	else
137	{
138	ShClSvcClientMsgFree(pClient, pMsgHdr);
139	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
140	}
141	}
142	else
143	rc = VERR_NO_MEMORY;
144
145	LogFlowFuncLeaveRC(rc);
146	return rc;
147	}
148
149	/**
150	* Reads a root list header from the guest.
151	*
152	* @returns VBox status code.
153	* @param pClient Client to read from.
154	* @param pTransfer Transfer to read root list header for.
155	* @param pHdr Where to store the root list header on succeess.
156	*/
157	int ShClSvcTransferGHRootListReadHdr(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, PSHCLLISTHDR pHdr)
158	{
159	PSHCLEVENT pEvent;
160	int rc = ShClSvcTransferGHRootListReadHdrAsync(pClient, pTransfer, &pEvent);
161	if (RT_SUCCESS(rc))
162	{
163	int rcEvent;
164	PSHCLEVENTPAYLOAD pPayload;
165	rc = ShClEventWaitEx(pEvent, pTransfer->uTimeoutMs, &rcEvent, &pPayload);
166	if (RT_SUCCESS(rc))
167	{
168	Assert(pPayload->cbData == sizeof(SHCLLISTHDR));
169
170	memcpy(pHdr, (PSHCLLISTHDR)pPayload->pvData, sizeof(SHCLLISTHDR));
171
172	LogFlowFunc(("cRoots=%RU32, fFeatures=0x%x\n", pHdr->cEntries, pHdr->fFeatures));
173
174	ShClPayloadFree(pPayload);
175	}
176	else
177	rc = rcEvent;
178
179	ShClEventRelease(pEvent);
180	pEvent = NULL;
181	}
182
183	LogFlowFuncLeaveRC(rc);
184	return rc;
185	}
186
187	/**
188	* Reads a root list entry from the guest, asynchronous version.
189	*
190	* @returns VBox status code.
191	* @param pClient Client to read from.
192	* @param pTransfer Transfer to read root list header for.
193	* @param idxEntry Index of entry to read.
194	* @param ppEvent Where to return the event to wait for.
195	* Must be released by the caller with ShClEventRelease().
196	*/
197	int ShClSvcTransferGHRootListReadEntryAsync(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, uint64_t idxEntry,
198	PSHCLEVENT *ppEvent)
199	{
200	LogFlowFuncEnter();
201
202	PSHCLCLIENTMSG pMsgEntry = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_ROOT_LIST_ENTRY_READ,
203	VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ_REQ);
204	PSHCLEVENT pEvent;
205	int rc = ShClEventSourceGenerateAndRegisterEvent(&pTransfer->Events, &pEvent);
206	if (RT_SUCCESS(rc))
207	{
208	HGCMSvcSetU64(&pMsgEntry->aParms[0],
209	VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uClientID, ShClTransferGetID(pTransfer), pEvent->idEvent));
210	HGCMSvcSetU32(&pMsgEntry->aParms[1], 0 /* fFeatures */);
211	HGCMSvcSetU64(&pMsgEntry->aParms[2], idxEntry /* uIndex */);
212
213	ShClSvcClientLock(pClient);
214
215	ShClSvcClientMsgAdd(pClient, pMsgEntry, true /* fAppend */);
216	rc = ShClSvcClientWakeup(pClient);
217
218	ShClSvcClientUnlock(pClient);
219
220	/* Remove event from list if caller did not request event handle or in case
221	* of failure (in this case caller should not release event). */
222	if ( RT_FAILURE(rc)
223	\|\| !ppEvent)
224	{
225	ShClEventRelease(pEvent);
226	pEvent = NULL;
227	}
228	else if (ppEvent)
229	*ppEvent = pEvent;
230	}
231	else
232	rc = VERR_NO_MEMORY;
233
234	LogFlowFuncLeave();
235	return rc;
236	}
237
238	/**
239	* Reads a root list entry from the guest.
240	*
241	* @returns VBox status code.
242	* @param pClient Client to read from.
243	* @param pTransfer Transfer to read root list header for.
244	* @param idxEntry Index of entry to read.
245	* @param ppListEntry Where to return the allocated root list entry.
246	*/
247	int ShClSvcTransferGHRootListReadEntry(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, uint64_t idxEntry,
248	PSHCLLISTENTRY *ppListEntry)
249	{
250	AssertPtrReturn(ppListEntry, VERR_INVALID_POINTER);
251
252	PSHCLEVENT pEvent;
253	int rc = ShClSvcTransferGHRootListReadEntryAsync(pClient, pTransfer, idxEntry, &pEvent);
254	if (RT_SUCCESS(rc))
255	{
256	int rcEvent;
257	PSHCLEVENTPAYLOAD pPayload;
258	rc = ShClEventWaitEx(pEvent, pTransfer->uTimeoutMs, &rcEvent, &pPayload);
259	if (RT_SUCCESS(rc))
260	{
261	ppListEntry = (PSHCLLISTENTRY)pPayload->pvData; / ppLisEntry own pPayload-pvData now. */
262	}
263	else
264	rc = rcEvent;
265
266	ShClEventRelease(pEvent);
267	pEvent = NULL;
268	}
269
270	LogFlowFuncLeaveRC(rc);
271	return rc;
272	}
273
274
275	/*********************************************************************************************************************************
276	* Provider interface implementation *
277	*********************************************************************************************************************************/
278
279	/** @copydoc SHCLTXPROVIDERIFACE::pfnRootListRead */
280	DECLCALLBACK(int) ShClSvcTransferIfaceGHRootListRead(PSHCLTXPROVIDERCTX pCtx)
281	{
282	LogFlowFuncEnter();
283
284	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
285	AssertPtr(pClient);
286
287	SHCLLISTHDR Hdr;
288	int rc = ShClSvcTransferGHRootListReadHdr(pClient, pCtx->pTransfer, &Hdr);
289	if (RT_SUCCESS(rc))
290	{
291	for (uint64_t i = 0; i < Hdr.cEntries; i++)
292	{
293	PSHCLLISTENTRY pEntry;
294	rc = ShClSvcTransferGHRootListReadEntry(pClient, pCtx->pTransfer, i, &pEntry);
295	if (RT_SUCCESS(rc))
296	rc = ShClTransferListAddEntry(&pCtx->pTransfer->lstRoots, pEntry, true /* fAppend */);
297
298	if (RT_FAILURE(rc))
299	break;
300	}
301	}
302
303	LogFlowFuncLeave();
304	return rc;
305	}
306
307	/** @copydoc SHCLTXPROVIDERIFACE::pfnListOpen */
308	DECLCALLBACK(int) ShClSvcTransferIfaceGHListOpen(PSHCLTXPROVIDERCTX pCtx,
309	PSHCLLISTOPENPARMS pOpenParms, PSHCLLISTHANDLE phList)
310	{
311	LogFlowFuncEnter();
312
313	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
314	AssertPtr(pClient);
315
316	int rc;
317
318	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_OPEN,
319	VBOX_SHCL_CPARMS_LIST_OPEN);
320	if (pMsg)
321	{
322	PSHCLEVENT pEvent;
323	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
324	if (RT_SUCCESS(rc))
325	{
326	pMsg->idCtx = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
327	pEvent->idEvent);
328
329	rc = ShClTransferTransformPath(pOpenParms->pszPath, pOpenParms->cbPath);
330	if (RT_SUCCESS(rc))
331	rc = shClSvcTransferMsgSetListOpen(pMsg->cParms, pMsg->aParms, pMsg->idCtx, pOpenParms);
332	if (RT_SUCCESS(rc))
333	{
334	ShClSvcClientLock(pClient);
335
336	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
337	rc = ShClSvcClientWakeup(pClient);
338
339	ShClSvcClientUnlock(pClient);
340
341	if (RT_SUCCESS(rc))
342	{
343	int rcEvent;
344	PSHCLEVENTPAYLOAD pPayload;
345	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
346	if (RT_SUCCESS(rc))
347	{
348	Assert(pPayload->cbData == sizeof(SHCLREPLY));
349
350	PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
351	AssertPtr(pReply);
352
353	Assert(pReply->uType == VBOX_SHCL_TX_REPLYMSGTYPE_LIST_OPEN);
354
355	LogFlowFunc(("hList=%RU64\n", pReply->u.ListOpen.uHandle));
356
357	*phList = pReply->u.ListOpen.uHandle;
358
359	ShClPayloadFree(pPayload);
360	}
361	else
362	rc = rcEvent;
363	}
364	}
365
366	ShClEventRelease(pEvent);
367	}
368	else
369	{
370	ShClSvcClientMsgFree(pClient, pMsg);
371	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
372	}
373	}
374	else
375	rc = VERR_NO_MEMORY;
376
377	LogFlowFuncLeaveRC(rc);
378	return rc;
379	}
380
381	/** @copydoc SHCLTXPROVIDERIFACE::pfnListClose */
382	DECLCALLBACK(int) ShClSvcTransferIfaceGHListClose(PSHCLTXPROVIDERCTX pCtx, SHCLLISTHANDLE hList)
383	{
384	LogFlowFuncEnter();
385
386	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
387	AssertPtr(pClient);
388
389	int rc;
390
391	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_CLOSE,
392	VBOX_SHCL_CPARMS_LIST_CLOSE);
393	if (pMsg)
394	{
395	PSHCLEVENT pEvent;
396	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
397	if (RT_SUCCESS(rc))
398	{
399	pMsg->idCtx = VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, pCtx->pTransfer->State.uID,
400	pEvent->idEvent);
401
402	rc = shClSvcTransferMsgSetListClose(pMsg->cParms, pMsg->aParms, pMsg->idCtx, hList);
403	if (RT_SUCCESS(rc))
404	{
405	ShClSvcClientLock(pClient);
406
407	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
408	rc = ShClSvcClientWakeup(pClient);
409
410	ShClSvcClientUnlock(pClient);
411
412	if (RT_SUCCESS(rc))
413	{
414	int rcEvent;
415	PSHCLEVENTPAYLOAD pPayload;
416	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
417	if (RT_SUCCESS(rc))
418	{
419	ShClPayloadFree(pPayload);
420	}
421	else
422	rc = rcEvent;
423	}
424	}
425
426	ShClEventRelease(pEvent);
427	}
428	else
429	{
430	ShClSvcClientMsgFree(pClient, pMsg);
431	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
432	}
433	}
434	else
435	rc = VERR_NO_MEMORY;
436
437	LogFlowFuncLeaveRC(rc);
438	return rc;
439	}
440
441	/** @copydoc SHCLTXPROVIDERIFACE::pfnListHdrRead */
442	DECLCALLBACK(int) ShClSvcTransferIfaceGHListHdrRead(PSHCLTXPROVIDERCTX pCtx,
443	SHCLLISTHANDLE hList, PSHCLLISTHDR pListHdr)
444	{
445	LogFlowFuncEnter();
446
447	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
448	AssertPtr(pClient);
449
450	int rc;
451
452	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_HDR_READ,
453	VBOX_SHCL_CPARMS_LIST_HDR_READ_REQ);
454	if (pMsg)
455	{
456	PSHCLEVENT pEvent;
457	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
458	if (RT_SUCCESS(rc))
459	{
460	HGCMSvcSetU64(&pMsg->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
461	pCtx->pTransfer->State.uID, pEvent->idEvent));
462	HGCMSvcSetU64(&pMsg->aParms[1], hList);
463	HGCMSvcSetU32(&pMsg->aParms[2], 0 /* fFlags */);
464
465	ShClSvcClientLock(pClient);
466
467	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
468	rc = ShClSvcClientWakeup(pClient);
469
470	ShClSvcClientUnlock(pClient);
471
472	if (RT_SUCCESS(rc))
473	{
474	int rcEvent;
475	PSHCLEVENTPAYLOAD pPayload;
476	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
477	if (RT_SUCCESS(rc))
478	{
479	Assert(pPayload->cbData == sizeof(SHCLLISTHDR));
480
481	pListHdr = (PSHCLLISTHDR)pPayload->pvData;
482
483	ShClPayloadFree(pPayload);
484	}
485	else
486	rc = rcEvent;
487	}
488
489	ShClEventRelease(pEvent);
490	}
491	else
492	{
493	ShClSvcClientMsgFree(pClient, pMsg);
494	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
495	}
496	}
497	else
498	rc = VERR_NO_MEMORY;
499
500	LogFlowFuncLeaveRC(rc);
501	return rc;
502	}
503
504	/** @copydoc SHCLTXPROVIDERIFACE::pfnListEntryRead */
505	DECLCALLBACK(int) ShClSvcTransferIfaceGHListEntryRead(PSHCLTXPROVIDERCTX pCtx,
506	SHCLLISTHANDLE hList, PSHCLLISTENTRY pListEntry)
507	{
508	LogFlowFuncEnter();
509
510	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
511	AssertPtr(pClient);
512
513	int rc;
514
515	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_LIST_ENTRY_READ,
516	VBOX_SHCL_CPARMS_LIST_ENTRY_READ);
517	if (pMsg)
518	{
519	PSHCLEVENT pEvent;
520	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
521	if (RT_SUCCESS(rc))
522	{
523	HGCMSvcSetU64(&pMsg->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
524	pCtx->pTransfer->State.uID, pEvent->idEvent));
525	HGCMSvcSetU64(&pMsg->aParms[1], hList);
526	HGCMSvcSetU32(&pMsg->aParms[2], 0 /* fInfo */);
527
528	ShClSvcClientLock(pClient);
529
530	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
531	rc = ShClSvcClientWakeup(pClient);
532
533	ShClSvcClientUnlock(pClient);
534
535	if (RT_SUCCESS(rc))
536	{
537	int rcEvent;
538	PSHCLEVENTPAYLOAD pPayload;
539	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
540	if (RT_SUCCESS(rc))
541	{
542	Assert(pPayload->cbData == sizeof(SHCLLISTENTRY));
543
544	rc = ShClTransferListEntryCopy(pListEntry, (PSHCLLISTENTRY)pPayload->pvData);
545
546	ShClPayloadFree(pPayload);
547	}
548	else
549	rc = rcEvent;
550	}
551
552	ShClEventRelease(pEvent);
553	}
554	else
555	{
556	ShClSvcClientMsgFree(pClient, pMsg);
557	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
558	}
559	}
560	else
561	rc = VERR_NO_MEMORY;
562
563	LogFlowFuncLeaveRC(rc);
564	return rc;
565	}
566
567	/** @copydoc SHCLTXPROVIDERIFACE::pfnObjOpen */
568	DECLCALLBACK(int) ShClSvcTransferIfaceGHObjOpen(PSHCLTXPROVIDERCTX pCtx, PSHCLOBJOPENCREATEPARMS pCreateParms, PSHCLOBJHANDLE phObj)
569	{
570	LogFlowFuncEnter();
571
572	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
573	AssertPtr(pClient);
574
575	int rc;
576
577	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_OPEN,
578	VBOX_SHCL_CPARMS_OBJ_OPEN);
579	if (pMsg)
580	{
581	PSHCLEVENT pEvent;
582	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
583	if (RT_SUCCESS(rc))
584	{
585	LogFlowFunc(("pszPath=%s, fCreate=0x%x\n", pCreateParms->pszPath, pCreateParms->fCreate));
586
587	rc = ShClTransferTransformPath(pCreateParms->pszPath, pCreateParms->cbPath);
588	if (RT_SUCCESS(rc))
589	{
590	const uint32_t cbPath = (uint32_t)strlen(pCreateParms->pszPath) + 1; /* Include terminating zero */
591
592	HGCMSvcSetU64(&pMsg->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
593	pCtx->pTransfer->State.uID, pEvent->idEvent));
594	HGCMSvcSetU64(&pMsg->aParms[1], 0); /* uHandle */
595	HGCMSvcSetPv (&pMsg->aParms[2], pCreateParms->pszPath, cbPath);
596	HGCMSvcSetU32(&pMsg->aParms[3], pCreateParms->fCreate);
597
598	ShClSvcClientLock(pClient);
599
600	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
601	rc = ShClSvcClientWakeup(pClient);
602
603	ShClSvcClientUnlock(pClient);
604
605	if (RT_SUCCESS(rc))
606	{
607	int rcEvent;
608	PSHCLEVENTPAYLOAD pPayload;
609	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
610	if (RT_SUCCESS(rc))
611	{
612	Assert(pPayload->cbData == sizeof(SHCLREPLY));
613
614	PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
615	AssertPtr(pReply);
616
617	Assert(pReply->uType == VBOX_SHCL_TX_REPLYMSGTYPE_OBJ_OPEN);
618
619	LogFlowFunc(("hObj=%RU64\n", pReply->u.ObjOpen.uHandle));
620
621	*phObj = pReply->u.ObjOpen.uHandle;
622
623	ShClPayloadFree(pPayload);
624	}
625	else
626	rc = rcEvent;
627	}
628	}
629
630	ShClEventRelease(pEvent);
631	}
632	else
633	{
634	ShClSvcClientMsgFree(pClient, pMsg);
635	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
636	}
637	}
638	else
639	rc = VERR_NO_MEMORY;
640
641	LogFlowFuncLeaveRC(rc);
642	return rc;
643	}
644
645	/** @copydoc SHCLTXPROVIDERIFACE::pfnObjClose */
646	DECLCALLBACK(int) ShClSvcTransferIfaceGHObjClose(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj)
647	{
648	LogFlowFuncEnter();
649
650	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
651	AssertPtr(pClient);
652
653	int rc;
654
655	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_CLOSE,
656	VBOX_SHCL_CPARMS_OBJ_CLOSE);
657	if (pMsg)
658	{
659	PSHCLEVENT pEvent;
660	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
661	if (RT_SUCCESS(rc))
662	{
663	HGCMSvcSetU64(&pMsg->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
664	pCtx->pTransfer->State.uID, pEvent->idEvent));
665	HGCMSvcSetU64(&pMsg->aParms[1], hObj);
666
667	ShClSvcClientLock(pClient);
668
669	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
670	rc = ShClSvcClientWakeup(pClient);
671
672	ShClSvcClientUnlock(pClient);
673
674	if (RT_SUCCESS(rc))
675	{
676	int rcEvent;
677	PSHCLEVENTPAYLOAD pPayload;
678	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
679	if (RT_SUCCESS(rc))
680	{
681	Assert(pPayload->cbData == sizeof(SHCLREPLY));
682	#ifdef VBOX_STRICT
683	PSHCLREPLY pReply = (PSHCLREPLY)pPayload->pvData;
684	AssertPtr(pReply);
685
686	Assert(pReply->uType == VBOX_SHCL_TX_REPLYMSGTYPE_OBJ_CLOSE);
687
688	LogFlowFunc(("hObj=%RU64\n", pReply->u.ObjClose.uHandle));
689	#endif
690	ShClPayloadFree(pPayload);
691	}
692	else
693	rc = rcEvent;
694	}
695
696	ShClEventRelease(pEvent);
697	}
698	else
699	{
700	ShClSvcClientMsgFree(pClient, pMsg);
701	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
702	}
703	}
704	else
705	rc = VERR_NO_MEMORY;
706
707	LogFlowFuncLeaveRC(rc);
708	return rc;
709	}
710
711	/** @copydoc SHCLTXPROVIDERIFACE::pfnObjRead */
712	DECLCALLBACK(int) ShClSvcTransferIfaceGHObjRead(PSHCLTXPROVIDERCTX pCtx, SHCLOBJHANDLE hObj,
713	void pvData, uint32_t cbData, uint32_t fFlags, uint32_t pcbRead)
714	{
715	LogFlowFuncEnter();
716
717	PSHCLCLIENT pClient = (PSHCLCLIENT)pCtx->pvUser;
718	AssertPtr(pClient);
719
720	int rc;
721
722	PSHCLCLIENTMSG pMsg = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_OBJ_READ,
723	VBOX_SHCL_CPARMS_OBJ_READ_REQ);
724	if (pMsg)
725	{
726	PSHCLEVENT pEvent;
727	rc = ShClEventSourceGenerateAndRegisterEvent(&pCtx->pTransfer->Events, &pEvent);
728	if (RT_SUCCESS(rc))
729	{
730	HGCMSvcSetU64(&pMsg->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID,
731	pCtx->pTransfer->State.uID, pEvent->idEvent));
732	HGCMSvcSetU64(&pMsg->aParms[1], hObj);
733	HGCMSvcSetU32(&pMsg->aParms[2], cbData);
734	HGCMSvcSetU32(&pMsg->aParms[3], fFlags);
735
736	ShClSvcClientLock(pClient);
737
738	ShClSvcClientMsgAdd(pClient, pMsg, true /* fAppend */);
739	rc = ShClSvcClientWakeup(pClient);
740
741	ShClSvcClientUnlock(pClient);
742
743	if (RT_SUCCESS(rc))
744	{
745	PSHCLEVENTPAYLOAD pPayload;
746	int rcEvent;
747	rc = ShClEventWaitEx(pEvent, pCtx->pTransfer->uTimeoutMs, &rcEvent, &pPayload);
748	if (RT_SUCCESS(rc))
749	{
750	Assert(pPayload->cbData == sizeof(SHCLOBJDATACHUNK));
751
752	PSHCLOBJDATACHUNK pDataChunk = (PSHCLOBJDATACHUNK)pPayload->pvData;
753	AssertPtr(pDataChunk);
754
755	const uint32_t cbRead = RT_MIN(cbData, pDataChunk->cbData);
756
757	memcpy(pvData, pDataChunk->pvData, cbRead);
758
759	if (pcbRead)
760	*pcbRead = cbRead;
761
762	ShClPayloadFree(pPayload);
763	}
764	else
765	rc = rcEvent;
766	}
767
768	ShClEventRelease(pEvent);
769	}
770	else
771	{
772	ShClSvcClientMsgFree(pClient, pMsg);
773	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
774	}
775	}
776	else
777	rc = VERR_NO_MEMORY;
778
779	LogFlowFuncLeaveRC(rc);
780	return rc;
781	}
782
783
784	/*********************************************************************************************************************************
785	* HGCM getters / setters *
786	*********************************************************************************************************************************/
787
788	/**
789	* Returns whether a HGCM message is allowed in a certain service mode or not.
790	*
791	* @returns \c true if message is allowed, \c false if not.
792	* @param uMode Service mode to check allowance for.
793	* @param uMsg HGCM message to check allowance for.
794	*/
795	bool shClSvcTransferMsgIsAllowed(uint32_t uMode, uint32_t uMsg)
796	{
797	const bool fHostToGuest = uMode == VBOX_SHCL_MODE_HOST_TO_GUEST
798	\|\| uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
799
800	const bool fGuestToHost = uMode == VBOX_SHCL_MODE_GUEST_TO_HOST
801	\|\| uMode == VBOX_SHCL_MODE_BIDIRECTIONAL;
802
803	bool fAllowed = false; /* If in doubt, don't allow. */
804
805	switch (uMsg)
806	{
807	case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE:
808	RT_FALL_THROUGH();
809	case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
810	RT_FALL_THROUGH();
811	case VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE:
812	RT_FALL_THROUGH();
813	case VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE:
814	RT_FALL_THROUGH();
815	case VBOX_SHCL_GUEST_FN_OBJ_WRITE:
816	fAllowed = fGuestToHost;
817	break;
818
819	case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
820	RT_FALL_THROUGH();
821	case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
822	RT_FALL_THROUGH();
823	case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
824	RT_FALL_THROUGH();
825	case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
826	RT_FALL_THROUGH();
827	case VBOX_SHCL_GUEST_FN_OBJ_READ:
828	fAllowed = fHostToGuest;
829	break;
830
831	case VBOX_SHCL_GUEST_FN_CONNECT:
832	RT_FALL_THROUGH();
833	case VBOX_SHCL_GUEST_FN_NEGOTIATE_CHUNK_SIZE:
834	RT_FALL_THROUGH();
835	case VBOX_SHCL_GUEST_FN_MSG_PEEK_WAIT:
836	RT_FALL_THROUGH();
837	case VBOX_SHCL_GUEST_FN_MSG_PEEK_NOWAIT:
838	RT_FALL_THROUGH();
839	case VBOX_SHCL_GUEST_FN_REPORT_FEATURES:
840	RT_FALL_THROUGH();
841	case VBOX_SHCL_GUEST_FN_QUERY_FEATURES:
842	RT_FALL_THROUGH();
843	case VBOX_SHCL_GUEST_FN_MSG_GET:
844	RT_FALL_THROUGH();
845	case VBOX_SHCL_GUEST_FN_REPLY:
846	RT_FALL_THROUGH();
847	case VBOX_SHCL_GUEST_FN_MSG_CANCEL:
848	RT_FALL_THROUGH();
849	case VBOX_SHCL_GUEST_FN_ERROR:
850	RT_FALL_THROUGH();
851	case VBOX_SHCL_GUEST_FN_LIST_OPEN:
852	RT_FALL_THROUGH();
853	case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
854	RT_FALL_THROUGH();
855	case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
856	RT_FALL_THROUGH();
857	case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
858	fAllowed = fHostToGuest \|\| fGuestToHost;
859	break;
860
861	default:
862	break;
863	}
864
865	LogFlowFunc(("uMsg=%RU32 (%s), uMode=%RU32 -> fAllowed=%RTbool\n", uMsg, ShClGuestMsgToStr(uMsg), uMode, fAllowed));
866	return fAllowed;
867	}
868
869	/**
870	* Gets a transfer message reply from HGCM service parameters.
871	*
872	* @returns VBox status code.
873	* @param cParms Number of HGCM parameters supplied in \a aParms.
874	* @param aParms Array of HGCM parameters.
875	* @param pReply Where to store the reply.
876	*/
877	static int shClSvcTransferMsgGetReply(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
878	PSHCLREPLY pReply)
879	{
880	int rc;
881
882	if (cParms >= VBOX_SHCL_CPARMS_REPLY_MIN)
883	{
884	/* aParms[0] has the context ID. */
885	rc = HGCMSvcGetU32(&aParms[1], &pReply->uType);
886	if (RT_SUCCESS(rc))
887	rc = HGCMSvcGetU32(&aParms[2], &pReply->rc);
888	if (RT_SUCCESS(rc))
889	rc = HGCMSvcGetPv(&aParms[3], &pReply->pvPayload, &pReply->cbPayload);
890
891	if (RT_SUCCESS(rc))
892	{
893	rc = VERR_INVALID_PARAMETER; /* Play safe. */
894
895	const unsigned idxParm = VBOX_SHCL_CPARMS_REPLY_MIN;
896
897	switch (pReply->uType)
898	{
899	case VBOX_SHCL_TX_REPLYMSGTYPE_TRANSFER_STATUS:
900	{
901	if (cParms > idxParm)
902	rc = HGCMSvcGetU32(&aParms[idxParm], &pReply->u.TransferStatus.uStatus);
903
904	LogFlowFunc(("uTransferStatus=%RU32 (%s)\n",
905	pReply->u.TransferStatus.uStatus, ShClTransferStatusToStr(pReply->u.TransferStatus.uStatus)));
906	break;
907	}
908
909	case VBOX_SHCL_TX_REPLYMSGTYPE_LIST_OPEN:
910	{
911	if (cParms > idxParm)
912	rc = HGCMSvcGetU64(&aParms[idxParm], &pReply->u.ListOpen.uHandle);
913
914	LogFlowFunc(("hListOpen=%RU64\n", pReply->u.ListOpen.uHandle));
915	break;
916	}
917
918	case VBOX_SHCL_TX_REPLYMSGTYPE_LIST_CLOSE:
919	{
920	if (cParms > idxParm)
921	rc = HGCMSvcGetU64(&aParms[idxParm], &pReply->u.ListClose.uHandle);
922
923	LogFlowFunc(("hListClose=%RU64\n", pReply->u.ListClose.uHandle));
924	break;
925	}
926
927	case VBOX_SHCL_TX_REPLYMSGTYPE_OBJ_OPEN:
928	{
929	if (cParms > idxParm)
930	rc = HGCMSvcGetU64(&aParms[idxParm], &pReply->u.ObjOpen.uHandle);
931
932	LogFlowFunc(("hObjOpen=%RU64\n", pReply->u.ObjOpen.uHandle));
933	break;
934	}
935
936	case VBOX_SHCL_TX_REPLYMSGTYPE_OBJ_CLOSE:
937	{
938	if (cParms > idxParm)
939	rc = HGCMSvcGetU64(&aParms[idxParm], &pReply->u.ObjClose.uHandle);
940
941	LogFlowFunc(("hObjClose=%RU64\n", pReply->u.ObjClose.uHandle));
942	break;
943	}
944
945	default:
946	rc = VERR_NOT_SUPPORTED;
947	break;
948	}
949	}
950	}
951	else
952	rc = VERR_INVALID_PARAMETER;
953
954	LogFlowFuncLeaveRC(rc);
955	return rc;
956	}
957
958	/**
959	* Gets a transfer root list header from HGCM service parameters.
960	*
961	* @returns VBox status code.
962	* @param cParms Number of HGCM parameters supplied in \a aParms.
963	* @param aParms Array of HGCM parameters.
964	* @param pRootLstHdr Where to store the transfer root list header on success.
965	*/
966	static int shClSvcTransferMsgGetRootListHdr(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
967	PSHCLLISTHDR pRootLstHdr)
968	{
969	int rc;
970
971	if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_HDR_WRITE)
972	{
973	rc = HGCMSvcGetU32(&aParms[1], &pRootLstHdr->fFeatures);
974	if (RT_SUCCESS(rc))
975	rc = HGCMSvcGetU64(&aParms[2], &pRootLstHdr->cEntries);
976	}
977	else
978	rc = VERR_INVALID_PARAMETER;
979
980	LogFlowFuncLeaveRC(rc);
981	return rc;
982	}
983
984	/**
985	* Gets a transfer root list entry from HGCM service parameters.
986	*
987	* @returns VBox status code.
988	* @param cParms Number of HGCM parameters supplied in \a aParms.
989	* @param aParms Array of HGCM parameters.
990	* @param pListEntry Where to store the root list entry.
991	*/
992	static int shClSvcTransferMsgGetRootListEntry(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
993	PSHCLLISTENTRY pListEntry)
994	{
995	int rc;
996
997	if (cParms == VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_WRITE)
998	{
999	rc = HGCMSvcGetU32(&aParms[1], &pListEntry->fInfo);
1000	/* Note: aParms[2] contains the entry index, currently being ignored. */
1001	if (RT_SUCCESS(rc))
1002	rc = HGCMSvcGetPv(&aParms[3], (void **)&pListEntry->pszName, &pListEntry->cbName);
1003	if (RT_SUCCESS(rc))
1004	{
1005	uint32_t cbInfo;
1006	rc = HGCMSvcGetU32(&aParms[4], &cbInfo);
1007	if (RT_SUCCESS(rc))
1008	{
1009	rc = HGCMSvcGetPv(&aParms[5], &pListEntry->pvInfo, &pListEntry->cbInfo);
1010	AssertReturn(cbInfo == pListEntry->cbInfo, VERR_INVALID_PARAMETER);
1011	}
1012	}
1013	}
1014	else
1015	rc = VERR_INVALID_PARAMETER;
1016
1017	LogFlowFuncLeaveRC(rc);
1018	return rc;
1019	}
1020
1021	/**
1022	* Gets a transfer list open request from HGCM service parameters.
1023	*
1024	* @returns VBox status code.
1025	* @param cParms Number of HGCM parameters supplied in \a aParms.
1026	* @param aParms Array of HGCM parameters.
1027	* @param pOpenParms Where to store the open parameters of the request.
1028	*/
1029	static int shClSvcTransferMsgGetListOpen(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
1030	PSHCLLISTOPENPARMS pOpenParms)
1031	{
1032	int rc;
1033
1034	if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
1035	{
1036	rc = HGCMSvcGetU32(&aParms[1], &pOpenParms->fList);
1037	if (RT_SUCCESS(rc))
1038	rc = HGCMSvcGetStr(&aParms[2], &pOpenParms->pszFilter, &pOpenParms->cbFilter);
1039	if (RT_SUCCESS(rc))
1040	rc = HGCMSvcGetStr(&aParms[3], &pOpenParms->pszPath, &pOpenParms->cbPath);
1041
1042	/** @todo Some more validation. */
1043	}
1044	else
1045	rc = VERR_INVALID_PARAMETER;
1046
1047	LogFlowFuncLeaveRC(rc);
1048	return rc;
1049	}
1050
1051	/**
1052	* Sets a transfer list open request to HGCM service parameters.
1053	*
1054	* @returns VBox status code.
1055	* @param cParms Number of HGCM parameters supplied in \a aParms.
1056	* @param aParms Array of HGCM parameters.
1057	* @param idCtx Context ID to use.
1058	* @param pOpenParms List open parameters to set.
1059	*/
1060	static int shClSvcTransferMsgSetListOpen(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
1061	uint64_t idCtx, PSHCLLISTOPENPARMS pOpenParms)
1062	{
1063	int rc;
1064
1065	if (cParms == VBOX_SHCL_CPARMS_LIST_OPEN)
1066	{
1067	HGCMSvcSetU64(&aParms[0], idCtx);
1068	HGCMSvcSetU32(&aParms[1], pOpenParms->fList);
1069	HGCMSvcSetPv (&aParms[2], pOpenParms->pszFilter, pOpenParms->cbFilter);
1070	HGCMSvcSetPv (&aParms[3], pOpenParms->pszPath, pOpenParms->cbPath);
1071	HGCMSvcSetU64(&aParms[4], 0); /* OUT: uHandle */
1072
1073	rc = VINF_SUCCESS;
1074	}
1075	else
1076	rc = VERR_INVALID_PARAMETER;
1077
1078	LogFlowFuncLeaveRC(rc);
1079	return rc;
1080	}
1081
1082	/**
1083	* Sets a transfer list close request to HGCM service parameters.
1084	*
1085	* @returns VBox status code.
1086	* @param cParms Number of HGCM parameters supplied in \a aParms.
1087	* @param aParms Array of HGCM parameters.
1088	* @param idCtx Context ID to use.
1089	* @param hList Handle of list to close.
1090	*/
1091	static int shClSvcTransferMsgSetListClose(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
1092	uint64_t idCtx, SHCLLISTHANDLE hList)
1093	{
1094	int rc;
1095
1096	if (cParms == VBOX_SHCL_CPARMS_LIST_CLOSE)
1097	{
1098	HGCMSvcSetU64(&aParms[0], idCtx);
1099	HGCMSvcSetU64(&aParms[1], hList);
1100
1101	rc = VINF_SUCCESS;
1102	}
1103	else
1104	rc = VERR_INVALID_PARAMETER;
1105
1106	LogFlowFuncLeaveRC(rc);
1107	return rc;
1108	}
1109
1110	/**
1111	* Gets a transfer list header from HGCM service parameters.
1112	*
1113	* @returns VBox status code.
1114	* @param cParms Number of HGCM parameters supplied in \a aParms.
1115	* @param aParms Array of HGCM parameters.
1116	* @param phList Where to store the list handle.
1117	* @param pListHdr Where to store the list header.
1118	*/
1119	static int shClSvcTransferMsgGetListHdr(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
1120	PSHCLLISTHANDLE phList, PSHCLLISTHDR pListHdr)
1121	{
1122	int rc;
1123
1124	if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
1125	{
1126	rc = HGCMSvcGetU64(&aParms[1], phList);
1127	/* Note: Flags (aParms[2]) not used here. */
1128	if (RT_SUCCESS(rc))
1129	rc = HGCMSvcGetU32(&aParms[3], &pListHdr->fFeatures);
1130	if (RT_SUCCESS(rc))
1131	rc = HGCMSvcGetU64(&aParms[4], &pListHdr->cEntries);
1132	if (RT_SUCCESS(rc))
1133	rc = HGCMSvcGetU64(&aParms[5], &pListHdr->cbTotalSize);
1134
1135	if (RT_SUCCESS(rc))
1136	{
1137	/** @todo Validate pvMetaFmt + cbMetaFmt. */
1138	/** @todo Validate header checksum. */
1139	}
1140	}
1141	else
1142	rc = VERR_INVALID_PARAMETER;
1143
1144	LogFlowFuncLeaveRC(rc);
1145	return rc;
1146	}
1147
1148	/**
1149	* Sets a transfer list header to HGCM service parameters.
1150	*
1151	* @returns VBox status code.
1152	* @param cParms Number of HGCM parameters supplied in \a aParms.
1153	* @param aParms Array of HGCM parameters.
1154	* @param pListHdr Pointer to list header to set.
1155	*/
1156	static int shClSvcTransferMsgSetListHdr(uint32_t cParms, VBOXHGCMSVCPARM aParms[], PSHCLLISTHDR pListHdr)
1157	{
1158	int rc;
1159
1160	if (cParms == VBOX_SHCL_CPARMS_LIST_HDR)
1161	{
1162	/** @todo Set pvMetaFmt + cbMetaFmt. */
1163	/** @todo Calculate header checksum. */
1164
1165	HGCMSvcSetU32(&aParms[3], pListHdr->fFeatures);
1166	HGCMSvcSetU64(&aParms[4], pListHdr->cEntries);
1167	HGCMSvcSetU64(&aParms[5], pListHdr->cbTotalSize);
1168
1169	rc = VINF_SUCCESS;
1170	}
1171	else
1172	rc = VERR_INVALID_PARAMETER;
1173
1174	LogFlowFuncLeaveRC(rc);
1175	return rc;
1176	}
1177
1178	/**
1179	* Gets a transfer list entry from HGCM service parameters.
1180	*
1181	* @returns VBox status code.
1182	* @param cParms Number of HGCM parameters supplied in \a aParms.
1183	* @param aParms Array of HGCM parameters.
1184	* @param phList Where to store the list handle.
1185	* @param pListEntry Where to store the list entry.
1186	*/
1187	static int shClSvcTransferMsgGetListEntry(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
1188	PSHCLLISTHANDLE phList, PSHCLLISTENTRY pListEntry)
1189	{
1190	int rc;
1191
1192	if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
1193	{
1194	rc = HGCMSvcGetU64(&aParms[1], phList);
1195	if (RT_SUCCESS(rc))
1196	rc = HGCMSvcGetU32(&aParms[2], &pListEntry->fInfo);
1197	if (RT_SUCCESS(rc))
1198	rc = HGCMSvcGetPv(&aParms[3], (void **)&pListEntry->pszName, &pListEntry->cbName);
1199	if (RT_SUCCESS(rc))
1200	{
1201	uint32_t cbInfo;
1202	rc = HGCMSvcGetU32(&aParms[4], &cbInfo);
1203	if (RT_SUCCESS(rc))
1204	{
1205	rc = HGCMSvcGetPv(&aParms[5], &pListEntry->pvInfo, &pListEntry->cbInfo);
1206	AssertReturn(cbInfo == pListEntry->cbInfo, VERR_INVALID_PARAMETER);
1207	}
1208	}
1209
1210	if (RT_SUCCESS(rc))
1211	{
1212	if (!ShClTransferListEntryIsValid(pListEntry))
1213	rc = VERR_INVALID_PARAMETER;
1214	}
1215	}
1216	else
1217	rc = VERR_INVALID_PARAMETER;
1218
1219	LogFlowFuncLeaveRC(rc);
1220	return rc;
1221	}
1222
1223	/**
1224	* Sets a Shared Clipboard list entry to HGCM service parameters.
1225	*
1226	* @returns VBox status code.
1227	* @param cParms Number of HGCM parameters supplied in \a aParms.
1228	* @param aParms Array of HGCM parameters.
1229	* @param pEntry Pointer list entry to set.
1230	*/
1231	static int shClSvcTransferMsgSetListEntry(uint32_t cParms, VBOXHGCMSVCPARM aParms[],
1232	PSHCLLISTENTRY pEntry)
1233	{
1234	int rc;
1235
1236	/* Sanity. */
1237	AssertReturn(ShClTransferListEntryIsValid(pEntry), VERR_INVALID_PARAMETER);
1238
1239	if (cParms == VBOX_SHCL_CPARMS_LIST_ENTRY)
1240	{
1241	/* Entry name */
1242	void *pvDst = aParms[3].u.pointer.addr;
1243	size_t cbDst = aParms[3].u.pointer.size;
1244	memcpy(pvDst, pEntry->pszName, RT_MIN(pEntry->cbName, cbDst));
1245
1246	/* Info size */
1247	HGCMSvcSetU32(&aParms[4], pEntry->cbInfo);
1248
1249	/* Info data */
1250	pvDst = aParms[5].u.pointer.addr;
1251	cbDst = aParms[5].u.pointer.size;
1252	memcpy(pvDst, pEntry->pvInfo, RT_MIN(pEntry->cbInfo, cbDst));
1253
1254	rc = VINF_SUCCESS;
1255	}
1256	else
1257	rc = VERR_INVALID_PARAMETER;
1258
1259	LogFlowFuncLeaveRC(rc);
1260	return rc;
1261	}
1262
1263	/**
1264	* Gets a transfer object data chunk from HGCM service parameters.
1265	*
1266	* @returns VBox status code.
1267	* @param cParms Number of HGCM parameters supplied in \a aParms.
1268	* @param aParms Array of HGCM parameters.
1269	* @param pDataChunk Where to store the object data chunk data.
1270	*/
1271	static int shClSvcTransferGetObjDataChunk(uint32_t cParms, VBOXHGCMSVCPARM aParms[], PSHCLOBJDATACHUNK pDataChunk)
1272	{
1273	AssertPtrReturn(aParms, VERR_INVALID_PARAMETER);
1274	AssertPtrReturn(pDataChunk, VERR_INVALID_PARAMETER);
1275
1276	int rc;
1277
1278	if (cParms == VBOX_SHCL_CPARMS_OBJ_WRITE)
1279	{
1280	rc = HGCMSvcGetU64(&aParms[1], &pDataChunk->uHandle);
1281	if (RT_SUCCESS(rc))
1282	{
1283	uint32_t cbToRead;
1284	rc = HGCMSvcGetU32(&aParms[2], &cbToRead);
1285	if (RT_SUCCESS(rc))
1286	{
1287	rc = HGCMSvcGetPv(&aParms[3], &pDataChunk->pvData, &pDataChunk->cbData);
1288	if (RT_SUCCESS(rc))
1289	rc = cbToRead == pDataChunk->cbData ? VINF_SUCCESS : VERR_INVALID_PARAMETER;
1290	}
1291
1292	/** @todo Implement checksum handling. */
1293	}
1294	}
1295	else
1296	rc = VERR_INVALID_PARAMETER;
1297
1298	LogFlowFuncLeaveRC(rc);
1299	return rc;
1300	}
1301
1302	/**
1303	* Handles a guest reply (VBOX_SHCL_GUEST_FN_REPLY) message.
1304	*
1305	* @returns VBox status code.
1306	* @param pClient Pointer to associated client.
1307	* @param pTransfer Transfer to handle reply for.
1308	* @param cParms Number of function parameters supplied.
1309	* @param aParms Array function parameters supplied.
1310	*/
1311	static int shClSvcTransferMsgHandleReply(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, uint32_t cParms, VBOXHGCMSVCPARM aParms[])
1312	{
1313	LogFlowFunc(("pTransfer=%p\n", pTransfer));
1314
1315	int rc;
1316
1317	uint32_t cbReply = sizeof(SHCLREPLY);
1318	PSHCLREPLY pReply = (PSHCLREPLY)RTMemAlloc(cbReply);
1319	if (pReply)
1320	{
1321	rc = shClSvcTransferMsgGetReply(cParms, aParms, pReply);
1322	if (RT_SUCCESS(rc))
1323	{
1324	if ( pReply->uType == VBOX_SHCL_TX_REPLYMSGTYPE_TRANSFER_STATUS
1325	&& pReply->u.TransferStatus.uStatus == SHCLTRANSFERSTATUS_REQUESTED)
1326	{
1327	/* SHCLTRANSFERSTATUS_REQUESTED is special, as it doesn't provide a transfer. */
1328	}
1329	else /* Everything else needs a valid transfer ID. */
1330	{
1331	if (!pTransfer)
1332	{
1333	LogRel2(("Shared Clipboard: Guest didn't specify a (valid) transfer\n"));
1334	rc = VERR_SHCLPB_TRANSFER_ID_NOT_FOUND;
1335	}
1336	}
1337
1338	if (RT_FAILURE(rc))
1339	{
1340	RTMemFree(pReply);
1341	pReply = NULL;
1342
1343	return rc;
1344	}
1345
1346	PSHCLEVENTPAYLOAD pPayload
1347	= (PSHCLEVENTPAYLOAD)RTMemAlloc(sizeof(SHCLEVENTPAYLOAD));
1348	if (pPayload)
1349	{
1350	pPayload->pvData = pReply;
1351	pPayload->cbData = cbReply;
1352
1353	SHCLTRANSFERID const idTransfer = pTransfer ? ShClTransferGetID(pTransfer) : NIL_SHCLTRANSFERID;
1354
1355	switch (pReply->uType)
1356	{
1357	case VBOX_SHCL_TX_REPLYMSGTYPE_TRANSFER_STATUS:
1358	{
1359	LogRel2(("Shared Clipboard: Guest reported status %s for transfer %RU16\n",
1360	ShClTransferStatusToStr(pReply->u.TransferStatus.uStatus), idTransfer));
1361
1362	/* SHCLTRANSFERSTATUS_REQUESTED is special, as it doesn't provide a transfer ID. */
1363	if (SHCLTRANSFERSTATUS_REQUESTED == pReply->u.TransferStatus.uStatus)
1364	{
1365	LogRel2(("Shared Clipboard: Guest requested a new host -> guest transfer\n"));
1366	}
1367
1368	switch (pReply->u.TransferStatus.uStatus)
1369	{
1370	case SHCLTRANSFERSTATUS_REQUESTED: /* Guest requests a H->G transfer. */
1371	{
1372	uint32_t const uMode = ShClSvcGetMode();
1373	if ( uMode == VBOX_SHCL_MODE_HOST_TO_GUEST
1374	\|\| uMode == VBOX_SHCL_MODE_BIDIRECTIONAL)
1375	{
1376	/* We only create (but not initialize) the transfer here. This is the most lightweight form of
1377	* having a pending transfer around. Report back the new transfer ID to the guest then. */
1378	if (pTransfer == NULL) /* Must not exist yet. */
1379	{
1380	rc = ShClSvcTransferCreate(pClient, SHCLTRANSFERDIR_TO_REMOTE, SHCLSOURCE_LOCAL,
1381	NIL_SHCLTRANSFERID /* Creates a new transfer ID */,
1382	&pTransfer);
1383	if (RT_SUCCESS(rc))
1384	{
1385	ShClSvcClientLock(pClient);
1386
1387	rc = shClSvcTransferSendStatusAsync(pClient, pTransfer,
1388	SHCLTRANSFERSTATUS_REQUESTED, VINF_SUCCESS,
1389	NULL);
1390	ShClSvcClientUnlock(pClient);
1391	}
1392	}
1393	else
1394	rc = VERR_WRONG_ORDER;
1395	}
1396	else
1397	rc = VERR_INVALID_PARAMETER;
1398
1399	break;
1400	}
1401
1402	case SHCLTRANSFERSTATUS_INITIALIZED: /* Guest reports the transfer as being initialized. */
1403	{
1404	switch (ShClTransferGetDir(pTransfer))
1405	{
1406	case SHCLTRANSFERDIR_FROM_REMOTE: /* G->H */
1407	/* Already done locally when creating the transfer. */
1408	break;
1409
1410	case SHCLTRANSFERDIR_TO_REMOTE: /* H->G */
1411	{
1412	/* Initialize the transfer on the host side. */
1413	rc = ShClSvcTransferInit(pClient, pTransfer);
1414	break;
1415	}
1416
1417	default:
1418	AssertFailed();
1419	break;
1420	}
1421
1422	break;
1423	}
1424	case SHCLTRANSFERSTATUS_STARTED: /* Guest has started the transfer on its side. */
1425	{
1426	/* We only need to start for H->G transfers here.
1427	* For G->H transfers we start this as soon as the host clipboard requests data. */
1428	if (ShClTransferGetDir(pTransfer) == SHCLTRANSFERDIR_TO_REMOTE)
1429	{
1430	/* Start the transfer on the host side. */
1431	rc = ShClSvcTransferStart(pClient, pTransfer);
1432	}
1433	break;
1434	}
1435
1436	case SHCLTRANSFERSTATUS_CANCELED:
1437	RT_FALL_THROUGH();
1438	case SHCLTRANSFERSTATUS_KILLED:
1439	{
1440	LogRel2(("Shared Clipboard: Guest has %s transfer %RU16\n",
1441	pReply->u.TransferStatus.uStatus == SHCLTRANSFERSTATUS_CANCELED ? "canceled" : "killed", idTransfer));
1442
1443	switch (pReply->u.TransferStatus.uStatus)
1444	{
1445	case SHCLTRANSFERSTATUS_CANCELED:
1446	rc = ShClTransferCancel(pTransfer);
1447	break;
1448
1449	case SHCLTRANSFERSTATUS_KILLED:
1450	rc = ShClTransferKill(pTransfer);
1451	break;
1452
1453	default:
1454	AssertFailed();
1455	break;
1456	}
1457
1458	break;
1459	}
1460
1461	case SHCLTRANSFERSTATUS_COMPLETED:
1462	{
1463	LogRel2(("Shared Clipboard: Guest has completed transfer %RU16\n", idTransfer));
1464
1465	rc = ShClTransferComplete(pTransfer);
1466	break;
1467	}
1468
1469	case SHCLTRANSFERSTATUS_ERROR:
1470	{
1471	LogRelMax(64, ("Shared Clipboard: Guest reported error %Rrc for transfer %RU16\n",
1472	pReply->rc, pTransfer->State.uID));
1473
1474	if (g_ExtState.pfnExtension)
1475	{
1476	SHCLEXTPARMS parms;
1477	RT_ZERO(parms);
1478
1479	parms.u.Error.rc = pReply->rc;
1480	parms.u.Error.pszMsg = RTStrAPrintf2("Guest reported error %Rrc for transfer %RU16", /** @todo Make the error messages more fine-grained based on rc. */
1481	pReply->rc, pTransfer->State.uID);
1482	AssertPtrBreakStmt(parms.u.Error.pszMsg, rc = VERR_NO_MEMORY);
1483
1484	g_ExtState.pfnExtension(g_ExtState.pvExtension, VBOX_CLIPBOARD_EXT_FN_ERROR, &parms, sizeof(parms));
1485
1486	RTStrFree(parms.u.Error.pszMsg);
1487	parms.u.Error.pszMsg = NULL;
1488	}
1489
1490	rc = ShClTransferError(pTransfer, pReply->rc);
1491	break;
1492	}
1493
1494	default:
1495	{
1496	LogRelMax(64, ("Shared Clipboard: Unknown transfer status %#x from guest received\n",
1497	pReply->u.TransferStatus.uStatus));
1498	rc = VERR_INVALID_PARAMETER;
1499	break;
1500	}
1501	}
1502
1503	/* Tell the backend. */
1504	int rc2 = ShClBackendTransferHandleStatusReply(pClient->pBackend, pClient, pTransfer,
1505	SHCLSOURCE_REMOTE,
1506	pReply->u.TransferStatus.uStatus, pReply->rc);
1507	if (RT_SUCCESS(rc))
1508	rc = rc2;
1509
1510	RT_FALL_THROUGH(); /* Make sure to also signal any waiters by using the block down below. */
1511	}
1512	case VBOX_SHCL_TX_REPLYMSGTYPE_LIST_OPEN:
1513	RT_FALL_THROUGH();
1514	case VBOX_SHCL_TX_REPLYMSGTYPE_LIST_CLOSE:
1515	RT_FALL_THROUGH();
1516	case VBOX_SHCL_TX_REPLYMSGTYPE_OBJ_OPEN:
1517	RT_FALL_THROUGH();
1518	case VBOX_SHCL_TX_REPLYMSGTYPE_OBJ_CLOSE:
1519	{
1520	uint64_t uCID;
1521	rc = HGCMSvcGetU64(&aParms[0], &uCID);
1522	if (RT_SUCCESS(rc))
1523	{
1524	const PSHCLEVENT pEvent
1525	= ShClEventSourceGetFromId(&pTransfer->Events, VBOX_SHCL_CONTEXTID_GET_EVENT(uCID));
1526	if (pEvent)
1527	{
1528	LogFlowFunc(("uCID=%RU64 -> idEvent=%RU32, rcReply=%Rrc\n", uCID, pEvent->idEvent, pReply->rc));
1529
1530	rc = ShClEventSignalEx(pEvent, pReply->rc, pPayload);
1531	}
1532	}
1533	break;
1534	}
1535
1536	default:
1537	LogRelMax(64, ("Shared Clipboard: Unknown reply type %#x from guest received\n", pReply->uType));
1538	ShClTransferCancel(pTransfer); /* Avoid clogging up the transfer list. */
1539	rc = VERR_INVALID_PARAMETER;
1540	break;
1541	}
1542
1543	if ( ShClTransferIsAborted(pTransfer)
1544	\|\| ShClTransferIsComplete(pTransfer))
1545	{
1546	ShClSvcTransferDestroy(pClient, pTransfer);
1547	pTransfer = NULL;
1548	}
1549
1550	if (RT_FAILURE(rc))
1551	{
1552	if (pPayload)
1553	RTMemFree(pPayload);
1554	}
1555	}
1556	else
1557	rc = VERR_NO_MEMORY;
1558	}
1559	}
1560	else
1561	rc = VERR_NO_MEMORY;
1562
1563	if (RT_FAILURE(rc))
1564	{
1565	if (pReply)
1566	RTMemFree(pReply);
1567	}
1568
1569	LogFlowFuncLeaveRC(rc);
1570	return rc;
1571	}
1572
1573	/**
1574	* Transfer message client (guest) handler for the Shared Clipboard host service.
1575	*
1576	* @returns VBox status code, or VINF_HGCM_ASYNC_EXECUTE if returning to the client will be deferred.
1577	* @param pClient Pointer to associated client.
1578	* @param callHandle The client's call handle of this call.
1579	* @param u32Function Function number being called.
1580	* @param cParms Number of function parameters supplied.
1581	* @param aParms Array function parameters supplied.
1582	* @param tsArrival Timestamp of arrival.
1583	*/
1584	int ShClSvcTransferMsgClientHandler(PSHCLCLIENT pClient,
1585	VBOXHGCMCALLHANDLE callHandle,
1586	uint32_t u32Function,
1587	uint32_t cParms,
1588	VBOXHGCMSVCPARM aParms[],
1589	uint64_t tsArrival)
1590	{
1591	RT_NOREF(callHandle, aParms, tsArrival);
1592
1593	LogFlowFunc(("uClient=%RU32, u32Function=%RU32 (%s), cParms=%RU32, g_ExtState.pfnExtension=%p\n",
1594	pClient->State.uClientID, u32Function, ShClGuestMsgToStr(u32Function), cParms, g_ExtState.pfnExtension));
1595
1596	/* Check if we've the right mode set. */
1597	if (!shClSvcTransferMsgIsAllowed(ShClSvcGetMode(), u32Function))
1598	{
1599	LogFunc(("Wrong clipboard mode, denying access\n"));
1600	return VERR_ACCESS_DENIED;
1601	}
1602
1603	int rc = VERR_INVALID_PARAMETER; /* Play safe by default. */
1604
1605	if (cParms < 1)
1606	return rc;
1607	ASSERT_GUEST_RETURN(aParms[0].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE);
1608
1609	uint64_t uCID = 0; /* Context ID */
1610	rc = HGCMSvcGetU64(&aParms[0], &uCID);
1611	if (RT_FAILURE(rc))
1612	return rc;
1613
1614	/*
1615	* Pre-check: For certain messages we need to make sure that a (right) transfer is present.
1616	*/
1617	const SHCLTRANSFERID idTransfer = VBOX_SHCL_CONTEXTID_GET_TRANSFER(uCID);
1618	PSHCLTRANSFER pTransfer = ShClTransferCtxGetTransferById(&pClient->Transfers.Ctx, idTransfer);
1619
1620	rc = VERR_INVALID_PARAMETER; /* Play safe. */
1621
1622	switch (u32Function)
1623	{
1624	case VBOX_SHCL_GUEST_FN_REPLY:
1625	{
1626	rc = shClSvcTransferMsgHandleReply(pClient, pTransfer, cParms, aParms);
1627	break;
1628	}
1629
1630	case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_READ:
1631	{
1632	if (cParms != VBOX_SHCL_CPARMS_ROOT_LIST_HDR_READ)
1633	break;
1634
1635	ASSERT_GUEST_RETURN(aParms[1].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /* Features */
1636	ASSERT_GUEST_RETURN(aParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE); /* # Entries */
1637
1638	SHCLLISTHDR rootListHdr;
1639	RT_ZERO(rootListHdr);
1640
1641	rootListHdr.cEntries = ShClTransferRootsCount(pTransfer);
1642	/** @todo BUGBUG What about the features? */
1643
1644	HGCMSvcSetU64(&aParms[0], 0 /* Context ID */);
1645	HGCMSvcSetU32(&aParms[1], rootListHdr.fFeatures);
1646	HGCMSvcSetU64(&aParms[2], rootListHdr.cEntries);
1647
1648	rc = VINF_SUCCESS;
1649	break;
1650	}
1651
1652	case VBOX_SHCL_GUEST_FN_ROOT_LIST_HDR_WRITE:
1653	{
1654	SHCLLISTHDR lstHdr;
1655	rc = shClSvcTransferMsgGetRootListHdr(cParms, aParms, &lstHdr);
1656	if (RT_SUCCESS(rc))
1657	{
1658	void *pvData = ShClTransferListHdrDup(&lstHdr);
1659	uint32_t cbData = sizeof(SHCLLISTHDR);
1660
1661	const PSHCLEVENT pEvent = ShClEventSourceGetFromId(&pTransfer->Events, VBOX_SHCL_CONTEXTID_GET_EVENT(uCID));
1662	if (pEvent)
1663	{
1664	PSHCLEVENTPAYLOAD pPayload;
1665	rc = ShClPayloadAlloc(pEvent->idEvent, pvData, cbData, &pPayload);
1666	if (RT_SUCCESS(rc))
1667	{
1668	rc = ShClEventSignal(pEvent, pPayload);
1669	if (RT_FAILURE(rc))
1670	ShClPayloadFree(pPayload);
1671	}
1672	}
1673	else
1674	rc = VERR_SHCLPB_EVENT_ID_NOT_FOUND;
1675	}
1676	break;
1677	}
1678
1679	case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_READ:
1680	{
1681	if (cParms != VBOX_SHCL_CPARMS_ROOT_LIST_ENTRY_READ)
1682	break;
1683
1684	ASSERT_GUEST_RETURN(aParms[1].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /* Info flags */
1685	ASSERT_GUEST_RETURN(aParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE); /* Entry index # */
1686	ASSERT_GUEST_RETURN(aParms[3].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Entry name */
1687	ASSERT_GUEST_RETURN(aParms[4].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /* Info size */
1688	ASSERT_GUEST_RETURN(aParms[5].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Info data */
1689
1690	uint32_t fInfo;
1691	rc = HGCMSvcGetU32(&aParms[1], &fInfo);
1692	AssertRCBreak(rc);
1693
1694	ASSERT_GUEST_RETURN(fInfo & VBOX_SHCL_INFO_F_FSOBJINFO, VERR_WRONG_PARAMETER_TYPE); /* Validate info flags. */
1695
1696	uint64_t uIdx;
1697	rc = HGCMSvcGetU64(&aParms[2], &uIdx);
1698	AssertRCBreak(rc);
1699
1700	PCSHCLLISTENTRY pEntry = ShClTransferRootsEntryGet(pTransfer, uIdx);
1701	if (pEntry)
1702	{
1703	/* Entry name */
1704	void *pvDst = aParms[3].u.pointer.addr;
1705	size_t cbDst = aParms[3].u.pointer.size;
1706	memcpy(pvDst, pEntry->pszName, RT_MIN(pEntry->cbName, cbDst));
1707
1708	/* Info size */
1709	HGCMSvcSetU32(&aParms[4], pEntry->cbInfo);
1710
1711	/* Info data */
1712	pvDst = aParms[5].u.pointer.addr;
1713	cbDst = aParms[5].u.pointer.size;
1714	memcpy(pvDst, pEntry->pvInfo, RT_MIN(pEntry->cbInfo, cbDst));
1715	}
1716	else
1717	rc = VERR_NOT_FOUND;
1718
1719	break;
1720	}
1721
1722	case VBOX_SHCL_GUEST_FN_ROOT_LIST_ENTRY_WRITE:
1723	{
1724	SHCLLISTENTRY lstEntry;
1725	rc = shClSvcTransferMsgGetRootListEntry(cParms, aParms, &lstEntry);
1726	if (RT_SUCCESS(rc))
1727	{
1728	void *pvData = ShClTransferListEntryDup(&lstEntry);
1729	uint32_t cbData = sizeof(SHCLLISTENTRY);
1730
1731	const PSHCLEVENT pEvent = ShClEventSourceGetFromId(&pTransfer->Events, VBOX_SHCL_CONTEXTID_GET_EVENT(uCID));
1732	if (pEvent)
1733	{
1734	PSHCLEVENTPAYLOAD pPayload;
1735	rc = ShClPayloadAlloc(pEvent->idEvent, pvData, cbData, &pPayload);
1736	if (RT_SUCCESS(rc))
1737	{
1738	rc = ShClEventSignal(pEvent, pPayload);
1739	if (RT_FAILURE(rc))
1740	ShClPayloadFree(pPayload);
1741	}
1742	}
1743	else
1744	rc = VERR_SHCLPB_EVENT_ID_NOT_FOUND;
1745	}
1746	break;
1747	}
1748
1749	case VBOX_SHCL_GUEST_FN_LIST_OPEN:
1750	{
1751	if (cParms != VBOX_SHCL_CPARMS_LIST_OPEN)
1752	break;
1753
1754	SHCLLISTOPENPARMS listOpenParms;
1755	rc = shClSvcTransferMsgGetListOpen(cParms, aParms, &listOpenParms);
1756	if (RT_SUCCESS(rc))
1757	{
1758	SHCLLISTHANDLE hList;
1759	rc = ShClTransferListOpen(pTransfer, &listOpenParms, &hList);
1760	if (RT_SUCCESS(rc))
1761	{
1762	/* Return list handle. */
1763	HGCMSvcSetU64(&aParms[4], hList);
1764	}
1765	}
1766	break;
1767	}
1768
1769	case VBOX_SHCL_GUEST_FN_LIST_CLOSE:
1770	{
1771	if (cParms != VBOX_SHCL_CPARMS_LIST_CLOSE)
1772	break;
1773
1774	SHCLLISTHANDLE hList;
1775	rc = HGCMSvcGetU64(&aParms[1], &hList);
1776	if (RT_SUCCESS(rc))
1777	{
1778	rc = ShClTransferListClose(pTransfer, hList);
1779	}
1780	break;
1781	}
1782
1783	case VBOX_SHCL_GUEST_FN_LIST_HDR_READ:
1784	{
1785	if (cParms != VBOX_SHCL_CPARMS_LIST_HDR)
1786	break;
1787
1788	SHCLLISTHANDLE hList;
1789	rc = HGCMSvcGetU64(&aParms[1], &hList); /* Get list handle. */
1790	if (RT_SUCCESS(rc))
1791	{
1792	SHCLLISTHDR hdrList;
1793	rc = ShClTransferListGetHeader(pTransfer, hList, &hdrList);
1794	if (RT_SUCCESS(rc))
1795	rc = shClSvcTransferMsgSetListHdr(cParms, aParms, &hdrList);
1796	}
1797	break;
1798	}
1799
1800	case VBOX_SHCL_GUEST_FN_LIST_HDR_WRITE:
1801	{
1802	SHCLLISTHDR hdrList;
1803	rc = ShClTransferListHdrInit(&hdrList);
1804	if (RT_SUCCESS(rc))
1805	{
1806	SHCLLISTHANDLE hList;
1807	rc = shClSvcTransferMsgGetListHdr(cParms, aParms, &hList, &hdrList);
1808	if (RT_SUCCESS(rc))
1809	{
1810	void *pvData = ShClTransferListHdrDup(&hdrList);
1811	uint32_t cbData = sizeof(SHCLLISTHDR);
1812
1813	const PSHCLEVENT pEvent = ShClEventSourceGetFromId(&pTransfer->Events, VBOX_SHCL_CONTEXTID_GET_EVENT(uCID));
1814	if (pEvent)
1815	{
1816	PSHCLEVENTPAYLOAD pPayload;
1817	rc = ShClPayloadAlloc(pEvent->idEvent, pvData, cbData, &pPayload);
1818	if (RT_SUCCESS(rc))
1819	{
1820	rc = ShClEventSignal(pEvent, pPayload);
1821	if (RT_FAILURE(rc))
1822	ShClPayloadFree(pPayload);
1823	}
1824	}
1825	else
1826	rc = VERR_SHCLPB_EVENT_ID_NOT_FOUND;
1827	}
1828	}
1829	break;
1830	}
1831
1832	case VBOX_SHCL_GUEST_FN_LIST_ENTRY_READ:
1833	{
1834	if (cParms != VBOX_SHCL_CPARMS_LIST_ENTRY)
1835	break;
1836
1837	SHCLLISTHANDLE hList;
1838	rc = HGCMSvcGetU64(&aParms[1], &hList); /* Get list handle. */
1839	if (RT_SUCCESS(rc))
1840	{
1841	SHCLLISTENTRY entryList;
1842	rc = ShClTransferListEntryInit(&entryList);
1843	if (RT_SUCCESS(rc))
1844	{
1845	rc = ShClTransferListRead(pTransfer, hList, &entryList);
1846	if (RT_SUCCESS(rc))
1847	rc = shClSvcTransferMsgSetListEntry(cParms, aParms, &entryList);
1848	}
1849	}
1850	break;
1851	}
1852
1853	case VBOX_SHCL_GUEST_FN_LIST_ENTRY_WRITE:
1854	{
1855	SHCLLISTENTRY entryList;
1856	rc = ShClTransferListEntryInit(&entryList);
1857	if (RT_SUCCESS(rc))
1858	{
1859	SHCLLISTHANDLE hList;
1860	rc = shClSvcTransferMsgGetListEntry(cParms, aParms, &hList, &entryList);
1861	if (RT_SUCCESS(rc))
1862	{
1863	void *pvData = ShClTransferListEntryDup(&entryList);
1864	uint32_t cbData = sizeof(SHCLLISTENTRY);
1865
1866	const PSHCLEVENT pEvent = ShClEventSourceGetFromId(&pTransfer->Events, VBOX_SHCL_CONTEXTID_GET_EVENT(uCID));
1867	if (pEvent)
1868	{
1869	PSHCLEVENTPAYLOAD pPayload;
1870	rc = ShClPayloadAlloc(pEvent->idEvent, pvData, cbData, &pPayload);
1871	if (RT_SUCCESS(rc))
1872	{
1873	rc = ShClEventSignal(pEvent, pPayload);
1874	if (RT_FAILURE(rc))
1875	ShClPayloadFree(pPayload);
1876	}
1877	}
1878	else
1879	rc = VERR_SHCLPB_EVENT_ID_NOT_FOUND;
1880	}
1881	}
1882	break;
1883	}
1884
1885	case VBOX_SHCL_GUEST_FN_OBJ_OPEN:
1886	{
1887	ASSERT_GUEST_STMT_BREAK(cParms == VBOX_SHCL_CPARMS_OBJ_OPEN, rc = VERR_WRONG_PARAMETER_COUNT);
1888
1889	SHCLOBJOPENCREATEPARMS openCreateParms;
1890	RT_ZERO(openCreateParms);
1891
1892	/* aParms[1] will return the object handle on success; see below. */
1893	rc = HGCMSvcGetStr(&aParms[2], &openCreateParms.pszPath, &openCreateParms.cbPath);
1894	if (RT_SUCCESS(rc))
1895	rc = HGCMSvcGetU32(&aParms[3], &openCreateParms.fCreate);
1896
1897	if (RT_SUCCESS(rc))
1898	{
1899	SHCLOBJHANDLE hObj;
1900	rc = ShClTransferObjOpen(pTransfer, &openCreateParms, &hObj);
1901	if (RT_SUCCESS(rc))
1902	{
1903	LogFlowFunc(("hObj=%RU64\n", hObj));
1904
1905	HGCMSvcSetU64(&aParms[1], hObj);
1906	}
1907	}
1908	break;
1909	}
1910
1911	case VBOX_SHCL_GUEST_FN_OBJ_CLOSE:
1912	{
1913	if (cParms != VBOX_SHCL_CPARMS_OBJ_CLOSE)
1914	break;
1915
1916	SHCLOBJHANDLE hObj;
1917	rc = HGCMSvcGetU64(&aParms[1], &hObj); /* Get object handle. */
1918	if (RT_SUCCESS(rc))
1919	rc = ShClTransferObjClose(pTransfer, hObj);
1920	break;
1921	}
1922
1923	case VBOX_SHCL_GUEST_FN_OBJ_READ:
1924	{
1925	if (cParms != VBOX_SHCL_CPARMS_OBJ_READ)
1926	break;
1927
1928	ASSERT_GUEST_RETURN(aParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, VERR_WRONG_PARAMETER_TYPE); /* Object handle */
1929	ASSERT_GUEST_RETURN(aParms[2].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /* Bytes to read */
1930	ASSERT_GUEST_RETURN(aParms[3].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Data buffer */
1931	ASSERT_GUEST_RETURN(aParms[4].type == VBOX_HGCM_SVC_PARM_32BIT, VERR_WRONG_PARAMETER_TYPE); /* Checksum data size */
1932	ASSERT_GUEST_RETURN(aParms[5].type == VBOX_HGCM_SVC_PARM_PTR, VERR_WRONG_PARAMETER_TYPE); /* Checksum data buffer*/
1933
1934	SHCLOBJHANDLE hObj;
1935	rc = HGCMSvcGetU64(&aParms[1], &hObj); /* Get object handle. */
1936	AssertRCBreak(rc);
1937
1938	uint32_t cbToRead = 0;
1939	rc = HGCMSvcGetU32(&aParms[2], &cbToRead);
1940	AssertRCBreak(rc);
1941
1942	void *pvBuf = NULL;
1943	uint32_t cbBuf = 0;
1944	rc = HGCMSvcGetPv(&aParms[3], &pvBuf, &cbBuf);
1945	AssertRCBreak(rc);
1946
1947	LogFlowFunc(("hObj=%RU64, cbBuf=%RU32, cbToRead=%RU32, rc=%Rrc\n", hObj, cbBuf, cbToRead, rc));
1948
1949	if ( RT_SUCCESS(rc)
1950	&& ( !cbBuf
1951	\|\| !cbToRead
1952	\|\| cbBuf < cbToRead
1953	)
1954	)
1955	{
1956	rc = VERR_INVALID_PARAMETER;
1957	}
1958
1959	if (RT_SUCCESS(rc))
1960	{
1961	uint32_t cbRead;
1962	rc = ShClTransferObjRead(pTransfer, hObj, pvBuf, cbToRead, 0 /* fFlags */, &cbRead);
1963	if (RT_SUCCESS(rc))
1964	{
1965	HGCMSvcSetU32(&aParms[2], cbRead);
1966
1967	/** @todo Implement checksum support. */
1968	}
1969	}
1970	break;
1971	}
1972
1973	case VBOX_SHCL_GUEST_FN_OBJ_WRITE:
1974	{
1975	SHCLOBJDATACHUNK dataChunk;
1976
1977	rc = shClSvcTransferGetObjDataChunk(cParms, aParms, &dataChunk);
1978	if (RT_SUCCESS(rc))
1979	{
1980	void *pvData = ShClTransferObjDataChunkDup(&dataChunk);
1981	uint32_t cbData = sizeof(SHCLOBJDATACHUNK);
1982
1983	const PSHCLEVENT pEvent = ShClEventSourceGetFromId(&pTransfer->Events, VBOX_SHCL_CONTEXTID_GET_EVENT(uCID));
1984	if (pEvent)
1985	{
1986	PSHCLEVENTPAYLOAD pPayload;
1987	rc = ShClPayloadAlloc(pEvent->idEvent, pvData, cbData, &pPayload);
1988	if (RT_SUCCESS(rc))
1989	{
1990	rc = ShClEventSignal(pEvent, pPayload);
1991	if (RT_FAILURE(rc))
1992	ShClPayloadFree(pPayload);
1993	}
1994	}
1995	else
1996	rc = VERR_SHCLPB_EVENT_ID_NOT_FOUND;
1997	}
1998
1999	break;
2000	}
2001
2002	default:
2003	rc = VERR_NOT_IMPLEMENTED;
2004	break;
2005	}
2006
2007	/* If anything wrong has happened, make sure to unregister the transfer again (if not done already) and tell the guest. */
2008	if ( RT_FAILURE(rc)
2009	&& pTransfer)
2010	{
2011	ShClSvcClientLock(pClient);
2012
2013	/* Let the guest know. */
2014	int rc2 = shClSvcTransferSendStatusAsync(pClient, pTransfer,
2015	SHCLTRANSFERSTATUS_ERROR, rc, NULL /* ppEvent */);
2016	AssertRC(rc2);
2017
2018	ShClSvcClientUnlock(pClient);
2019
2020	ShClSvcTransferDestroy(pClient, pTransfer);
2021	}
2022
2023	LogFlowFunc(("[Client %RU32] Returning rc=%Rrc\n", pClient->State.uClientID, rc));
2024	return rc;
2025	}
2026
2027	/**
2028	* Transfer message host handler for the Shared Clipboard host service.
2029	*
2030	* @returns VBox status code.
2031	* @param u32Function Function number being called.
2032	* @param cParms Number of function parameters supplied.
2033	* @param aParms Array function parameters supplied.
2034	*/
2035	int ShClSvcTransferMsgHostHandler(uint32_t u32Function,
2036	uint32_t cParms,
2037	VBOXHGCMSVCPARM aParms[])
2038	{
2039	RT_NOREF(cParms, aParms);
2040
2041	int rc = VERR_NOT_IMPLEMENTED; /* Play safe. */
2042
2043	switch (u32Function)
2044	{
2045	case VBOX_SHCL_HOST_FN_CANCEL: /** @todo BUGBUG Implement this. */
2046	break;
2047
2048	case VBOX_SHCL_HOST_FN_ERROR: /** @todo BUGBUG Implement this. */
2049	break;
2050
2051	default:
2052	break;
2053
2054	}
2055
2056	LogFlowFuncLeaveRC(rc);
2057	return rc;
2058	}
2059
2060	int shClSvcTransferHostMsgHandler(PSHCLCLIENT pClient, PSHCLCLIENTMSG pMsg)
2061	{
2062	RT_NOREF(pClient);
2063
2064	int rc;
2065
2066	switch (pMsg->idMsg)
2067	{
2068	default:
2069	rc = VINF_SUCCESS;
2070	break;
2071	}
2072
2073	LogFlowFuncLeaveRC(rc);
2074	return rc;
2075	}
2076
2077	/**
2078	* Reports a transfer status to the guest.
2079	*
2080	* @returns VBox status code.
2081	* @param pClient Client that owns the transfer.
2082	* @param idTransfer Transfer ID to report status for.
2083	* @param enmDir Transfer direction to report status for.
2084	* @param enmSts Status to report.
2085	* @param rcTransfer Result code to report. Optional and depending on status.
2086	* @param ppEvent Where to return the wait event on success. Optional.
2087	* Must be released by the caller with ShClEventRelease().
2088	*
2089	* @note Caller must enter the client's critical section.
2090	*/
2091	static int shClSvcTransferSendStatusExAsync(PSHCLCLIENT pClient, SHCLTRANSFERID idTransfer,
2092	SHCLTRANSFERDIR enmDir, SHCLTRANSFERSTATUS enmSts, int rcTransfer,
2093	PSHCLEVENT *ppEvent)
2094	{
2095	AssertPtrReturn(pClient, VERR_INVALID_POINTER);
2096	AssertReturn(idTransfer != NIL_SHCLTRANSFERID, VERR_INVALID_PARAMETER);
2097	/* ppEvent is optional. */
2098
2099	Assert(RTCritSectIsOwner(&pClient->CritSect));
2100
2101	PSHCLCLIENTMSG pMsgReadData = ShClSvcClientMsgAlloc(pClient, VBOX_SHCL_HOST_MSG_TRANSFER_STATUS,
2102	VBOX_SHCL_CPARMS_TRANSFER_STATUS);
2103	if (!pMsgReadData)
2104	return VERR_NO_MEMORY;
2105
2106	PSHCLEVENT pEvent;
2107	int rc = ShClEventSourceGenerateAndRegisterEvent(&pClient->EventSrc, &pEvent);
2108	if (RT_SUCCESS(rc))
2109	{
2110	HGCMSvcSetU64(&pMsgReadData->aParms[0], VBOX_SHCL_CONTEXTID_MAKE(pClient->State.uSessionID, idTransfer, pEvent->idEvent));
2111	HGCMSvcSetU32(&pMsgReadData->aParms[1], enmDir);
2112	HGCMSvcSetU32(&pMsgReadData->aParms[2], enmSts);
2113	HGCMSvcSetU32(&pMsgReadData->aParms[3], (uint32_t)rcTransfer); /** @todo uint32_t vs. int. */
2114	HGCMSvcSetU32(&pMsgReadData->aParms[4], 0 /* fFlags, unused */);
2115
2116	ShClSvcClientMsgAdd(pClient, pMsgReadData, true /* fAppend */);
2117
2118	rc = ShClSvcClientWakeup(pClient);
2119	if (RT_SUCCESS(rc))
2120	{
2121	LogRel2(("Shared Clipboard: Reported status %s (rc=%Rrc) of transfer %RU16 to guest\n",
2122	ShClTransferStatusToStr(enmSts), rcTransfer, idTransfer));
2123
2124	if (ppEvent)
2125	{
2126	ppEvent = pEvent; / Takes ownership. */
2127	}
2128	else /* If event is not consumed by the caller, release the event again. */
2129	ShClEventRelease(pEvent);
2130	}
2131	else
2132	ShClEventRelease(pEvent);
2133	}
2134	else
2135	rc = VERR_SHCLPB_MAX_EVENTS_REACHED;
2136
2137	if (RT_FAILURE(rc))
2138	LogRelMax(64, ("Shared Clipboard: Reporting status %s (%Rrc) for transfer %RU16 to guest failed with %Rrc\n",
2139	ShClTransferStatusToStr(enmSts), rcTransfer, idTransfer, rc));
2140
2141	LogFlowFuncLeaveRC(rc);
2142	return rc;
2143	}
2144
2145	/**
2146	* Reports a transfer status to the guest, internal version.
2147	*
2148	* @returns VBox status code.
2149	* @param pClient Client that owns the transfer.
2150	* @param pTransfer Transfer to report status for.
2151	* @param enmSts Status to report.
2152	* @param rcTransfer Result code to report. Optional and depending on status.
2153	* @param ppEvent Where to return the wait event on success. Optional.
2154	* Must be released by the caller with ShClEventRelease().
2155	*
2156	* @note Caller must enter the client's critical section.
2157	*/
2158	static int shClSvcTransferSendStatusAsync(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS enmSts,
2159	int rcTransfer, PSHCLEVENT *ppEvent)
2160	{
2161	AssertPtrReturn(pClient, VERR_INVALID_POINTER);
2162	AssertPtrReturn(pTransfer, VERR_INVALID_POINTER);
2163	/* ppEvent is optional. */
2164
2165	return shClSvcTransferSendStatusExAsync(pClient, ShClTransferGetID(pTransfer), ShClTransferGetDir(pTransfer),
2166	enmSts, rcTransfer, ppEvent);
2167	}
2168
2169	/**
2170	* Reports a transfer status to the guest.
2171	*
2172	* @returns VBox status code.
2173	* @param pClient Client that owns the transfer.
2174	* @param pTransfer Transfer to report status for.
2175	* @param enmSts Status to report.
2176	* @param rcTransfer Result code to report. Optional and depending on status.
2177	* @param ppEvent Where to return the wait event on success. Optional.
2178	* Must be released by the caller with ShClEventRelease().
2179	*/
2180	int ShClSvcTransferSendStatusAsync(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, SHCLTRANSFERSTATUS enmSts,
2181	int rcTransfer, PSHCLEVENT *ppEvent)
2182	{
2183	return shClSvcTransferSendStatusAsync(pClient, pTransfer, enmSts, rcTransfer, ppEvent);
2184	}
2185
2186	/**
2187	* Cleans up (unregisters and destroys) all transfers not in started state (anymore).
2188	*
2189	* @param pClient Client to clean up transfers for.
2190	*
2191	* @note Caller needs to take the critical section.
2192	*/
2193	static void shClSvcTransferCleanupAllUnused(PSHCLCLIENT pClient)
2194	{
2195	Assert(RTCritSectIsOwner(&pClient->CritSect));
2196
2197	LogFlowFuncEnter();
2198
2199	PSHCLTRANSFERCTX pTxCtx = &pClient->Transfers.Ctx;
2200
2201	PSHCLTRANSFER pTransfer, pTransferNext;
2202	RTListForEachSafe(&pTxCtx->List, pTransfer, pTransferNext, SHCLTRANSFER, Node)
2203	{
2204	SHCLTRANSFERSTATUS const enmSts = ShClTransferGetStatus(pTransfer);
2205	if (enmSts != SHCLTRANSFERSTATUS_STARTED)
2206	{
2207	/* Let the guest know. */
2208	int rc2 = shClSvcTransferSendStatusAsync(pClient, pTransfer,
2209	SHCLTRANSFERSTATUS_UNINITIALIZED, VINF_SUCCESS, NULL /* ppEvent */);
2210	AssertRC(rc2);
2211
2212	ShClTransferCtxUnregisterById(pTxCtx, pTransfer->State.uID);
2213	ShClTransferDestroy(pTransfer);
2214	}
2215	}
2216	}
2217
2218	/**
2219	* Creates a new transfer on the host.
2220	*
2221	* @returns VBox status code.
2222	* @param pClient Client that owns the transfer.
2223	* @param enmDir Transfer direction to create.
2224	* @param enmSource Transfer source to create.
2225	* @param idTransfer Transfer ID to use for creation.
2226	* If set to NIL_SHCLTRANSFERID, a new transfer ID will be created.
2227	* @param ppTransfer Where to return the created transfer on success. Optional and can be NULL.
2228	*/
2229	int ShClSvcTransferCreate(PSHCLCLIENT pClient, SHCLTRANSFERDIR enmDir, SHCLSOURCE enmSource, SHCLTRANSFERID idTransfer, PSHCLTRANSFER *ppTransfer)
2230	{
2231	AssertPtrReturn(pClient, VERR_INVALID_POINTER);
2232	/* ppTransfer is optional. */
2233
2234	LogFlowFuncEnter();
2235
2236	ShClSvcClientLock(pClient);
2237
2238	/* When creating a new transfer, this is a good time to clean up old stuff we don't need anymore. */
2239	shClSvcTransferCleanupAllUnused(pClient);
2240
2241	PSHCLTRANSFER pTransfer;
2242	int rc = ShClTransferCreate(enmDir, enmSource, &pClient->Transfers.Callbacks, &pTransfer);
2243	if (RT_SUCCESS(rc))
2244	{
2245	if (idTransfer == NIL_SHCLTRANSFERID)
2246	rc = ShClTransferCtxRegister(&pClient->Transfers.Ctx, pTransfer, &idTransfer);
2247	else
2248	rc = ShClTransferCtxRegisterById(&pClient->Transfers.Ctx, pTransfer, idTransfer);
2249	if (RT_SUCCESS(rc))
2250	{
2251	if (ppTransfer)
2252	*ppTransfer = pTransfer;
2253	}
2254	}
2255
2256	ShClSvcClientUnlock(pClient);
2257
2258	if (RT_FAILURE(rc))
2259	ShClTransferDestroy(pTransfer);
2260
2261	if (RT_FAILURE(rc))
2262	LogRel(("Shared Clipboard: Creating transfer failed with %Rrc\n", rc));
2263
2264	LogFlowFuncLeaveRC(rc);
2265	return rc;
2266	}
2267
2268	/**
2269	* Destroys a transfer on the host.
2270	*
2271	* @param pClient Client to destroy transfer for.
2272	* @param pTransfer Transfer to destroy.
2273	* The pointer will be invalid after return.
2274	*/
2275	void ShClSvcTransferDestroy(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
2276	{
2277	if (!pTransfer)
2278	return;
2279
2280	LogFlowFuncEnter();
2281
2282	ShClSvcClientLock(pClient);
2283
2284	PSHCLTRANSFERCTX pTxCtx = &pClient->Transfers.Ctx;
2285
2286	ShClTransferCtxUnregisterById(pTxCtx, pTransfer->State.uID);
2287
2288	/* Make sure to let the guest know. */
2289	int rc = shClSvcTransferSendStatusAsync(pClient, pTransfer,
2290	SHCLTRANSFERSTATUS_UNINITIALIZED, VINF_SUCCESS, NULL /* ppEvent */);
2291	AssertRC(rc);
2292
2293	ShClTransferDestroy(pTransfer);
2294	pTransfer = NULL;
2295
2296	ShClSvcClientUnlock(pClient);
2297
2298	LogFlowFuncLeave();
2299	}
2300
2301	/**
2302	* Initializes a (created) transfer on the host.
2303	*
2304	* @returns VBox status code.
2305	* @param pClient Client that owns the transfer.
2306	* @param pTransfer Transfer to initialize.
2307	*/
2308	int ShClSvcTransferInit(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
2309	{
2310	AssertPtrReturn(pClient, VERR_INVALID_POINTER);
2311
2312	LogFlowFuncEnter();
2313
2314	ShClSvcClientLock(pClient);
2315
2316	Assert(ShClTransferGetStatus(pTransfer) == SHCLTRANSFERSTATUS_NONE);
2317
2318	PSHCLTRANSFERCTX pTxCtx = &pClient->Transfers.Ctx;
2319
2320	int rc;
2321
2322	if (!ShClTransferCtxIsMaximumReached(pTxCtx))
2323	{
2324	SHCLTRANSFERDIR const enmDir = ShClTransferGetDir(pTransfer);
2325
2326	LogRel2(("Shared Clipboard: Initializing %s transfer ...\n",
2327	enmDir == SHCLTRANSFERDIR_FROM_REMOTE ? "guest -> host" : "host -> guest"));
2328
2329	rc = ShClTransferInit(pTransfer);
2330	}
2331	else
2332	rc = VERR_SHCLPB_MAX_TRANSFERS_REACHED;
2333
2334	/* Tell the guest the outcome. */
2335	int rc2 = shClSvcTransferSendStatusAsync(pClient, pTransfer,
2336	RT_SUCCESS(rc)
2337	? SHCLTRANSFERSTATUS_INITIALIZED : SHCLTRANSFERSTATUS_ERROR, rc,
2338	NULL /* ppEvent */);
2339	if (RT_SUCCESS(rc))
2340	rc2 = rc;
2341
2342	if (RT_FAILURE(rc))
2343	LogRel(("Shared Clipboard: Initializing transfer failed with %Rrc\n", rc));
2344
2345	ShClSvcClientUnlock(pClient);
2346
2347	LogFlowFuncLeaveRC(rc);
2348	return rc;
2349	}
2350
2351	/**
2352	* Starts a transfer, communicating the status to the guest side.
2353	*
2354	* @returns VBox status code.
2355	* @param pClient Client that owns the transfer.
2356	* @param pTransfer Transfer to start.
2357	*/
2358	int ShClSvcTransferStart(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer)
2359	{
2360	LogRel2(("Shared Clipboard: Starting transfer %RU16 ...\n", pTransfer->State.uID));
2361
2362	ShClSvcClientLock(pClient);
2363
2364	int rc = ShClTransferStart(pTransfer);
2365
2366	/* Let the guest know in any case
2367	* (so that it can tear down the transfer on error as well). */
2368	int rc2 = shClSvcTransferSendStatusAsync(pClient, pTransfer,
2369	RT_SUCCESS(rc)
2370	? SHCLTRANSFERSTATUS_STARTED : SHCLTRANSFERSTATUS_ERROR, rc,
2371	NULL /* ppEvent */);
2372	if (RT_SUCCESS(rc))
2373	rc = rc2;
2374
2375	ShClSvcClientUnlock(pClient);
2376	return rc;
2377	}
2378
2379	/**
2380	* Stops (and destroys) a transfer, communicating the status to the guest side.
2381	*
2382	* @returns VBox status code.
2383	* @param pClient Client that owns the transfer.
2384	* @param pTransfer Transfer to stop. The pointer will be invalid on success.
2385	* @param fWaitForGuest Set to \c true to wait for acknowledgement from guest, or \c false to skip waiting.
2386	*/
2387	int ShClSvcTransferStop(PSHCLCLIENT pClient, PSHCLTRANSFER pTransfer, bool fWaitForGuest)
2388	{
2389	LogRel2(("Shared Clipboard: Stopping transfer %RU16 ...\n", pTransfer->State.uID));
2390
2391	ShClSvcClientLock(pClient);
2392
2393	PSHCLEVENT pEvent;
2394	int rc = shClSvcTransferSendStatusAsync(pClient, pTransfer,
2395	SHCLTRANSFERSTATUS_COMPLETED, VINF_SUCCESS, &pEvent);
2396	if ( RT_SUCCESS(rc)
2397	&& fWaitForGuest)
2398	{
2399	LogRel2(("Shared Clipboard: Waiting for stop of transfer %RU16 on guest ...\n", pTransfer->State.uID));
2400
2401	ShClSvcClientUnlock(pClient);
2402
2403	rc = ShClEventWait(pEvent, pTransfer->uTimeoutMs, NULL /* ppPayload */);
2404	if (RT_SUCCESS(rc))
2405	LogRel2(("Shared Clipboard: Stopped transfer %RU16 on guest\n", pTransfer->State.uID));
2406
2407	ShClEventRelease(pEvent);
2408
2409	ShClSvcClientLock(pClient);
2410	}
2411
2412	if (RT_FAILURE(rc))
2413	LogRelMax(64, ("Shared Clipboard: Unable to stop transfer %RU16 on guest, rc=%Rrc\n",
2414	pTransfer->State.uID, rc));
2415
2416	ShClSvcClientUnlock(pClient);
2417
2418	LogFlowFuncLeaveRC(rc);
2419	return rc;
2420	}
2421
2422	/**
2423	* Sets the host service's (file) transfer mode.
2424	*
2425	* @returns VBox status code.
2426	* @param fMode Transfer mode to set.
2427	*/
2428	int shClSvcTransferModeSet(uint32_t fMode)
2429	{
2430	if (fMode & ~VBOX_SHCL_TRANSFER_MODE_F_VALID_MASK)
2431	return VERR_INVALID_FLAGS;
2432
2433	g_fTransferMode = fMode;
2434
2435	LogRel2(("Shared Clipboard: File transfers are now %s\n",
2436	g_fTransferMode & VBOX_SHCL_TRANSFER_MODE_F_ENABLED ? "enabled" : "disabled"));
2437
2438	/* If file transfers are being disabled, make sure to also reset (destroy) all pending transfers. */
2439	if (!(g_fTransferMode & VBOX_SHCL_TRANSFER_MODE_F_ENABLED))
2440	{
2441	ClipboardClientMap::const_iterator itClient = g_mapClients.begin();
2442	while (itClient != g_mapClients.end())
2443	{
2444	PSHCLCLIENT pClient = itClient->second;
2445	AssertPtr(pClient);
2446
2447	shClSvcTransferDestroyAll(pClient);
2448
2449	++itClient;
2450	}
2451	}
2452
2453	LogFlowFuncLeaveRC(VINF_SUCCESS);
2454	return VINF_SUCCESS;
2455	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostServices/SharedClipboard/VBoxSharedClipboardSvc-transfers.cpp@ 105745

Download in other formats: