mappings.cpp@ 84909

Last change on this file since 84909 was 82968, checked in by vboxsync, 5 years ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.9 KB

Line
1	/* $Id: mappings.cpp 82968 2020-02-04 10:35:17Z vboxsync $ */
2	/** @file
3	* Shared Folders Service - Mappings support.
4	*/
5
6	/*
7	* Copyright (C) 2006-2020 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	#ifdef UNITTEST
24	# include "testcase/tstSharedFolderService.h"
25	#endif
26
27	#include "mappings.h"
28	#include "vbsfpath.h"
29	#include <iprt/alloc.h>
30	#include <iprt/assert.h>
31	#include <iprt/list.h>
32	#include <iprt/path.h>
33	#include <iprt/string.h>
34	#include <VBox/AssertGuest.h>
35
36	#ifdef UNITTEST
37	# include "teststubs.h"
38	#endif
39
40
41	/*********************************************************************************************************************************
42	* Global Variables *
43	*********************************************************************************************************************************/
44	extern PVBOXHGCMSVCHELPERS g_pHelpers; /* service.cpp */
45
46
47	/* Shared folders order in the saved state and in the g_FolderMapping can differ.
48	* So a translation array of root handle is needed.
49	*/
50
51	static MAPPING g_FolderMapping[SHFL_MAX_MAPPINGS];
52	static SHFLROOT g_aIndexFromRoot[SHFL_MAX_MAPPINGS];
53	/**< Array running parallel to g_aIndexFromRoot and which entries are increased
54	* as an root handle is added or removed.
55	*
56	* This helps the guest figuring out that a mapping may have been reconfigured
57	* or that saved state has been restored. Entry reuse is very likely given that
58	* vbsfRootHandleAdd() always starts searching at the start for an unused entry.
59	*/
60	static uint32_t g_auRootHandleVersions[SHFL_MAX_MAPPINGS];
61	/** Version number that is increased for every change made.
62	* This is used by the automount guest service to wait for changes.
63	* @note This does not need saving, the guest should be woken up and refresh
64	* its sate when restored. */
65	static uint32_t volatile g_uFolderMappingsVersion = 0;
66
67
68	/** For recording async vbsfMappingsWaitForChanges calls. */
69	typedef struct SHFLMAPPINGSWAIT
70	{
71	RTLISTNODE ListEntry; /*< List entry. /
72	PSHFLCLIENTDATA pClient; /*< The client that's waiting. /
73	VBOXHGCMCALLHANDLE hCall; /*< The call handle to signal completion with. /
74	PVBOXHGCMSVCPARM pParm; /*< The 32-bit unsigned parameter to stuff g_uFolderMappingsVersion into. /
75	} SHFLMAPPINGSWAIT;
76	/** Pointer to async mappings change wait. */
77	typedef SHFLMAPPINGSWAIT *PSHFLMAPPINGSWAIT;
78	/** List head for clients waiting on mapping changes (SHFLMAPPINGSWAIT). */
79	static RTLISTANCHOR g_MappingsChangeWaiters;
80	/** Number of clients waiting on mapping changes.
81	* We use this to limit the number of waiting calls the clients can make. */
82	static uint32_t g_cMappingChangeWaiters = 0;
83	static void vbsfMappingsWakeupAllWaiters(void);
84
85
86	void vbsfMappingInit(void)
87	{
88	unsigned root;
89
90	for (root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
91	{
92	g_aIndexFromRoot[root] = SHFL_ROOT_NIL;
93	}
94
95	RTListInit(&g_MappingsChangeWaiters);
96	}
97
98	/**
99	* Called before loading mappings from saved state to drop the root IDs.
100	*/
101	void vbsfMappingLoadingStart(void)
102	{
103	for (SHFLROOT idRoot = 0; idRoot < RT_ELEMENTS(g_aIndexFromRoot); idRoot++)
104	g_aIndexFromRoot[idRoot] = SHFL_ROOT_NIL;
105
106	for (SHFLROOT i = 0; i < RT_ELEMENTS(g_FolderMapping); i++)
107	g_FolderMapping[i].fLoadedRootId = false;
108	}
109
110	/**
111	* Called when a mapping is loaded to restore the root ID and make sure it
112	* exists.
113	*
114	* @returns VBox status code.
115	*/
116	int vbsfMappingLoaded(const MAPPING *pLoadedMapping, SHFLROOT root)
117	{
118	/* Mapping loaded from the saved state with the 'root' index. Which means
119	* the guest uses the 'root' as root handle for this folder.
120	* Check whether there is the same mapping in g_FolderMapping and
121	* update the g_aIndexFromRoot.
122	*
123	* Also update the mapping properties, which were lost: cMappings.
124	*/
125	if (root >= SHFL_MAX_MAPPINGS)
126	{
127	return VERR_INVALID_PARAMETER;
128	}
129
130	SHFLROOT i;
131	for (i = 0; i < RT_ELEMENTS(g_FolderMapping); i++)
132	{
133	MAPPING *pMapping = &g_FolderMapping[i];
134
135	/* Equal? */
136	if ( pLoadedMapping->fValid == pMapping->fValid
137	&& ShflStringSizeOfBuffer(pLoadedMapping->pMapName) == ShflStringSizeOfBuffer(pMapping->pMapName)
138	&& memcmp(pLoadedMapping->pMapName, pMapping->pMapName, ShflStringSizeOfBuffer(pMapping->pMapName)) == 0)
139	{
140	Log(("vbsfMappingLoaded: root=%u i=%u (was %u) (%ls)\n",
141	root, i, g_aIndexFromRoot[root], pLoadedMapping->pMapName->String.utf16));
142
143	if (!pMapping->fLoadedRootId)
144	{
145	/* First encounter. */
146	pMapping->fLoadedRootId = true;
147
148	/* Update the mapping properties. */
149	pMapping->cMappings = pLoadedMapping->cMappings;
150	}
151	else
152	{
153	/* When pMapping->fLoadedRootId is already true it means that another HGCM client uses the same mapping. */
154	Assert(pMapping->cMappings > 1);
155	}
156
157	/* Actual index is i. Remember that when the guest uses 'root' it is actually 'i'. */
158	AssertLogRelMsg(g_aIndexFromRoot[root] == SHFL_ROOT_NIL,
159	("idRoot=%u: current %u ([%s]), new %u (%ls [%s])\n",
160	root, g_aIndexFromRoot[root], g_FolderMapping[g_aIndexFromRoot[root]].pszFolderName,
161	i, pLoadedMapping->pMapName->String.utf16, pLoadedMapping->pszFolderName));
162	g_aIndexFromRoot[root] = i;
163
164	/* The mapping is known to the host and is used by the guest.
165	* No need for a 'placeholder'.
166	*/
167	return VINF_SUCCESS;
168	}
169	}
170
171	/* No corresponding mapping on the host but the guest still uses it.
172	* Add a 'placeholder' mapping.
173	*/
174	LogRel2(("SharedFolders: mapping a placeholder for '%ls' -> '%s'\n",
175	pLoadedMapping->pMapName->String.ucs2, pLoadedMapping->pszFolderName));
176	return vbsfMappingsAdd(pLoadedMapping->pszFolderName, pLoadedMapping->pMapName,
177	pLoadedMapping->fWritable, pLoadedMapping->fAutoMount, pLoadedMapping->pAutoMountPoint,
178	pLoadedMapping->fSymlinksCreate, /* fMissing = / true, / fPlaceholder = */ true);
179	}
180
181	/**
182	* Called after loading mappings from saved state to make sure every mapping has
183	* a root ID.
184	*/
185	void vbsfMappingLoadingDone(void)
186	{
187	for (SHFLROOT iMapping = 0; iMapping < RT_ELEMENTS(g_FolderMapping); iMapping++)
188	if (g_FolderMapping[iMapping].fValid)
189	{
190	AssertLogRel(g_FolderMapping[iMapping].pMapName);
191	AssertLogRel(g_FolderMapping[iMapping].pszFolderName);
192
193	SHFLROOT idRoot;
194	for (idRoot = 0; idRoot < RT_ELEMENTS(g_aIndexFromRoot); idRoot++)
195	if (g_aIndexFromRoot[idRoot] == iMapping)
196	break;
197	if (idRoot >= RT_ELEMENTS(g_aIndexFromRoot))
198	{
199	for (idRoot = 0; idRoot < RT_ELEMENTS(g_aIndexFromRoot); idRoot++)
200	if (g_aIndexFromRoot[idRoot] == SHFL_ROOT_NIL)
201	break;
202	if (idRoot < RT_ELEMENTS(g_aIndexFromRoot))
203	g_aIndexFromRoot[idRoot] = iMapping;
204	else
205	LogRel(("SharedFolders: Warning! No free root ID entry for mapping #%u: %ls [%s]\n", iMapping,
206	g_FolderMapping[iMapping].pMapName->String.ucs2, g_FolderMapping[iMapping].pszFolderName));
207	}
208	}
209
210	/* Log the root ID mappings: */
211	if (LogRelIs2Enabled())
212	for (SHFLROOT idRoot = 0; idRoot < RT_ELEMENTS(g_aIndexFromRoot); idRoot++)
213	{
214	SHFLROOT const iMapping = g_aIndexFromRoot[idRoot];
215	if (iMapping != SHFL_ROOT_NIL)
216	LogRel2(("SharedFolders: idRoot %u: iMapping #%u: %ls [%s]\n", idRoot, iMapping,
217	g_FolderMapping[iMapping].pMapName->String.ucs2, g_FolderMapping[iMapping].pszFolderName));
218	}
219	}
220
221
222	MAPPING *vbsfMappingGetByRoot(SHFLROOT root)
223	{
224	if (root < RT_ELEMENTS(g_aIndexFromRoot))
225	{
226	SHFLROOT iMapping = g_aIndexFromRoot[root];
227
228	if ( iMapping != SHFL_ROOT_NIL
229	&& iMapping < RT_ELEMENTS(g_FolderMapping))
230	{
231	return &g_FolderMapping[iMapping];
232	}
233	}
234
235	return NULL;
236	}
237
238	static SHFLROOT vbsfMappingGetRootFromIndex(SHFLROOT iMapping)
239	{
240	unsigned root;
241
242	for (root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
243	{
244	if (iMapping == g_aIndexFromRoot[root])
245	{
246	return root;
247	}
248	}
249
250	return SHFL_ROOT_NIL;
251	}
252
253	static MAPPING vbsfMappingGetByName(PRTUTF16 pwszName, SHFLROOT pRoot)
254	{
255	for (unsigned i = 0; i < SHFL_MAX_MAPPINGS; i++)
256	{
257	if ( g_FolderMapping[i].fValid
258	&& !g_FolderMapping[i].fPlaceholder) /* Don't allow mapping placeholders. */
259	{
260	if (!RTUtf16LocaleICmp(g_FolderMapping[i].pMapName->String.ucs2, pwszName))
261	{
262	SHFLROOT root = vbsfMappingGetRootFromIndex(i);
263
264	if (root != SHFL_ROOT_NIL)
265	{
266	if (pRoot)
267	{
268	*pRoot = root;
269	}
270	return &g_FolderMapping[i];
271	}
272	AssertFailed();
273	}
274	}
275	}
276	return NULL;
277	}
278
279	static void vbsfRootHandleAdd(SHFLROOT iMapping)
280	{
281	for (unsigned root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
282	{
283	if (g_aIndexFromRoot[root] == SHFL_ROOT_NIL)
284	{
285	g_aIndexFromRoot[root] = iMapping;
286	g_auRootHandleVersions[root] += 1;
287	return;
288	}
289	}
290
291	AssertFailed();
292	}
293
294	static void vbsfRootHandleRemove(SHFLROOT iMapping)
295	{
296	unsigned cFound = 0;
297
298	for (unsigned root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
299	{
300	if (g_aIndexFromRoot[root] == iMapping)
301	{
302	g_aIndexFromRoot[root] = SHFL_ROOT_NIL;
303	g_auRootHandleVersions[root] += 1;
304	Log(("vbsfRootHandleRemove: Removed root=%u (iMapping=%u)\n", root, iMapping));
305
306	/* Note! Do not stop here as g_aIndexFromRoot may (at least it could
307	prior to the introduction of fLoadedRootId) contain
308	duplicates after restoring save state. */
309	cFound++;
310	}
311	}
312
313	Assert(cFound > 0); RT_NOREF(cFound);
314	}
315
316
317
318	#ifdef UNITTEST
319	/** Unit test the SHFL_FN_ADD_MAPPING API. Located here as a form of API
320	* documentation. */
321	void testMappingsAdd(RTTEST hTest)
322	{
323	/* If the number or types of parameters are wrong the API should fail. */
324	testMappingsAddBadParameters(hTest);
325	/* Add tests as required... */
326	}
327	#endif
328	/*
329	* We are always executed from one specific HGCM thread. So thread safe.
330	*/
331	int vbsfMappingsAdd(const char *pszFolderName, PSHFLSTRING pMapName, bool fWritable,
332	bool fAutoMount, PSHFLSTRING pAutoMountPoint, bool fSymlinksCreate, bool fMissing, bool fPlaceholder)
333	{
334	unsigned i;
335
336	Assert(pszFolderName && pMapName);
337
338	Log(("vbsfMappingsAdd %ls\n", pMapName->String.ucs2));
339
340	/* Check for duplicates, ignoring placeholders to give the GUI to change stuff at runtime. */
341	/** @todo bird: Not entirely sure about ignoring placeholders, but you cannot
342	* trigger auto-umounting without ignoring them. */
343	if (!fPlaceholder)
344	{
345	for (i = 0; i < SHFL_MAX_MAPPINGS; i++)
346	{
347	if ( g_FolderMapping[i].fValid
348	&& !g_FolderMapping[i].fPlaceholder)
349	{
350	if (!RTUtf16LocaleICmp(g_FolderMapping[i].pMapName->String.ucs2, pMapName->String.ucs2))
351	{
352	AssertMsgFailed(("vbsfMappingsAdd: %ls mapping already exists!!\n", pMapName->String.ucs2));
353	return VERR_ALREADY_EXISTS;
354	}
355	}
356	}
357	}
358
359	for (i = 0; i < SHFL_MAX_MAPPINGS; i++)
360	{
361	if (g_FolderMapping[i].fValid == false)
362	{
363	/* Make sure the folder name is an absolute path, otherwise we're
364	likely to get into trouble with buffer sizes in vbsfPathGuestToHost. */
365	char szAbsFolderName[RTPATH_MAX];
366	int rc = vbsfPathAbs(NULL, pszFolderName, szAbsFolderName, sizeof(szAbsFolderName));
367	AssertRCReturn(rc, rc);
368
369	g_FolderMapping[i].pszFolderName = RTStrDup(szAbsFolderName);
370	g_FolderMapping[i].pMapName = ShflStringDup(pMapName);
371	g_FolderMapping[i].pAutoMountPoint = ShflStringDup(pAutoMountPoint);
372	if ( !g_FolderMapping[i].pszFolderName
373	\|\| !g_FolderMapping[i].pMapName
374	\|\| !g_FolderMapping[i].pAutoMountPoint)
375	{
376	RTStrFree(g_FolderMapping[i].pszFolderName);
377	RTMemFree(g_FolderMapping[i].pMapName);
378	RTMemFree(g_FolderMapping[i].pAutoMountPoint);
379	return VERR_NO_MEMORY;
380	}
381
382	g_FolderMapping[i].fValid = true;
383	g_FolderMapping[i].cMappings = 0;
384	g_FolderMapping[i].fWritable = fWritable;
385	g_FolderMapping[i].fAutoMount = fAutoMount;
386	g_FolderMapping[i].fSymlinksCreate = fSymlinksCreate;
387	g_FolderMapping[i].fMissing = fMissing;
388	g_FolderMapping[i].fPlaceholder = fPlaceholder;
389	g_FolderMapping[i].fLoadedRootId = false;
390
391	/* Check if the host file system is case sensitive */
392	RTFSPROPERTIES prop;
393	prop.fCaseSensitive = false; /* Shut up MSC. */
394	rc = RTFsQueryProperties(g_FolderMapping[i].pszFolderName, &prop);
395	#ifndef DEBUG_bird /* very annoying */
396	AssertRC(rc);
397	#endif
398	g_FolderMapping[i].fHostCaseSensitive = RT_SUCCESS(rc) ? prop.fCaseSensitive : false;
399	vbsfRootHandleAdd(i);
400	vbsfMappingsWakeupAllWaiters();
401	break;
402	}
403	}
404	if (i == SHFL_MAX_MAPPINGS)
405	{
406	AssertLogRelMsgFailed(("vbsfMappingsAdd: no more room to add mapping %s to %ls!!\n", pszFolderName, pMapName->String.ucs2));
407	return VERR_TOO_MUCH_DATA;
408	}
409
410	Log(("vbsfMappingsAdd: added mapping %s to %ls (slot %u, root %u)\n",
411	pszFolderName, pMapName->String.ucs2, i, vbsfMappingGetRootFromIndex(i)));
412	return VINF_SUCCESS;
413	}
414
415	#ifdef UNITTEST
416	/** Unit test the SHFL_FN_REMOVE_MAPPING API. Located here as a form of API
417	* documentation. */
418	void testMappingsRemove(RTTEST hTest)
419	{
420	/* If the number or types of parameters are wrong the API should fail. */
421	testMappingsRemoveBadParameters(hTest);
422	/* Add tests as required... */
423	}
424	#endif
425	int vbsfMappingsRemove(PSHFLSTRING pMapName)
426	{
427	Assert(pMapName);
428	Log(("vbsfMappingsRemove %ls\n", pMapName->String.ucs2));
429
430	/*
431	* We must iterate thru the whole table as may have 0+ placeholder entries
432	* and 0-1 regular entries with the same name. Also, it is good to kick
433	* the guest automounter into action wrt to evicting placeholders.
434	*/
435	int rc = VERR_FILE_NOT_FOUND;
436	for (unsigned i = 0; i < SHFL_MAX_MAPPINGS; i++)
437	{
438	if (g_FolderMapping[i].fValid == true)
439	{
440	if (!RTUtf16LocaleICmp(g_FolderMapping[i].pMapName->String.ucs2, pMapName->String.ucs2))
441	{
442	if (g_FolderMapping[i].cMappings != 0)
443	{
444	LogRel2(("SharedFolders: removing '%ls' -> '%s'%s, which is still used by the guest\n", pMapName->String.ucs2,
445	g_FolderMapping[i].pszFolderName, g_FolderMapping[i].fPlaceholder ? " (again)" : ""));
446	g_FolderMapping[i].fMissing = true;
447	g_FolderMapping[i].fPlaceholder = true;
448	vbsfMappingsWakeupAllWaiters();
449	rc = VINF_PERMISSION_DENIED;
450	}
451	else
452	{
453	/* pMapName can be the same as g_FolderMapping[i].pMapName when
454	* called from vbsfUnmapFolder, log it before deallocating the memory. */
455	Log(("vbsfMappingsRemove: mapping %ls removed\n", pMapName->String.ucs2));
456	bool fSame = g_FolderMapping[i].pMapName == pMapName;
457
458	RTStrFree(g_FolderMapping[i].pszFolderName);
459	RTMemFree(g_FolderMapping[i].pMapName);
460	g_FolderMapping[i].pszFolderName = NULL;
461	g_FolderMapping[i].pMapName = NULL;
462	g_FolderMapping[i].fValid = false;
463	vbsfRootHandleRemove(i);
464	vbsfMappingsWakeupAllWaiters();
465	if (rc == VERR_FILE_NOT_FOUND)
466	rc = VINF_SUCCESS;
467	if (fSame)
468	break;
469	}
470	}
471	}
472	}
473
474	return rc;
475	}
476
477	const char* vbsfMappingsQueryHostRoot(SHFLROOT root)
478	{
479	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
480	AssertReturn(pFolderMapping, NULL);
481	if (pFolderMapping->fMissing)
482	return NULL;
483	return pFolderMapping->pszFolderName;
484	}
485
486	int vbsfMappingsQueryHostRootEx(SHFLROOT hRoot, const char *ppszRoot, uint32_t pcbRootLen)
487	{
488	MAPPING *pFolderMapping = vbsfMappingGetByRoot(hRoot);
489	AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
490	if (pFolderMapping->fMissing)
491	return VERR_NOT_FOUND;
492	if ( pFolderMapping->pszFolderName == NULL
493	\|\| pFolderMapping->pszFolderName[0] == 0)
494	return VERR_NOT_FOUND;
495	*ppszRoot = pFolderMapping->pszFolderName;
496	*pcbRootLen = (uint32_t)strlen(pFolderMapping->pszFolderName);
497	return VINF_SUCCESS;
498	}
499
500	bool vbsfIsGuestMappingCaseSensitive(SHFLROOT root)
501	{
502	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
503	AssertReturn(pFolderMapping, false);
504	return pFolderMapping->fGuestCaseSensitive;
505	}
506
507	bool vbsfIsHostMappingCaseSensitive(SHFLROOT root)
508	{
509	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
510	AssertReturn(pFolderMapping, false);
511	return pFolderMapping->fHostCaseSensitive;
512	}
513
514	#ifdef UNITTEST
515	/** Unit test the SHFL_FN_QUERY_MAPPINGS API. Located here as a form of API
516	* documentation (or should it better be inline in include/VBox/shflsvc.h?) */
517	void testMappingsQuery(RTTEST hTest)
518	{
519	/* The API should return all mappings if we provide enough buffers. */
520	testMappingsQuerySimple(hTest);
521	/* If we provide too few buffers that should be signalled correctly. */
522	testMappingsQueryTooFewBuffers(hTest);
523	/* The SHFL_MF_AUTOMOUNT flag means return only auto-mounted mappings. */
524	testMappingsQueryAutoMount(hTest);
525	/* The mappings return array must have numberOfMappings entries. */
526	testMappingsQueryArrayWrongSize(hTest);
527	}
528	#endif
529	/**
530	* @note If pMappings / *pcMappings is smaller than the actual amount of
531	* mappings that could have been returned *pcMappings contains the
532	* required buffer size so that the caller can retry the operation if
533	* wanted.
534	*/
535	int vbsfMappingsQuery(PSHFLCLIENTDATA pClient, bool fOnlyAutoMounts, PSHFLMAPPING pMappings, uint32_t *pcMappings)
536	{
537	LogFlow(("vbsfMappingsQuery: pClient = %p, pMappings = %p, pcMappings = %p, *pcMappings = %d\n",
538	pClient, pMappings, pcMappings, *pcMappings));
539
540	uint32_t const cMaxMappings = *pcMappings;
541	uint32_t idx = 0;
542	for (uint32_t i = 0; i < SHFL_MAX_MAPPINGS; i++)
543	{
544	MAPPING *pFolderMapping = vbsfMappingGetByRoot(i);
545	if ( pFolderMapping != NULL
546	&& pFolderMapping->fValid
547	&& ( !fOnlyAutoMounts
548	\|\| (pFolderMapping->fAutoMount && !pFolderMapping->fPlaceholder)) )
549	{
550	if (idx < cMaxMappings)
551	{
552	pMappings[idx].u32Status = SHFL_MS_NEW;
553	pMappings[idx].root = i;
554	}
555	idx++;
556	}
557	}
558
559	/* Return actual number of mappings, regardless whether the handed in
560	* mapping buffer was big enough. */
561	/** @todo r=bird: This is non-standard interface behaviour. We return
562	* VERR_BUFFER_OVERFLOW or at least a VINF_BUFFER_OVERFLOW here.
563	*
564	* Guess this goes well along with ORing SHFL_MF_AUTOMOUNT into
565	* pClient->fu32Flags rather than passing it as fOnlyAutoMounts...
566	* Not amused by this. */
567	*pcMappings = idx;
568
569	RT_NOREF_PV(pClient);
570	LogFlow(("vbsfMappingsQuery: returns VINF_SUCCESS (idx=%u, cMaxMappings=%u)\n", idx, cMaxMappings));
571	return VINF_SUCCESS;
572	}
573
574	#ifdef UNITTEST
575	/** Unit test the SHFL_FN_QUERY_MAP_NAME API. Located here as a form of API
576	* documentation. */
577	void testMappingsQueryName(RTTEST hTest)
578	{
579	/* If we query an valid mapping it should be returned. */
580	testMappingsQueryNameValid(hTest);
581	/* If we query an invalid mapping that should be signalled. */
582	testMappingsQueryNameInvalid(hTest);
583	/* If we pass in a bad string buffer that should be detected. */
584	testMappingsQueryNameBadBuffer(hTest);
585	}
586	#endif
587	int vbsfMappingsQueryName(PSHFLCLIENTDATA pClient, SHFLROOT root, SHFLSTRING *pString)
588	{
589	LogFlow(("vbsfMappingsQuery: pClient = %p, root = %d, *pString = %p\n", pClient, root, pString));
590
591	int rc;
592	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
593	if (pFolderMapping)
594	{
595	if (pFolderMapping->fValid)
596	{
597	if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
598	rc = ShflStringCopyUtf16BufAsUtf8(pString, pFolderMapping->pMapName);
599	else
600	{
601	/* Not using ShlfStringCopy here as behaviour shouldn't change... */
602	if (pString->u16Size < pFolderMapping->pMapName->u16Size)
603	{
604	Log(("vbsfMappingsQuery: passed string too short (%d < %d bytes)!\n",
605	pString->u16Size, pFolderMapping->pMapName->u16Size));
606	rc = VERR_INVALID_PARAMETER;
607	}
608	else
609	{
610	pString->u16Length = pFolderMapping->pMapName->u16Length;
611	memcpy(pString->String.ucs2, pFolderMapping->pMapName->String.ucs2,
612	pFolderMapping->pMapName->u16Size);
613	rc = VINF_SUCCESS;
614	}
615	}
616	}
617	else
618	rc = VERR_FILE_NOT_FOUND;
619	}
620	else
621	rc = VERR_INVALID_PARAMETER;
622
623	LogFlow(("vbsfMappingsQuery:Name return rc = %Rrc\n", rc));
624	return rc;
625	}
626
627	/** Queries fWritable flag for the given root. Returns error if the root is not accessible.
628	*/
629	int vbsfMappingsQueryWritable(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fWritable)
630	{
631	RT_NOREF1(pClient);
632	int rc = VINF_SUCCESS;
633
634	LogFlow(("vbsfMappingsQueryWritable: pClient = %p, root = %d\n", pClient, root));
635
636	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
637	AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
638
639	if ( pFolderMapping->fValid
640	&& !pFolderMapping->fMissing)
641	*fWritable = pFolderMapping->fWritable;
642	else
643	rc = VERR_FILE_NOT_FOUND;
644
645	LogFlow(("vbsfMappingsQuery:Writable return rc = %Rrc\n", rc));
646
647	return rc;
648	}
649
650	int vbsfMappingsQueryAutoMount(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fAutoMount)
651	{
652	RT_NOREF1(pClient);
653	int rc = VINF_SUCCESS;
654
655	LogFlow(("vbsfMappingsQueryAutoMount: pClient = %p, root = %d\n", pClient, root));
656
657	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
658	AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
659
660	if (pFolderMapping->fValid == true)
661	*fAutoMount = pFolderMapping->fAutoMount;
662	else
663	rc = VERR_FILE_NOT_FOUND;
664
665	LogFlow(("vbsfMappingsQueryAutoMount:Writable return rc = %Rrc\n", rc));
666
667	return rc;
668	}
669
670	int vbsfMappingsQuerySymlinksCreate(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fSymlinksCreate)
671	{
672	RT_NOREF1(pClient);
673	int rc = VINF_SUCCESS;
674
675	LogFlow(("vbsfMappingsQueryAutoMount: pClient = %p, root = %d\n", pClient, root));
676
677	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
678	AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
679
680	if (pFolderMapping->fValid == true)
681	*fSymlinksCreate = pFolderMapping->fSymlinksCreate;
682	else
683	rc = VERR_FILE_NOT_FOUND;
684
685	LogFlow(("vbsfMappingsQueryAutoMount:SymlinksCreate return rc = %Rrc\n", rc));
686
687	return rc;
688	}
689
690	/**
691	* Implements SHFL_FN_QUERY_MAP_INFO.
692	* @since VBox 6.0
693	*/
694	int vbsfMappingsQueryInfo(PSHFLCLIENTDATA pClient, SHFLROOT root, PSHFLSTRING pNameBuf, PSHFLSTRING pMntPtBuf,
695	uint64_t pfFlags, uint32_t puVersion)
696	{
697	LogFlow(("vbsfMappingsQueryInfo: pClient=%p root=%d\n", pClient, root));
698
699	/* Resolve the root handle. */
700	int rc;
701	PMAPPING pFolderMapping = vbsfMappingGetByRoot(root);
702	if (pFolderMapping)
703	{
704	if (pFolderMapping->fValid)
705	{
706	/*
707	* Produce the output.
708	*/
709	*puVersion = g_auRootHandleVersions[root];
710
711	*pfFlags = 0;
712	if (pFolderMapping->fWritable)
713	*pfFlags \|= SHFL_MIF_WRITABLE;
714	if (pFolderMapping->fAutoMount)
715	*pfFlags \|= SHFL_MIF_AUTO_MOUNT;
716	if (pFolderMapping->fHostCaseSensitive)
717	*pfFlags \|= SHFL_MIF_HOST_ICASE;
718	if (pFolderMapping->fGuestCaseSensitive)
719	*pfFlags \|= SHFL_MIF_GUEST_ICASE;
720	if (pFolderMapping->fSymlinksCreate)
721	*pfFlags \|= SHFL_MIF_SYMLINK_CREATION;
722
723	int rc2;
724	if (pClient->fu32Flags & SHFL_CF_UTF8)
725	{
726	rc = ShflStringCopyUtf16BufAsUtf8(pNameBuf, pFolderMapping->pMapName);
727	rc2 = ShflStringCopyUtf16BufAsUtf8(pMntPtBuf, pFolderMapping->pAutoMountPoint);
728	}
729	else
730	{
731	rc = ShflStringCopy(pNameBuf, pFolderMapping->pMapName, sizeof(RTUTF16));
732	rc2 = ShflStringCopy(pMntPtBuf, pFolderMapping->pAutoMountPoint, sizeof(RTUTF16));
733	}
734	if (RT_SUCCESS(rc))
735	rc = rc2;
736	}
737	else
738	rc = VERR_FILE_NOT_FOUND;
739	}
740	else
741	rc = VERR_INVALID_PARAMETER;
742	LogFlow(("vbsfMappingsQueryInfo: returns %Rrc\n", rc));
743	return rc;
744	}
745
746
747
748	#ifdef UNITTEST
749	/** Unit test the SHFL_FN_MAP_FOLDER API. Located here as a form of API
750	* documentation. */
751	void testMapFolder(RTTEST hTest)
752	{
753	/* If we try to map a valid name we should get the root. */
754	testMapFolderValid(hTest);
755	/* If we try to map a valid name we should get VERR_FILE_NOT_FOUND. */
756	testMapFolderInvalid(hTest);
757	/* If we map a folder twice we can unmap it twice.
758	* Currently unmapping too often is only asserted but not signalled. */
759	testMapFolderTwice(hTest);
760	/* The delimiter should be converted in e.g. file delete operations. */
761	testMapFolderDelimiter(hTest);
762	/* Test case sensitive mapping by opening a file with the wrong case. */
763	testMapFolderCaseSensitive(hTest);
764	/* Test case insensitive mapping by opening a file with the wrong case. */
765	testMapFolderCaseInsensitive(hTest);
766	/* If the number or types of parameters are wrong the API should fail. */
767	testMapFolderBadParameters(hTest);
768	}
769	#endif
770	int vbsfMapFolder(PSHFLCLIENTDATA pClient, PSHFLSTRING pszMapName,
771	RTUTF16 wcDelimiter, bool fCaseSensitive, SHFLROOT *pRoot)
772	{
773	MAPPING *pFolderMapping = NULL;
774
775	if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
776	{
777	Log(("vbsfMapFolder %s\n", pszMapName->String.utf8));
778	}
779	else
780	{
781	Log(("vbsfMapFolder %ls\n", pszMapName->String.ucs2));
782	}
783
784	AssertMsgReturn(wcDelimiter == '/' \|\| wcDelimiter == '\\',
785	("Invalid path delimiter: %#x\n", wcDelimiter),
786	VERR_INVALID_PARAMETER);
787	if (pClient->PathDelimiter == 0)
788	{
789	pClient->PathDelimiter = wcDelimiter;
790	}
791	else
792	{
793	AssertMsgReturn(wcDelimiter == pClient->PathDelimiter,
794	("wcDelimiter=%#x PathDelimiter=%#x", wcDelimiter, pClient->PathDelimiter),
795	VERR_INVALID_PARAMETER);
796	}
797
798	SHFLROOT RootTmp;
799	if (!pRoot)
800	pRoot = &RootTmp;
801	if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
802	{
803	int rc;
804	PRTUTF16 utf16Name;
805
806	rc = RTStrToUtf16((const char *) pszMapName->String.utf8, &utf16Name);
807	if (RT_FAILURE (rc))
808	return rc;
809
810	pFolderMapping = vbsfMappingGetByName(utf16Name, pRoot);
811	RTUtf16Free(utf16Name);
812	}
813	else
814	{
815	pFolderMapping = vbsfMappingGetByName(pszMapName->String.ucs2, pRoot);
816	}
817
818	if (!pFolderMapping)
819	{
820	return VERR_FILE_NOT_FOUND;
821	}
822
823	/*
824	* Check for reference count overflows and settings compatibility.
825	* For paranoid reasons, we don't allow modifying the case sensitivity
826	* setting while there are other mappings of a folder.
827	*/
828	AssertLogRelReturn(*pRoot < RT_ELEMENTS(pClient->acMappings), VERR_INTERNAL_ERROR);
829	AssertLogRelReturn(!pClient->fHasMappingCounts \|\| pClient->acMappings[*pRoot] < _32K, VERR_TOO_MANY_OPENS);
830	ASSERT_GUEST_LOGREL_MSG_RETURN( pFolderMapping->cMappings == 0
831	\|\| pFolderMapping->fGuestCaseSensitive == fCaseSensitive,
832	("Incompatible case sensitivity setting: %s: %u mappings, %ssenitive, requested %ssenitive!\n",
833	pFolderMapping->pszFolderName, pFolderMapping->cMappings,
834	pFolderMapping->fGuestCaseSensitive ? "" : "in", fCaseSensitive ? "" : "in"),
835	VERR_INCOMPATIBLE_CONFIG);
836
837	/*
838	* Go ahead and map it.
839	*/
840	if (pClient->fHasMappingCounts)
841	pClient->acMappings[*pRoot] += 1;
842	pFolderMapping->cMappings++;
843	pFolderMapping->fGuestCaseSensitive = fCaseSensitive;
844	Log(("vbsfMmapFolder (cMappings=%u, acMappings[%u]=%u)\n", pFolderMapping->cMappings, pRoot, pClient->acMappings[pRoot]));
845	return VINF_SUCCESS;
846	}
847
848	#ifdef UNITTEST
849	/** Unit test the SHFL_FN_UNMAP_FOLDER API. Located here as a form of API
850	* documentation. */
851	void testUnmapFolder(RTTEST hTest)
852	{
853	/* Unmapping a mapped folder should succeed.
854	* If the folder is not mapped this is only asserted, not signalled. */
855	testUnmapFolderValid(hTest);
856	/* Unmapping a non-existant root should fail. */
857	testUnmapFolderInvalid(hTest);
858	/* If the number or types of parameters are wrong the API should fail. */
859	testUnmapFolderBadParameters(hTest);
860	}
861	#endif
862	int vbsfUnmapFolder(PSHFLCLIENTDATA pClient, SHFLROOT root)
863	{
864	RT_NOREF1(pClient);
865	int rc = VINF_SUCCESS;
866
867	MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
868	if (pFolderMapping == NULL)
869	{
870	AssertFailed();
871	return VERR_FILE_NOT_FOUND;
872	}
873	Assert(pFolderMapping->fValid == true && pFolderMapping->cMappings > 0);
874
875	AssertLogRelReturn(root < RT_ELEMENTS(pClient->acMappings), VERR_INTERNAL_ERROR);
876	AssertLogRelReturn(!pClient->fHasMappingCounts \|\| pClient->acMappings[root] > 0, VERR_INVALID_HANDLE);
877
878	if (pClient->fHasMappingCounts)
879	pClient->acMappings[root] -= 1;
880
881	if (pFolderMapping->cMappings > 0)
882	pFolderMapping->cMappings--;
883
884	uint32_t const cMappings = pFolderMapping->cMappings;
885	if ( cMappings == 0
886	&& pFolderMapping->fPlaceholder)
887	{
888	/* Automatically remove, it is not used by the guest anymore. */
889	Assert(pFolderMapping->fMissing);
890	LogRel2(("SharedFolders: unmapping placeholder '%ls' -> '%s'\n",
891	pFolderMapping->pMapName->String.ucs2, pFolderMapping->pszFolderName));
892	vbsfMappingsRemove(pFolderMapping->pMapName);
893	}
894
895	Log(("vbsfUnmapFolder (cMappings=%u, acMappings[%u]=%u)\n", cMappings, root, pClient->acMappings[root]));
896	return rc;
897	}
898
899	/**
900	* SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES implementation.
901	*
902	* @returns VBox status code.
903	* @retval VINF_SUCCESS on change.
904	* @retval VINF_TRY_AGAIN on resume.
905	* @retval VINF_HGCM_ASYNC_EXECUTE if waiting.
906	* @retval VERR_CANCELLED if cancelled.
907	* @retval VERR_OUT_OF_RESOURCES if there are too many pending waits.
908	*
909	* @param pClient The calling client.
910	* @param hCall The call handle.
911	* @param pParm The parameter (32-bit).
912	* @param fRestored Set if this is a call restored & resubmitted from saved
913	* state.
914	* @since VBox 6.0
915	*/
916	int vbsfMappingsWaitForChanges(PSHFLCLIENTDATA pClient, VBOXHGCMCALLHANDLE hCall, PVBOXHGCMSVCPARM pParm, bool fRestored)
917	{
918	/*
919	* Return immediately if the fodler mappings have changed since last call
920	* or if we got restored from saved state (adding of global folders, etc).
921	*/
922	uint32_t uCurVersion = g_uFolderMappingsVersion;
923	if ( pParm->u.uint32 != uCurVersion
924	\|\| fRestored
925	\|\| (pClient->fu32Flags & SHFL_CF_CANCEL_NEXT_WAIT) )
926	{
927	int rc = VINF_SUCCESS;
928	if (pClient->fu32Flags & SHFL_CF_CANCEL_NEXT_WAIT)
929	{
930	pClient->fu32Flags &= ~SHFL_CF_CANCEL_NEXT_WAIT;
931	rc = VERR_CANCELLED;
932	}
933	else if (fRestored)
934	{
935	rc = VINF_TRY_AGAIN;
936	if (pParm->u.uint32 == uCurVersion)
937	uCurVersion = uCurVersion != UINT32_C(0x55555555) ? UINT32_C(0x55555555) : UINT32_C(0x99999999);
938	}
939	Log(("vbsfMappingsWaitForChanges: Version %#x -> %#x, returning %Rrc immediately.\n", pParm->u.uint32, uCurVersion, rc));
940	pParm->u.uint32 = uCurVersion;
941	return rc;
942	}
943
944	/*
945	* Setup a wait if we can.
946	*/
947	if (g_cMappingChangeWaiters < 64)
948	{
949	PSHFLMAPPINGSWAIT pWait = (PSHFLMAPPINGSWAIT)RTMemAlloc(sizeof(*pWait));
950	if (pWait)
951	{
952	pWait->pClient = pClient;
953	pWait->hCall = hCall;
954	pWait->pParm = pParm;
955
956	RTListAppend(&g_MappingsChangeWaiters, &pWait->ListEntry);
957	g_cMappingChangeWaiters += 1;
958	return VINF_HGCM_ASYNC_EXECUTE;
959	}
960	return VERR_NO_MEMORY;
961	}
962	LogRelMax(32, ("vbsfMappingsWaitForChanges: Too many threads waiting for changes!\n"));
963	return VERR_OUT_OF_RESOURCES;
964	}
965
966	/**
967	* SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS implementation.
968	*
969	* @returns VINF_SUCCESS
970	* @param pClient The calling client to cancel all waits for.
971	* @since VBox 6.0
972	*/
973	int vbsfMappingsCancelChangesWaits(PSHFLCLIENTDATA pClient)
974	{
975	uint32_t const uCurVersion = g_uFolderMappingsVersion;
976
977	PSHFLMAPPINGSWAIT pCur, pNext;
978	RTListForEachSafe(&g_MappingsChangeWaiters, pCur, pNext, SHFLMAPPINGSWAIT, ListEntry)
979	{
980	if (pCur->pClient == pClient)
981	{
982	RTListNodeRemove(&pCur->ListEntry);
983	pCur->pParm->u.uint32 = uCurVersion;
984	g_pHelpers->pfnCallComplete(pCur->hCall, VERR_CANCELLED);
985	RTMemFree(pCur);
986	}
987	}
988
989	/* Set a flag to make sure the next SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES doesn't block.
990	This should help deal with races between this call and a thread about to do a wait. */
991	pClient->fu32Flags \|= SHFL_CF_CANCEL_NEXT_WAIT;
992
993	return VINF_SUCCESS;
994	}
995
996	/**
997	* Wakes up all clients waiting on
998	*/
999	static void vbsfMappingsWakeupAllWaiters(void)
1000	{
1001	uint32_t const uCurVersion = ++g_uFolderMappingsVersion;
1002
1003	PSHFLMAPPINGSWAIT pCur, pNext;
1004	RTListForEachSafe(&g_MappingsChangeWaiters, pCur, pNext, SHFLMAPPINGSWAIT, ListEntry)
1005	{
1006	RTListNodeRemove(&pCur->ListEntry);
1007	pCur->pParm->u.uint32 = uCurVersion;
1008	g_pHelpers->pfnCallComplete(pCur->hCall, VERR_CANCELLED);
1009	RTMemFree(pCur);
1010	}
1011	}
1012

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

source: vbox/trunk/src/VBox/HostServices/SharedFolders/mappings.cpp@ 84909

Download in other formats: