VBoxSharedFoldersSvc.cpp@ 78668

Last change on this file since 78668 was 78467, checked in by vboxsync, 6 years ago
SharedFoldersSvc: Adding an alternative remove function that also closes the handle so that windows guests can combine two host calls and speed up deletion. bugref:9172
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 87.1 KB

Line
1	/* $Id: VBoxSharedFoldersSvc.cpp 78467 2019-05-11 01:04:24Z vboxsync $ */
2	/** @file
3	* Shared Folders - Host service entry points.
4	*/
5
6	/*
7	* Copyright (C) 2006-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
23	#include <VBox/shflsvc.h>
24
25	#include "shfl.h"
26	#include "mappings.h"
27	#include "shflhandle.h"
28	#include "vbsf.h"
29	#include <iprt/alloc.h>
30	#include <iprt/string.h>
31	#include <iprt/assert.h>
32	#include <VBox/AssertGuest.h>
33	#include <VBox/vmm/ssm.h>
34	#include <VBox/vmm/pdmifs.h>
35
36
37	/*********************************************************************************************************************************
38	* Defined Constants And Macros *
39	*********************************************************************************************************************************/
40	#define SHFL_SAVED_STATE_VERSION_FOLDERNAME_UTF16 2
41	#define SHFL_SAVED_STATE_VERSION_PRE_AUTO_MOUNT_POINT 3
42	#define SHFL_SAVED_STATE_VERSION 4
43
44
45	/*********************************************************************************************************************************
46	* Global Variables *
47	*********************************************************************************************************************************/
48	PVBOXHGCMSVCHELPERS g_pHelpers;
49	static PPDMLED g_pStatusLed = NULL;
50
51	/** @name Shared folder statistics.
52	* @{ */
53	static STAMPROFILE g_StatQueryMappings;
54	static STAMPROFILE g_StatQueryMappingsFail;
55	static STAMPROFILE g_StatQueryMapName;
56	static STAMPROFILE g_StatCreate;
57	static STAMPROFILE g_StatCreateFail;
58	static STAMPROFILE g_StatLookup;
59	static STAMPROFILE g_StatLookupFail;
60	static STAMPROFILE g_StatClose;
61	static STAMPROFILE g_StatCloseFail;
62	static STAMPROFILE g_StatRead;
63	static STAMPROFILE g_StatReadFail;
64	static STAMPROFILE g_StatWrite;
65	static STAMPROFILE g_StatWriteFail;
66	static STAMPROFILE g_StatLock;
67	static STAMPROFILE g_StatLockFail;
68	static STAMPROFILE g_StatList;
69	static STAMPROFILE g_StatListFail;
70	static STAMPROFILE g_StatReadLink;
71	static STAMPROFILE g_StatReadLinkFail;
72	static STAMPROFILE g_StatMapFolderOld;
73	static STAMPROFILE g_StatMapFolder;
74	static STAMPROFILE g_StatMapFolderFail;
75	static STAMPROFILE g_StatUnmapFolder;
76	static STAMPROFILE g_StatUnmapFolderFail;
77	static STAMPROFILE g_StatInformationFail;
78	static STAMPROFILE g_StatInformationSetFile;
79	static STAMPROFILE g_StatInformationSetFileFail;
80	static STAMPROFILE g_StatInformationSetSize;
81	static STAMPROFILE g_StatInformationSetSizeFail;
82	static STAMPROFILE g_StatInformationGetFile;
83	static STAMPROFILE g_StatInformationGetFileFail;
84	static STAMPROFILE g_StatInformationGetVolume;
85	static STAMPROFILE g_StatInformationGetVolumeFail;
86	static STAMPROFILE g_StatRemove;
87	static STAMPROFILE g_StatRemoveFail;
88	static STAMPROFILE g_StatCloseAndRemove;
89	static STAMPROFILE g_StatCloseAndRemoveFail;
90	static STAMPROFILE g_StatRename;
91	static STAMPROFILE g_StatRenameFail;
92	static STAMPROFILE g_StatFlush;
93	static STAMPROFILE g_StatFlushFail;
94	static STAMPROFILE g_StatSetUtf8;
95	static STAMPROFILE g_StatSetFileSize;
96	static STAMPROFILE g_StatSetFileSizeFail;
97	static STAMPROFILE g_StatSymlink;
98	static STAMPROFILE g_StatSymlinkFail;
99	static STAMPROFILE g_StatSetSymlinks;
100	static STAMPROFILE g_StatQueryMapInfo;
101	static STAMPROFILE g_StatQueryFeatures;
102	static STAMPROFILE g_StatCopyFile;
103	static STAMPROFILE g_StatCopyFileFail;
104	static STAMPROFILE g_StatCopyFilePart;
105	static STAMPROFILE g_StatCopyFilePartFail;
106	static STAMPROFILE g_StatWaitForMappingsChanges;
107	static STAMPROFILE g_StatWaitForMappingsChangesFail;
108	static STAMPROFILE g_StatCancelMappingsChangesWait;
109	static STAMPROFILE g_StatUnknown;
110	static STAMPROFILE g_StatMsgStage1;
111	/** @} */
112
113
114	/** @page pg_shfl_svc Shared Folders Host Service
115	*
116	* Shared Folders map a host file system to guest logical filesystem.
117	* A mapping represents 'host name'<->'guest name' translation and a root
118	* identifier to be used to access this mapping.
119	* Examples: "C:\WINNT"<->"F:", "C:\WINNT\System32"<->"/mnt/host/system32".
120	*
121	* Therefore, host name and guest name are strings interpreted
122	* only by host service and guest client respectively. Host name is
123	* passed to guest only for informational purpose. Guest may for example
124	* display the string or construct volume label out of the string.
125	*
126	* Root identifiers are unique for whole guest life,
127	* that is until next guest reset/fresh start.
128	* 32 bit value incremented for each new mapping is used.
129	*
130	* Mapping strings are taken from VM XML configuration on VM startup.
131	* The service DLL takes mappings during initialization. There is
132	* also API for changing mappings at runtime.
133	*
134	* Current mappings and root identifiers are saved when VM is saved.
135	*
136	* Guest may use any of these mappings. Full path information
137	* about an object on a mapping consists of the root identifier and
138	* a full path of object.
139	*
140	* Guest IFS connects to the service and calls SHFL_FN_QUERY_MAP
141	* function which returns current mappings. For guest convenience,
142	* removed mappings also returned with REMOVED flag and new mappings
143	* are marked with NEW flag.
144	*
145	* To access host file system guest just forwards file system calls
146	* to the service, and specifies full paths or handles for objects.
147	*
148	*
149	*/
150
151
152
153	static DECLCALLBACK(int) svcUnload (void *)
154	{
155	int rc = VINF_SUCCESS;
156
157	Log(("svcUnload\n"));
158	vbsfFreeHandleTable();
159
160	if (g_pHelpers)
161	HGCMSvcHlpStamDeregister(g_pHelpers, "/HGCM/VBoxSharedFolders/*");
162	return rc;
163	}
164
165	static DECLCALLBACK(int) svcConnect (void , uint32_t u32ClientID, void pvClient, uint32_t fRequestor, bool fRestoring)
166	{
167	RT_NOREF(u32ClientID, fRequestor, fRestoring);
168	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
169	Log(("SharedFolders host service: connected, u32ClientID = %u\n", u32ClientID));
170
171	pClient->fHasMappingCounts = true;
172	return VINF_SUCCESS;
173	}
174
175	static DECLCALLBACK(int) svcDisconnect (void , uint32_t u32ClientID, void pvClient)
176	{
177	RT_NOREF1(u32ClientID);
178	int rc = VINF_SUCCESS;
179	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
180
181	Log(("SharedFolders host service: disconnected, u32ClientID = %u\n", u32ClientID));
182
183	vbsfDisconnect(pClient);
184	return rc;
185	}
186
187	/** @note We only save as much state as required to access the shared folder again after restore.
188	* All I/O requests pending at the time of saving will never be completed or result in errors.
189	* (file handles no longer valid etc)
190	* This works as designed at the moment. A full state save would be difficult and not always possible
191	* as the contents of a shared folder might change in between save and restore.
192	*/
193	static DECLCALLBACK(int) svcSaveState(void , uint32_t u32ClientID, void pvClient, PSSMHANDLE pSSM)
194	{
195	#ifndef UNITTEST /* Read this as not yet tested */
196	RT_NOREF1(u32ClientID);
197	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
198
199	Log(("SharedFolders host service: saving state, u32ClientID = %u\n", u32ClientID));
200
201	int rc = SSMR3PutU32(pSSM, SHFL_SAVED_STATE_VERSION);
202	AssertRCReturn(rc, rc);
203
204	rc = SSMR3PutU32(pSSM, SHFL_MAX_MAPPINGS);
205	AssertRCReturn(rc, rc);
206
207	/* Save client structure length & contents */
208	rc = SSMR3PutU32(pSSM, sizeof(*pClient));
209	AssertRCReturn(rc, rc);
210
211	rc = SSMR3PutMem(pSSM, pClient, sizeof(*pClient));
212	AssertRCReturn(rc, rc);
213
214	/* Save all the active mappings. */
215	for (int i=0;i<SHFL_MAX_MAPPINGS;i++)
216	{
217	/* Mapping are saved in the order of increasing root handle values. */
218	MAPPING *pFolderMapping = vbsfMappingGetByRoot(i);
219
220	rc = SSMR3PutU32(pSSM, pFolderMapping? pFolderMapping->cMappings: 0);
221	AssertRCReturn(rc, rc);
222
223	rc = SSMR3PutBool(pSSM, pFolderMapping? pFolderMapping->fValid: false);
224	AssertRCReturn(rc, rc);
225
226	if (pFolderMapping && pFolderMapping->fValid)
227	{
228	uint32_t len = (uint32_t)strlen(pFolderMapping->pszFolderName);
229	SSMR3PutU32(pSSM, len);
230	SSMR3PutStrZ(pSSM, pFolderMapping->pszFolderName);
231
232	len = ShflStringSizeOfBuffer(pFolderMapping->pMapName);
233	SSMR3PutU32(pSSM, len);
234	SSMR3PutMem(pSSM, pFolderMapping->pMapName, len);
235
236	SSMR3PutBool(pSSM, pFolderMapping->fHostCaseSensitive);
237
238	SSMR3PutBool(pSSM, pFolderMapping->fGuestCaseSensitive);
239
240	len = ShflStringSizeOfBuffer(pFolderMapping->pAutoMountPoint);
241	SSMR3PutU32(pSSM, len);
242	rc = SSMR3PutMem(pSSM, pFolderMapping->pAutoMountPoint, len);
243	AssertRCReturn(rc, rc);
244	}
245	}
246
247	#else
248	RT_NOREF3(u32ClientID, pvClient, pSSM);
249	#endif
250	return VINF_SUCCESS;
251	}
252
253	static DECLCALLBACK(int) svcLoadState(void , uint32_t u32ClientID, void pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
254	{
255	#ifndef UNITTEST /* Read this as not yet tested */
256	RT_NOREF(u32ClientID, uVersion);
257	uint32_t nrMappings;
258	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
259	uint32_t len, version;
260
261	Log(("SharedFolders host service: loading state, u32ClientID = %u\n", u32ClientID));
262
263	int rc = SSMR3GetU32(pSSM, &version);
264	AssertRCReturn(rc, rc);
265
266	if ( version > SHFL_SAVED_STATE_VERSION
267	\|\| version < SHFL_SAVED_STATE_VERSION_FOLDERNAME_UTF16)
268	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
269
270	rc = SSMR3GetU32(pSSM, &nrMappings);
271	AssertRCReturn(rc, rc);
272	if (nrMappings != SHFL_MAX_MAPPINGS)
273	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
274
275	/* Restore the client data (flags + path delimiter + mapping counts (new) at the moment) */
276	rc = SSMR3GetU32(pSSM, &len);
277	AssertRCReturn(rc, rc);
278
279	if (len == RT_UOFFSETOF(SHFLCLIENTDATA, acMappings))
280	pClient->fHasMappingCounts = false;
281	else if (len != sizeof(*pClient))
282	return SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
283	"Saved SHFLCLIENTDATA size %u differs from current %u!\n", len, sizeof(*pClient));
284
285	rc = SSMR3GetMem(pSSM, pClient, len);
286	AssertRCReturn(rc, rc);
287
288	/* We don't actually (fully) restore the state; we simply check if the current state is as we it expect it to be. */
289	for (int i=0;i<SHFL_MAX_MAPPINGS;i++)
290	{
291	/* Load the saved mapping description and try to find it in the mappings. */
292	MAPPING mapping;
293	RT_ZERO(mapping);
294
295	/* restore the folder mapping counter. */
296	rc = SSMR3GetU32(pSSM, &mapping.cMappings);
297	AssertRCReturn(rc, rc);
298
299	rc = SSMR3GetBool(pSSM, &mapping.fValid);
300	AssertRCReturn(rc, rc);
301
302	if (mapping.fValid)
303	{
304	uint32_t cb;
305
306	/* Load the host path name. */
307	rc = SSMR3GetU32(pSSM, &cb);
308	AssertRCReturn(rc, rc);
309
310	char *pszFolderName;
311	if (version == SHFL_SAVED_STATE_VERSION_FOLDERNAME_UTF16)
312	{
313	AssertReturn(cb > SHFLSTRING_HEADER_SIZE && cb <= UINT16_MAX + SHFLSTRING_HEADER_SIZE && !(cb & 1),
314	SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS, "Bad folder name size: %#x\n", cb));
315	PSHFLSTRING pFolderName = (PSHFLSTRING)RTMemAlloc(cb);
316	AssertReturn(pFolderName != NULL, VERR_NO_MEMORY);
317
318	rc = SSMR3GetMem(pSSM, pFolderName, cb);
319	AssertRCReturn(rc, rc);
320	AssertReturn(pFolderName->u16Size < cb && pFolderName->u16Length < pFolderName->u16Size,
321	SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
322	"Bad folder name string: %#x/%#x cb=%#x\n",
323	pFolderName->u16Size, pFolderName->u16Length, cb));
324
325	rc = RTUtf16ToUtf8(pFolderName->String.ucs2, &pszFolderName);
326	RTMemFree(pFolderName);
327	AssertRCReturn(rc, rc);
328	}
329	else
330	{
331	pszFolderName = (char *)RTStrAlloc(cb + 1);
332	AssertReturn(pszFolderName, VERR_NO_MEMORY);
333
334	rc = SSMR3GetStrZ(pSSM, pszFolderName, cb + 1);
335	AssertRCReturn(rc, rc);
336	mapping.pszFolderName = pszFolderName;
337	}
338
339	/* Load the map name. */
340	rc = SSMR3GetU32(pSSM, &cb);
341	AssertRCReturn(rc, rc);
342	AssertReturn(cb > SHFLSTRING_HEADER_SIZE && cb <= UINT16_MAX + SHFLSTRING_HEADER_SIZE && !(cb & 1),
343	SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS, "Bad map name size: %#x\n", cb));
344
345	PSHFLSTRING pMapName = (PSHFLSTRING)RTMemAlloc(cb);
346	AssertReturn(pMapName != NULL, VERR_NO_MEMORY);
347
348	rc = SSMR3GetMem(pSSM, pMapName, cb);
349	AssertRCReturn(rc, rc);
350	AssertReturn(pMapName->u16Size < cb && pMapName->u16Length < pMapName->u16Size,
351	SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
352	"Bad map name string: %#x/%#x cb=%#x\n",
353	pMapName->u16Size, pMapName->u16Length, cb));
354
355	/* Load case sensitivity config. */
356	rc = SSMR3GetBool(pSSM, &mapping.fHostCaseSensitive);
357	AssertRCReturn(rc, rc);
358
359	rc = SSMR3GetBool(pSSM, &mapping.fGuestCaseSensitive);
360	AssertRCReturn(rc, rc);
361
362	/* Load the auto mount point. */
363	PSHFLSTRING pAutoMountPoint;
364	if (version > SHFL_SAVED_STATE_VERSION_PRE_AUTO_MOUNT_POINT)
365	{
366	rc = SSMR3GetU32(pSSM, &cb);
367	AssertRCReturn(rc, rc);
368	AssertReturn(cb > SHFLSTRING_HEADER_SIZE && cb <= UINT16_MAX + SHFLSTRING_HEADER_SIZE && !(cb & 1),
369	SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS, "Bad auto mount point size: %#x\n", cb));
370
371	pAutoMountPoint = (PSHFLSTRING)RTMemAlloc(cb);
372	AssertReturn(pAutoMountPoint != NULL, VERR_NO_MEMORY);
373
374	rc = SSMR3GetMem(pSSM, pAutoMountPoint, cb);
375	AssertRCReturn(rc, rc);
376	AssertReturn(pAutoMountPoint->u16Size < cb && pAutoMountPoint->u16Length < pAutoMountPoint->u16Size,
377	SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
378	"Bad auto mount point string: %#x/%#x cb=%#x\n",
379	pAutoMountPoint->u16Size, pAutoMountPoint->u16Length, cb));
380
381	}
382	else
383	{
384	pAutoMountPoint = ShflStringDupUtf8("");
385	AssertReturn(pAutoMountPoint, VERR_NO_MEMORY);
386	}
387
388	mapping.pszFolderName = pszFolderName;
389	mapping.pMapName = pMapName;
390	mapping.pAutoMountPoint = pAutoMountPoint;
391
392	/* 'i' is the root handle of the saved mapping. */
393	rc = vbsfMappingLoaded (&mapping, i);
394	if (RT_FAILURE(rc))
395	{
396	LogRel(("SharedFolders host service: %Rrc loading %d [%ls] -> [%s]\n",
397	rc, i, pMapName->String.ucs2, pszFolderName));
398	}
399
400	RTMemFree(pAutoMountPoint);
401	RTMemFree(pMapName);
402	RTStrFree(pszFolderName);
403
404	AssertRCReturn(rc, rc);
405	}
406	}
407	Log(("SharedFolders host service: successfully loaded state\n"));
408	#else
409	RT_NOREF(u32ClientID, pvClient, pSSM, uVersion);
410	#endif
411	return VINF_SUCCESS;
412	}
413
414	static DECLCALLBACK(void) svcCall (void , VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void pvClient,
415	uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival)
416	{
417	RT_NOREF(u32ClientID, tsArrival);
418	#ifndef VBOX_WITHOUT_RELEASE_STATISTICS
419	uint64_t tsStart;
420	STAM_GET_TS(tsStart);
421	STAM_REL_PROFILE_ADD_PERIOD(&g_StatMsgStage1, tsStart - tsArrival);
422	#endif
423	Log(("SharedFolders host service: svcCall: u32ClientID = %u, fn = %u, cParms = %u, pparms = %p\n", u32ClientID, u32Function, cParms, paParms));
424
425	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
426
427	bool fAsynchronousProcessing = false;
428
429	#ifdef LOG_ENABLED
430	for (uint32_t i = 0; i < cParms; i++)
431	{
432	/** @todo parameters other than 32 bit */
433	Log((" pparms[%d]: type %u, value %u\n", i, paParms[i].type, paParms[i].u.uint32));
434	}
435	#endif
436
437	int rc = VINF_SUCCESS;
438	PSTAMPROFILE pStat, pStatFail;
439	switch (u32Function)
440	{
441	case SHFL_FN_QUERY_MAPPINGS:
442	{
443	pStat = &g_StatQueryMappings;
444	pStatFail = &g_StatQueryMappingsFail;
445	Log(("SharedFolders host service: svcCall: SHFL_FN_QUERY_MAPPINGS\n"));
446
447	/* Verify parameter count and types. */
448	if (cParms != SHFL_CPARMS_QUERY_MAPPINGS)
449	{
450	rc = VERR_INVALID_PARAMETER;
451	}
452	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
453	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* numberOfMappings */
454	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* mappings */
455	)
456	{
457	rc = VERR_INVALID_PARAMETER;
458	}
459	else
460	{
461	/* Fetch parameters. */
462	uint32_t fu32Flags = paParms[0].u.uint32;
463	uint32_t cMappings = paParms[1].u.uint32;
464	SHFLMAPPING pMappings = (SHFLMAPPING )paParms[2].u.pointer.addr;
465	uint32_t cbMappings = paParms[2].u.pointer.size;
466
467	/* Verify parameters values. */
468	if ( (fu32Flags & ~SHFL_MF_MASK) != 0
469	\|\| cbMappings / sizeof (SHFLMAPPING) != cMappings
470	)
471	{
472	rc = VERR_INVALID_PARAMETER;
473	}
474	else
475	{
476	/* Execute the function. */
477	if (fu32Flags & SHFL_MF_UTF8)
478	pClient->fu32Flags \|= SHFL_CF_UTF8;
479	/// @todo r=bird: Someone please explain this amusing code (r63916):
480	//if (fu32Flags & SHFL_MF_AUTOMOUNT)
481	// pClient->fu32Flags \|= SHFL_MF_AUTOMOUNT;
482	//
483	//rc = vbsfMappingsQuery(pClient, pMappings, &cMappings);
484
485	rc = vbsfMappingsQuery(pClient, RT_BOOL(fu32Flags & SHFL_MF_AUTOMOUNT), pMappings, &cMappings);
486	if (RT_SUCCESS(rc))
487	{
488	/* Report that there are more mappings to get if
489	* handed in buffer is too small. */
490	if (paParms[1].u.uint32 < cMappings)
491	rc = VINF_BUFFER_OVERFLOW;
492
493	/* Update parameters. */
494	paParms[1].u.uint32 = cMappings;
495	}
496	}
497	}
498
499
500	} break;
501
502	case SHFL_FN_QUERY_MAP_NAME:
503	{
504	pStatFail = pStat = &g_StatQueryMapName;
505	Log(("SharedFolders host service: svcCall: SHFL_FN_QUERY_MAP_NAME\n"));
506
507	/* Verify parameter count and types. */
508	if (cParms != SHFL_CPARMS_QUERY_MAP_NAME)
509	{
510	rc = VERR_INVALID_PARAMETER;
511	}
512	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* Root. */
513	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* Name. */
514	)
515	{
516	rc = VERR_INVALID_PARAMETER;
517	}
518	else
519	{
520	/* Fetch parameters. */
521	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
522	SHFLSTRING pString = (SHFLSTRING )paParms[1].u.pointer.addr;
523
524	/* Verify parameters values. */
525	if (!ShflStringIsValidOut(pString, paParms[1].u.pointer.size))
526	{
527	rc = VERR_INVALID_PARAMETER;
528	}
529	else
530	{
531	/* Execute the function. */
532	rc = vbsfMappingsQueryName(pClient, root, pString);
533
534	if (RT_SUCCESS(rc))
535	{
536	/* Update parameters.*/
537	; /* None. */
538	}
539	}
540	}
541
542	} break;
543
544	case SHFL_FN_CREATE:
545	{
546	pStat = &g_StatCreate;
547	pStatFail = &g_StatCreateFail;
548	Log(("SharedFolders host service: svcCall: SHFL_FN_CREATE\n"));
549
550	/* Verify parameter count and types. */
551	if (cParms != SHFL_CPARMS_CREATE)
552	{
553	rc = VERR_INVALID_PARAMETER;
554	}
555	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
556	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
557	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* parms */
558	)
559	{
560	Log(("SharedFolders host service: Invalid parameters types\n"));
561	rc = VERR_INVALID_PARAMETER;
562	}
563	else
564	{
565	/* Fetch parameters. */
566	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
567	SHFLSTRING pPath = (SHFLSTRING )paParms[1].u.pointer.addr;
568	uint32_t cbPath = paParms[1].u.pointer.size;
569	SHFLCREATEPARMS pParms = (SHFLCREATEPARMS )paParms[2].u.pointer.addr;
570	uint32_t cbParms = paParms[2].u.pointer.size;
571
572	/* Verify parameters values. */
573	if ( !ShflStringIsValidIn(pPath, cbPath, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
574	\|\| (cbParms != sizeof (SHFLCREATEPARMS))
575	)
576	{
577	AssertMsgFailed (("Invalid parameters cbPath or cbParms (%x, %x - expected >=%x, %x)\n",
578	cbPath, cbParms, sizeof(SHFLSTRING), sizeof (SHFLCREATEPARMS)));
579	rc = VERR_INVALID_PARAMETER;
580	}
581	else
582	{
583	if (pParms->CreateFlags & SHFL_CF_LOOKUP)
584	{
585	pStat = &g_StatLookup;
586	pStatFail = &g_StatLookupFail;
587	}
588
589	/* Execute the function. */
590	rc = vbsfCreate (pClient, root, pPath, cbPath, pParms);
591
592	if (RT_SUCCESS(rc))
593	{
594	/* Update parameters.*/
595	; /* none */
596	}
597	}
598	}
599	break;
600	}
601
602	case SHFL_FN_CLOSE:
603	{
604	pStat = &g_StatClose;
605	pStatFail = &g_StatCloseFail;
606	Log(("SharedFolders host service: svcCall: SHFL_FN_CLOSE\n"));
607
608	/* Verify parameter count and types. */
609	if (cParms != SHFL_CPARMS_CLOSE)
610	{
611	rc = VERR_INVALID_PARAMETER;
612	}
613	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
614	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
615	)
616	{
617	rc = VERR_INVALID_PARAMETER;
618	}
619	else
620	{
621	/* Fetch parameters. */
622	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
623	SHFLHANDLE Handle = paParms[1].u.uint64;
624
625	/* Verify parameters values. */
626	if (Handle == SHFL_HANDLE_ROOT)
627	{
628	rc = VERR_INVALID_PARAMETER;
629	}
630	else
631	if (Handle == SHFL_HANDLE_NIL)
632	{
633	AssertMsgFailed(("Invalid handle!\n"));
634	rc = VERR_INVALID_HANDLE;
635	}
636	else
637	{
638	/* Execute the function. */
639	rc = vbsfClose (pClient, root, Handle);
640
641	if (RT_SUCCESS(rc))
642	{
643	/* Update parameters.*/
644	; /* none */
645	}
646	}
647	}
648	break;
649
650	}
651
652	/* Read object content. */
653	case SHFL_FN_READ:
654	{
655	pStat = &g_StatRead;
656	pStatFail = &g_StatReadFail;
657	Log(("SharedFolders host service: svcCall: SHFL_FN_READ\n"));
658	/* Verify parameter count and types. */
659	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_READ, rc = VERR_WRONG_PARAMETER_COUNT);
660	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* root */
661	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* handle */
662	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* offset */
663	ASSERT_GUEST_STMT_BREAK(paParms[3].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* count */
664	ASSERT_GUEST_STMT_BREAK( paParms[4].type == VBOX_HGCM_SVC_PARM_PTR
665	\|\| paParms[4].type == VBOX_HGCM_SVC_PARM_PAGES, rc = VERR_WRONG_PARAMETER_TYPE); /* buffer */
666
667	/* Fetch parameters. */
668	SHFLROOT const idRoot = (SHFLROOT)paParms[0].u.uint32;
669	SHFLHANDLE const hFile = paParms[1].u.uint64;
670	uint64_t const offFile = paParms[2].u.uint64;
671	uint32_t cbRead = paParms[3].u.uint32;
672
673	/* Verify parameters values. */
674	ASSERT_GUEST_STMT_BREAK(hFile != SHFL_HANDLE_ROOT, rc = VERR_INVALID_PARAMETER);
675	ASSERT_GUEST_STMT_BREAK(hFile != SHFL_HANDLE_NIL, rc = VERR_INVALID_HANDLE);
676	if (paParms[4].type == VBOX_HGCM_SVC_PARM_PTR)
677	ASSERT_GUEST_STMT_BREAK(cbRead <= paParms[4].u.pointer.size, rc = VERR_INVALID_HANDLE);
678	else
679	ASSERT_GUEST_STMT_BREAK(cbRead <= paParms[4].u.Pages.cb, rc = VERR_OUT_OF_RANGE);
680
681	/* Execute the function. */
682	if (g_pStatusLed)
683	{
684	Assert(g_pStatusLed->u32Magic == PDMLED_MAGIC);
685	g_pStatusLed->Asserted.s.fReading = g_pStatusLed->Actual.s.fReading = 1;
686	}
687
688	if (paParms[4].type == VBOX_HGCM_SVC_PARM_PTR)
689	rc = vbsfRead(pClient, idRoot, hFile, offFile, &cbRead, (uint8_t *)paParms[4].u.pointer.addr);
690	else
691	rc = vbsfReadPages(pClient, idRoot, hFile, offFile, &cbRead, &paParms[4].u.Pages);
692
693	if (g_pStatusLed)
694	g_pStatusLed->Actual.s.fReading = 0;
695
696	/* Update parameters.*/
697	paParms[3].u.uint32 = RT_SUCCESS(rc) ? cbRead : 0 /* nothing read */;
698	break;
699	}
700
701	/* Write new object content. */
702	case SHFL_FN_WRITE:
703	{
704	pStat = &g_StatWrite;
705	pStatFail = &g_StatWriteFail;
706	Log(("SharedFolders host service: svcCall: SHFL_FN_WRITE\n"));
707
708	/* Verify parameter count and types. */
709	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_WRITE, rc = VERR_WRONG_PARAMETER_COUNT);
710	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* root */
711	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* handle */
712	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* offset */
713	ASSERT_GUEST_STMT_BREAK(paParms[3].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* count */
714	ASSERT_GUEST_STMT_BREAK( paParms[4].type == VBOX_HGCM_SVC_PARM_PTR
715	\|\| paParms[4].type == VBOX_HGCM_SVC_PARM_PAGES, rc = VERR_WRONG_PARAMETER_TYPE); /* buffer */
716	/* Fetch parameters. */
717	SHFLROOT const idRoot = (SHFLROOT)paParms[0].u.uint32;
718	SHFLHANDLE const hFile = paParms[1].u.uint64;
719	uint64_t offFile = paParms[2].u.uint64;
720	uint32_t cbWrite = paParms[3].u.uint32;
721
722	/* Verify parameters values. */
723	ASSERT_GUEST_STMT_BREAK(hFile != SHFL_HANDLE_ROOT, rc = VERR_INVALID_PARAMETER);
724	ASSERT_GUEST_STMT_BREAK(hFile != SHFL_HANDLE_NIL, rc = VERR_INVALID_HANDLE);
725	if (paParms[4].type == VBOX_HGCM_SVC_PARM_PTR)
726	ASSERT_GUEST_STMT_BREAK(cbWrite <= paParms[4].u.pointer.size, rc = VERR_INVALID_HANDLE);
727	else
728	ASSERT_GUEST_STMT_BREAK(cbWrite <= paParms[4].u.Pages.cb, rc = VERR_OUT_OF_RANGE);
729
730	/* Execute the function. */
731	if (g_pStatusLed)
732	{
733	Assert(g_pStatusLed->u32Magic == PDMLED_MAGIC);
734	g_pStatusLed->Asserted.s.fWriting = g_pStatusLed->Actual.s.fWriting = 1;
735	}
736
737	if (paParms[4].type == VBOX_HGCM_SVC_PARM_PTR)
738	rc = vbsfWrite(pClient, idRoot, hFile, &offFile, &cbWrite, (uint8_t *)paParms[4].u.pointer.addr);
739	else
740	rc = vbsfWritePages(pClient, idRoot, hFile, &offFile, &cbWrite, &paParms[4].u.Pages);
741
742	if (g_pStatusLed)
743	g_pStatusLed->Actual.s.fWriting = 0;
744
745	/* Update parameters.*/
746	if (RT_SUCCESS(rc))
747	{
748	paParms[3].u.uint32 = cbWrite;
749	paParms[4].u.uint64 = offFile;
750	}
751	else
752	paParms[3].u.uint32 = 0;
753	break;
754	}
755
756	/* Lock/unlock a range in the object. */
757	case SHFL_FN_LOCK:
758	pStat = &g_StatLock;
759	pStatFail = &g_StatLockFail;
760	Log(("SharedFolders host service: svcCall: SHFL_FN_LOCK\n"));
761
762	/* Verify parameter count and types. */
763	if (cParms != SHFL_CPARMS_LOCK)
764	{
765	rc = VERR_INVALID_PARAMETER;
766	}
767	else
768	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
769	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
770	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
771	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_64BIT /* length */
772	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
773	)
774	{
775	rc = VERR_INVALID_PARAMETER;
776	}
777	else
778	{
779	/* Fetch parameters. */
780	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
781	SHFLHANDLE Handle = paParms[1].u.uint64;
782	uint64_t offset = paParms[2].u.uint64;
783	uint64_t length = paParms[3].u.uint64;
784	uint32_t flags = paParms[4].u.uint32;
785
786	/* Verify parameters values. */
787	if (Handle == SHFL_HANDLE_ROOT)
788	{
789	rc = VERR_INVALID_PARAMETER;
790	}
791	else
792	if (Handle == SHFL_HANDLE_NIL)
793	{
794	AssertMsgFailed(("Invalid handle!\n"));
795	rc = VERR_INVALID_HANDLE;
796	}
797	else if (flags & SHFL_LOCK_WAIT)
798	{
799	/** @todo This should be properly implemented by the shared folders service.
800	* The service thread must never block. If an operation requires
801	* blocking, it must be processed by another thread and when it is
802	* completed, the another thread must call
803	*
804	* g_pHelpers->pfnCallComplete (callHandle, rc);
805	*
806	* The operation is async.
807	* fAsynchronousProcessing = true;
808	*/
809
810	/* Here the operation must be posted to another thread. At the moment it is not implemented.
811	* Until it is implemented, try to perform the operation without waiting.
812	*/
813	flags &= ~SHFL_LOCK_WAIT;
814
815	/* Execute the function. */
816	if ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
817	rc = vbsfUnlock(pClient, root, Handle, offset, length, flags);
818	else
819	rc = vbsfLock(pClient, root, Handle, offset, length, flags);
820
821	if (RT_SUCCESS(rc))
822	{
823	/* Update parameters.*/
824	/* none */
825	}
826	}
827	else
828	{
829	/* Execute the function. */
830	if ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
831	rc = vbsfUnlock(pClient, root, Handle, offset, length, flags);
832	else
833	rc = vbsfLock(pClient, root, Handle, offset, length, flags);
834
835	if (RT_SUCCESS(rc))
836	{
837	/* Update parameters.*/
838	/* none */
839	}
840	}
841	}
842	break;
843
844	/* List object content. */
845	case SHFL_FN_LIST:
846	{
847	pStat = &g_StatList;
848	pStatFail = &g_StatListFail;
849	Log(("SharedFolders host service: svcCall: SHFL_FN_LIST\n"));
850
851	/* Verify parameter count and types. */
852	if (cParms != SHFL_CPARMS_LIST)
853	{
854	rc = VERR_INVALID_PARAMETER;
855	}
856	else
857	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
858	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
859	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
860	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* cb */
861	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* pPath */
862	\|\| paParms[5].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
863	\|\| paParms[6].type != VBOX_HGCM_SVC_PARM_32BIT /* resumePoint */
864	\|\| paParms[7].type != VBOX_HGCM_SVC_PARM_32BIT /* cFiles (out) */
865	)
866	{
867	rc = VERR_INVALID_PARAMETER;
868	}
869	else
870	{
871	/* Fetch parameters. */
872	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
873	SHFLHANDLE Handle = paParms[1].u.uint64;
874	uint32_t flags = paParms[2].u.uint32;
875	uint32_t length = paParms[3].u.uint32;
876	SHFLSTRING pPath = (paParms[4].u.pointer.size == 0) ? 0 : (SHFLSTRING )paParms[4].u.pointer.addr;
877	uint8_t pBuffer = (uint8_t )paParms[5].u.pointer.addr;
878	uint32_t resumePoint = paParms[6].u.uint32;
879	uint32_t cFiles = 0;
880
881	/* Verify parameters values. */
882	if ( (length < sizeof (SHFLDIRINFO))
883	\|\| length > paParms[5].u.pointer.size
884	\|\| !ShflStringIsValidOrNullIn(pPath, paParms[4].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
885	)
886	{
887	rc = VERR_INVALID_PARAMETER;
888	}
889	else
890	{
891	if (g_pStatusLed)
892	{
893	Assert(g_pStatusLed->u32Magic == PDMLED_MAGIC);
894	g_pStatusLed->Asserted.s.fReading = g_pStatusLed->Actual.s.fReading = 1;
895	}
896
897	/* Execute the function. */
898	rc = vbsfDirList (pClient, root, Handle, pPath, flags, &length, pBuffer, &resumePoint, &cFiles);
899
900	if (g_pStatusLed)
901	g_pStatusLed->Actual.s.fReading = 0;
902
903	if (rc == VERR_NO_MORE_FILES && cFiles != 0)
904	rc = VINF_SUCCESS; /* Successfully return these files. */
905
906	if (RT_SUCCESS(rc))
907	{
908	/* Update parameters.*/
909	paParms[3].u.uint32 = length;
910	paParms[6].u.uint32 = resumePoint;
911	paParms[7].u.uint32 = cFiles;
912	}
913	else
914	{
915	paParms[3].u.uint32 = 0; /* nothing read */
916	paParms[6].u.uint32 = 0;
917	paParms[7].u.uint32 = cFiles;
918	}
919	}
920	}
921	break;
922	}
923
924	/* Read symlink destination */
925	case SHFL_FN_READLINK:
926	{
927	pStat = &g_StatReadLink;
928	pStatFail = &g_StatReadLinkFail;
929	Log(("SharedFolders host service: svcCall: SHFL_FN_READLINK\n"));
930
931	/* Verify parameter count and types. */
932	if (cParms != SHFL_CPARMS_READLINK)
933	{
934	rc = VERR_INVALID_PARAMETER;
935	}
936	else
937	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
938	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
939	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
940	)
941	{
942	rc = VERR_INVALID_PARAMETER;
943	}
944	else
945	{
946	/* Fetch parameters. */
947	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
948	SHFLSTRING pPath = (SHFLSTRING )paParms[1].u.pointer.addr;
949	uint32_t cbPath = paParms[1].u.pointer.size;
950	uint8_t pBuffer = (uint8_t )paParms[2].u.pointer.addr;
951	uint32_t cbBuffer = paParms[2].u.pointer.size;
952
953	/* Verify parameters values. */
954	if (!ShflStringIsValidOrNullIn(pPath, paParms[1].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
955	{
956	rc = VERR_INVALID_PARAMETER;
957	}
958	else
959	{
960	/* Execute the function. */
961	rc = vbsfReadLink (pClient, root, pPath, cbPath, pBuffer, cbBuffer);
962
963	if (RT_SUCCESS(rc))
964	{
965	/* Update parameters.*/
966	; /* none */
967	}
968	}
969	}
970
971	break;
972	}
973
974	/* Legacy interface */
975	case SHFL_FN_MAP_FOLDER_OLD:
976	{
977	pStatFail = pStat = &g_StatMapFolderOld;
978	Log(("SharedFolders host service: svcCall: SHFL_FN_MAP_FOLDER_OLD\n"));
979
980	/* Verify parameter count and types. */
981	if (cParms != SHFL_CPARMS_MAP_FOLDER_OLD)
982	{
983	rc = VERR_INVALID_PARAMETER;
984	}
985	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */
986	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
987	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* delimiter */
988	)
989	{
990	rc = VERR_INVALID_PARAMETER;
991	}
992	else
993	{
994	/* Fetch parameters. */
995	PSHFLSTRING pszMapName = (PSHFLSTRING)paParms[0].u.pointer.addr;
996	SHFLROOT root = (SHFLROOT)paParms[1].u.uint32;
997	RTUTF16 delimiter = (RTUTF16)paParms[2].u.uint32;
998
999	/* Verify parameters values. */
1000	if (!ShflStringIsValidIn(pszMapName, paParms[0].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
1001	{
1002	rc = VERR_INVALID_PARAMETER;
1003	}
1004	else
1005	{
1006	/* Execute the function. */
1007	rc = vbsfMapFolder (pClient, pszMapName, delimiter, false, &root);
1008
1009	if (RT_SUCCESS(rc))
1010	{
1011	/* Update parameters.*/
1012	paParms[1].u.uint32 = root;
1013	}
1014	}
1015	}
1016	break;
1017	}
1018
1019	case SHFL_FN_MAP_FOLDER:
1020	{
1021	pStat = &g_StatMapFolder;
1022	pStatFail = &g_StatMapFolderFail;
1023	Log(("SharedFolders host service: svcCall: SHFL_FN_MAP_FOLDER\n"));
1024	if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
1025	Log(("SharedFolders host service: request to map folder '%s'\n",
1026	((PSHFLSTRING)paParms[0].u.pointer.addr)->String.utf8));
1027	else
1028	Log(("SharedFolders host service: request to map folder '%ls'\n",
1029	((PSHFLSTRING)paParms[0].u.pointer.addr)->String.ucs2));
1030
1031	/* Verify parameter count and types. */
1032	if (cParms != SHFL_CPARMS_MAP_FOLDER)
1033	{
1034	rc = VERR_INVALID_PARAMETER;
1035	}
1036	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */
1037	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1038	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* delimiter */
1039	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* fCaseSensitive */
1040	)
1041	{
1042	rc = VERR_INVALID_PARAMETER;
1043	}
1044	else
1045	{
1046	/* Fetch parameters. */
1047	PSHFLSTRING pszMapName = (PSHFLSTRING)paParms[0].u.pointer.addr;
1048	SHFLROOT root = (SHFLROOT)paParms[1].u.uint32;
1049	RTUTF16 delimiter = (RTUTF16)paParms[2].u.uint32;
1050	bool fCaseSensitive = !!paParms[3].u.uint32;
1051
1052	/* Verify parameters values. */
1053	if (ShflStringIsValidIn(pszMapName, paParms[0].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
1054	{
1055	rc = VINF_SUCCESS;
1056	}
1057	else
1058	{
1059	rc = VERR_INVALID_PARAMETER;
1060
1061	/* Fudge for windows GAs getting the length wrong by one char. */
1062	if ( !(pClient->fu32Flags & SHFL_CF_UTF8)
1063	&& paParms[0].u.pointer.size >= sizeof(SHFLSTRING)
1064	&& pszMapName->u16Length >= 2
1065	&& pszMapName->String.ucs2[pszMapName->u16Length / 2 - 1] == 0x0000)
1066	{
1067	pszMapName->u16Length -= 2;
1068	if (ShflStringIsValidIn(pszMapName, paParms[0].u.pointer.size, false /fUtf8Not16/))
1069	rc = VINF_SUCCESS;
1070	else
1071	pszMapName->u16Length += 2;
1072	}
1073	}
1074
1075	/* Execute the function. */
1076	if (RT_SUCCESS(rc))
1077	rc = vbsfMapFolder (pClient, pszMapName, delimiter, fCaseSensitive, &root);
1078
1079	if (RT_SUCCESS(rc))
1080	{
1081	/* Update parameters.*/
1082	paParms[1].u.uint32 = root;
1083	}
1084	}
1085	Log(("SharedFolders host service: map operation result %Rrc\n", rc));
1086	if (RT_SUCCESS(rc))
1087	Log(("SharedFolders host service: mapped to handle %d\n", paParms[1].u.uint32));
1088	break;
1089	}
1090
1091	case SHFL_FN_UNMAP_FOLDER:
1092	{
1093	pStat = &g_StatUnmapFolder;
1094	pStatFail = &g_StatUnmapFolderFail;
1095	Log(("SharedFolders host service: svcCall: SHFL_FN_UNMAP_FOLDER\n"));
1096	Log(("SharedFolders host service: request to unmap folder handle %u\n",
1097	paParms[0].u.uint32));
1098
1099	/* Verify parameter count and types. */
1100	if (cParms != SHFL_CPARMS_UNMAP_FOLDER)
1101	{
1102	rc = VERR_INVALID_PARAMETER;
1103	}
1104	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1105	)
1106	{
1107	rc = VERR_INVALID_PARAMETER;
1108	}
1109	else
1110	{
1111	/* Fetch parameters. */
1112	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1113
1114	/* Execute the function. */
1115	rc = vbsfUnmapFolder (pClient, root);
1116
1117	if (RT_SUCCESS(rc))
1118	{
1119	/* Update parameters.*/
1120	/* nothing */
1121	}
1122	}
1123	Log(("SharedFolders host service: unmap operation result %Rrc\n", rc));
1124	break;
1125	}
1126
1127	/* Query/set object information. */
1128	case SHFL_FN_INFORMATION:
1129	{
1130	pStatFail = pStat = &g_StatInformationFail;
1131	Log(("SharedFolders host service: svcCall: SHFL_FN_INFORMATION\n"));
1132
1133	/* Verify parameter count and types. */
1134	if (cParms != SHFL_CPARMS_INFORMATION)
1135	{
1136	rc = VERR_INVALID_PARAMETER;
1137	}
1138	else
1139	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1140	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
1141	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
1142	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* cb */
1143	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
1144	)
1145	{
1146	rc = VERR_INVALID_PARAMETER;
1147	}
1148	else
1149	{
1150	/* Fetch parameters. */
1151	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1152	SHFLHANDLE Handle = paParms[1].u.uint64;
1153	uint32_t flags = paParms[2].u.uint32;
1154	uint32_t length = paParms[3].u.uint32;
1155	uint8_t pBuffer = (uint8_t )paParms[4].u.pointer.addr;
1156
1157	/* Verify parameters values. */
1158	if (length > paParms[4].u.pointer.size)
1159	{
1160	rc = VERR_INVALID_PARAMETER;
1161	}
1162	else
1163	{
1164	/* Execute the function. */
1165	if (flags & SHFL_INFO_SET)
1166	{
1167	rc = vbsfSetFSInfo (pClient, root, Handle, flags, &length, pBuffer);
1168
1169	if (flags & SHFL_INFO_FILE)
1170	{
1171	pStat = &g_StatInformationSetFile;
1172	pStatFail = &g_StatInformationSetFileFail;
1173	}
1174	else if (flags & SHFL_INFO_SIZE)
1175	{
1176	pStat = &g_StatInformationSetSize;
1177	pStatFail = &g_StatInformationSetSizeFail;
1178	}
1179	}
1180	else /* SHFL_INFO_GET */
1181	{
1182	rc = vbsfQueryFSInfo (pClient, root, Handle, flags, &length, pBuffer);
1183
1184	if (flags & SHFL_INFO_FILE)
1185	{
1186	pStat = &g_StatInformationGetFile;
1187	pStatFail = &g_StatInformationGetFileFail;
1188	}
1189	else if (flags & SHFL_INFO_VOLUME)
1190	{
1191	pStat = &g_StatInformationGetVolume;
1192	pStatFail = &g_StatInformationGetVolumeFail;
1193	}
1194	}
1195
1196	if (RT_SUCCESS(rc))
1197	{
1198	/* Update parameters.*/
1199	paParms[3].u.uint32 = length;
1200	}
1201	else
1202	{
1203	paParms[3].u.uint32 = 0; /* nothing read */
1204	}
1205	}
1206	}
1207	break;
1208	}
1209
1210	/* Remove or rename object */
1211	case SHFL_FN_REMOVE:
1212	{
1213	pStat = &g_StatRemove;
1214	pStatFail = &g_StatRemoveFail;
1215	Log(("SharedFolders host service: svcCall: SHFL_FN_REMOVE\n"));
1216
1217	/* Verify parameter count and types. */
1218	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_REMOVE, rc = VERR_WRONG_PARAMETER_COUNT);
1219	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* root */
1220	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_PTR, rc = VERR_WRONG_PARAMETER_TYPE); /* path */
1221	PCSHFLSTRING pStrPath = (PCSHFLSTRING)paParms[1].u.pointer.addr;
1222	ASSERT_GUEST_STMT_BREAK(ShflStringIsValidIn(pStrPath, paParms[1].u.pointer.size,
1223	RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)),
1224	rc = VERR_INVALID_PARAMETER);
1225	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* flags */
1226	uint32_t const fFlags = paParms[2].u.uint32;
1227	ASSERT_GUEST_STMT_BREAK(!(fFlags & ~(SHFL_REMOVE_FILE \| SHFL_REMOVE_DIR \| SHFL_REMOVE_SYMLINK)),
1228	rc = VERR_INVALID_FLAGS);
1229
1230	/* Execute the function. */
1231	rc = vbsfRemove(pClient, paParms[0].u.uint32, pStrPath, paParms[1].u.pointer.size, fFlags, SHFL_HANDLE_NIL);
1232	break;
1233	}
1234
1235	case SHFL_FN_CLOSE_AND_REMOVE:
1236	{
1237	pStat = &g_StatCloseAndRemove;
1238	pStatFail = &g_StatCloseAndRemoveFail;
1239	Log(("SharedFolders host service: svcCall: SHFL_FN_CLOSE_AND_REMOVE\n"));
1240
1241	/* Verify parameter count and types. */
1242	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_CLOSE_AND_REMOVE, rc = VERR_WRONG_PARAMETER_COUNT);
1243	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* root */
1244	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_PTR, rc = VERR_WRONG_PARAMETER_TYPE); /* path */
1245	PCSHFLSTRING pStrPath = (PCSHFLSTRING)paParms[1].u.pointer.addr;
1246	ASSERT_GUEST_STMT_BREAK(ShflStringIsValidIn(pStrPath, paParms[1].u.pointer.size,
1247	RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)),
1248	rc = VERR_INVALID_PARAMETER);
1249	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* flags */
1250	uint32_t const fFlags = paParms[2].u.uint32;
1251	ASSERT_GUEST_STMT_BREAK(!(fFlags & ~(SHFL_REMOVE_FILE \| SHFL_REMOVE_DIR \| SHFL_REMOVE_SYMLINK)),
1252	rc = VERR_INVALID_FLAGS);
1253	SHFLHANDLE const hToClose = paParms[3].u.uint64;
1254	ASSERT_GUEST_STMT_BREAK(hToClose != SHFL_HANDLE_ROOT, rc = VERR_INVALID_HANDLE);
1255
1256	/* Execute the function. */
1257	rc = vbsfRemove(pClient, paParms[0].u.uint32, pStrPath, paParms[1].u.pointer.size, fFlags, hToClose);
1258	break;
1259	}
1260
1261	case SHFL_FN_RENAME:
1262	{
1263	pStat = &g_StatRename;
1264	pStatFail = &g_StatRenameFail;
1265	Log(("SharedFolders host service: svcCall: SHFL_FN_RENAME\n"));
1266
1267	/* Verify parameter count and types. */
1268	if (cParms != SHFL_CPARMS_RENAME)
1269	{
1270	rc = VERR_INVALID_PARAMETER;
1271	}
1272	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1273	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* src */
1274	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* dest */
1275	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
1276	)
1277	{
1278	rc = VERR_INVALID_PARAMETER;
1279	}
1280	else
1281	{
1282	/* Fetch parameters. */
1283	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1284	SHFLSTRING pSrc = (SHFLSTRING )paParms[1].u.pointer.addr;
1285	SHFLSTRING pDest = (SHFLSTRING )paParms[2].u.pointer.addr;
1286	uint32_t flags = paParms[3].u.uint32;
1287
1288	/* Verify parameters values. */
1289	if ( !ShflStringIsValidIn(pSrc, paParms[1].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
1290	\|\| !ShflStringIsValidIn(pDest, paParms[2].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
1291	)
1292	{
1293	rc = VERR_INVALID_PARAMETER;
1294	}
1295	else
1296	{
1297	/* Execute the function. */
1298	rc = vbsfRename (pClient, root, pSrc, pDest, flags);
1299	if (RT_SUCCESS(rc))
1300	{
1301	/* Update parameters.*/
1302	; /* none */
1303	}
1304	}
1305	}
1306	break;
1307	}
1308
1309	case SHFL_FN_FLUSH:
1310	{
1311	pStat = &g_StatFlush;
1312	pStatFail = &g_StatFlushFail;
1313	Log(("SharedFolders host service: svcCall: SHFL_FN_FLUSH\n"));
1314
1315	/* Verify parameter count and types. */
1316	if (cParms != SHFL_CPARMS_FLUSH)
1317	{
1318	rc = VERR_INVALID_PARAMETER;
1319	}
1320	else
1321	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1322	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
1323	)
1324	{
1325	rc = VERR_INVALID_PARAMETER;
1326	}
1327	else
1328	{
1329	/* Fetch parameters. */
1330	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1331	SHFLHANDLE Handle = paParms[1].u.uint64;
1332
1333	/* Verify parameters values. */
1334	if (Handle == SHFL_HANDLE_ROOT)
1335	{
1336	rc = VERR_INVALID_PARAMETER;
1337	}
1338	else
1339	if (Handle == SHFL_HANDLE_NIL)
1340	{
1341	AssertMsgFailed(("Invalid handle!\n"));
1342	rc = VERR_INVALID_HANDLE;
1343	}
1344	else
1345	{
1346	/* Execute the function. */
1347
1348	rc = vbsfFlush (pClient, root, Handle);
1349
1350	if (RT_SUCCESS(rc))
1351	{
1352	/* Nothing to do */
1353	}
1354	}
1355	}
1356	} break;
1357
1358	case SHFL_FN_SET_UTF8:
1359	{
1360	pStatFail = pStat = &g_StatSetUtf8;
1361
1362	pClient->fu32Flags \|= SHFL_CF_UTF8;
1363	rc = VINF_SUCCESS;
1364	break;
1365	}
1366
1367	case SHFL_FN_SYMLINK:
1368	{
1369	pStat = &g_StatSymlink;
1370	pStatFail = &g_StatSymlinkFail;
1371	Log(("SharedFolders host service: svnCall: SHFL_FN_SYMLINK\n"));
1372
1373	/* Verify parameter count and types. */
1374	if (cParms != SHFL_CPARMS_SYMLINK)
1375	{
1376	rc = VERR_INVALID_PARAMETER;
1377	}
1378	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1379	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* newPath */
1380	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* oldPath */
1381	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_PTR /* info */
1382	)
1383	{
1384	rc = VERR_INVALID_PARAMETER;
1385	}
1386	else
1387	{
1388	/* Fetch parameters. */
1389	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1390	SHFLSTRING pNewPath = (SHFLSTRING )paParms[1].u.pointer.addr;
1391	SHFLSTRING pOldPath = (SHFLSTRING )paParms[2].u.pointer.addr;
1392	SHFLFSOBJINFO pInfo = (SHFLFSOBJINFO )paParms[3].u.pointer.addr;
1393	uint32_t cbInfo = paParms[3].u.pointer.size;
1394
1395	/* Verify parameters values. */
1396	if ( !ShflStringIsValidIn(pNewPath, paParms[1].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
1397	\|\| !ShflStringIsValidIn(pOldPath, paParms[2].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
1398	\|\| (cbInfo != sizeof(SHFLFSOBJINFO))
1399	)
1400	{
1401	rc = VERR_INVALID_PARAMETER;
1402	}
1403	else
1404	{
1405	/* Execute the function. */
1406	rc = vbsfSymlink (pClient, root, pNewPath, pOldPath, pInfo);
1407	if (RT_SUCCESS(rc))
1408	{
1409	/* Update parameters.*/
1410	; /* none */
1411	}
1412	}
1413	}
1414	}
1415	break;
1416
1417	case SHFL_FN_SET_SYMLINKS:
1418	{
1419	pStatFail = pStat = &g_StatSetSymlinks;
1420
1421	pClient->fu32Flags \|= SHFL_CF_SYMLINKS;
1422	rc = VINF_SUCCESS;
1423	break;
1424	}
1425
1426	case SHFL_FN_QUERY_MAP_INFO:
1427	{
1428	pStatFail = pStat = &g_StatQueryMapInfo;
1429	Log(("SharedFolders host service: svnCall: SHFL_FN_QUERY_MAP_INFO\n"));
1430
1431	/* Validate input: */
1432	rc = VERR_INVALID_PARAMETER;
1433	ASSERT_GUEST_BREAK(cParms == SHFL_CPARMS_QUERY_MAP_INFO);
1434	ASSERT_GUEST_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT); /* root */
1435	ASSERT_GUEST_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_PTR); /* name */
1436	PSHFLSTRING pNameBuf = (PSHFLSTRING)paParms[1].u.pointer.addr;
1437	ASSERT_GUEST_BREAK(ShflStringIsValidOut(pNameBuf, paParms[1].u.pointer.size));
1438	ASSERT_GUEST_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_PTR); /* mountPoint */
1439	PSHFLSTRING pMntPtBuf = (PSHFLSTRING)paParms[2].u.pointer.addr;
1440	ASSERT_GUEST_BREAK(ShflStringIsValidOut(pMntPtBuf, paParms[2].u.pointer.size));
1441	ASSERT_GUEST_BREAK(paParms[3].type == VBOX_HGCM_SVC_PARM_64BIT); /* flags */
1442	ASSERT_GUEST_BREAK(!(paParms[3].u.uint64 & ~(SHFL_MIQF_DRIVE_LETTER \| SHFL_MIQF_PATH))); /* flags */
1443	ASSERT_GUEST_BREAK(paParms[4].type == VBOX_HGCM_SVC_PARM_32BIT); /* version */
1444
1445	/* Execute the function: */
1446	rc = vbsfMappingsQueryInfo(pClient, paParms[0].u.uint32, pNameBuf, pMntPtBuf,
1447	&paParms[3].u.uint64, &paParms[4].u.uint32);
1448	break;
1449	}
1450
1451	case SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES:
1452	{
1453	pStat = &g_StatWaitForMappingsChanges;
1454	pStatFail = &g_StatWaitForMappingsChangesFail;
1455	Log(("SharedFolders host service: svnCall: SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES\n"));
1456
1457	/* Validate input: */
1458	rc = VERR_INVALID_PARAMETER;
1459	ASSERT_GUEST_BREAK(cParms == SHFL_CPARMS_WAIT_FOR_MAPPINGS_CHANGES);
1460	ASSERT_GUEST_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT); /* uFolderMappingsVersion */
1461
1462	/* Execute the function: */
1463	rc = vbsfMappingsWaitForChanges(pClient, callHandle, paParms, g_pHelpers->pfnIsCallRestored(callHandle));
1464	fAsynchronousProcessing = rc == VINF_HGCM_ASYNC_EXECUTE;
1465	break;
1466	}
1467
1468	case SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS:
1469	{
1470	pStatFail = pStat = &g_StatCancelMappingsChangesWait;
1471	Log(("SharedFolders host service: svnCall: SHFL_FN_CANCEL_WAIT_FOR_CHANGES\n"));
1472
1473	/* Validate input: */
1474	rc = VERR_INVALID_PARAMETER;
1475	ASSERT_GUEST_BREAK(cParms == SHFL_CPARMS_CANCEL_MAPPINGS_CHANGES_WAITS);
1476
1477	/* Execute the function: */
1478	rc = vbsfMappingsCancelChangesWaits(pClient);
1479	break;
1480	}
1481
1482	case SHFL_FN_SET_FILE_SIZE:
1483	{
1484	pStat = &g_StatSetFileSize;
1485	pStatFail = &g_StatSetFileSizeFail;
1486	Log(("SharedFolders host service: svcCall: SHFL_FN_SET_FILE_SIZE\n"));
1487
1488	/* Validate input: */
1489	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_SET_FILE_SIZE, rc = VERR_WRONG_PARAMETER_COUNT);
1490	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* id32Root */
1491	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* u64Handle */
1492	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* cb64NewSize */
1493
1494	/* Execute the function: */
1495	rc = vbsfSetFileSize(pClient, paParms[0].u.uint32, paParms[1].u.uint64, paParms[2].u.uint64);
1496	break;
1497	}
1498
1499	case SHFL_FN_QUERY_FEATURES:
1500	{
1501	pStat = pStatFail = &g_StatQueryFeatures;
1502
1503	/* Validate input: */
1504	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_QUERY_FEATURES, rc = VERR_WRONG_PARAMETER_COUNT);
1505	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* f64Features */
1506	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* u32LastFunction */
1507
1508	/* Execute the function: */
1509	paParms[0].u.uint64 = SHFL_FEATURE_WRITE_UPDATES_OFFSET;
1510	paParms[1].u.uint32 = SHFL_FN_LAST;
1511	rc = VINF_SUCCESS;
1512	break;
1513	}
1514
1515	case SHFL_FN_COPY_FILE:
1516	{
1517	pStat = &g_StatCopyFile;
1518	pStatFail = &g_StatCopyFileFail;
1519
1520	/* Validate input: */
1521	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_COPY_FILE, rc = VERR_WRONG_PARAMETER_COUNT);
1522	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* i32RootSrc */
1523	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_PTR, rc = VERR_WRONG_PARAMETER_TYPE); /* pStrPathSrc */
1524	PCSHFLSTRING pStrPathSrc = (PCSHFLSTRING)paParms[1].u.pointer.addr;
1525	ASSERT_GUEST_STMT_BREAK(ShflStringIsValidIn(pStrPathSrc, paParms[1].u.pointer.size,
1526	RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)),
1527	rc = VERR_INVALID_PARAMETER);
1528	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* i32RootDst */
1529	ASSERT_GUEST_STMT_BREAK(paParms[3].type == VBOX_HGCM_SVC_PARM_PTR, rc = VERR_WRONG_PARAMETER_TYPE); /* pStrPathDst */
1530	PCSHFLSTRING pStrPathDst = (PCSHFLSTRING)paParms[3].u.pointer.addr;
1531	ASSERT_GUEST_STMT_BREAK(ShflStringIsValidIn(pStrPathDst, paParms[3].u.pointer.size,
1532	RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)),
1533	rc = VERR_INVALID_PARAMETER);
1534	ASSERT_GUEST_STMT_BREAK(paParms[4].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* f32Flags */
1535	ASSERT_GUEST_STMT_BREAK(paParms[4].u.uint32 == 0, rc = VERR_INVALID_FLAGS);
1536
1537	/* Execute the function: */
1538	rc = vbsfCopyFile(pClient, paParms[0].u.uint32, pStrPathSrc, paParms[2].u.uint64, pStrPathDst, paParms[3].u.uint32);
1539	break;
1540	}
1541
1542
1543	case SHFL_FN_COPY_FILE_PART:
1544	{
1545	pStat = &g_StatCopyFilePart;
1546	pStatFail = &g_StatCopyFilePartFail;
1547
1548	/* Validate input: */
1549	ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_COPY_FILE_PART, rc = VERR_WRONG_PARAMETER_COUNT);
1550	ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* i32RootSrc */
1551	ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* u64HandleSrc */
1552	ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* off64Src */
1553	ASSERT_GUEST_STMT_BREAK((int64_t)paParms[2].u.uint64 >= 0, rc = VERR_NEGATIVE_SEEK);
1554	ASSERT_GUEST_STMT_BREAK(paParms[3].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* i32RootDst */
1555	ASSERT_GUEST_STMT_BREAK(paParms[4].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* u64HandleDst */
1556	ASSERT_GUEST_STMT_BREAK(paParms[5].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* off64Dst */
1557	ASSERT_GUEST_STMT_BREAK((int64_t)paParms[5].u.uint64 >= 0, rc = VERR_NEGATIVE_SEEK);
1558	ASSERT_GUEST_STMT_BREAK(paParms[6].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* cb64ToCopy */
1559	ASSERT_GUEST_STMT_BREAK(paParms[6].u.uint64 < _1E, rc = VERR_OUT_OF_RANGE);
1560	ASSERT_GUEST_STMT_BREAK(paParms[7].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* f32Flags */
1561	ASSERT_GUEST_STMT_BREAK(paParms[7].u.uint32 == 0, rc = VERR_INVALID_FLAGS);
1562
1563	/* Execute the function: */
1564	rc = vbsfCopyFilePart(pClient,
1565	paParms[0].u.uint32, paParms[1].u.uint64, paParms[2].u.uint64,
1566	paParms[3].u.uint32, paParms[4].u.uint64, paParms[5].u.uint64,
1567	&paParms[6].u.uint64, paParms[7].u.uint64);
1568	break;
1569	}
1570
1571	default:
1572	{
1573	pStatFail = pStat = &g_StatUnknown;
1574	rc = VERR_NOT_IMPLEMENTED;
1575	break;
1576	}
1577	}
1578
1579	LogFlow(("SharedFolders host service: svcCall: rc=%Rrc\n", rc));
1580
1581	if ( !fAsynchronousProcessing
1582	\|\| RT_FAILURE (rc))
1583	{
1584	/* Complete the operation if it was unsuccessful or
1585	* it was processed synchronously.
1586	*/
1587	g_pHelpers->pfnCallComplete (callHandle, rc);
1588	}
1589
1590	#ifndef VBOX_WITHOUT_RELEASE_STATISTICS
1591	/* Statistics: */
1592	uint64_t cTicks;
1593	STAM_GET_TS(cTicks);
1594	cTicks -= tsStart;
1595	if (RT_SUCCESS(rc))
1596	STAM_REL_PROFILE_ADD_PERIOD(pStat, cTicks);
1597	else
1598	STAM_REL_PROFILE_ADD_PERIOD(pStatFail, cTicks);
1599	#endif
1600
1601	LogFlow(("\n")); /* Add a new line to differentiate between calls more easily. */
1602	}
1603
1604	/*
1605	* We differentiate between a function handler for the guest (svcCall) and one
1606	* for the host. The guest is not allowed to add or remove mappings for obvious
1607	* security reasons.
1608	*/
1609	static DECLCALLBACK(int) svcHostCall (void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
1610	{
1611	int rc = VINF_SUCCESS;
1612
1613	Log(("svcHostCall: fn = %d, cParms = %d, pparms = %d\n", u32Function, cParms, paParms));
1614
1615	#ifdef DEBUG
1616	uint32_t i;
1617
1618	for (i = 0; i < cParms; i++)
1619	{
1620	/** @todo parameters other than 32 bit */
1621	Log((" pparms[%d]: type %d value %d\n", i, paParms[i].type, paParms[i].u.uint32));
1622	}
1623	#endif
1624
1625	switch (u32Function)
1626	{
1627	case SHFL_FN_ADD_MAPPING:
1628	{
1629	Log(("SharedFolders host service: svcCall: SHFL_FN_ADD_MAPPING\n"));
1630	LogRel(("SharedFolders host service: Adding host mapping\n"));
1631	/* Verify parameter count and types. */
1632	if ( (cParms != SHFL_CPARMS_ADD_MAPPING)
1633	)
1634	{
1635	rc = VERR_INVALID_PARAMETER;
1636	}
1637	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* host folder path */
1638	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* map name */
1639	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* fFlags */
1640	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_PTR /* auto mount point */
1641	)
1642	{
1643	rc = VERR_INVALID_PARAMETER;
1644	}
1645	else
1646	{
1647	/* Fetch parameters. */
1648	SHFLSTRING pHostPath = (SHFLSTRING )paParms[0].u.pointer.addr;
1649	SHFLSTRING pMapName = (SHFLSTRING )paParms[1].u.pointer.addr;
1650	uint32_t fFlags = paParms[2].u.uint32;
1651	SHFLSTRING pAutoMountPoint = (SHFLSTRING )paParms[3].u.pointer.addr;
1652
1653	/* Verify parameters values. */
1654	if ( !ShflStringIsValidIn(pHostPath, paParms[0].u.pointer.size, false /fUtf8Not16/)
1655	\|\| !ShflStringIsValidIn(pMapName, paParms[1].u.pointer.size, false /fUtf8Not16/)
1656	\|\| !ShflStringIsValidIn(pAutoMountPoint, paParms[3].u.pointer.size, false /fUtf8Not16/)
1657	)
1658	{
1659	rc = VERR_INVALID_PARAMETER;
1660	}
1661	else
1662	{
1663	LogRel((" Host path '%ls', map name '%ls', %s, automount=%s, automntpnt=%s, create_symlinks=%s, missing=%s\n",
1664	pHostPath->String.utf16, pMapName->String.utf16,
1665	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_WRITABLE) ? "writable" : "read-only",
1666	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_AUTOMOUNT) ? "true" : "false",
1667	pAutoMountPoint->String.utf16,
1668	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_CREATE_SYMLINKS) ? "true" : "false",
1669	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_MISSING) ? "true" : "false"));
1670
1671	char *pszHostPath;
1672	rc = RTUtf16ToUtf8(pHostPath->String.ucs2, &pszHostPath);
1673	if (RT_SUCCESS(rc))
1674	{
1675	/* Execute the function. */
1676	rc = vbsfMappingsAdd(pszHostPath, pMapName,
1677	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_WRITABLE),
1678	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_AUTOMOUNT),
1679	pAutoMountPoint,
1680	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_CREATE_SYMLINKS),
1681	RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_MISSING),
1682	/* fPlaceholder = */ false);
1683	if (RT_SUCCESS(rc))
1684	{
1685	/* Update parameters.*/
1686	; /* none */
1687	}
1688	RTStrFree(pszHostPath);
1689	}
1690	}
1691	}
1692	if (RT_FAILURE(rc))
1693	LogRel(("SharedFolders host service: Adding host mapping failed with rc=%Rrc\n", rc));
1694	break;
1695	}
1696
1697	case SHFL_FN_REMOVE_MAPPING:
1698	{
1699	Log(("SharedFolders host service: svcCall: SHFL_FN_REMOVE_MAPPING\n"));
1700	LogRel(("SharedFolders host service: Removing host mapping '%ls'\n",
1701	((SHFLSTRING *)paParms[0].u.pointer.addr)->String.ucs2));
1702
1703	/* Verify parameter count and types. */
1704	if (cParms != SHFL_CPARMS_REMOVE_MAPPING)
1705	{
1706	rc = VERR_INVALID_PARAMETER;
1707	}
1708	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* folder name */
1709	)
1710	{
1711	rc = VERR_INVALID_PARAMETER;
1712	}
1713	else
1714	{
1715	/* Fetch parameters. */
1716	SHFLSTRING pString = (SHFLSTRING )paParms[0].u.pointer.addr;
1717
1718	/* Verify parameters values. */
1719	if (!ShflStringIsValidIn(pString, paParms[0].u.pointer.size, false /fUtf8Not16/))
1720	{
1721	rc = VERR_INVALID_PARAMETER;
1722	}
1723	else
1724	{
1725	/* Execute the function. */
1726	rc = vbsfMappingsRemove (pString);
1727
1728	if (RT_SUCCESS(rc))
1729	{
1730	/* Update parameters.*/
1731	; /* none */
1732	}
1733	}
1734	}
1735	if (RT_FAILURE(rc))
1736	LogRel(("SharedFolders host service: Removing host mapping failed with rc=%Rrc\n", rc));
1737	break;
1738	}
1739
1740	case SHFL_FN_SET_STATUS_LED:
1741	{
1742	Log(("SharedFolders host service: svcCall: SHFL_FN_SET_STATUS_LED\n"));
1743
1744	/* Verify parameter count and types. */
1745	if (cParms != SHFL_CPARMS_SET_STATUS_LED)
1746	{
1747	rc = VERR_INVALID_PARAMETER;
1748	}
1749	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* folder name */
1750	)
1751	{
1752	rc = VERR_INVALID_PARAMETER;
1753	}
1754	else
1755	{
1756	/* Fetch parameters. */
1757	PPDMLED pLed = (PPDMLED)paParms[0].u.pointer.addr;
1758	uint32_t cbLed = paParms[0].u.pointer.size;
1759
1760	/* Verify parameters values. */
1761	if ( (cbLed != sizeof (PDMLED))
1762	)
1763	{
1764	rc = VERR_INVALID_PARAMETER;
1765	}
1766	else
1767	{
1768	/* Execute the function. */
1769	g_pStatusLed = pLed;
1770	rc = VINF_SUCCESS;
1771	}
1772	}
1773	break;
1774	}
1775
1776	default:
1777	rc = VERR_NOT_IMPLEMENTED;
1778	break;
1779	}
1780
1781	LogFlow(("SharedFolders host service: svcHostCall ended with rc=%Rrc\n", rc));
1782	return rc;
1783	}
1784
1785	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
1786	{
1787	int rc = VINF_SUCCESS;
1788
1789	Log(("SharedFolders host service: VBoxHGCMSvcLoad: ptable = %p\n", ptable));
1790
1791	if (!VALID_PTR(ptable))
1792	{
1793	LogRelFunc(("SharedFolders host service: Bad value of ptable (%p)\n", ptable));
1794	rc = VERR_INVALID_PARAMETER;
1795	}
1796	else
1797	{
1798	Log(("SharedFolders host service: VBoxHGCMSvcLoad: ptable->cbSize = %u, ptable->u32Version = 0x%08X\n",
1799	ptable->cbSize, ptable->u32Version));
1800
1801	if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
1802	\|\| ptable->u32Version != VBOX_HGCM_SVC_VERSION)
1803	{
1804	LogRelFunc(("SharedFolders host service: Version mismatch while loading: ptable->cbSize = %u (should be %u), ptable->u32Version = 0x%08X (should be 0x%08X)\n",
1805	ptable->cbSize, sizeof (VBOXHGCMSVCFNTABLE), ptable->u32Version, VBOX_HGCM_SVC_VERSION));
1806	rc = VERR_VERSION_MISMATCH;
1807	}
1808	else
1809	{
1810	g_pHelpers = ptable->pHelpers;
1811
1812	ptable->cbClient = sizeof (SHFLCLIENTDATA);
1813
1814	ptable->pfnUnload = svcUnload;
1815	ptable->pfnConnect = svcConnect;
1816	ptable->pfnDisconnect = svcDisconnect;
1817	ptable->pfnCall = svcCall;
1818	ptable->pfnHostCall = svcHostCall;
1819	ptable->pfnSaveState = svcSaveState;
1820	ptable->pfnLoadState = svcLoadState;
1821	ptable->pfnNotify = NULL;
1822	ptable->pvService = NULL;
1823	}
1824
1825	/* Init handle table */
1826	rc = vbsfInitHandleTable();
1827	AssertRC(rc);
1828
1829	vbsfMappingInit();
1830
1831	/* Finally, register statistics if everything went well: */
1832	if (RT_SUCCESS(rc))
1833	{
1834	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMappings, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAPPINGS successes", "/HGCM/VBoxSharedFolders/FnQueryMappings");
1835	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMappingsFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAPPINGS failures", "/HGCM/VBoxSharedFolders/FnQueryMappingsFail");
1836	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMapName, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAP_NAME", "/HGCM/VBoxSharedFolders/FnQueryMapName");
1837	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCreate, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/CREATE successes", "/HGCM/VBoxSharedFolders/FnCreate");
1838	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCreateFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/CREATE failures", "/HGCM/VBoxSharedFolders/FnCreateFail");
1839	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLookup, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/LOOKUP successes", "/HGCM/VBoxSharedFolders/FnLookup");
1840	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLookupFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/LOOKUP failures", "/HGCM/VBoxSharedFolders/FnLookupFail");
1841	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatClose, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CLOSE successes", "/HGCM/VBoxSharedFolders/FnClose");
1842	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCloseFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CLOSE failures", "/HGCM/VBoxSharedFolders/FnCloseFail");
1843	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRead, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READ successes", "/HGCM/VBoxSharedFolders/FnRead");
1844	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatReadFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READ failures", "/HGCM/VBoxSharedFolders/FnReadFail");
1845	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWrite, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WRITE successes", "/HGCM/VBoxSharedFolders/FnWrite");
1846	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWriteFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WRITE failures", "/HGCM/VBoxSharedFolders/FnWriteFail");
1847	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLock, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LOCK successes", "/HGCM/VBoxSharedFolders/FnLock");
1848	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLockFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LOCK failures", "/HGCM/VBoxSharedFolders/FnLockFail");
1849	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatList, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LIST successes", "/HGCM/VBoxSharedFolders/FnList");
1850	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatListFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LIST failures", "/HGCM/VBoxSharedFolders/FnListFail");
1851	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatReadLink, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READLINK successes", "/HGCM/VBoxSharedFolders/FnReadLink");
1852	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatReadLinkFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READLINK failures", "/HGCM/VBoxSharedFolders/FnReadLinkFail");
1853	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMapFolderOld, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_MAP_FOLDER_OLD", "/HGCM/VBoxSharedFolders/FnMapFolderOld");
1854	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMapFolder, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_MAP_FOLDER successes", "/HGCM/VBoxSharedFolders/FnMapFolder");
1855	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMapFolderFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_MAP_FOLDER failures", "/HGCM/VBoxSharedFolders/FnMapFolderFail");
1856	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatUnmapFolder, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_UNMAP_FOLDER successes", "/HGCM/VBoxSharedFolders/FnUnmapFolder");
1857	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatUnmapFolderFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_UNMAP_FOLDER failures", "/HGCM/VBoxSharedFolders/FnUnmapFolderFail");
1858	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION early failures", "/HGCM/VBoxSharedFolders/FnInformationFail");
1859	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetFile, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/FILE successes", "/HGCM/VBoxSharedFolders/FnInformationSetFile");
1860	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetFileFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/FILE failures", "/HGCM/VBoxSharedFolders/FnInformationSetFileFail");
1861	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetSize, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/SIZE successes", "/HGCM/VBoxSharedFolders/FnInformationSetSize");
1862	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetSizeFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/SIZE failures", "/HGCM/VBoxSharedFolders/FnInformationSetSizeFail");
1863	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetFile, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/FILE successes", "/HGCM/VBoxSharedFolders/FnInformationGetFile");
1864	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetFileFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/FILE failures", "/HGCM/VBoxSharedFolders/FnInformationGetFileFail");
1865	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetVolume, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/VOLUME successes", "/HGCM/VBoxSharedFolders/FnInformationGetVolume");
1866	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetVolumeFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/VOLUME failures", "/HGCM/VBoxSharedFolders/FnInformationGetVolumeFail");
1867	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRemove, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_REMOVE successes", "/HGCM/VBoxSharedFolders/FnRemove");
1868	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRemoveFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_REMOVE failures", "/HGCM/VBoxSharedFolders/FnRemoveFail");
1869	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCloseAndRemove, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CLOSE_AND_REMOVE successes", "/HGCM/VBoxSharedFolders/FnCloseAndRemove");
1870	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCloseAndRemoveFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CLOSE_AND_REMOVE failures", "/HGCM/VBoxSharedFolders/FnCloseAndRemoveFail");
1871	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRename, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_RENAME successes", "/HGCM/VBoxSharedFolders/FnRename");
1872	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRenameFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_RENAME failures", "/HGCM/VBoxSharedFolders/FnRenameFail");
1873	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatFlush, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_FLUSH successes", "/HGCM/VBoxSharedFolders/FnFlush");
1874	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatFlushFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_FLUSH failures", "/HGCM/VBoxSharedFolders/FnFlushFail");
1875	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSetUtf8, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SET_UTF8", "/HGCM/VBoxSharedFolders/FnSetUtf8");
1876	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSymlink, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SYMLINK successes", "/HGCM/VBoxSharedFolders/FnSymlink");
1877	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSymlinkFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SYMLINK failures", "/HGCM/VBoxSharedFolders/FnSymlinkFail");
1878	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSetSymlinks, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SET_SYMLINKS", "/HGCM/VBoxSharedFolders/FnSetSymlink");
1879	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMapInfo, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAP_INFO", "/HGCM/VBoxSharedFolders/FnQueryMapInfo");
1880	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryFeatures, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_FEATURES", "/HGCM/VBoxSharedFolders/FnQueryFeatures");
1881	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCopyFile, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_COPY_FILE successes", "/HGCM/VBoxSharedFolders/FnCopyFile");
1882	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCopyFileFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_COPY_FILE failures", "/HGCM/VBoxSharedFolders/FnCopyFileFail");
1883	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCopyFilePart, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_COPY_FILE_PART successes", "/HGCM/VBoxSharedFolders/FnCopyFilePart");
1884	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCopyFilePartFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_COPY_FILE_PART failures", "/HGCM/VBoxSharedFolders/FnCopyFilePartFail");
1885	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWaitForMappingsChanges, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES successes", "/HGCM/VBoxSharedFolders/FnWaitForMappingsChanges");
1886	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWaitForMappingsChangesFail,STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES failures","/HGCM/VBoxSharedFolders/FnWaitForMappingsChangesFail");
1887	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCancelMappingsChangesWait, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS", "/HGCM/VBoxSharedFolders/FnCancelMappingsChangesWaits");
1888	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatUnknown, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_???", "/HGCM/VBoxSharedFolders/FnUnknown");
1889	HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMsgStage1, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "Time from VMMDev arrival to worker thread.","/HGCM/VBoxSharedFolders/MsgStage1");
1890	}
1891	}
1892
1893	return rc;
1894	}
1895

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

source: vbox/trunk/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.cpp@ 78668

Download in other formats: