service.cpp@ 75506

Last change on this file since 75506 was 75506, checked in by vboxsync, 6 years ago
Make scm happy.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 77.6 KB

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

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

source: vbox/trunk/src/VBox/HostServices/SharedFolders/service.cpp@ 75506

Download in other formats: