VBoxSharedFoldersSvc.cpp@ 78875

Last change on this file since 78875 was 78699, checked in by vboxsync, 6 years ago
SharedFoldersSvc: Adding function that lets the guest set the error code style. The idea is that the host will do a some error code adjustments when the guest and host OSes differ, as this is much more effient than the guest doing it. The deman is chiefly for windows guests. [build fix] bugref:9172
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 89.2 KB

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

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

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

Download in other formats: