service.cpp@ 22902

Last change on this file since 22902 was 21485, checked in by vboxsync, 15 years ago
sf: parameter validation.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 46.0 KB

Line
1	/** @file
2	* Shared Folders: Host service entry points.
3	*/
4
5	/*
6	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
7	*
8	* This file is part of VirtualBox Open Source Edition (OSE), as
9	* available from http://www.virtualbox.org. This file is free software;
10	* you can redistribute it and/or modify it under the terms of the GNU
11	* General Public License (GPL) as published by the Free Software
12	* Foundation, in version 2 as it comes in the "COPYING" file of the
13	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15	*
16	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
17	* Clara, CA 95054 USA or visit http://www.sun.com if you need
18	* additional information or have any questions.
19	*/
20
21	#include <VBox/shflsvc.h>
22
23
24	#include "shfl.h"
25	#include "mappings.h"
26	#include "shflhandle.h"
27	#include "vbsf.h"
28	#include <iprt/alloc.h>
29	#include <iprt/string.h>
30	#include <iprt/assert.h>
31	#include <VBox/ssm.h>
32	#include <VBox/pdm.h>
33
34	#define SHFL_SSM_VERSION 2
35
36
37	/* Shared Folders Host Service.
38	*
39	* Shared Folders map a host file system to guest logical filesystem.
40	* A mapping represents 'host name'<->'guest name' translation and a root
41	* identifier to be used to access this mapping.
42	* Examples: "C:\WINNT"<->"F:", "C:\WINNT\System32"<->"/mnt/host/system32".
43	*
44	* Therefore, host name and guest name are strings interpreted
45	* only by host service and guest client respectively. Host name is
46	* passed to guest only for informational purpose. Guest may for example
47	* display the string or construct volume label out of the string.
48	*
49	* Root identifiers are unique for whole guest life,
50	* that is until next guest reset/fresh start.
51	* 32 bit value incremented for each new mapping is used.
52	*
53	* Mapping strings are taken from VM XML configuration on VM startup.
54	* The service DLL takes mappings during initialization. There is
55	* also API for changing mappings at runtime.
56	*
57	* Current mappings and root identifiers are saved when VM is saved.
58	*
59	* Guest may use any of these mappings. Full path information
60	* about an object on a mapping consists of the root indentifier and
61	* a full path of object.
62	*
63	* Guest IFS connects to the service and calls SHFL_FN_QUERY_MAP
64	* function which returns current mappings. For guest convenience,
65	* removed mappings also returned with REMOVED flag and new mappings
66	* are marked with NEW flag.
67	*
68	* To access host file system guest just forwards file system calls
69	* to the service, and specifies full paths or handles for objects.
70	*
71	*
72	*/
73
74
75	PVBOXHGCMSVCHELPERS g_pHelpers;
76	static PPDMLED pStatusLed = NULL;
77
78	static DECLCALLBACK(int) svcUnload (void *)
79	{
80	int rc = VINF_SUCCESS;
81
82	Log(("svcUnload\n"));
83
84	return rc;
85	}
86
87	static DECLCALLBACK(int) svcConnect (void , uint32_t u32ClientID, void pvClient)
88	{
89	int rc = VINF_SUCCESS;
90
91	NOREF(u32ClientID);
92	NOREF(pvClient);
93
94	LogRel(("SharedFolders host service: connected, u32ClientID = %d\n", u32ClientID));
95
96	return rc;
97	}
98
99	static DECLCALLBACK(int) svcDisconnect (void , uint32_t u32ClientID, void pvClient)
100	{
101	int rc = VINF_SUCCESS;
102	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
103
104	LogRel(("SharedFolders host service: disconnected, u32ClientID = %d\n", u32ClientID));
105
106	vbsfDisconnect(pClient);
107	return rc;
108	}
109
110	/** @note We only save as much state as required to access the shared folder again after restore.
111	* All I/O requests pending at the time of saving will never be completed or result in errors.
112	* (file handles no longer valid etc)
113	* This works as designed at the moment. A full state save would be difficult and not always possible
114	* as the contents of a shared folder might change in between save and restore.
115	*/
116	static DECLCALLBACK(int) svcSaveState(void , uint32_t u32ClientID, void pvClient, PSSMHANDLE pSSM)
117	{
118	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
119
120	LogRel(("SharedFolders host service: saving state, u32ClientID = %d\n", u32ClientID));
121
122	int rc = SSMR3PutU32(pSSM, SHFL_SSM_VERSION);
123	AssertRCReturn(rc, rc);
124
125	rc = SSMR3PutU32(pSSM, SHFL_MAX_MAPPINGS);
126	AssertRCReturn(rc, rc);
127
128	/* Save client structure length & contents */
129	rc = SSMR3PutU32(pSSM, sizeof(*pClient));
130	AssertRCReturn(rc, rc);
131
132	rc = SSMR3PutMem(pSSM, pClient, sizeof(*pClient));
133	AssertRCReturn(rc, rc);
134
135	/* Save all the active mappings. */
136	for (int i=0;i<SHFL_MAX_MAPPINGS;i++)
137	{
138	/* Mapping are saved in the order of increasing root handle values. */
139	MAPPING *pFolderMapping = vbsfMappingGetByRoot(i);
140
141	rc = SSMR3PutU32(pSSM, pFolderMapping? pFolderMapping->cMappings: 0);
142	AssertRCReturn(rc, rc);
143
144	rc = SSMR3PutBool(pSSM, pFolderMapping? pFolderMapping->fValid: false);
145	AssertRCReturn(rc, rc);
146
147	if (pFolderMapping && pFolderMapping->fValid)
148	{
149	uint32_t len;
150
151	len = ShflStringSizeOfBuffer(pFolderMapping->pFolderName);
152	rc = SSMR3PutU32(pSSM, len);
153	AssertRCReturn(rc, rc);
154
155	rc = SSMR3PutMem(pSSM, pFolderMapping->pFolderName, len);
156	AssertRCReturn(rc, rc);
157
158	len = ShflStringSizeOfBuffer(pFolderMapping->pMapName);
159	rc = SSMR3PutU32(pSSM, len);
160	AssertRCReturn(rc, rc);
161
162	rc = SSMR3PutMem(pSSM, pFolderMapping->pMapName, len);
163	AssertRCReturn(rc, rc);
164
165	rc = SSMR3PutBool(pSSM, pFolderMapping->fHostCaseSensitive);
166	AssertRCReturn(rc, rc);
167
168	rc = SSMR3PutBool(pSSM, pFolderMapping->fGuestCaseSensitive);
169	AssertRCReturn(rc, rc);
170	}
171	}
172
173	return VINF_SUCCESS;
174	}
175
176	static DECLCALLBACK(int) svcLoadState(void , uint32_t u32ClientID, void pvClient, PSSMHANDLE pSSM)
177	{
178	uint32_t nrMappings;
179	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
180	uint32_t len, version;
181
182	LogRel(("SharedFolders host service: loading state, u32ClientID = %d\n", u32ClientID));
183
184	int rc = SSMR3GetU32(pSSM, &version);
185	AssertRCReturn(rc, rc);
186
187	if (version != SHFL_SSM_VERSION)
188	return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
189
190	rc = SSMR3GetU32(pSSM, &nrMappings);
191	AssertRCReturn(rc, rc);
192	if (nrMappings != SHFL_MAX_MAPPINGS)
193	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
194
195	/* Restore the client data (flags + path delimiter at the moment) */
196	rc = SSMR3GetU32(pSSM, &len);
197	AssertRCReturn(rc, rc);
198
199	if (len != sizeof(*pClient))
200	return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
201
202	rc = SSMR3GetMem(pSSM, pClient, sizeof(*pClient));
203	AssertRCReturn(rc, rc);
204
205	/* We don't actually (fully) restore the state; we simply check if the current state is as we it expect it to be. */
206	for (int i=0;i<SHFL_MAX_MAPPINGS;i++)
207	{
208	/* Load the saved mapping description and try to find it in the mappings. */
209	MAPPING mapping;
210	memset (&mapping, 0, sizeof (mapping));
211
212	/* restore the folder mapping counter. */
213	rc = SSMR3GetU32(pSSM, &mapping.cMappings);
214	AssertRCReturn(rc, rc);
215
216	rc = SSMR3GetBool(pSSM, &mapping.fValid);
217	AssertRCReturn(rc, rc);
218
219	if (mapping.fValid)
220	{
221	uint32_t cbFolderName;
222	PSHFLSTRING pFolderName;
223
224	uint32_t cbMapName;
225	PSHFLSTRING pMapName;
226
227	/* Load the host path name. */
228	rc = SSMR3GetU32(pSSM, &cbFolderName);
229	AssertRCReturn(rc, rc);
230
231	pFolderName = (PSHFLSTRING)RTMemAlloc(cbFolderName);
232	AssertReturn(pFolderName != NULL, VERR_NO_MEMORY);
233
234	rc = SSMR3GetMem(pSSM, pFolderName, cbFolderName);
235	AssertRCReturn(rc, rc);
236
237	/* Load the map name. */
238	rc = SSMR3GetU32(pSSM, &cbMapName);
239	AssertRCReturn(rc, rc);
240
241	pMapName = (PSHFLSTRING)RTMemAlloc(cbMapName);
242	AssertReturn(pMapName != NULL, VERR_NO_MEMORY);
243
244	rc = SSMR3GetMem(pSSM, pMapName, cbMapName);
245	AssertRCReturn(rc, rc);
246
247	rc = SSMR3GetBool(pSSM, &mapping.fHostCaseSensitive);
248	AssertRCReturn(rc, rc);
249
250	rc = SSMR3GetBool(pSSM, &mapping.fGuestCaseSensitive);
251	AssertRCReturn(rc, rc);
252
253	mapping.pFolderName = pFolderName;
254	mapping.pMapName = pMapName;
255
256	/* 'i' is the root handle of the saved mapping. */
257	rc = vbsfMappingLoaded (&mapping, i);
258
259	RTMemFree(pMapName);
260	RTMemFree(pFolderName);
261
262	AssertRCReturn(rc, rc);
263	}
264	}
265	LogRel(("SharedFolders host service: success\n"));
266	return VINF_SUCCESS;
267	}
268
269	static DECLCALLBACK(void) svcCall (void , VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void pvClient, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
270	{
271	int rc = VINF_SUCCESS;
272
273	Log(("svcCall: u32ClientID = %d, fn = %d, cParms = %d, pparms = %d\n", u32ClientID, u32Function, cParms, paParms));
274
275	SHFLCLIENTDATA pClient = (SHFLCLIENTDATA )pvClient;
276
277	bool fAsynchronousProcessing = false;
278
279	#ifdef DEBUG
280	uint32_t i;
281
282	for (i = 0; i < cParms; i++)
283	{
284	/** @todo parameters other than 32 bit */
285	Log((" pparms[%d]: type %d value %d\n", i, paParms[i].type, paParms[i].u.uint32));
286	}
287	#endif
288
289	switch (u32Function)
290	{
291	case SHFL_FN_QUERY_MAPPINGS:
292	{
293	Log(("svcCall: SHFL_FN_QUERY_MAPPINGS\n"));
294
295	/* Verify parameter count and types. */
296	if (cParms != SHFL_CPARMS_QUERY_MAPPINGS)
297	{
298	rc = VERR_INVALID_PARAMETER;
299	}
300	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
301	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* numberOfMappings */
302	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* mappings */
303	)
304	{
305	rc = VERR_INVALID_PARAMETER;
306	}
307	else
308	{
309	/* Fetch parameters. */
310	uint32_t fu32Flags = paParms[0].u.uint32;
311	uint32_t cMappings = paParms[1].u.uint32;
312	SHFLMAPPING pMappings = (SHFLMAPPING )paParms[2].u.pointer.addr;
313	uint32_t cbMappings = paParms[2].u.pointer.size;
314
315	/* Verify parameters values. */
316	if ( (fu32Flags & ~SHFL_MF_UTF8) != 0
317	\|\| cbMappings / sizeof (SHFLMAPPING) < cMappings
318	)
319	{
320	rc = VERR_INVALID_PARAMETER;
321	}
322	else
323	{
324	/* Execute the function. */
325	if (fu32Flags & SHFL_MF_UTF8)
326	{
327	pClient->fu32Flags \|= SHFL_CF_UTF8;
328	}
329
330	rc = vbsfMappingsQuery (pClient, pMappings, &cMappings);
331
332	if (RT_SUCCESS(rc))
333	{
334	/* Update parameters.*/
335	paParms[1].u.uint32 = cMappings;
336	}
337	}
338	}
339
340
341	} break;
342
343	case SHFL_FN_QUERY_MAP_NAME:
344	{
345	Log(("svcCall: SHFL_FN_QUERY_MAP_NAME\n"));
346
347	/* Verify parameter count and types. */
348	if (cParms != SHFL_CPARMS_QUERY_MAP_NAME)
349	{
350	rc = VERR_INVALID_PARAMETER;
351	}
352	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
353	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* name */
354	)
355	{
356	rc = VERR_INVALID_PARAMETER;
357	}
358	else
359	{
360	/* Fetch parameters. */
361	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
362	SHFLSTRING pString = (SHFLSTRING )paParms[1].u.pointer.addr;
363
364	/* Verify parameters values. */
365	if (!ShflStringIsValid(pString, paParms[1].u.pointer.size))
366	{
367	rc = VERR_INVALID_PARAMETER;
368	}
369	else
370	{
371	/* Execute the function. */
372	rc = vbsfMappingsQueryName (pClient, root, pString);
373
374	if (RT_SUCCESS(rc))
375	{
376	/* Update parameters.*/
377	; /* none */
378	}
379	}
380	}
381
382	} break;
383
384	case SHFL_FN_CREATE:
385	{
386	Log(("svcCall: SHFL_FN_CREATE\n"));
387
388	/* Verify parameter count and types. */
389	if (cParms != SHFL_CPARMS_CREATE)
390	{
391	rc = VERR_INVALID_PARAMETER;
392	}
393	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
394	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
395	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* parms */
396	)
397	{
398	Log(("Invalid parameters types\n"));
399	rc = VERR_INVALID_PARAMETER;
400	}
401	else
402	{
403	/* Fetch parameters. */
404	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
405	SHFLSTRING pPath = (SHFLSTRING )paParms[1].u.pointer.addr;
406	uint32_t cbPath = paParms[1].u.pointer.size;
407	SHFLCREATEPARMS pParms = (SHFLCREATEPARMS )paParms[2].u.pointer.addr;
408	uint32_t cbParms = paParms[2].u.pointer.size;
409
410	/* Verify parameters values. */
411	if ( !ShflStringIsValid(pPath, cbPath)
412	\|\| (cbParms != sizeof (SHFLCREATEPARMS))
413	)
414	{
415	AssertMsgFailed (("Invalid parameters cbPath or cbParms (%x, %x - expected >=%x, %x)\n",
416	cbPath, cbParms, sizeof(SHFLSTRING), sizeof (SHFLCREATEPARMS)));
417	rc = VERR_INVALID_PARAMETER;
418	}
419	else
420	{
421	/* Execute the function. */
422
423	rc = vbsfCreate (pClient, root, pPath, cbPath, pParms);
424
425	if (RT_SUCCESS(rc))
426	{
427	/* Update parameters.*/
428	; /* none */
429	}
430	}
431	}
432	break;
433	}
434
435	case SHFL_FN_CLOSE:
436	{
437	Log(("svcCall: SHFL_FN_CLOSE\n"));
438
439	/* Verify parameter count and types. */
440	if (cParms != SHFL_CPARMS_CLOSE)
441	{
442	rc = VERR_INVALID_PARAMETER;
443	}
444	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
445	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
446	)
447	{
448	rc = VERR_INVALID_PARAMETER;
449	}
450	else
451	{
452	/* Fetch parameters. */
453	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
454	SHFLHANDLE Handle = paParms[1].u.uint64;
455
456	/* Verify parameters values. */
457	if (Handle == SHFL_HANDLE_ROOT)
458	{
459	rc = VERR_INVALID_PARAMETER;
460	}
461	else
462	if (Handle == SHFL_HANDLE_NIL)
463	{
464	AssertMsgFailed(("Invalid handle!!!!\n"));
465	rc = VERR_INVALID_HANDLE;
466	}
467	else
468	{
469	/* Execute the function. */
470
471	rc = vbsfClose (pClient, root, Handle);
472
473	if (RT_SUCCESS(rc))
474	{
475	/* Update parameters.*/
476	; /* none */
477	}
478	}
479	}
480	break;
481
482	}
483
484	/** Read object content. */
485	case SHFL_FN_READ:
486	Log(("svcCall: SHFL_FN_READ\n"));
487
488	/* Verify parameter count and types. */
489	if (cParms != SHFL_CPARMS_READ)
490	{
491	rc = VERR_INVALID_PARAMETER;
492	}
493	else
494	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
495	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
496	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
497	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* count */
498	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
499	)
500	{
501	rc = VERR_INVALID_PARAMETER;
502	}
503	else
504	{
505	/* Fetch parameters. */
506	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
507	SHFLHANDLE Handle = paParms[1].u.uint64;
508	uint64_t offset = paParms[2].u.uint64;
509	uint32_t count = paParms[3].u.uint32;
510	uint8_t pBuffer = (uint8_t )paParms[4].u.pointer.addr;
511
512	/* Verify parameters values. */
513	if ( Handle == SHFL_HANDLE_ROOT
514	\|\| count > paParms[4].u.pointer.size
515	)
516	{
517	rc = VERR_INVALID_PARAMETER;
518	}
519	else
520	if (Handle == SHFL_HANDLE_NIL)
521	{
522	AssertMsgFailed(("Invalid handle!!!!\n"));
523	rc = VERR_INVALID_HANDLE;
524	}
525	else
526	{
527	/* Execute the function. */
528	if (pStatusLed)
529	{
530	Assert(pStatusLed->u32Magic == PDMLED_MAGIC);
531	pStatusLed->Asserted.s.fReading = pStatusLed->Actual.s.fReading = 1;
532	}
533
534	rc = vbsfRead (pClient, root, Handle, offset, &count, pBuffer);
535	if (pStatusLed)
536	pStatusLed->Actual.s.fReading = 0;
537
538	if (RT_SUCCESS(rc))
539	{
540	/* Update parameters.*/
541	paParms[3].u.uint32 = count;
542	}
543	else
544	{
545	paParms[3].u.uint32 = 0; /* nothing read */
546	}
547	}
548	}
549	break;
550
551	/** Write new object content. */
552	case SHFL_FN_WRITE:
553	Log(("svcCall: SHFL_FN_WRITE\n"));
554
555	/* Verify parameter count and types. */
556	if (cParms != SHFL_CPARMS_WRITE)
557	{
558	rc = VERR_INVALID_PARAMETER;
559	}
560	else
561	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
562	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
563	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
564	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* count */
565	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
566	)
567	{
568	rc = VERR_INVALID_PARAMETER;
569	}
570	else
571	{
572	/* Fetch parameters. */
573	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
574	SHFLHANDLE Handle = paParms[1].u.uint64;
575	uint64_t offset = paParms[2].u.uint64;
576	uint32_t count = paParms[3].u.uint32;
577	uint8_t pBuffer = (uint8_t )paParms[4].u.pointer.addr;
578
579	/* Verify parameters values. */
580	if ( Handle == SHFL_HANDLE_ROOT
581	\|\| count > paParms[4].u.pointer.size
582	)
583	{
584	rc = VERR_INVALID_PARAMETER;
585	}
586	else
587	if (Handle == SHFL_HANDLE_NIL)
588	{
589	AssertMsgFailed(("Invalid handle!!!!\n"));
590	rc = VERR_INVALID_HANDLE;
591	}
592	else
593	{
594	/* Execute the function. */
595	if (pStatusLed)
596	{
597	Assert(pStatusLed->u32Magic == PDMLED_MAGIC);
598	pStatusLed->Asserted.s.fWriting = pStatusLed->Actual.s.fWriting = 1;
599	}
600
601	rc = vbsfWrite (pClient, root, Handle, offset, &count, pBuffer);
602	if (pStatusLed)
603	pStatusLed->Actual.s.fWriting = 0;
604
605	if (RT_SUCCESS(rc))
606	{
607	/* Update parameters.*/
608	paParms[3].u.uint32 = count;
609	}
610	else
611	{
612	paParms[3].u.uint32 = 0; /* nothing read */
613	}
614	}
615	}
616	break;
617
618	/** Lock/unlock a range in the object. */
619	case SHFL_FN_LOCK:
620	Log(("svcCall: SHFL_FN_LOCK\n"));
621
622	/* Verify parameter count and types. */
623	if (cParms != SHFL_CPARMS_LOCK)
624	{
625	rc = VERR_INVALID_PARAMETER;
626	}
627	else
628	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
629	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
630	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
631	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_64BIT /* length */
632	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
633	)
634	{
635	rc = VERR_INVALID_PARAMETER;
636	}
637	else
638	{
639	/* Fetch parameters. */
640	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
641	SHFLHANDLE Handle = paParms[1].u.uint64;
642	uint64_t offset = paParms[2].u.uint64;
643	uint64_t length = paParms[3].u.uint64;
644	uint32_t flags = paParms[4].u.uint32;
645
646	/* Verify parameters values. */
647	if (Handle == SHFL_HANDLE_ROOT)
648	{
649	rc = VERR_INVALID_PARAMETER;
650	}
651	else
652	if (Handle == SHFL_HANDLE_NIL)
653	{
654	AssertMsgFailed(("Invalid handle!!!!\n"));
655	rc = VERR_INVALID_HANDLE;
656	}
657	else if (flags & SHFL_LOCK_WAIT)
658	{
659	/* @todo This should be properly implemented by the shared folders service.
660	* The service thread must never block. If an operation requires
661	* blocking, it must be processed by another thread and when it is
662	* completed, the another thread must call
663	*
664	* g_pHelpers->pfnCallComplete (callHandle, rc);
665	*
666	* The operation is async.
667	* fAsynchronousProcessing = true;
668	*/
669
670	/* Here the operation must be posted to another thread. At the moment it is not implemented.
671	* Until it is implemented, try to perform the operation without waiting.
672	*/
673	flags &= ~SHFL_LOCK_WAIT;
674
675	/* Execute the function. */
676	if ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
677	rc = vbsfUnlock(pClient, root, Handle, offset, length, flags);
678	else
679	rc = vbsfLock(pClient, root, Handle, offset, length, flags);
680
681	if (VBOX_SUCCESS(rc))
682	{
683	/* Update parameters.*/
684	/* none */
685	}
686	}
687	else
688	{
689	/* Execute the function. */
690	if ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
691	rc = vbsfUnlock(pClient, root, Handle, offset, length, flags);
692	else
693	rc = vbsfLock(pClient, root, Handle, offset, length, flags);
694
695	if (RT_SUCCESS(rc))
696	{
697	/* Update parameters.*/
698	/* none */
699	}
700	}
701	}
702	break;
703
704	/** List object content. */
705	case SHFL_FN_LIST:
706	{
707	Log(("svcCall: SHFL_FN_LIST\n"));
708
709	/* Verify parameter count and types. */
710	if (cParms != SHFL_CPARMS_LIST)
711	{
712	rc = VERR_INVALID_PARAMETER;
713	}
714	else
715	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
716	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
717	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
718	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* cb */
719	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* pPath */
720	\|\| paParms[5].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
721	\|\| paParms[6].type != VBOX_HGCM_SVC_PARM_32BIT /* resumePoint */
722	\|\| paParms[7].type != VBOX_HGCM_SVC_PARM_32BIT /* cFiles (out) */
723	)
724	{
725	rc = VERR_INVALID_PARAMETER;
726	}
727	else
728	{
729	/* Fetch parameters. */
730	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
731	SHFLHANDLE Handle = paParms[1].u.uint64;
732	uint32_t flags = paParms[2].u.uint32;
733	uint32_t length = paParms[3].u.uint32;
734	SHFLSTRING pPath = (paParms[4].u.pointer.size == 0) ? 0 : (SHFLSTRING )paParms[4].u.pointer.addr;
735	uint8_t pBuffer = (uint8_t )paParms[5].u.pointer.addr;
736	uint32_t resumePoint = paParms[6].u.uint32;
737	uint32_t cFiles = 0;
738
739	/* Verify parameters values. */
740	if ( (length < sizeof (SHFLDIRINFO))
741	\|\| length > paParms[5].u.pointer.size
742	\|\| !ShflStringIsValidOrNull(pPath, paParms[4].u.pointer.size)
743	)
744	{
745	rc = VERR_INVALID_PARAMETER;
746	}
747	else
748	{
749	if (pStatusLed)
750	{
751	Assert(pStatusLed->u32Magic == PDMLED_MAGIC);
752	pStatusLed->Asserted.s.fReading = pStatusLed->Actual.s.fReading = 1;
753	}
754
755	/* Execute the function. */
756	rc = vbsfDirList (pClient, root, Handle, pPath, flags, &length, pBuffer, &resumePoint, &cFiles);
757
758	if (pStatusLed)
759	pStatusLed->Actual.s.fReading = 0;
760
761	if (rc == VERR_NO_MORE_FILES && cFiles != 0)
762	rc = VINF_SUCCESS; /* Successfully return these files. */
763
764	if (RT_SUCCESS(rc))
765	{
766	/* Update parameters.*/
767	paParms[3].u.uint32 = length;
768	paParms[6].u.uint32 = resumePoint;
769	paParms[7].u.uint32 = cFiles;
770	}
771	else
772	{
773	paParms[3].u.uint32 = 0; /* nothing read */
774	paParms[6].u.uint32 = 0;
775	paParms[7].u.uint32 = cFiles;
776	}
777	}
778	}
779	break;
780	}
781
782	/* Legacy interface */
783	case SHFL_FN_MAP_FOLDER_OLD:
784	{
785	Log(("svcCall: SHFL_FN_MAP_FOLDER_OLD\n"));
786
787	/* Verify parameter count and types. */
788	if (cParms != SHFL_CPARMS_MAP_FOLDER_OLD)
789	{
790	rc = VERR_INVALID_PARAMETER;
791	}
792	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */
793	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
794	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* delimiter */
795	)
796	{
797	rc = VERR_INVALID_PARAMETER;
798	}
799	else
800	{
801	/* Fetch parameters. */
802	PSHFLSTRING pszMapName = (PSHFLSTRING)paParms[0].u.pointer.addr;
803	SHFLROOT root = (SHFLROOT)paParms[1].u.uint32;
804	RTUTF16 delimiter = (RTUTF16)paParms[2].u.uint32;
805
806	/* Verify parameters values. */
807	if (!ShflStringIsValid(pszMapName, paParms[0].u.pointer.size))
808	{
809	rc = VERR_INVALID_PARAMETER;
810	}
811	else
812	{
813	/* Execute the function. */
814	rc = vbsfMapFolder (pClient, pszMapName, delimiter, false, &root);
815
816	if (RT_SUCCESS(rc))
817	{
818	/* Update parameters.*/
819	paParms[1].u.uint32 = root;
820	}
821	}
822	}
823	break;
824	}
825
826	case SHFL_FN_MAP_FOLDER:
827	{
828	Log(("svcCall: SHFL_FN_MAP_FOLDER\n"));
829	if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
830	LogRel(("SharedFolders host service: request to map folder %S\n",
831	((PSHFLSTRING)paParms[0].u.pointer.addr)->String.utf8));
832	else
833	LogRel(("SharedFolders host service: request to map folder %lS\n",
834	((PSHFLSTRING)paParms[0].u.pointer.addr)->String.ucs2));
835
836	/* Verify parameter count and types. */
837	if (cParms != SHFL_CPARMS_MAP_FOLDER)
838	{
839	rc = VERR_INVALID_PARAMETER;
840	}
841	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */
842	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
843	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* delimiter */
844	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* fCaseSensitive */
845	)
846	{
847	rc = VERR_INVALID_PARAMETER;
848	}
849	else
850	{
851	/* Fetch parameters. */
852	PSHFLSTRING pszMapName = (PSHFLSTRING)paParms[0].u.pointer.addr;
853	SHFLROOT root = (SHFLROOT)paParms[1].u.uint32;
854	RTUTF16 delimiter = (RTUTF16)paParms[2].u.uint32;
855	bool fCaseSensitive = !!paParms[3].u.uint32;
856
857	/* Verify parameters values. */
858	if (!ShflStringIsValid(pszMapName, paParms[0].u.pointer.size))
859	{
860	rc = VERR_INVALID_PARAMETER;
861	}
862	else
863	{
864
865	/* Execute the function. */
866	rc = vbsfMapFolder (pClient, pszMapName, delimiter, fCaseSensitive, &root);
867
868	if (RT_SUCCESS(rc))
869	{
870	/* Update parameters.*/
871	paParms[1].u.uint32 = root;
872	}
873	}
874	}
875	LogRel(("SharedFolders host service: map operation result %Rrc.\n", rc));
876	if (RT_SUCCESS(rc))
877	LogRel((" Mapped to handle %d.\n", paParms[1].u.uint32));
878	break;
879	}
880
881	case SHFL_FN_UNMAP_FOLDER:
882	{
883	Log(("svcCall: SHFL_FN_UNMAP_FOLDER\n"));
884	LogRel(("SharedFolders host service: request to unmap folder handle %d\n",
885	paParms[0].u.uint32));
886
887	/* Verify parameter count and types. */
888	if (cParms != SHFL_CPARMS_UNMAP_FOLDER)
889	{
890	rc = VERR_INVALID_PARAMETER;
891	}
892	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
893	)
894	{
895	rc = VERR_INVALID_PARAMETER;
896	}
897	else
898	{
899	/* Fetch parameters. */
900	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
901
902	/* Execute the function. */
903	rc = vbsfUnmapFolder (pClient, root);
904
905	if (RT_SUCCESS(rc))
906	{
907	/* Update parameters.*/
908	/* nothing */
909	}
910	}
911	LogRel(("SharedFolders host service: unmap operation result %Rrc.\n", rc));
912	break;
913	}
914
915	/** Query/set object information. */
916	case SHFL_FN_INFORMATION:
917	{
918	Log(("svcCall: SHFL_FN_INFORMATION\n"));
919
920	/* Verify parameter count and types. */
921	if (cParms != SHFL_CPARMS_INFORMATION)
922	{
923	rc = VERR_INVALID_PARAMETER;
924	}
925	else
926	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
927	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
928	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
929	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* cb */
930	\|\| paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
931	)
932	{
933	rc = VERR_INVALID_PARAMETER;
934	}
935	else
936	{
937	/* Fetch parameters. */
938	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
939	SHFLHANDLE Handle = paParms[1].u.uint64;
940	uint32_t flags = paParms[2].u.uint32;
941	uint32_t length = paParms[3].u.uint32;
942	uint8_t pBuffer = (uint8_t )paParms[4].u.pointer.addr;
943
944	/* Verify parameters values. */
945	if (length > paParms[4].u.pointer.size)
946	{
947	rc = VERR_INVALID_PARAMETER;
948	}
949	else
950	{
951	/* Execute the function. */
952	if (flags & SHFL_INFO_SET)
953	rc = vbsfSetFSInfo (pClient, root, Handle, flags, &length, pBuffer);
954	else /* SHFL_INFO_GET */
955	rc = vbsfQueryFSInfo (pClient, root, Handle, flags, &length, pBuffer);
956
957	if (RT_SUCCESS(rc))
958	{
959	/* Update parameters.*/
960	paParms[3].u.uint32 = length;
961	}
962	else
963	{
964	paParms[3].u.uint32 = 0; /* nothing read */
965	}
966	}
967	}
968	break;
969	}
970
971	/** Remove or rename object */
972	case SHFL_FN_REMOVE:
973	{
974	Log(("svcCall: SHFL_FN_REMOVE\n"));
975
976	/* Verify parameter count and types. */
977	if (cParms != SHFL_CPARMS_REMOVE)
978	{
979	rc = VERR_INVALID_PARAMETER;
980	}
981	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
982	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
983	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
984	)
985	{
986	rc = VERR_INVALID_PARAMETER;
987	}
988	else
989	{
990	/* Fetch parameters. */
991	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
992	SHFLSTRING pPath = (SHFLSTRING )paParms[1].u.pointer.addr;
993	uint32_t cbPath = paParms[1].u.pointer.size;
994	uint32_t flags = paParms[2].u.uint32;
995
996	/* Verify parameters values. */
997	if (!ShflStringIsValid(pPath, cbPath))
998	{
999	rc = VERR_INVALID_PARAMETER;
1000	}
1001	else
1002	{
1003	/* Execute the function. */
1004
1005	rc = vbsfRemove (pClient, root, pPath, cbPath, flags);
1006	if (RT_SUCCESS(rc))
1007	{
1008	/* Update parameters.*/
1009	; /* none */
1010	}
1011	}
1012	}
1013	break;
1014	}
1015
1016	case SHFL_FN_RENAME:
1017	{
1018	Log(("svcCall: SHFL_FN_RENAME\n"));
1019
1020	/* Verify parameter count and types. */
1021	if (cParms != SHFL_CPARMS_RENAME)
1022	{
1023	rc = VERR_INVALID_PARAMETER;
1024	}
1025	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1026	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* src */
1027	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* dest */
1028	\|\| paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
1029	)
1030	{
1031	rc = VERR_INVALID_PARAMETER;
1032	}
1033	else
1034	{
1035	/* Fetch parameters. */
1036	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1037	SHFLSTRING pSrc = (SHFLSTRING )paParms[1].u.pointer.addr;
1038	SHFLSTRING pDest = (SHFLSTRING )paParms[2].u.pointer.addr;
1039	uint32_t flags = paParms[3].u.uint32;
1040
1041	/* Verify parameters values. */
1042	if ( !ShflStringIsValid(pSrc, paParms[1].u.pointer.size)
1043	\|\| !ShflStringIsValid(pDest, paParms[2].u.pointer.size)
1044	)
1045	{
1046	rc = VERR_INVALID_PARAMETER;
1047	}
1048	else
1049	{
1050	/* Execute the function. */
1051	rc = vbsfRename (pClient, root, pSrc, pDest, flags);
1052	if (RT_SUCCESS(rc))
1053	{
1054	/* Update parameters.*/
1055	; /* none */
1056	}
1057	}
1058	}
1059	break;
1060	}
1061
1062	case SHFL_FN_FLUSH:
1063	{
1064	Log(("svcCall: SHFL_FN_FLUSH\n"));
1065
1066	/* Verify parameter count and types. */
1067	if (cParms != SHFL_CPARMS_FLUSH)
1068	{
1069	rc = VERR_INVALID_PARAMETER;
1070	}
1071	else
1072	if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
1073	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
1074	)
1075	{
1076	rc = VERR_INVALID_PARAMETER;
1077	}
1078	else
1079	{
1080	/* Fetch parameters. */
1081	SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
1082	SHFLHANDLE Handle = paParms[1].u.uint64;
1083
1084	/* Verify parameters values. */
1085	if (Handle == SHFL_HANDLE_ROOT)
1086	{
1087	rc = VERR_INVALID_PARAMETER;
1088	}
1089	else
1090	if (Handle == SHFL_HANDLE_NIL)
1091	{
1092	AssertMsgFailed(("Invalid handle!!!!\n"));
1093	rc = VERR_INVALID_HANDLE;
1094	}
1095	else
1096	{
1097	/* Execute the function. */
1098
1099	rc = vbsfFlush (pClient, root, Handle);
1100
1101	if (RT_SUCCESS(rc))
1102	{
1103	/* Nothing to do */
1104	}
1105	}
1106	}
1107	} break;
1108
1109	case SHFL_FN_SET_UTF8:
1110	{
1111	pClient->fu32Flags \|= SHFL_CF_UTF8;
1112	rc = VINF_SUCCESS;
1113	break;
1114	}
1115
1116	default:
1117	{
1118	rc = VERR_NOT_IMPLEMENTED;
1119	break;
1120	}
1121	}
1122
1123	LogFlow(("svcCall: rc = %Rrc\n", rc));
1124
1125	if ( !fAsynchronousProcessing
1126	\|\| RT_FAILURE (rc))
1127	{
1128	/* Complete the operation if it was unsuccessful or
1129	* it was processed synchronously.
1130	*/
1131	g_pHelpers->pfnCallComplete (callHandle, rc);
1132	}
1133
1134	LogFlow(("\n")); /* Add a new line to differentiate between calls more easily. */
1135	}
1136
1137	/*
1138	* We differentiate between a function handler for the guest and one for the host. The guest is not allowed to add or remove mappings for obvious security reasons.
1139	*/
1140	static DECLCALLBACK(int) svcHostCall (void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
1141	{
1142	int rc = VINF_SUCCESS;
1143
1144	Log(("svcHostCall: fn = %d, cParms = %d, pparms = %d\n", u32Function, cParms, paParms));
1145
1146	#ifdef DEBUG
1147	uint32_t i;
1148
1149	for (i = 0; i < cParms; i++)
1150	{
1151	/** @todo parameters other than 32 bit */
1152	Log((" pparms[%d]: type %d value %d\n", i, paParms[i].type, paParms[i].u.uint32));
1153	}
1154	#endif
1155
1156	switch (u32Function)
1157	{
1158	case SHFL_FN_ADD_MAPPING:
1159	{
1160	Log(("svcCall: SHFL_FN_ADD_MAPPING\n"));
1161	LogRel(("SharedFolders host service: adding host mapping.\n"));
1162	LogRel((" Host path %lS, map name %lS, writable %d\n",
1163	((SHFLSTRING *)paParms[0].u.pointer.addr)->String.ucs2,
1164	((SHFLSTRING *)paParms[1].u.pointer.addr)->String.ucs2,
1165	paParms[2].u.uint32));
1166
1167	/* Verify parameter count and types. */
1168	if (cParms != SHFL_CPARMS_ADD_MAPPING)
1169	{
1170	rc = VERR_INVALID_PARAMETER;
1171	}
1172	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* host folder name */
1173	\|\| paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* guest map name */
1174	\|\| paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* fWritable */
1175	)
1176	{
1177	rc = VERR_INVALID_PARAMETER;
1178	}
1179	else
1180	{
1181	/* Fetch parameters. */
1182	SHFLSTRING pFolderName = (SHFLSTRING )paParms[0].u.pointer.addr;
1183	SHFLSTRING pMapName = (SHFLSTRING )paParms[1].u.pointer.addr;
1184	uint32_t fWritable = paParms[2].u.uint32;
1185
1186	/* Verify parameters values. */
1187	if ( !ShflStringIsValid(pFolderName, paParms[0].u.pointer.size)
1188	\|\| !ShflStringIsValid(pMapName, paParms[1].u.pointer.size)
1189	)
1190	{
1191	rc = VERR_INVALID_PARAMETER;
1192	}
1193	else
1194	{
1195	/* Execute the function. */
1196	rc = vbsfMappingsAdd (pFolderName, pMapName, fWritable);
1197
1198	if (RT_SUCCESS(rc))
1199	{
1200	/* Update parameters.*/
1201	; /* none */
1202	}
1203	}
1204	}
1205	LogRel(("SharedFolders host service: add mapping result %Rrc\n", rc));
1206	break;
1207	}
1208
1209	case SHFL_FN_REMOVE_MAPPING:
1210	{
1211	Log(("svcCall: SHFL_FN_REMOVE_MAPPING\n"));
1212	LogRel(("SharedFolders host service: removing host mapping %lS\n",
1213	((SHFLSTRING *)paParms[0].u.pointer.addr)->String.ucs2));
1214
1215	/* Verify parameter count and types. */
1216	if (cParms != SHFL_CPARMS_REMOVE_MAPPING)
1217	{
1218	rc = VERR_INVALID_PARAMETER;
1219	}
1220	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* folder name */
1221	)
1222	{
1223	rc = VERR_INVALID_PARAMETER;
1224	}
1225	else
1226	{
1227	/* Fetch parameters. */
1228	SHFLSTRING pString = (SHFLSTRING )paParms[0].u.pointer.addr;
1229
1230	/* Verify parameters values. */
1231	if (!ShflStringIsValid(pString, paParms[0].u.pointer.size))
1232	{
1233	rc = VERR_INVALID_PARAMETER;
1234	}
1235	else
1236	{
1237	/* Execute the function. */
1238	rc = vbsfMappingsRemove (pString);
1239
1240	if (RT_SUCCESS(rc))
1241	{
1242	/* Update parameters.*/
1243	; /* none */
1244	}
1245	}
1246	}
1247	LogRel(("SharedFolders host service: remove mapping result %Rrc\n", rc));
1248	break;
1249	}
1250
1251	case SHFL_FN_SET_STATUS_LED:
1252	{
1253	Log(("svcCall: SHFL_FN_SET_STATUS_LED\n"));
1254
1255	/* Verify parameter count and types. */
1256	if (cParms != SHFL_CPARMS_SET_STATUS_LED)
1257	{
1258	rc = VERR_INVALID_PARAMETER;
1259	}
1260	else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* folder name */
1261	)
1262	{
1263	rc = VERR_INVALID_PARAMETER;
1264	}
1265	else
1266	{
1267	/* Fetch parameters. */
1268	PPDMLED pLed = (PPDMLED)paParms[0].u.pointer.addr;
1269	uint32_t cbLed = paParms[0].u.pointer.size;
1270
1271	/* Verify parameters values. */
1272	if ( (cbLed != sizeof (PDMLED))
1273	)
1274	{
1275	rc = VERR_INVALID_PARAMETER;
1276	}
1277	else
1278	{
1279	/* Execute the function. */
1280	pStatusLed = pLed;
1281	rc = VINF_SUCCESS;
1282	}
1283	}
1284	break;
1285	}
1286
1287	default:
1288	rc = VERR_NOT_IMPLEMENTED;
1289	break;
1290	}
1291
1292	LogFlow(("svcHostCall: rc = %Rrc\n", rc));
1293	return rc;
1294	}
1295
1296	extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
1297	{
1298	int rc = VINF_SUCCESS;
1299
1300	Log(("VBoxHGCMSvcLoad: ptable = %p\n", ptable));
1301
1302	if (!VALID_PTR(ptable))
1303	{
1304	LogRelFunc(("Bad value of ptable (%p) in shared folders service\n", ptable));
1305	rc = VERR_INVALID_PARAMETER;
1306	}
1307	else
1308	{
1309	Log(("VBoxHGCMSvcLoad: ptable->cbSize = %d, ptable->u32Version = 0x%08X\n", ptable->cbSize, ptable->u32Version));
1310
1311	if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
1312	\|\| ptable->u32Version != VBOX_HGCM_SVC_VERSION)
1313	{
1314	LogRelFunc(("version mismatch loading shared folders service: ptable->cbSize = %d, should be %d, ptable->u32Version = 0x%08X, should be 0x%08X\n", ptable->cbSize, sizeof (VBOXHGCMSVCFNTABLE), ptable->u32Version, VBOX_HGCM_SVC_VERSION));
1315	rc = VERR_VERSION_MISMATCH;
1316	}
1317	else
1318	{
1319	g_pHelpers = ptable->pHelpers;
1320
1321	ptable->cbClient = sizeof (SHFLCLIENTDATA);
1322
1323	ptable->pfnUnload = svcUnload;
1324	ptable->pfnConnect = svcConnect;
1325	ptable->pfnDisconnect = svcDisconnect;
1326	ptable->pfnCall = svcCall;
1327	ptable->pfnHostCall = svcHostCall;
1328	ptable->pfnSaveState = svcSaveState;
1329	ptable->pfnLoadState = svcLoadState;
1330	ptable->pvService = NULL;
1331	}
1332
1333	/* Init handle table */
1334	rc = vbsfInitHandleTable();
1335	AssertRC(rc);
1336
1337	vbsfMappingInit();
1338	}
1339
1340	return rc;
1341	}

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

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

Download in other formats: