summaryrefslogtreecommitdiffstats
path: root/src/VBox/HostServices/SharedFolders
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-06 03:01:46 +0000
commitf8fe689a81f906d1b91bb3220acde2a4ecb14c5b (patch)
tree26484e9d7e2c67806c2d1760196ff01aaa858e8c /src/VBox/HostServices/SharedFolders
parentInitial commit. (diff)
downloadvirtualbox-f8fe689a81f906d1b91bb3220acde2a4ecb14c5b.tar.xz
virtualbox-f8fe689a81f906d1b91bb3220acde2a4ecb14c5b.zip
Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/VBox/HostServices/SharedFolders')
-rw-r--r--src/VBox/HostServices/SharedFolders/Makefile.kmk54
-rw-r--r--src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.cpp1838
-rw-r--r--src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.rc51
-rw-r--r--src/VBox/HostServices/SharedFolders/mappings.cpp939
-rw-r--r--src/VBox/HostServices/SharedFolders/mappings.h80
-rw-r--r--src/VBox/HostServices/SharedFolders/shfl.h73
-rw-r--r--src/VBox/HostServices/SharedFolders/shflhandle.cpp226
-rw-r--r--src/VBox/HostServices/SharedFolders/shflhandle.h80
-rw-r--r--src/VBox/HostServices/SharedFolders/testcase/Makefile.kmk94
-rw-r--r--src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp1332
-rw-r--r--src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.h130
-rw-r--r--src/VBox/HostServices/SharedFolders/testcase/tstShflCase.cpp442
-rw-r--r--src/VBox/HostServices/SharedFolders/testcase/tstShflSizes.cpp134
-rw-r--r--src/VBox/HostServices/SharedFolders/teststubs.h87
-rw-r--r--src/VBox/HostServices/SharedFolders/vbsf.cpp2107
-rw-r--r--src/VBox/HostServices/SharedFolders/vbsf.h49
-rw-r--r--src/VBox/HostServices/SharedFolders/vbsfpath.cpp701
-rw-r--r--src/VBox/HostServices/SharedFolders/vbsfpath.h70
-rw-r--r--src/VBox/HostServices/SharedFolders/vbsfpathabs.cpp185
19 files changed, 8672 insertions, 0 deletions
diff --git a/src/VBox/HostServices/SharedFolders/Makefile.kmk b/src/VBox/HostServices/SharedFolders/Makefile.kmk
new file mode 100644
index 00000000..1ac6845b
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/Makefile.kmk
@@ -0,0 +1,54 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the Shared Folders Host Service.
+#
+
+#
+# Copyright (C) 2006-2019 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+
+SUB_DEPTH = ../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+# Include sub-makefile(s).
+include $(PATH_SUB_CURRENT)/testcase/Makefile.kmk
+
+#
+# The shared folder service DLL.
+#
+DLLS += VBoxSharedFolders
+VBoxSharedFolders_TEMPLATE = VBOXR3
+VBoxSharedFolders_NAME.os2 = VBoxSFld
+VBoxSharedFolders_DEFS = VBOX_WITH_HGCM RTSHFL
+VBoxSharedFolders_INCS.win = \
+ $(VBOX_PATH_SDK)
+
+VBoxSharedFolders_LDFLAGS.darwin = \
+ -framework Carbon \
+ -install_name $(VBOX_DYLD_EXECUTABLE_PATH)/VBoxSharedFolders.dylib
+
+VBoxSharedFolders_SOURCES = \
+ VBoxSharedFoldersSvc.cpp \
+ shflhandle.cpp \
+ vbsf.cpp \
+ vbsfpath.cpp \
+ vbsfpathabs.cpp \
+ mappings.cpp
+VBoxSharedFolders_SOURCES.win = \
+ VBoxSharedFoldersSvc.rc
+
+VBoxSharedFolders_LIBS = \
+ $(LIB_VMM) \
+ $(LIB_RUNTIME) \
+ $(LIB_REM)
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.cpp b/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.cpp
new file mode 100644
index 00000000..04fe0b1b
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.cpp
@@ -0,0 +1,1838 @@
+/* $Id: VBoxSharedFoldersSvc.cpp $ */
+/** @file
+ * Shared Folders - Host service entry points.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
+#include <VBox/shflsvc.h>
+
+#include "shfl.h"
+#include "mappings.h"
+#include "shflhandle.h"
+#include "vbsf.h"
+#include <iprt/alloc.h>
+#include <iprt/string.h>
+#include <iprt/assert.h>
+#include <VBox/AssertGuest.h>
+#include <VBox/vmm/ssm.h>
+#include <VBox/vmm/pdmifs.h>
+
+
+/*********************************************************************************************************************************
+* Defined Constants And Macros *
+*********************************************************************************************************************************/
+#define SHFL_SAVED_STATE_VERSION_FOLDERNAME_UTF16 2
+#define SHFL_SAVED_STATE_VERSION_PRE_AUTO_MOUNT_POINT 3
+#define SHFL_SAVED_STATE_VERSION 4
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+PVBOXHGCMSVCHELPERS g_pHelpers;
+static PPDMLED g_pStatusLed = NULL;
+
+/** @name Shared folder statistics.
+ * @{ */
+static STAMPROFILE g_StatQueryMappings;
+static STAMPROFILE g_StatQueryMappingsFail;
+static STAMPROFILE g_StatQueryMapName;
+static STAMPROFILE g_StatCreate;
+static STAMPROFILE g_StatCreateFail;
+static STAMPROFILE g_StatLookup;
+static STAMPROFILE g_StatLookupFail;
+static STAMPROFILE g_StatClose;
+static STAMPROFILE g_StatCloseFail;
+static STAMPROFILE g_StatRead;
+static STAMPROFILE g_StatReadFail;
+static STAMPROFILE g_StatWrite;
+static STAMPROFILE g_StatWriteFail;
+static STAMPROFILE g_StatLock;
+static STAMPROFILE g_StatLockFail;
+static STAMPROFILE g_StatList;
+static STAMPROFILE g_StatListFail;
+static STAMPROFILE g_StatReadLink;
+static STAMPROFILE g_StatReadLinkFail;
+static STAMPROFILE g_StatMapFolderOld;
+static STAMPROFILE g_StatMapFolder;
+static STAMPROFILE g_StatMapFolderFail;
+static STAMPROFILE g_StatUnmapFolder;
+static STAMPROFILE g_StatUnmapFolderFail;
+static STAMPROFILE g_StatInformationFail;
+static STAMPROFILE g_StatInformationSetFile;
+static STAMPROFILE g_StatInformationSetFileFail;
+static STAMPROFILE g_StatInformationSetSize;
+static STAMPROFILE g_StatInformationSetSizeFail;
+static STAMPROFILE g_StatInformationGetFile;
+static STAMPROFILE g_StatInformationGetFileFail;
+static STAMPROFILE g_StatInformationGetVolume;
+static STAMPROFILE g_StatInformationGetVolumeFail;
+static STAMPROFILE g_StatRemove;
+static STAMPROFILE g_StatRemoveFail;
+static STAMPROFILE g_StatRename;
+static STAMPROFILE g_StatRenameFail;
+static STAMPROFILE g_StatFlush;
+static STAMPROFILE g_StatFlushFail;
+static STAMPROFILE g_StatSetUtf8;
+static STAMPROFILE g_StatSetFileSize;
+static STAMPROFILE g_StatSetFileSizeFail;
+static STAMPROFILE g_StatSymlink;
+static STAMPROFILE g_StatSymlinkFail;
+static STAMPROFILE g_StatSetSymlinks;
+static STAMPROFILE g_StatQueryMapInfo;
+static STAMPROFILE g_StatWaitForMappingsChanges;
+static STAMPROFILE g_StatWaitForMappingsChangesFail;
+static STAMPROFILE g_StatCancelMappingsChangesWait;
+static STAMPROFILE g_StatUnknown;
+static STAMPROFILE g_StatMsgStage1;
+/** @} */
+
+
+/** @page pg_shfl_svc Shared Folders Host Service
+ *
+ * Shared Folders map a host file system to guest logical filesystem.
+ * A mapping represents 'host name'<->'guest name' translation and a root
+ * identifier to be used to access this mapping.
+ * Examples: "C:\WINNT"<->"F:", "C:\WINNT\System32"<->"/mnt/host/system32".
+ *
+ * Therefore, host name and guest name are strings interpreted
+ * only by host service and guest client respectively. Host name is
+ * passed to guest only for informational purpose. Guest may for example
+ * display the string or construct volume label out of the string.
+ *
+ * Root identifiers are unique for whole guest life,
+ * that is until next guest reset/fresh start.
+ * 32 bit value incremented for each new mapping is used.
+ *
+ * Mapping strings are taken from VM XML configuration on VM startup.
+ * The service DLL takes mappings during initialization. There is
+ * also API for changing mappings at runtime.
+ *
+ * Current mappings and root identifiers are saved when VM is saved.
+ *
+ * Guest may use any of these mappings. Full path information
+ * about an object on a mapping consists of the root identifier and
+ * a full path of object.
+ *
+ * Guest IFS connects to the service and calls SHFL_FN_QUERY_MAP
+ * function which returns current mappings. For guest convenience,
+ * removed mappings also returned with REMOVED flag and new mappings
+ * are marked with NEW flag.
+ *
+ * To access host file system guest just forwards file system calls
+ * to the service, and specifies full paths or handles for objects.
+ *
+ *
+ */
+
+
+
+static DECLCALLBACK(int) svcUnload (void *)
+{
+ int rc = VINF_SUCCESS;
+
+ Log(("svcUnload\n"));
+ vbsfFreeHandleTable();
+
+ if (g_pHelpers)
+ HGCMSvcHlpStamDeregister(g_pHelpers, "/HGCM/VBoxSharedFolders/*");
+ return rc;
+}
+
+static DECLCALLBACK(int) svcConnect (void *, uint32_t u32ClientID, void *pvClient, uint32_t fRequestor, bool fRestoring)
+{
+ RT_NOREF(u32ClientID, fRequestor, fRestoring);
+ SHFLCLIENTDATA *pClient = (SHFLCLIENTDATA *)pvClient;
+ Log(("SharedFolders host service: connected, u32ClientID = %u\n", u32ClientID));
+
+ pClient->fHasMappingCounts = true;
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) svcDisconnect (void *, uint32_t u32ClientID, void *pvClient)
+{
+ RT_NOREF1(u32ClientID);
+ int rc = VINF_SUCCESS;
+ SHFLCLIENTDATA *pClient = (SHFLCLIENTDATA *)pvClient;
+
+ Log(("SharedFolders host service: disconnected, u32ClientID = %u\n", u32ClientID));
+
+ vbsfDisconnect(pClient);
+ return rc;
+}
+
+/** @note We only save as much state as required to access the shared folder again after restore.
+ * All I/O requests pending at the time of saving will never be completed or result in errors.
+ * (file handles no longer valid etc)
+ * This works as designed at the moment. A full state save would be difficult and not always possible
+ * as the contents of a shared folder might change in between save and restore.
+ */
+static DECLCALLBACK(int) svcSaveState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM)
+{
+#ifndef UNITTEST /* Read this as not yet tested */
+ RT_NOREF1(u32ClientID);
+ SHFLCLIENTDATA *pClient = (SHFLCLIENTDATA *)pvClient;
+
+ Log(("SharedFolders host service: saving state, u32ClientID = %u\n", u32ClientID));
+
+ int rc = SSMR3PutU32(pSSM, SHFL_SAVED_STATE_VERSION);
+ AssertRCReturn(rc, rc);
+
+ rc = SSMR3PutU32(pSSM, SHFL_MAX_MAPPINGS);
+ AssertRCReturn(rc, rc);
+
+ /* Save client structure length & contents */
+ rc = SSMR3PutU32(pSSM, sizeof(*pClient));
+ AssertRCReturn(rc, rc);
+
+ rc = SSMR3PutMem(pSSM, pClient, sizeof(*pClient));
+ AssertRCReturn(rc, rc);
+
+ /* Save all the active mappings. */
+ for (int i=0;i<SHFL_MAX_MAPPINGS;i++)
+ {
+ /* Mapping are saved in the order of increasing root handle values. */
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(i);
+
+ rc = SSMR3PutU32(pSSM, pFolderMapping? pFolderMapping->cMappings: 0);
+ AssertRCReturn(rc, rc);
+
+ rc = SSMR3PutBool(pSSM, pFolderMapping? pFolderMapping->fValid: false);
+ AssertRCReturn(rc, rc);
+
+ if (pFolderMapping && pFolderMapping->fValid)
+ {
+ uint32_t len = (uint32_t)strlen(pFolderMapping->pszFolderName);
+ SSMR3PutU32(pSSM, len);
+ SSMR3PutStrZ(pSSM, pFolderMapping->pszFolderName);
+
+ len = ShflStringSizeOfBuffer(pFolderMapping->pMapName);
+ SSMR3PutU32(pSSM, len);
+ SSMR3PutMem(pSSM, pFolderMapping->pMapName, len);
+
+ SSMR3PutBool(pSSM, pFolderMapping->fHostCaseSensitive);
+
+ SSMR3PutBool(pSSM, pFolderMapping->fGuestCaseSensitive);
+
+ len = ShflStringSizeOfBuffer(pFolderMapping->pAutoMountPoint);
+ SSMR3PutU32(pSSM, len);
+ rc = SSMR3PutMem(pSSM, pFolderMapping->pAutoMountPoint, len);
+ AssertRCReturn(rc, rc);
+ }
+ }
+
+#else
+ RT_NOREF3(u32ClientID, pvClient, pSSM);
+#endif
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) svcLoadState(void *, uint32_t u32ClientID, void *pvClient, PSSMHANDLE pSSM, uint32_t uVersion)
+{
+#ifndef UNITTEST /* Read this as not yet tested */
+ RT_NOREF(u32ClientID, uVersion);
+ uint32_t nrMappings;
+ SHFLCLIENTDATA *pClient = (SHFLCLIENTDATA *)pvClient;
+ uint32_t len, version;
+
+ Log(("SharedFolders host service: loading state, u32ClientID = %u\n", u32ClientID));
+
+ int rc = SSMR3GetU32(pSSM, &version);
+ AssertRCReturn(rc, rc);
+
+ if ( version > SHFL_SAVED_STATE_VERSION
+ || version < SHFL_SAVED_STATE_VERSION_FOLDERNAME_UTF16)
+ return VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
+
+ rc = SSMR3GetU32(pSSM, &nrMappings);
+ AssertRCReturn(rc, rc);
+ if (nrMappings != SHFL_MAX_MAPPINGS)
+ return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
+
+ /* Restore the client data (flags + path delimiter + mapping counts (new) at the moment) */
+ rc = SSMR3GetU32(pSSM, &len);
+ AssertRCReturn(rc, rc);
+
+ if (len == RT_UOFFSETOF(SHFLCLIENTDATA, acMappings))
+ pClient->fHasMappingCounts = false;
+ else if (len != sizeof(*pClient))
+ return SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
+ "Saved SHFLCLIENTDATA size %u differs from current %u!\n", len, sizeof(*pClient));
+
+ rc = SSMR3GetMem(pSSM, pClient, len);
+ AssertRCReturn(rc, rc);
+
+ /* We don't actually (fully) restore the state; we simply check if the current state is as we it expect it to be. */
+ for (int i=0;i<SHFL_MAX_MAPPINGS;i++)
+ {
+ /* Load the saved mapping description and try to find it in the mappings. */
+ MAPPING mapping;
+ RT_ZERO(mapping);
+
+ /* restore the folder mapping counter. */
+ rc = SSMR3GetU32(pSSM, &mapping.cMappings);
+ AssertRCReturn(rc, rc);
+
+ rc = SSMR3GetBool(pSSM, &mapping.fValid);
+ AssertRCReturn(rc, rc);
+
+ if (mapping.fValid)
+ {
+ uint32_t cb;
+
+ /* Load the host path name. */
+ rc = SSMR3GetU32(pSSM, &cb);
+ AssertRCReturn(rc, rc);
+
+ char *pszFolderName;
+ if (version == SHFL_SAVED_STATE_VERSION_FOLDERNAME_UTF16)
+ {
+ AssertReturn(cb > SHFLSTRING_HEADER_SIZE && cb <= UINT16_MAX + SHFLSTRING_HEADER_SIZE && !(cb & 1),
+ SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS, "Bad folder name size: %#x\n", cb));
+ PSHFLSTRING pFolderName = (PSHFLSTRING)RTMemAlloc(cb);
+ AssertReturn(pFolderName != NULL, VERR_NO_MEMORY);
+
+ rc = SSMR3GetMem(pSSM, pFolderName, cb);
+ AssertRCReturn(rc, rc);
+ AssertReturn(pFolderName->u16Size < cb && pFolderName->u16Length < pFolderName->u16Size,
+ SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
+ "Bad folder name string: %#x/%#x cb=%#x\n",
+ pFolderName->u16Size, pFolderName->u16Length, cb));
+
+ rc = RTUtf16ToUtf8(pFolderName->String.ucs2, &pszFolderName);
+ RTMemFree(pFolderName);
+ AssertRCReturn(rc, rc);
+ }
+ else
+ {
+ pszFolderName = (char *)RTStrAlloc(cb + 1);
+ AssertReturn(pszFolderName, VERR_NO_MEMORY);
+
+ rc = SSMR3GetStrZ(pSSM, pszFolderName, cb + 1);
+ AssertRCReturn(rc, rc);
+ mapping.pszFolderName = pszFolderName;
+ }
+
+ /* Load the map name. */
+ rc = SSMR3GetU32(pSSM, &cb);
+ AssertRCReturn(rc, rc);
+ AssertReturn(cb > SHFLSTRING_HEADER_SIZE && cb <= UINT16_MAX + SHFLSTRING_HEADER_SIZE && !(cb & 1),
+ SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS, "Bad map name size: %#x\n", cb));
+
+ PSHFLSTRING pMapName = (PSHFLSTRING)RTMemAlloc(cb);
+ AssertReturn(pMapName != NULL, VERR_NO_MEMORY);
+
+ rc = SSMR3GetMem(pSSM, pMapName, cb);
+ AssertRCReturn(rc, rc);
+ AssertReturn(pMapName->u16Size < cb && pMapName->u16Length < pMapName->u16Size,
+ SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
+ "Bad map name string: %#x/%#x cb=%#x\n",
+ pMapName->u16Size, pMapName->u16Length, cb));
+
+ /* Load case sensitivity config. */
+ rc = SSMR3GetBool(pSSM, &mapping.fHostCaseSensitive);
+ AssertRCReturn(rc, rc);
+
+ rc = SSMR3GetBool(pSSM, &mapping.fGuestCaseSensitive);
+ AssertRCReturn(rc, rc);
+
+ /* Load the auto mount point. */
+ PSHFLSTRING pAutoMountPoint;
+ if (version > SHFL_SAVED_STATE_VERSION_PRE_AUTO_MOUNT_POINT)
+ {
+ rc = SSMR3GetU32(pSSM, &cb);
+ AssertRCReturn(rc, rc);
+ AssertReturn(cb > SHFLSTRING_HEADER_SIZE && cb <= UINT16_MAX + SHFLSTRING_HEADER_SIZE && !(cb & 1),
+ SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS, "Bad auto mount point size: %#x\n", cb));
+
+ pAutoMountPoint = (PSHFLSTRING)RTMemAlloc(cb);
+ AssertReturn(pAutoMountPoint != NULL, VERR_NO_MEMORY);
+
+ rc = SSMR3GetMem(pSSM, pAutoMountPoint, cb);
+ AssertRCReturn(rc, rc);
+ AssertReturn(pAutoMountPoint->u16Size < cb && pAutoMountPoint->u16Length < pAutoMountPoint->u16Size,
+ SSMR3SetLoadError(pSSM, VERR_SSM_DATA_UNIT_FORMAT_CHANGED, RT_SRC_POS,
+ "Bad auto mount point string: %#x/%#x cb=%#x\n",
+ pAutoMountPoint->u16Size, pAutoMountPoint->u16Length, cb));
+
+ }
+ else
+ {
+ pAutoMountPoint = ShflStringDupUtf8("");
+ AssertReturn(pAutoMountPoint, VERR_NO_MEMORY);
+ }
+
+ mapping.pszFolderName = pszFolderName;
+ mapping.pMapName = pMapName;
+ mapping.pAutoMountPoint = pAutoMountPoint;
+
+ /* 'i' is the root handle of the saved mapping. */
+ rc = vbsfMappingLoaded (&mapping, i);
+ if (RT_FAILURE(rc))
+ {
+ LogRel(("SharedFolders host service: %Rrc loading %d [%ls] -> [%s]\n",
+ rc, i, pMapName->String.ucs2, pszFolderName));
+ }
+
+ RTMemFree(pAutoMountPoint);
+ RTMemFree(pMapName);
+ RTStrFree(pszFolderName);
+
+ AssertRCReturn(rc, rc);
+ }
+ }
+ Log(("SharedFolders host service: successfully loaded state\n"));
+#else
+ RT_NOREF(u32ClientID, pvClient, pSSM, uVersion);
+#endif
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(void) svcCall (void *, VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void *pvClient,
+ uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[], uint64_t tsArrival)
+{
+ RT_NOREF(u32ClientID, tsArrival);
+#ifndef VBOX_WITHOUT_RELEASE_STATISTICS
+ uint64_t tsStart;
+ STAM_GET_TS(tsStart);
+ STAM_REL_PROFILE_ADD_PERIOD(&g_StatMsgStage1, tsStart - tsArrival);
+#endif
+ Log(("SharedFolders host service: svcCall: u32ClientID = %u, fn = %u, cParms = %u, pparms = %p\n", u32ClientID, u32Function, cParms, paParms));
+
+ SHFLCLIENTDATA *pClient = (SHFLCLIENTDATA *)pvClient;
+
+ bool fAsynchronousProcessing = false;
+
+#ifdef LOG_ENABLED
+ for (uint32_t i = 0; i < cParms; i++)
+ {
+ /** @todo parameters other than 32 bit */
+ Log((" pparms[%d]: type %u, value %u\n", i, paParms[i].type, paParms[i].u.uint32));
+ }
+#endif
+
+ int rc = VINF_SUCCESS;
+ PSTAMPROFILE pStat, pStatFail;
+ switch (u32Function)
+ {
+ case SHFL_FN_QUERY_MAPPINGS:
+ {
+ pStat = &g_StatQueryMappings;
+ pStatFail = &g_StatQueryMappingsFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_QUERY_MAPPINGS\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_QUERY_MAPPINGS)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* numberOfMappings */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* mappings */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ uint32_t fu32Flags = paParms[0].u.uint32;
+ uint32_t cMappings = paParms[1].u.uint32;
+ SHFLMAPPING *pMappings = (SHFLMAPPING *)paParms[2].u.pointer.addr;
+ uint32_t cbMappings = paParms[2].u.pointer.size;
+
+ /* Verify parameters values. */
+ if ( (fu32Flags & ~SHFL_MF_MASK) != 0
+ || cbMappings / sizeof (SHFLMAPPING) != cMappings
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ if (fu32Flags & SHFL_MF_UTF8)
+ pClient->fu32Flags |= SHFL_CF_UTF8;
+ /// @todo r=bird: Someone please explain this amusing code (r63916):
+ //if (fu32Flags & SHFL_MF_AUTOMOUNT)
+ // pClient->fu32Flags |= SHFL_MF_AUTOMOUNT;
+ //
+ //rc = vbsfMappingsQuery(pClient, pMappings, &cMappings);
+
+ rc = vbsfMappingsQuery(pClient, RT_BOOL(fu32Flags & SHFL_MF_AUTOMOUNT), pMappings, &cMappings);
+ if (RT_SUCCESS(rc))
+ {
+ /* Report that there are more mappings to get if
+ * handed in buffer is too small. */
+ if (paParms[1].u.uint32 < cMappings)
+ rc = VINF_BUFFER_OVERFLOW;
+
+ /* Update parameters. */
+ paParms[1].u.uint32 = cMappings;
+ }
+ }
+ }
+
+
+ } break;
+
+ case SHFL_FN_QUERY_MAP_NAME:
+ {
+ pStatFail = pStat = &g_StatQueryMapName;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_QUERY_MAP_NAME\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_QUERY_MAP_NAME)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* Root. */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* Name. */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLSTRING *pString = (SHFLSTRING *)paParms[1].u.pointer.addr;
+
+ /* Verify parameters values. */
+ if (!ShflStringIsValidOut(pString, paParms[1].u.pointer.size))
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfMappingsQueryName(pClient, root, pString);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* None. */
+ }
+ }
+ }
+
+ } break;
+
+ case SHFL_FN_CREATE:
+ {
+ pStat = &g_StatCreate;
+ pStatFail = &g_StatCreateFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_CREATE\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_CREATE)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* parms */
+ )
+ {
+ Log(("SharedFolders host service: Invalid parameters types\n"));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLSTRING *pPath = (SHFLSTRING *)paParms[1].u.pointer.addr;
+ uint32_t cbPath = paParms[1].u.pointer.size;
+ SHFLCREATEPARMS *pParms = (SHFLCREATEPARMS *)paParms[2].u.pointer.addr;
+ uint32_t cbParms = paParms[2].u.pointer.size;
+
+ /* Verify parameters values. */
+ if ( !ShflStringIsValidIn(pPath, cbPath, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
+ || (cbParms != sizeof (SHFLCREATEPARMS))
+ )
+ {
+ AssertMsgFailed (("Invalid parameters cbPath or cbParms (%x, %x - expected >=%x, %x)\n",
+ cbPath, cbParms, sizeof(SHFLSTRING), sizeof (SHFLCREATEPARMS)));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ if (pParms->CreateFlags & SHFL_CF_LOOKUP)
+ {
+ pStat = &g_StatLookup;
+ pStatFail = &g_StatLookupFail;
+ }
+
+ /* Execute the function. */
+ rc = vbsfCreate (pClient, root, pPath, cbPath, pParms);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+ break;
+ }
+
+ case SHFL_FN_CLOSE:
+ {
+ pStat = &g_StatClose;
+ pStatFail = &g_StatCloseFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_CLOSE\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_CLOSE)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+
+ /* Verify parameters values. */
+ if (Handle == SHFL_HANDLE_ROOT)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if (Handle == SHFL_HANDLE_NIL)
+ {
+ AssertMsgFailed(("Invalid handle!\n"));
+ rc = VERR_INVALID_HANDLE;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfClose (pClient, root, Handle);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+ break;
+
+ }
+
+ /** Read object content. */
+ case SHFL_FN_READ:
+ pStat = &g_StatRead;
+ pStatFail = &g_StatReadFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_READ\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_READ)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* count */
+ || paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+ uint64_t offset = paParms[2].u.uint64;
+ uint32_t count = paParms[3].u.uint32;
+ uint8_t *pBuffer = (uint8_t *)paParms[4].u.pointer.addr;
+
+ /* Verify parameters values. */
+ if ( Handle == SHFL_HANDLE_ROOT
+ || count > paParms[4].u.pointer.size
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if (Handle == SHFL_HANDLE_NIL)
+ {
+ AssertMsgFailed(("Invalid handle!\n"));
+ rc = VERR_INVALID_HANDLE;
+ }
+ else
+ {
+ /* Execute the function. */
+ if (g_pStatusLed)
+ {
+ Assert(g_pStatusLed->u32Magic == PDMLED_MAGIC);
+ g_pStatusLed->Asserted.s.fReading = g_pStatusLed->Actual.s.fReading = 1;
+ }
+
+ rc = vbsfRead (pClient, root, Handle, offset, &count, pBuffer);
+ if (g_pStatusLed)
+ g_pStatusLed->Actual.s.fReading = 0;
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ paParms[3].u.uint32 = count;
+ }
+ else
+ {
+ paParms[3].u.uint32 = 0; /* nothing read */
+ }
+ }
+ }
+ break;
+
+ /** Write new object content. */
+ case SHFL_FN_WRITE:
+ pStat = &g_StatWrite;
+ pStatFail = &g_StatWriteFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_WRITE\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_WRITE)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* count */
+ || paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+ uint64_t offset = paParms[2].u.uint64;
+ uint32_t count = paParms[3].u.uint32;
+ uint8_t *pBuffer = (uint8_t *)paParms[4].u.pointer.addr;
+
+ /* Verify parameters values. */
+ if ( Handle == SHFL_HANDLE_ROOT
+ || count > paParms[4].u.pointer.size
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if (Handle == SHFL_HANDLE_NIL)
+ {
+ AssertMsgFailed(("Invalid handle!\n"));
+ rc = VERR_INVALID_HANDLE;
+ }
+ else
+ {
+ /* Execute the function. */
+ if (g_pStatusLed)
+ {
+ Assert(g_pStatusLed->u32Magic == PDMLED_MAGIC);
+ g_pStatusLed->Asserted.s.fWriting = g_pStatusLed->Actual.s.fWriting = 1;
+ }
+
+ rc = vbsfWrite (pClient, root, Handle, offset, &count, pBuffer);
+ if (g_pStatusLed)
+ g_pStatusLed->Actual.s.fWriting = 0;
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ paParms[3].u.uint32 = count;
+ }
+ else
+ {
+ paParms[3].u.uint32 = 0; /* nothing read */
+ }
+ }
+ }
+ break;
+
+ /** Lock/unlock a range in the object. */
+ case SHFL_FN_LOCK:
+ pStat = &g_StatLock;
+ pStatFail = &g_StatLockFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_LOCK\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_LOCK)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_64BIT /* offset */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_64BIT /* length */
+ || paParms[4].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+ uint64_t offset = paParms[2].u.uint64;
+ uint64_t length = paParms[3].u.uint64;
+ uint32_t flags = paParms[4].u.uint32;
+
+ /* Verify parameters values. */
+ if (Handle == SHFL_HANDLE_ROOT)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if (Handle == SHFL_HANDLE_NIL)
+ {
+ AssertMsgFailed(("Invalid handle!\n"));
+ rc = VERR_INVALID_HANDLE;
+ }
+ else if (flags & SHFL_LOCK_WAIT)
+ {
+ /** @todo This should be properly implemented by the shared folders service.
+ * The service thread must never block. If an operation requires
+ * blocking, it must be processed by another thread and when it is
+ * completed, the another thread must call
+ *
+ * g_pHelpers->pfnCallComplete (callHandle, rc);
+ *
+ * The operation is async.
+ * fAsynchronousProcessing = true;
+ */
+
+ /* Here the operation must be posted to another thread. At the moment it is not implemented.
+ * Until it is implemented, try to perform the operation without waiting.
+ */
+ flags &= ~SHFL_LOCK_WAIT;
+
+ /* Execute the function. */
+ if ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
+ rc = vbsfUnlock(pClient, root, Handle, offset, length, flags);
+ else
+ rc = vbsfLock(pClient, root, Handle, offset, length, flags);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ /* none */
+ }
+ }
+ else
+ {
+ /* Execute the function. */
+ if ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
+ rc = vbsfUnlock(pClient, root, Handle, offset, length, flags);
+ else
+ rc = vbsfLock(pClient, root, Handle, offset, length, flags);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ /* none */
+ }
+ }
+ }
+ break;
+
+ /** List object content. */
+ case SHFL_FN_LIST:
+ {
+ pStat = &g_StatList;
+ pStatFail = &g_StatListFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_LIST\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_LIST)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* cb */
+ || paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* pPath */
+ || paParms[5].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
+ || paParms[6].type != VBOX_HGCM_SVC_PARM_32BIT /* resumePoint */
+ || paParms[7].type != VBOX_HGCM_SVC_PARM_32BIT /* cFiles (out) */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+ uint32_t flags = paParms[2].u.uint32;
+ uint32_t length = paParms[3].u.uint32;
+ SHFLSTRING *pPath = (paParms[4].u.pointer.size == 0) ? 0 : (SHFLSTRING *)paParms[4].u.pointer.addr;
+ uint8_t *pBuffer = (uint8_t *)paParms[5].u.pointer.addr;
+ uint32_t resumePoint = paParms[6].u.uint32;
+ uint32_t cFiles = 0;
+
+ /* Verify parameters values. */
+ if ( (length < sizeof (SHFLDIRINFO))
+ || length > paParms[5].u.pointer.size
+ || !ShflStringIsValidOrNullIn(pPath, paParms[4].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ if (g_pStatusLed)
+ {
+ Assert(g_pStatusLed->u32Magic == PDMLED_MAGIC);
+ g_pStatusLed->Asserted.s.fReading = g_pStatusLed->Actual.s.fReading = 1;
+ }
+
+ /* Execute the function. */
+ rc = vbsfDirList (pClient, root, Handle, pPath, flags, &length, pBuffer, &resumePoint, &cFiles);
+
+ if (g_pStatusLed)
+ g_pStatusLed->Actual.s.fReading = 0;
+
+ if (rc == VERR_NO_MORE_FILES && cFiles != 0)
+ rc = VINF_SUCCESS; /* Successfully return these files. */
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ paParms[3].u.uint32 = length;
+ paParms[6].u.uint32 = resumePoint;
+ paParms[7].u.uint32 = cFiles;
+ }
+ else
+ {
+ paParms[3].u.uint32 = 0; /* nothing read */
+ paParms[6].u.uint32 = 0;
+ paParms[7].u.uint32 = cFiles;
+ }
+ }
+ }
+ break;
+ }
+
+ /* Read symlink destination */
+ case SHFL_FN_READLINK:
+ {
+ pStat = &g_StatReadLink;
+ pStatFail = &g_StatReadLinkFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_READLINK\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_READLINK)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLSTRING *pPath = (SHFLSTRING *)paParms[1].u.pointer.addr;
+ uint32_t cbPath = paParms[1].u.pointer.size;
+ uint8_t *pBuffer = (uint8_t *)paParms[2].u.pointer.addr;
+ uint32_t cbBuffer = paParms[2].u.pointer.size;
+
+ /* Verify parameters values. */
+ if (!ShflStringIsValidOrNullIn(pPath, paParms[1].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfReadLink (pClient, root, pPath, cbPath, pBuffer, cbBuffer);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+
+ break;
+ }
+
+ /* Legacy interface */
+ case SHFL_FN_MAP_FOLDER_OLD:
+ {
+ pStatFail = pStat = &g_StatMapFolderOld;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_MAP_FOLDER_OLD\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_MAP_FOLDER_OLD)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* delimiter */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ PSHFLSTRING pszMapName = (PSHFLSTRING)paParms[0].u.pointer.addr;
+ SHFLROOT root = (SHFLROOT)paParms[1].u.uint32;
+ RTUTF16 delimiter = (RTUTF16)paParms[2].u.uint32;
+
+ /* Verify parameters values. */
+ if (!ShflStringIsValidIn(pszMapName, paParms[0].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfMapFolder (pClient, pszMapName, delimiter, false, &root);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ paParms[1].u.uint32 = root;
+ }
+ }
+ }
+ break;
+ }
+
+ case SHFL_FN_MAP_FOLDER:
+ {
+ pStat = &g_StatMapFolder;
+ pStatFail = &g_StatMapFolderFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_MAP_FOLDER\n"));
+ if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ Log(("SharedFolders host service: request to map folder '%s'\n",
+ ((PSHFLSTRING)paParms[0].u.pointer.addr)->String.utf8));
+ else
+ Log(("SharedFolders host service: request to map folder '%ls'\n",
+ ((PSHFLSTRING)paParms[0].u.pointer.addr)->String.ucs2));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_MAP_FOLDER)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* path */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* delimiter */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* fCaseSensitive */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ PSHFLSTRING pszMapName = (PSHFLSTRING)paParms[0].u.pointer.addr;
+ SHFLROOT root = (SHFLROOT)paParms[1].u.uint32;
+ RTUTF16 delimiter = (RTUTF16)paParms[2].u.uint32;
+ bool fCaseSensitive = !!paParms[3].u.uint32;
+
+ /* Verify parameters values. */
+ if (ShflStringIsValidIn(pszMapName, paParms[0].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
+ {
+ rc = VINF_SUCCESS;
+ }
+ else
+ {
+ rc = VERR_INVALID_PARAMETER;
+
+ /* Fudge for windows GAs getting the length wrong by one char. */
+ if ( !(pClient->fu32Flags & SHFL_CF_UTF8)
+ && paParms[0].u.pointer.size >= sizeof(SHFLSTRING)
+ && pszMapName->u16Length >= 2
+ && pszMapName->String.ucs2[pszMapName->u16Length / 2 - 1] == 0x0000)
+ {
+ pszMapName->u16Length -= 2;
+ if (ShflStringIsValidIn(pszMapName, paParms[0].u.pointer.size, false /*fUtf8Not16*/))
+ rc = VINF_SUCCESS;
+ else
+ pszMapName->u16Length += 2;
+ }
+ }
+
+ /* Execute the function. */
+ if (RT_SUCCESS(rc))
+ rc = vbsfMapFolder (pClient, pszMapName, delimiter, fCaseSensitive, &root);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ paParms[1].u.uint32 = root;
+ }
+ }
+ Log(("SharedFolders host service: map operation result %Rrc\n", rc));
+ if (RT_SUCCESS(rc))
+ Log(("SharedFolders host service: mapped to handle %d\n", paParms[1].u.uint32));
+ break;
+ }
+
+ case SHFL_FN_UNMAP_FOLDER:
+ {
+ pStat = &g_StatUnmapFolder;
+ pStatFail = &g_StatUnmapFolderFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_UNMAP_FOLDER\n"));
+ Log(("SharedFolders host service: request to unmap folder handle %u\n",
+ paParms[0].u.uint32));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_UNMAP_FOLDER)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+
+ /* Execute the function. */
+ rc = vbsfUnmapFolder (pClient, root);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ /* nothing */
+ }
+ }
+ Log(("SharedFolders host service: unmap operation result %Rrc\n", rc));
+ break;
+ }
+
+ /** Query/set object information. */
+ case SHFL_FN_INFORMATION:
+ {
+ pStatFail = pStat = &g_StatInformationFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_INFORMATION\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_INFORMATION)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* cb */
+ || paParms[4].type != VBOX_HGCM_SVC_PARM_PTR /* buffer */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+ uint32_t flags = paParms[2].u.uint32;
+ uint32_t length = paParms[3].u.uint32;
+ uint8_t *pBuffer = (uint8_t *)paParms[4].u.pointer.addr;
+
+ /* Verify parameters values. */
+ if (length > paParms[4].u.pointer.size)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ if (flags & SHFL_INFO_SET)
+ {
+ rc = vbsfSetFSInfo (pClient, root, Handle, flags, &length, pBuffer);
+
+ if (flags & SHFL_INFO_FILE)
+ {
+ pStat = &g_StatInformationSetFile;
+ pStatFail = &g_StatInformationSetFileFail;
+ }
+ else if (flags & SHFL_INFO_SIZE)
+ {
+ pStat = &g_StatInformationSetSize;
+ pStatFail = &g_StatInformationSetSizeFail;
+ }
+ }
+ else /* SHFL_INFO_GET */
+ {
+ rc = vbsfQueryFSInfo (pClient, root, Handle, flags, &length, pBuffer);
+
+ if (flags & SHFL_INFO_FILE)
+ {
+ pStat = &g_StatInformationGetFile;
+ pStatFail = &g_StatInformationGetFileFail;
+ }
+ else if (flags & SHFL_INFO_VOLUME)
+ {
+ pStat = &g_StatInformationGetVolume;
+ pStatFail = &g_StatInformationGetVolumeFail;
+ }
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ paParms[3].u.uint32 = length;
+ }
+ else
+ {
+ paParms[3].u.uint32 = 0; /* nothing read */
+ }
+ }
+ }
+ break;
+ }
+
+ /** Remove or rename object */
+ case SHFL_FN_REMOVE:
+ {
+ pStat = &g_StatRemove;
+ pStatFail = &g_StatRemoveFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_REMOVE\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_REMOVE)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* path */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLSTRING *pPath = (SHFLSTRING *)paParms[1].u.pointer.addr;
+ uint32_t cbPath = paParms[1].u.pointer.size;
+ uint32_t flags = paParms[2].u.uint32;
+
+ /* Verify parameters values. */
+ if (!ShflStringIsValidIn(pPath, cbPath, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)))
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfRemove (pClient, root, pPath, cbPath, flags);
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+ break;
+ }
+
+ case SHFL_FN_RENAME:
+ {
+ pStat = &g_StatRename;
+ pStatFail = &g_StatRenameFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_RENAME\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_RENAME)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* src */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* dest */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_32BIT /* flags */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLSTRING *pSrc = (SHFLSTRING *)paParms[1].u.pointer.addr;
+ SHFLSTRING *pDest = (SHFLSTRING *)paParms[2].u.pointer.addr;
+ uint32_t flags = paParms[3].u.uint32;
+
+ /* Verify parameters values. */
+ if ( !ShflStringIsValidIn(pSrc, paParms[1].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
+ || !ShflStringIsValidIn(pDest, paParms[2].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfRename (pClient, root, pSrc, pDest, flags);
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+ break;
+ }
+
+ case SHFL_FN_FLUSH:
+ {
+ pStat = &g_StatFlush;
+ pStatFail = &g_StatFlushFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_FLUSH\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_FLUSH)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_64BIT /* handle */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLHANDLE Handle = paParms[1].u.uint64;
+
+ /* Verify parameters values. */
+ if (Handle == SHFL_HANDLE_ROOT)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ if (Handle == SHFL_HANDLE_NIL)
+ {
+ AssertMsgFailed(("Invalid handle!\n"));
+ rc = VERR_INVALID_HANDLE;
+ }
+ else
+ {
+ /* Execute the function. */
+
+ rc = vbsfFlush (pClient, root, Handle);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Nothing to do */
+ }
+ }
+ }
+ } break;
+
+ case SHFL_FN_SET_UTF8:
+ {
+ pStatFail = pStat = &g_StatSetUtf8;
+
+ pClient->fu32Flags |= SHFL_CF_UTF8;
+ rc = VINF_SUCCESS;
+ break;
+ }
+
+ case SHFL_FN_SYMLINK:
+ {
+ pStat = &g_StatSymlink;
+ pStatFail = &g_StatSymlinkFail;
+ Log(("SharedFolders host service: svnCall: SHFL_FN_SYMLINK\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_SYMLINK)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_32BIT /* root */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* newPath */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_PTR /* oldPath */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_PTR /* info */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLROOT root = (SHFLROOT)paParms[0].u.uint32;
+ SHFLSTRING *pNewPath = (SHFLSTRING *)paParms[1].u.pointer.addr;
+ SHFLSTRING *pOldPath = (SHFLSTRING *)paParms[2].u.pointer.addr;
+ SHFLFSOBJINFO *pInfo = (SHFLFSOBJINFO *)paParms[3].u.pointer.addr;
+ uint32_t cbInfo = paParms[3].u.pointer.size;
+
+ /* Verify parameters values. */
+ if ( !ShflStringIsValidIn(pNewPath, paParms[1].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
+ || !ShflStringIsValidIn(pOldPath, paParms[2].u.pointer.size, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8))
+ || (cbInfo != sizeof(SHFLFSOBJINFO))
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfSymlink (pClient, root, pNewPath, pOldPath, pInfo);
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+ }
+ break;
+
+ case SHFL_FN_SET_SYMLINKS:
+ {
+ pStatFail = pStat = &g_StatSetSymlinks;
+
+ pClient->fu32Flags |= SHFL_CF_SYMLINKS;
+ rc = VINF_SUCCESS;
+ break;
+ }
+
+ case SHFL_FN_QUERY_MAP_INFO:
+ {
+ pStatFail = pStat = &g_StatQueryMapInfo;
+ Log(("SharedFolders host service: svnCall: SHFL_FN_QUERY_MAP_INFO\n"));
+
+ /* Validate input: */
+ rc = VERR_INVALID_PARAMETER;
+ ASSERT_GUEST_BREAK(cParms == SHFL_CPARMS_QUERY_MAP_INFO);
+ ASSERT_GUEST_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT); /* root */
+ ASSERT_GUEST_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_PTR); /* name */
+ PSHFLSTRING pNameBuf = (PSHFLSTRING)paParms[1].u.pointer.addr;
+ ASSERT_GUEST_BREAK(ShflStringIsValidOut(pNameBuf, paParms[1].u.pointer.size));
+ ASSERT_GUEST_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_PTR); /* mountPoint */
+ PSHFLSTRING pMntPtBuf = (PSHFLSTRING)paParms[2].u.pointer.addr;
+ ASSERT_GUEST_BREAK(ShflStringIsValidOut(pMntPtBuf, paParms[2].u.pointer.size));
+ ASSERT_GUEST_BREAK(paParms[3].type == VBOX_HGCM_SVC_PARM_64BIT); /* flags */
+ ASSERT_GUEST_BREAK(!(paParms[3].u.uint64 & ~(SHFL_MIQF_DRIVE_LETTER | SHFL_MIQF_PATH))); /* flags */
+ ASSERT_GUEST_BREAK(paParms[4].type == VBOX_HGCM_SVC_PARM_32BIT); /* version */
+
+ /* Execute the function: */
+ rc = vbsfMappingsQueryInfo(pClient, paParms[0].u.uint32, pNameBuf, pMntPtBuf,
+ &paParms[3].u.uint64, &paParms[4].u.uint32);
+ break;
+ }
+
+ case SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES:
+ {
+ pStat = &g_StatWaitForMappingsChanges;
+ pStatFail = &g_StatWaitForMappingsChangesFail;
+ Log(("SharedFolders host service: svnCall: SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES\n"));
+
+ /* Validate input: */
+ rc = VERR_INVALID_PARAMETER;
+ ASSERT_GUEST_BREAK(cParms == SHFL_CPARMS_WAIT_FOR_MAPPINGS_CHANGES);
+ ASSERT_GUEST_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT); /* uFolderMappingsVersion */
+
+ /* Execute the function: */
+ rc = vbsfMappingsWaitForChanges(pClient, callHandle, paParms, g_pHelpers->pfnIsCallRestored(callHandle));
+ fAsynchronousProcessing = rc == VINF_HGCM_ASYNC_EXECUTE;
+ break;
+ }
+
+ case SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS:
+ {
+ pStatFail = pStat = &g_StatCancelMappingsChangesWait;
+ Log(("SharedFolders host service: svnCall: SHFL_FN_CANCEL_WAIT_FOR_CHANGES\n"));
+
+ /* Validate input: */
+ rc = VERR_INVALID_PARAMETER;
+ ASSERT_GUEST_BREAK(cParms == SHFL_CPARMS_CANCEL_MAPPINGS_CHANGES_WAITS);
+
+ /* Execute the function: */
+ rc = vbsfMappingsCancelChangesWaits(pClient);
+ break;
+ }
+
+ case SHFL_FN_SET_FILE_SIZE:
+ {
+ pStat = &g_StatSetFileSize;
+ pStatFail = &g_StatSetFileSizeFail;
+ Log(("SharedFolders host service: svcCall: SHFL_FN_SET_FILE_SIZE\n"));
+
+ /* Validate input: */
+ ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_SET_FILE_SIZE, rc = VERR_WRONG_PARAMETER_COUNT);
+ ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* id32Root */
+ ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* u64Handle */
+ ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* cb64NewSize */
+
+ /* Execute the function: */
+ rc = vbsfSetFileSize(pClient, paParms[0].u.uint32, paParms[1].u.uint64, paParms[2].u.uint64);
+ break;
+ }
+
+ default:
+ {
+ pStatFail = pStat = &g_StatUnknown;
+ rc = VERR_NOT_IMPLEMENTED;
+ break;
+ }
+ }
+
+ LogFlow(("SharedFolders host service: svcCall: rc=%Rrc\n", rc));
+
+ if ( !fAsynchronousProcessing
+ || RT_FAILURE (rc))
+ {
+ /* Complete the operation if it was unsuccessful or
+ * it was processed synchronously.
+ */
+ g_pHelpers->pfnCallComplete (callHandle, rc);
+ }
+
+#ifndef VBOX_WITHOUT_RELEASE_STATISTICS
+ /* Statistics: */
+ uint64_t cTicks;
+ STAM_GET_TS(cTicks);
+ cTicks -= tsStart;
+ if (RT_SUCCESS(rc))
+ STAM_REL_PROFILE_ADD_PERIOD(pStat, cTicks);
+ else
+ STAM_REL_PROFILE_ADD_PERIOD(pStatFail, cTicks);
+#endif
+
+ LogFlow(("\n")); /* Add a new line to differentiate between calls more easily. */
+}
+
+/*
+ * We differentiate between a function handler for the guest (svcCall) and one
+ * for the host. The guest is not allowed to add or remove mappings for obvious
+ * security reasons.
+ */
+static DECLCALLBACK(int) svcHostCall (void *, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
+{
+ int rc = VINF_SUCCESS;
+
+ Log(("svcHostCall: fn = %d, cParms = %d, pparms = %d\n", u32Function, cParms, paParms));
+
+#ifdef DEBUG
+ uint32_t i;
+
+ for (i = 0; i < cParms; i++)
+ {
+ /** @todo parameters other than 32 bit */
+ Log((" pparms[%d]: type %d value %d\n", i, paParms[i].type, paParms[i].u.uint32));
+ }
+#endif
+
+ switch (u32Function)
+ {
+ case SHFL_FN_ADD_MAPPING:
+ {
+ Log(("SharedFolders host service: svcCall: SHFL_FN_ADD_MAPPING\n"));
+ LogRel(("SharedFolders host service: Adding host mapping\n"));
+ /* Verify parameter count and types. */
+ if ( (cParms != SHFL_CPARMS_ADD_MAPPING)
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* host folder path */
+ || paParms[1].type != VBOX_HGCM_SVC_PARM_PTR /* map name */
+ || paParms[2].type != VBOX_HGCM_SVC_PARM_32BIT /* fFlags */
+ || paParms[3].type != VBOX_HGCM_SVC_PARM_PTR /* auto mount point */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLSTRING *pHostPath = (SHFLSTRING *)paParms[0].u.pointer.addr;
+ SHFLSTRING *pMapName = (SHFLSTRING *)paParms[1].u.pointer.addr;
+ uint32_t fFlags = paParms[2].u.uint32;
+ SHFLSTRING *pAutoMountPoint = (SHFLSTRING *)paParms[3].u.pointer.addr;
+
+ /* Verify parameters values. */
+ if ( !ShflStringIsValidIn(pHostPath, paParms[0].u.pointer.size, false /*fUtf8Not16*/)
+ || !ShflStringIsValidIn(pMapName, paParms[1].u.pointer.size, false /*fUtf8Not16*/)
+ || !ShflStringIsValidIn(pAutoMountPoint, paParms[3].u.pointer.size, false /*fUtf8Not16*/)
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ LogRel((" Host path '%ls', map name '%ls', %s, automount=%s, automntpnt=%s, create_symlinks=%s, missing=%s\n",
+ pHostPath->String.utf16, pMapName->String.utf16,
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_WRITABLE) ? "writable" : "read-only",
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_AUTOMOUNT) ? "true" : "false",
+ pAutoMountPoint->String.utf16,
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_CREATE_SYMLINKS) ? "true" : "false",
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_MISSING) ? "true" : "false"));
+
+ char *pszHostPath;
+ rc = RTUtf16ToUtf8(pHostPath->String.ucs2, &pszHostPath);
+ if (RT_SUCCESS(rc))
+ {
+ /* Execute the function. */
+ rc = vbsfMappingsAdd(pszHostPath, pMapName,
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_WRITABLE),
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_AUTOMOUNT),
+ pAutoMountPoint,
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_CREATE_SYMLINKS),
+ RT_BOOL(fFlags & SHFL_ADD_MAPPING_F_MISSING),
+ /* fPlaceholder = */ false);
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ RTStrFree(pszHostPath);
+ }
+ }
+ }
+ if (RT_FAILURE(rc))
+ LogRel(("SharedFolders host service: Adding host mapping failed with rc=%Rrc\n", rc));
+ break;
+ }
+
+ case SHFL_FN_REMOVE_MAPPING:
+ {
+ Log(("SharedFolders host service: svcCall: SHFL_FN_REMOVE_MAPPING\n"));
+ LogRel(("SharedFolders host service: Removing host mapping '%ls'\n",
+ ((SHFLSTRING *)paParms[0].u.pointer.addr)->String.ucs2));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_REMOVE_MAPPING)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* folder name */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ SHFLSTRING *pString = (SHFLSTRING *)paParms[0].u.pointer.addr;
+
+ /* Verify parameters values. */
+ if (!ShflStringIsValidIn(pString, paParms[0].u.pointer.size, false /*fUtf8Not16*/))
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ rc = vbsfMappingsRemove (pString);
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Update parameters.*/
+ ; /* none */
+ }
+ }
+ }
+ if (RT_FAILURE(rc))
+ LogRel(("SharedFolders host service: Removing host mapping failed with rc=%Rrc\n", rc));
+ break;
+ }
+
+ case SHFL_FN_SET_STATUS_LED:
+ {
+ Log(("SharedFolders host service: svcCall: SHFL_FN_SET_STATUS_LED\n"));
+
+ /* Verify parameter count and types. */
+ if (cParms != SHFL_CPARMS_SET_STATUS_LED)
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else if ( paParms[0].type != VBOX_HGCM_SVC_PARM_PTR /* folder name */
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Fetch parameters. */
+ PPDMLED pLed = (PPDMLED)paParms[0].u.pointer.addr;
+ uint32_t cbLed = paParms[0].u.pointer.size;
+
+ /* Verify parameters values. */
+ if ( (cbLed != sizeof (PDMLED))
+ )
+ {
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ /* Execute the function. */
+ g_pStatusLed = pLed;
+ rc = VINF_SUCCESS;
+ }
+ }
+ break;
+ }
+
+ default:
+ rc = VERR_NOT_IMPLEMENTED;
+ break;
+ }
+
+ LogFlow(("SharedFolders host service: svcHostCall ended with rc=%Rrc\n", rc));
+ return rc;
+}
+
+extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable)
+{
+ int rc = VINF_SUCCESS;
+
+ Log(("SharedFolders host service: VBoxHGCMSvcLoad: ptable = %p\n", ptable));
+
+ if (!VALID_PTR(ptable))
+ {
+ LogRelFunc(("SharedFolders host service: Bad value of ptable (%p)\n", ptable));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ Log(("SharedFolders host service: VBoxHGCMSvcLoad: ptable->cbSize = %u, ptable->u32Version = 0x%08X\n",
+ ptable->cbSize, ptable->u32Version));
+
+ if ( ptable->cbSize != sizeof (VBOXHGCMSVCFNTABLE)
+ || ptable->u32Version != VBOX_HGCM_SVC_VERSION)
+ {
+ LogRelFunc(("SharedFolders host service: Version mismatch while loading: ptable->cbSize = %u (should be %u), ptable->u32Version = 0x%08X (should be 0x%08X)\n",
+ ptable->cbSize, sizeof (VBOXHGCMSVCFNTABLE), ptable->u32Version, VBOX_HGCM_SVC_VERSION));
+ rc = VERR_VERSION_MISMATCH;
+ }
+ else
+ {
+ g_pHelpers = ptable->pHelpers;
+
+ ptable->cbClient = sizeof (SHFLCLIENTDATA);
+
+ ptable->pfnUnload = svcUnload;
+ ptable->pfnConnect = svcConnect;
+ ptable->pfnDisconnect = svcDisconnect;
+ ptable->pfnCall = svcCall;
+ ptable->pfnHostCall = svcHostCall;
+ ptable->pfnSaveState = svcSaveState;
+ ptable->pfnLoadState = svcLoadState;
+ ptable->pfnNotify = NULL;
+ ptable->pvService = NULL;
+ }
+
+ /* Init handle table */
+ rc = vbsfInitHandleTable();
+ AssertRC(rc);
+
+ vbsfMappingInit();
+
+ /* Finally, register statistics if everything went well: */
+ if (RT_SUCCESS(rc))
+ {
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMappings, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAPPINGS successes", "/HGCM/VBoxSharedFolders/FnQueryMappings");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMappingsFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAPPINGS failures", "/HGCM/VBoxSharedFolders/FnQueryMappingsFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMapName, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAP_NAME", "/HGCM/VBoxSharedFolders/FnQueryMapName");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCreate, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/CREATE successes", "/HGCM/VBoxSharedFolders/FnCreate");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCreateFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/CREATE failures", "/HGCM/VBoxSharedFolders/FnCreateFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLookup, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/LOOKUP successes", "/HGCM/VBoxSharedFolders/FnLookup");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLookupFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CREATE/LOOKUP failures", "/HGCM/VBoxSharedFolders/FnLookupFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatClose, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CLOSE successes", "/HGCM/VBoxSharedFolders/FnClose");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCloseFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CLOSE failures", "/HGCM/VBoxSharedFolders/FnCloseFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRead, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READ successes", "/HGCM/VBoxSharedFolders/FnRead");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatReadFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READ failures", "/HGCM/VBoxSharedFolders/FnReadFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWrite, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WRITE successes", "/HGCM/VBoxSharedFolders/FnWrite");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWriteFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WRITE failures", "/HGCM/VBoxSharedFolders/FnWriteFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLock, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LOCK successes", "/HGCM/VBoxSharedFolders/FnLock");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatLockFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LOCK failures", "/HGCM/VBoxSharedFolders/FnLockFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatList, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LIST successes", "/HGCM/VBoxSharedFolders/FnList");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatListFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_LIST failures", "/HGCM/VBoxSharedFolders/FnListFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatReadLink, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READLINK successes", "/HGCM/VBoxSharedFolders/FnReadLink");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatReadLinkFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_READLINK failures", "/HGCM/VBoxSharedFolders/FnReadLinkFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMapFolderOld, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_MAP_FOLDER_OLD", "/HGCM/VBoxSharedFolders/FnMapFolderOld");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMapFolder, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_MAP_FOLDER successes", "/HGCM/VBoxSharedFolders/FnMapFolder");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMapFolderFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_MAP_FOLDER failures", "/HGCM/VBoxSharedFolders/FnMapFolderFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatUnmapFolder, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_UNMAP_FOLDER successes", "/HGCM/VBoxSharedFolders/FnUnmapFolder");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatUnmapFolderFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_UNMAP_FOLDER failures", "/HGCM/VBoxSharedFolders/FnUnmapFolderFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION early failures", "/HGCM/VBoxSharedFolders/FnInformationFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetFile, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/FILE successes", "/HGCM/VBoxSharedFolders/FnInformationSetFile");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetFileFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/FILE failures", "/HGCM/VBoxSharedFolders/FnInformationSetFileFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetSize, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/SIZE successes", "/HGCM/VBoxSharedFolders/FnInformationSetSize");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationSetSizeFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/SET/SIZE failures", "/HGCM/VBoxSharedFolders/FnInformationSetSizeFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetFile, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/FILE successes", "/HGCM/VBoxSharedFolders/FnInformationGetFile");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetFileFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/FILE failures", "/HGCM/VBoxSharedFolders/FnInformationGetFileFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetVolume, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/VOLUME successes", "/HGCM/VBoxSharedFolders/FnInformationGetVolume");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatInformationGetVolumeFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_INFORMATION/GET/VOLUME failures", "/HGCM/VBoxSharedFolders/FnInformationGetVolumeFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRemove, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_REMOVE successes", "/HGCM/VBoxSharedFolders/FnRemove");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRemoveFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_REMOVE failures", "/HGCM/VBoxSharedFolders/FnRemoveFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRename, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_RENAME successes", "/HGCM/VBoxSharedFolders/FnRename");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatRenameFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_RENAME failures", "/HGCM/VBoxSharedFolders/FnRenameFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatFlush, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_FLUSH successes", "/HGCM/VBoxSharedFolders/FnFlush");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatFlushFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_FLUSH failures", "/HGCM/VBoxSharedFolders/FnFlushFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSetUtf8, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SET_UTF8", "/HGCM/VBoxSharedFolders/FnSetUtf8");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSymlink, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SYMLINK successes", "/HGCM/VBoxSharedFolders/FnSymlink");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSymlinkFail, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SYMLINK failures", "/HGCM/VBoxSharedFolders/FnSymlinkFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatSetSymlinks, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_SET_SYMLINKS", "/HGCM/VBoxSharedFolders/FnSetSymlink");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatQueryMapInfo, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_QUERY_MAP_INFO", "/HGCM/VBoxSharedFolders/FnQueryMapInfo");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWaitForMappingsChanges, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES successes", "/HGCM/VBoxSharedFolders/FnWaitForMappingsChanges");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatWaitForMappingsChangesFail,STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES failures","/HGCM/VBoxSharedFolders/FnWaitForMappingsChangesFail");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatCancelMappingsChangesWait, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS", "/HGCM/VBoxSharedFolders/FnCancelMappingsChangesWaits");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatUnknown, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "SHFL_FN_???", "/HGCM/VBoxSharedFolders/FnUnknown");
+ HGCMSvcHlpStamRegister(g_pHelpers, &g_StatMsgStage1, STAMTYPE_PROFILE, STAMVISIBILITY_ALWAYS, STAMUNIT_CALLS, "Time from VMMDev arrival to worker thread.","/HGCM/VBoxSharedFolders/MsgStage1");
+ }
+ }
+
+ return rc;
+}
+
diff --git a/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.rc b/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.rc
new file mode 100644
index 00000000..fb9e5418
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/VBoxSharedFoldersSvc.rc
@@ -0,0 +1,51 @@
+/* $Id: VBoxSharedFoldersSvc.rc $ */
+/** @file
+ * VBoxSharedFolders - Resource file containing version info and icon.
+ */
+
+/*
+ * Copyright (C) 2015-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#include <windows.h>
+#include <VBox/version.h>
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION VBOX_RC_FILE_VERSION
+ PRODUCTVERSION VBOX_RC_FILE_VERSION
+ FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
+ FILEFLAGS VBOX_RC_FILE_FLAGS
+ FILEOS VBOX_RC_FILE_OS
+ FILETYPE VBOX_RC_TYPE_DLL
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "040904b0" // Lang=US English, CharSet=Unicode
+ BEGIN
+ VALUE "FileDescription", "VirtualBox Shared Folders Host Service\0"
+ VALUE "InternalName", "VBoxSharedFolders\0"
+ VALUE "OriginalFilename", "VBoxSharedFolders.dll\0"
+ VALUE "CompanyName", VBOX_RC_COMPANY_NAME
+ VALUE "FileVersion", VBOX_RC_FILE_VERSION_STR
+ VALUE "LegalCopyright", VBOX_RC_LEGAL_COPYRIGHT
+ VALUE "ProductName", VBOX_RC_PRODUCT_NAME_STR
+ VALUE "ProductVersion", VBOX_RC_PRODUCT_VERSION_STR
+ VBOX_RC_MORE_STRINGS
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x409, 1200
+ END
+END
diff --git a/src/VBox/HostServices/SharedFolders/mappings.cpp b/src/VBox/HostServices/SharedFolders/mappings.cpp
new file mode 100644
index 00000000..1c76d78c
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/mappings.cpp
@@ -0,0 +1,939 @@
+/* $Id: mappings.cpp $ */
+/** @file
+ * Shared Folders Service - Mappings support.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
+#ifdef UNITTEST
+# include "testcase/tstSharedFolderService.h"
+#endif
+
+#include "mappings.h"
+#include "vbsfpath.h"
+#include <iprt/alloc.h>
+#include <iprt/assert.h>
+#include <iprt/list.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <VBox/AssertGuest.h>
+
+#ifdef UNITTEST
+# include "teststubs.h"
+#endif
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+extern PVBOXHGCMSVCHELPERS g_pHelpers; /* service.cpp */
+
+
+/* Shared folders order in the saved state and in the g_FolderMapping can differ.
+ * So a translation array of root handle is needed.
+ */
+
+static MAPPING g_FolderMapping[SHFL_MAX_MAPPINGS];
+static SHFLROOT g_aIndexFromRoot[SHFL_MAX_MAPPINGS];
+/**< Array running parallel to g_aIndexFromRoot and which entries are increased
+ * as an root handle is added or removed.
+ *
+ * This helps the guest figuring out that a mapping may have been reconfigured
+ * or that saved state has been restored. Entry reuse is very likely given that
+ * vbsfRootHandleAdd() always starts searching at the start for an unused entry.
+ */
+static uint32_t g_auRootHandleVersions[SHFL_MAX_MAPPINGS];
+/** Version number that is increased for every change made.
+ * This is used by the automount guest service to wait for changes.
+ * @note This does not need saving, the guest should be woken up and refresh
+ * its sate when restored. */
+static uint32_t volatile g_uFolderMappingsVersion = 0;
+
+
+/** For recording async vbsfMappingsWaitForChanges calls. */
+typedef struct SHFLMAPPINGSWAIT
+{
+ RTLISTNODE ListEntry; /**< List entry. */
+ PSHFLCLIENTDATA pClient; /**< The client that's waiting. */
+ VBOXHGCMCALLHANDLE hCall; /**< The call handle to signal completion with. */
+ PVBOXHGCMSVCPARM pParm; /**< The 32-bit unsigned parameter to stuff g_uFolderMappingsVersion into. */
+} SHFLMAPPINGSWAIT;
+/** Pointer to async mappings change wait. */
+typedef SHFLMAPPINGSWAIT *PSHFLMAPPINGSWAIT;
+/** List head for clients waiting on mapping changes (SHFLMAPPINGSWAIT). */
+static RTLISTANCHOR g_MappingsChangeWaiters;
+/** Number of clients waiting on mapping changes.
+ * We use this to limit the number of waiting calls the clients can make. */
+static uint32_t g_cMappingChangeWaiters = 0;
+static void vbsfMappingsWakeupAllWaiters(void);
+
+
+void vbsfMappingInit(void)
+{
+ unsigned root;
+
+ for (root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
+ {
+ g_aIndexFromRoot[root] = SHFL_ROOT_NIL;
+ }
+
+ RTListInit(&g_MappingsChangeWaiters);
+}
+
+int vbsfMappingLoaded(const MAPPING *pLoadedMapping, SHFLROOT root)
+{
+ /* Mapping loaded from the saved state with the index. Which means
+ * the guest uses the iMapping as root handle for this folder.
+ * Check whether there is the same mapping in g_FolderMapping and
+ * update the g_aIndexFromRoot.
+ *
+ * Also update the mapping properties, which were lost: cMappings.
+ */
+ if (root >= SHFL_MAX_MAPPINGS)
+ {
+ return VERR_INVALID_PARAMETER;
+ }
+
+ SHFLROOT i;
+ for (i = 0; i < RT_ELEMENTS(g_FolderMapping); i++)
+ {
+ MAPPING *pMapping = &g_FolderMapping[i];
+
+ /* Equal? */
+ if ( pLoadedMapping->fValid == pMapping->fValid
+ && ShflStringSizeOfBuffer(pLoadedMapping->pMapName) == ShflStringSizeOfBuffer(pMapping->pMapName)
+ && memcmp(pLoadedMapping->pMapName, pMapping->pMapName, ShflStringSizeOfBuffer(pMapping->pMapName)) == 0)
+ {
+ if (!pMapping->fLoadedRootId)
+ {
+ pMapping->fLoadedRootId = true;
+ Log(("vbsfMappingLoaded: root=%u i=%u (was %u) (%ls)\n",
+ root, i, g_aIndexFromRoot[root], pLoadedMapping->pMapName->String.utf16));
+
+ /* Actual index is i. */
+ /** @todo This will not work with global shared folders, as these can change
+ * while state is saved and these blind assignments may hid new ones. */
+ g_aIndexFromRoot[root] = i;
+
+ /* Update the mapping properties. */
+ pMapping->cMappings = pLoadedMapping->cMappings;
+
+ return VINF_SUCCESS;
+ }
+ }
+ }
+
+ /* No corresponding mapping on the host but the guest still uses it.
+ * Add a 'placeholder' mapping.
+ */
+ LogRel2(("SharedFolders: mapping a placeholder for '%ls' -> '%s'\n",
+ pLoadedMapping->pMapName->String.ucs2, pLoadedMapping->pszFolderName));
+ return vbsfMappingsAdd(pLoadedMapping->pszFolderName, pLoadedMapping->pMapName,
+ pLoadedMapping->fWritable, pLoadedMapping->fAutoMount, pLoadedMapping->pAutoMountPoint,
+ pLoadedMapping->fSymlinksCreate, /* fMissing = */ true, /* fPlaceholder = */ true);
+}
+
+MAPPING *vbsfMappingGetByRoot(SHFLROOT root)
+{
+ if (root < RT_ELEMENTS(g_aIndexFromRoot))
+ {
+ SHFLROOT iMapping = g_aIndexFromRoot[root];
+
+ if ( iMapping != SHFL_ROOT_NIL
+ && iMapping < RT_ELEMENTS(g_FolderMapping))
+ {
+ return &g_FolderMapping[iMapping];
+ }
+ }
+
+ return NULL;
+}
+
+static SHFLROOT vbsfMappingGetRootFromIndex(SHFLROOT iMapping)
+{
+ unsigned root;
+
+ for (root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
+ {
+ if (iMapping == g_aIndexFromRoot[root])
+ {
+ return root;
+ }
+ }
+
+ return SHFL_ROOT_NIL;
+}
+
+static MAPPING *vbsfMappingGetByName(PRTUTF16 pwszName, SHFLROOT *pRoot)
+{
+ for (unsigned i = 0; i < SHFL_MAX_MAPPINGS; i++)
+ {
+ if ( g_FolderMapping[i].fValid
+ && !g_FolderMapping[i].fPlaceholder) /* Don't allow mapping placeholders. */
+ {
+ if (!RTUtf16LocaleICmp(g_FolderMapping[i].pMapName->String.ucs2, pwszName))
+ {
+ SHFLROOT root = vbsfMappingGetRootFromIndex(i);
+
+ if (root != SHFL_ROOT_NIL)
+ {
+ if (pRoot)
+ {
+ *pRoot = root;
+ }
+ return &g_FolderMapping[i];
+ }
+ AssertFailed();
+ }
+ }
+ }
+ return NULL;
+}
+
+static void vbsfRootHandleAdd(SHFLROOT iMapping)
+{
+ for (unsigned root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
+ {
+ if (g_aIndexFromRoot[root] == SHFL_ROOT_NIL)
+ {
+ g_aIndexFromRoot[root] = iMapping;
+ g_auRootHandleVersions[root] += 1;
+ return;
+ }
+ }
+
+ AssertFailed();
+}
+
+static void vbsfRootHandleRemove(SHFLROOT iMapping)
+{
+ unsigned cFound = 0;
+
+ for (unsigned root = 0; root < RT_ELEMENTS(g_aIndexFromRoot); root++)
+ {
+ if (g_aIndexFromRoot[root] == iMapping)
+ {
+ g_aIndexFromRoot[root] = SHFL_ROOT_NIL;
+ g_auRootHandleVersions[root] += 1;
+ Log(("vbsfRootHandleRemove: Removed root=%u (iMapping=%u)\n", root, iMapping));
+
+ /* Note! Do not stop here as g_aIndexFromRoot may (at least it could
+ prior to the introduction of fLoadedRootId) contain
+ duplicates after restoring save state. */
+ cFound++;
+ }
+ }
+
+ Assert(cFound > 0); RT_NOREF(cFound);
+}
+
+
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_ADD_MAPPING API. Located here as a form of API
+ * documentation. */
+void testMappingsAdd(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testMappingsAddBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+/*
+ * We are always executed from one specific HGCM thread. So thread safe.
+ */
+int vbsfMappingsAdd(const char *pszFolderName, PSHFLSTRING pMapName, bool fWritable,
+ bool fAutoMount, PSHFLSTRING pAutoMountPoint, bool fSymlinksCreate, bool fMissing, bool fPlaceholder)
+{
+ unsigned i;
+
+ Assert(pszFolderName && pMapName);
+
+ Log(("vbsfMappingsAdd %ls\n", pMapName->String.ucs2));
+
+ /* Check for duplicates, ignoring placeholders to give the GUI to change stuff at runtime. */
+ /** @todo bird: Not entirely sure about ignoring placeholders, but you cannot
+ * trigger auto-umounting without ignoring them. */
+ if (!fPlaceholder)
+ {
+ for (i = 0; i < SHFL_MAX_MAPPINGS; i++)
+ {
+ if ( g_FolderMapping[i].fValid
+ && !g_FolderMapping[i].fPlaceholder)
+ {
+ if (!RTUtf16LocaleICmp(g_FolderMapping[i].pMapName->String.ucs2, pMapName->String.ucs2))
+ {
+ AssertMsgFailed(("vbsfMappingsAdd: %ls mapping already exists!!\n", pMapName->String.ucs2));
+ return VERR_ALREADY_EXISTS;
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < SHFL_MAX_MAPPINGS; i++)
+ {
+ if (g_FolderMapping[i].fValid == false)
+ {
+ /* Make sure the folder name is an absolute path, otherwise we're
+ likely to get into trouble with buffer sizes in vbsfPathGuestToHost. */
+ char szAbsFolderName[RTPATH_MAX];
+ int rc = vbsfPathAbs(NULL, pszFolderName, szAbsFolderName, sizeof(szAbsFolderName));
+ AssertRCReturn(rc, rc);
+
+ g_FolderMapping[i].pszFolderName = RTStrDup(szAbsFolderName);
+ g_FolderMapping[i].pMapName = ShflStringDup(pMapName);
+ g_FolderMapping[i].pAutoMountPoint = ShflStringDup(pAutoMountPoint);
+ if ( !g_FolderMapping[i].pszFolderName
+ || !g_FolderMapping[i].pMapName
+ || !g_FolderMapping[i].pAutoMountPoint)
+ {
+ RTStrFree(g_FolderMapping[i].pszFolderName);
+ RTMemFree(g_FolderMapping[i].pMapName);
+ RTMemFree(g_FolderMapping[i].pAutoMountPoint);
+ return VERR_NO_MEMORY;
+ }
+
+ g_FolderMapping[i].fValid = true;
+ g_FolderMapping[i].cMappings = 0;
+ g_FolderMapping[i].fWritable = fWritable;
+ g_FolderMapping[i].fAutoMount = fAutoMount;
+ g_FolderMapping[i].fSymlinksCreate = fSymlinksCreate;
+ g_FolderMapping[i].fMissing = fMissing;
+ g_FolderMapping[i].fPlaceholder = fPlaceholder;
+ g_FolderMapping[i].fLoadedRootId = false;
+
+ /* Check if the host file system is case sensitive */
+ RTFSPROPERTIES prop;
+ prop.fCaseSensitive = false; /* Shut up MSC. */
+ rc = RTFsQueryProperties(g_FolderMapping[i].pszFolderName, &prop);
+ AssertRC(rc);
+ g_FolderMapping[i].fHostCaseSensitive = RT_SUCCESS(rc) ? prop.fCaseSensitive : false;
+ vbsfRootHandleAdd(i);
+ vbsfMappingsWakeupAllWaiters();
+ break;
+ }
+ }
+ if (i == SHFL_MAX_MAPPINGS)
+ {
+ AssertLogRelMsgFailed(("vbsfMappingsAdd: no more room to add mapping %s to %ls!!\n", pszFolderName, pMapName->String.ucs2));
+ return VERR_TOO_MUCH_DATA;
+ }
+
+ Log(("vbsfMappingsAdd: added mapping %s to %ls (slot %u, root %u)\n",
+ pszFolderName, pMapName->String.ucs2, i, vbsfMappingGetRootFromIndex(i)));
+ return VINF_SUCCESS;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_REMOVE_MAPPING API. Located here as a form of API
+ * documentation. */
+void testMappingsRemove(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testMappingsRemoveBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfMappingsRemove(PSHFLSTRING pMapName)
+{
+ Assert(pMapName);
+ Log(("vbsfMappingsRemove %ls\n", pMapName->String.ucs2));
+
+ /*
+ * We must iterate thru the whole table as may have 0+ placeholder entries
+ * and 0-1 regular entries with the same name. Also, it is good to kick
+ * the guest automounter into action wrt to evicting placeholders.
+ */
+ int rc = VERR_FILE_NOT_FOUND;
+ for (unsigned i = 0; i < SHFL_MAX_MAPPINGS; i++)
+ {
+ if (g_FolderMapping[i].fValid == true)
+ {
+ if (!RTUtf16LocaleICmp(g_FolderMapping[i].pMapName->String.ucs2, pMapName->String.ucs2))
+ {
+ if (g_FolderMapping[i].cMappings != 0)
+ {
+ LogRel2(("SharedFolders: removing '%ls' -> '%s'%s, which is still used by the guest\n", pMapName->String.ucs2,
+ g_FolderMapping[i].pszFolderName, g_FolderMapping[i].fPlaceholder ? " (again)" : ""));
+ g_FolderMapping[i].fMissing = true;
+ g_FolderMapping[i].fPlaceholder = true;
+ vbsfMappingsWakeupAllWaiters();
+ rc = VINF_PERMISSION_DENIED;
+ }
+ else
+ {
+ /* pMapName can be the same as g_FolderMapping[i].pMapName when
+ * called from vbsfUnmapFolder, log it before deallocating the memory. */
+ Log(("vbsfMappingsRemove: mapping %ls removed\n", pMapName->String.ucs2));
+ bool fSame = g_FolderMapping[i].pMapName == pMapName;
+
+ RTStrFree(g_FolderMapping[i].pszFolderName);
+ RTMemFree(g_FolderMapping[i].pMapName);
+ g_FolderMapping[i].pszFolderName = NULL;
+ g_FolderMapping[i].pMapName = NULL;
+ g_FolderMapping[i].fValid = false;
+ vbsfRootHandleRemove(i);
+ vbsfMappingsWakeupAllWaiters();
+ if (rc == VERR_FILE_NOT_FOUND)
+ rc = VINF_SUCCESS;
+ if (fSame)
+ break;
+ }
+ }
+ }
+ }
+
+ return rc;
+}
+
+const char* vbsfMappingsQueryHostRoot(SHFLROOT root)
+{
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ AssertReturn(pFolderMapping, NULL);
+ if (pFolderMapping->fMissing)
+ return NULL;
+ return pFolderMapping->pszFolderName;
+}
+
+int vbsfMappingsQueryHostRootEx(SHFLROOT hRoot, const char **ppszRoot, uint32_t *pcbRootLen)
+{
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(hRoot);
+ AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
+ if (pFolderMapping->fMissing)
+ return VERR_NOT_FOUND;
+ if ( pFolderMapping->pszFolderName == NULL
+ || pFolderMapping->pszFolderName[0] == 0)
+ return VERR_NOT_FOUND;
+ *ppszRoot = pFolderMapping->pszFolderName;
+ *pcbRootLen = (uint32_t)strlen(pFolderMapping->pszFolderName);
+ return VINF_SUCCESS;
+}
+
+bool vbsfIsGuestMappingCaseSensitive(SHFLROOT root)
+{
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ AssertReturn(pFolderMapping, false);
+ return pFolderMapping->fGuestCaseSensitive;
+}
+
+bool vbsfIsHostMappingCaseSensitive(SHFLROOT root)
+{
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ AssertReturn(pFolderMapping, false);
+ return pFolderMapping->fHostCaseSensitive;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_QUERY_MAPPINGS API. Located here as a form of API
+ * documentation (or should it better be inline in include/VBox/shflsvc.h?) */
+void testMappingsQuery(RTTEST hTest)
+{
+ /* The API should return all mappings if we provide enough buffers. */
+ testMappingsQuerySimple(hTest);
+ /* If we provide too few buffers that should be signalled correctly. */
+ testMappingsQueryTooFewBuffers(hTest);
+ /* The SHFL_MF_AUTOMOUNT flag means return only auto-mounted mappings. */
+ testMappingsQueryAutoMount(hTest);
+ /* The mappings return array must have numberOfMappings entries. */
+ testMappingsQueryArrayWrongSize(hTest);
+}
+#endif
+/**
+ * @note If pMappings / *pcMappings is smaller than the actual amount of
+ * mappings that *could* have been returned *pcMappings contains the
+ * required buffer size so that the caller can retry the operation if
+ * wanted.
+ */
+int vbsfMappingsQuery(PSHFLCLIENTDATA pClient, bool fOnlyAutoMounts, PSHFLMAPPING pMappings, uint32_t *pcMappings)
+{
+ LogFlow(("vbsfMappingsQuery: pClient = %p, pMappings = %p, pcMappings = %p, *pcMappings = %d\n",
+ pClient, pMappings, pcMappings, *pcMappings));
+
+ uint32_t const cMaxMappings = *pcMappings;
+ uint32_t idx = 0;
+ for (uint32_t i = 0; i < SHFL_MAX_MAPPINGS; i++)
+ {
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(i);
+ if ( pFolderMapping != NULL
+ && pFolderMapping->fValid
+ && ( !fOnlyAutoMounts
+ || (pFolderMapping->fAutoMount && !pFolderMapping->fPlaceholder)) )
+ {
+ if (idx < cMaxMappings)
+ {
+ pMappings[idx].u32Status = SHFL_MS_NEW;
+ pMappings[idx].root = i;
+ }
+ idx++;
+ }
+ }
+
+ /* Return actual number of mappings, regardless whether the handed in
+ * mapping buffer was big enough. */
+ /** @todo r=bird: This is non-standard interface behaviour. We return
+ * VERR_BUFFER_OVERFLOW or at least a VINF_BUFFER_OVERFLOW here.
+ *
+ * Guess this goes well along with ORing SHFL_MF_AUTOMOUNT into
+ * pClient->fu32Flags rather than passing it as fOnlyAutoMounts...
+ * Not amused by this. */
+ *pcMappings = idx;
+
+ RT_NOREF_PV(pClient);
+ LogFlow(("vbsfMappingsQuery: returns VINF_SUCCESS (idx=%u, cMaxMappings=%u)\n", idx, cMaxMappings));
+ return VINF_SUCCESS;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_QUERY_MAP_NAME API. Located here as a form of API
+ * documentation. */
+void testMappingsQueryName(RTTEST hTest)
+{
+ /* If we query an valid mapping it should be returned. */
+ testMappingsQueryNameValid(hTest);
+ /* If we query an invalid mapping that should be signalled. */
+ testMappingsQueryNameInvalid(hTest);
+ /* If we pass in a bad string buffer that should be detected. */
+ testMappingsQueryNameBadBuffer(hTest);
+}
+#endif
+int vbsfMappingsQueryName(PSHFLCLIENTDATA pClient, SHFLROOT root, SHFLSTRING *pString)
+{
+ LogFlow(("vbsfMappingsQuery: pClient = %p, root = %d, *pString = %p\n", pClient, root, pString));
+
+ int rc;
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ if (pFolderMapping)
+ {
+ if (pFolderMapping->fValid)
+ {
+ if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ rc = ShflStringCopyUtf16BufAsUtf8(pString, pFolderMapping->pMapName);
+ else
+ {
+ /* Not using ShlfStringCopy here as behaviour shouldn't change... */
+ if (pString->u16Size < pFolderMapping->pMapName->u16Size)
+ {
+ Log(("vbsfMappingsQuery: passed string too short (%d < %d bytes)!\n",
+ pString->u16Size, pFolderMapping->pMapName->u16Size));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ else
+ {
+ pString->u16Length = pFolderMapping->pMapName->u16Length;
+ memcpy(pString->String.ucs2, pFolderMapping->pMapName->String.ucs2,
+ pFolderMapping->pMapName->u16Size);
+ rc = VINF_SUCCESS;
+ }
+ }
+ }
+ else
+ rc = VERR_FILE_NOT_FOUND;
+ }
+ else
+ rc = VERR_INVALID_PARAMETER;
+
+ LogFlow(("vbsfMappingsQuery:Name return rc = %Rrc\n", rc));
+ return rc;
+}
+
+/** Queries fWritable flag for the given root. Returns error if the root is not accessible.
+ */
+int vbsfMappingsQueryWritable(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fWritable)
+{
+ RT_NOREF1(pClient);
+ int rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfMappingsQueryWritable: pClient = %p, root = %d\n", pClient, root));
+
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
+
+ if ( pFolderMapping->fValid
+ && !pFolderMapping->fMissing)
+ *fWritable = pFolderMapping->fWritable;
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ LogFlow(("vbsfMappingsQuery:Writable return rc = %Rrc\n", rc));
+
+ return rc;
+}
+
+int vbsfMappingsQueryAutoMount(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fAutoMount)
+{
+ RT_NOREF1(pClient);
+ int rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfMappingsQueryAutoMount: pClient = %p, root = %d\n", pClient, root));
+
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
+
+ if (pFolderMapping->fValid == true)
+ *fAutoMount = pFolderMapping->fAutoMount;
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ LogFlow(("vbsfMappingsQueryAutoMount:Writable return rc = %Rrc\n", rc));
+
+ return rc;
+}
+
+int vbsfMappingsQuerySymlinksCreate(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fSymlinksCreate)
+{
+ RT_NOREF1(pClient);
+ int rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfMappingsQueryAutoMount: pClient = %p, root = %d\n", pClient, root));
+
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ AssertReturn(pFolderMapping, VERR_INVALID_PARAMETER);
+
+ if (pFolderMapping->fValid == true)
+ *fSymlinksCreate = pFolderMapping->fSymlinksCreate;
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ LogFlow(("vbsfMappingsQueryAutoMount:SymlinksCreate return rc = %Rrc\n", rc));
+
+ return rc;
+}
+
+/**
+ * Implements SHFL_FN_QUERY_MAP_INFO.
+ * @since VBox 6.0
+ */
+int vbsfMappingsQueryInfo(PSHFLCLIENTDATA pClient, SHFLROOT root, PSHFLSTRING pNameBuf, PSHFLSTRING pMntPtBuf,
+ uint64_t *pfFlags, uint32_t *puVersion)
+{
+ LogFlow(("vbsfMappingsQueryInfo: pClient=%p root=%d\n", pClient, root));
+
+ /* Resolve the root handle. */
+ int rc;
+ PMAPPING pFolderMapping = vbsfMappingGetByRoot(root);
+ if (pFolderMapping)
+ {
+ if (pFolderMapping->fValid)
+ {
+ /*
+ * Produce the output.
+ */
+ *puVersion = g_auRootHandleVersions[root];
+
+ *pfFlags = 0;
+ if (pFolderMapping->fWritable)
+ *pfFlags |= SHFL_MIF_WRITABLE;
+ if (pFolderMapping->fAutoMount)
+ *pfFlags |= SHFL_MIF_AUTO_MOUNT;
+ if (pFolderMapping->fHostCaseSensitive)
+ *pfFlags |= SHFL_MIF_HOST_ICASE;
+ if (pFolderMapping->fGuestCaseSensitive)
+ *pfFlags |= SHFL_MIF_GUEST_ICASE;
+ if (pFolderMapping->fSymlinksCreate)
+ *pfFlags |= SHFL_MIF_SYMLINK_CREATION;
+
+ int rc2;
+ if (pClient->fu32Flags & SHFL_CF_UTF8)
+ {
+ rc = ShflStringCopyUtf16BufAsUtf8(pNameBuf, pFolderMapping->pMapName);
+ rc2 = ShflStringCopyUtf16BufAsUtf8(pMntPtBuf, pFolderMapping->pAutoMountPoint);
+ }
+ else
+ {
+ rc = ShflStringCopy(pNameBuf, pFolderMapping->pMapName, sizeof(RTUTF16));
+ rc2 = ShflStringCopy(pMntPtBuf, pFolderMapping->pAutoMountPoint, sizeof(RTUTF16));
+ }
+ if (RT_SUCCESS(rc))
+ rc = rc2;
+ }
+ else
+ rc = VERR_FILE_NOT_FOUND;
+ }
+ else
+ rc = VERR_INVALID_PARAMETER;
+ LogFlow(("vbsfMappingsQueryInfo: returns %Rrc\n", rc));
+ return rc;
+}
+
+
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_MAP_FOLDER API. Located here as a form of API
+ * documentation. */
+void testMapFolder(RTTEST hTest)
+{
+ /* If we try to map a valid name we should get the root. */
+ testMapFolderValid(hTest);
+ /* If we try to map a valid name we should get VERR_FILE_NOT_FOUND. */
+ testMapFolderInvalid(hTest);
+ /* If we map a folder twice we can unmap it twice.
+ * Currently unmapping too often is only asserted but not signalled. */
+ testMapFolderTwice(hTest);
+ /* The delimiter should be converted in e.g. file delete operations. */
+ testMapFolderDelimiter(hTest);
+ /* Test case sensitive mapping by opening a file with the wrong case. */
+ testMapFolderCaseSensitive(hTest);
+ /* Test case insensitive mapping by opening a file with the wrong case. */
+ testMapFolderCaseInsensitive(hTest);
+ /* If the number or types of parameters are wrong the API should fail. */
+ testMapFolderBadParameters(hTest);
+}
+#endif
+int vbsfMapFolder(PSHFLCLIENTDATA pClient, PSHFLSTRING pszMapName,
+ RTUTF16 wcDelimiter, bool fCaseSensitive, SHFLROOT *pRoot)
+{
+ MAPPING *pFolderMapping = NULL;
+
+ if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ {
+ Log(("vbsfMapFolder %s\n", pszMapName->String.utf8));
+ }
+ else
+ {
+ Log(("vbsfMapFolder %ls\n", pszMapName->String.ucs2));
+ }
+
+ AssertMsgReturn(wcDelimiter == '/' || wcDelimiter == '\\',
+ ("Invalid path delimiter: %#x\n", wcDelimiter),
+ VERR_INVALID_PARAMETER);
+ if (pClient->PathDelimiter == 0)
+ {
+ pClient->PathDelimiter = wcDelimiter;
+ }
+ else
+ {
+ AssertMsgReturn(wcDelimiter == pClient->PathDelimiter,
+ ("wcDelimiter=%#x PathDelimiter=%#x", wcDelimiter, pClient->PathDelimiter),
+ VERR_INVALID_PARAMETER);
+ }
+
+ SHFLROOT RootTmp;
+ if (!pRoot)
+ pRoot = &RootTmp;
+ if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ {
+ int rc;
+ PRTUTF16 utf16Name;
+
+ rc = RTStrToUtf16((const char *) pszMapName->String.utf8, &utf16Name);
+ if (RT_FAILURE (rc))
+ return rc;
+
+ pFolderMapping = vbsfMappingGetByName(utf16Name, pRoot);
+ RTUtf16Free(utf16Name);
+ }
+ else
+ {
+ pFolderMapping = vbsfMappingGetByName(pszMapName->String.ucs2, pRoot);
+ }
+
+ if (!pFolderMapping)
+ {
+ return VERR_FILE_NOT_FOUND;
+ }
+
+ /*
+ * Check for reference count overflows and settings compatibility.
+ * For paranoid reasons, we don't allow modifying the case sensitivity
+ * setting while there are other mappings of a folder.
+ */
+ AssertLogRelReturn(*pRoot < RT_ELEMENTS(pClient->acMappings), VERR_INTERNAL_ERROR);
+ AssertLogRelReturn(!pClient->fHasMappingCounts || pClient->acMappings[*pRoot] < _32K, VERR_TOO_MANY_OPENS);
+ ASSERT_GUEST_LOGREL_MSG_RETURN( pFolderMapping->cMappings == 0
+ || pFolderMapping->fGuestCaseSensitive == fCaseSensitive,
+ ("Incompatible case sensitivity setting: %s: %u mappings, %ssenitive, requested %ssenitive!\n",
+ pFolderMapping->pszFolderName, pFolderMapping->cMappings,
+ pFolderMapping->fGuestCaseSensitive ? "" : "in", fCaseSensitive ? "" : "in"),
+ VERR_INCOMPATIBLE_CONFIG);
+
+ /*
+ * Go ahead and map it.
+ */
+ if (pClient->fHasMappingCounts)
+ pClient->acMappings[*pRoot] += 1;
+ pFolderMapping->cMappings++;
+ pFolderMapping->fGuestCaseSensitive = fCaseSensitive;
+ Log(("vbsfMmapFolder (cMappings=%u, acMappings[%u]=%u)\n", pFolderMapping->cMappings, *pRoot, pClient->acMappings[*pRoot]));
+ return VINF_SUCCESS;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_UNMAP_FOLDER API. Located here as a form of API
+ * documentation. */
+void testUnmapFolder(RTTEST hTest)
+{
+ /* Unmapping a mapped folder should succeed.
+ * If the folder is not mapped this is only asserted, not signalled. */
+ testUnmapFolderValid(hTest);
+ /* Unmapping a non-existant root should fail. */
+ testUnmapFolderInvalid(hTest);
+ /* If the number or types of parameters are wrong the API should fail. */
+ testUnmapFolderBadParameters(hTest);
+}
+#endif
+int vbsfUnmapFolder(PSHFLCLIENTDATA pClient, SHFLROOT root)
+{
+ RT_NOREF1(pClient);
+ int rc = VINF_SUCCESS;
+
+ MAPPING *pFolderMapping = vbsfMappingGetByRoot(root);
+ if (pFolderMapping == NULL)
+ {
+ AssertFailed();
+ return VERR_FILE_NOT_FOUND;
+ }
+ Assert(pFolderMapping->fValid == true && pFolderMapping->cMappings > 0);
+
+ AssertLogRelReturn(root < RT_ELEMENTS(pClient->acMappings), VERR_INTERNAL_ERROR);
+ AssertLogRelReturn(!pClient->fHasMappingCounts || pClient->acMappings[root] > 0, VERR_INVALID_HANDLE);
+
+ if (pClient->fHasMappingCounts)
+ pClient->acMappings[root] -= 1;
+
+ if (pFolderMapping->cMappings > 0)
+ pFolderMapping->cMappings--;
+
+ uint32_t const cMappings = pFolderMapping->cMappings;
+ if ( cMappings == 0
+ && pFolderMapping->fPlaceholder)
+ {
+ /* Automatically remove, it is not used by the guest anymore. */
+ Assert(pFolderMapping->fMissing);
+ LogRel2(("SharedFolders: unmapping placeholder '%ls' -> '%s'\n",
+ pFolderMapping->pMapName->String.ucs2, pFolderMapping->pszFolderName));
+ vbsfMappingsRemove(pFolderMapping->pMapName);
+ }
+
+ Log(("vbsfUnmapFolder (cMappings=%u, acMappings[%u]=%u)\n", cMappings, root, pClient->acMappings[root]));
+ return rc;
+}
+
+/**
+ * SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES implementation.
+ *
+ * @returns VBox status code.
+ * @retval VINF_SUCCESS on change.
+ * @retval VINF_TRY_AGAIN on resume.
+ * @retval VINF_HGCM_ASYNC_EXECUTE if waiting.
+ * @retval VERR_CANCELLED if cancelled.
+ * @retval VERR_OUT_OF_RESOURCES if there are too many pending waits.
+ *
+ * @param pClient The calling client.
+ * @param hCall The call handle.
+ * @param pParm The parameter (32-bit).
+ * @param fRestored Set if this is a call restored & resubmitted from saved
+ * state.
+ * @since VBox 6.0
+ */
+int vbsfMappingsWaitForChanges(PSHFLCLIENTDATA pClient, VBOXHGCMCALLHANDLE hCall, PVBOXHGCMSVCPARM pParm, bool fRestored)
+{
+ /*
+ * Return immediately if the fodler mappings have changed since last call
+ * or if we got restored from saved state (adding of global folders, etc).
+ */
+ uint32_t uCurVersion = g_uFolderMappingsVersion;
+ if ( pParm->u.uint32 != uCurVersion
+ || fRestored
+ || (pClient->fu32Flags & SHFL_CF_CANCEL_NEXT_WAIT) )
+ {
+ int rc = VINF_SUCCESS;
+ if (pClient->fu32Flags & SHFL_CF_CANCEL_NEXT_WAIT)
+ {
+ pClient->fu32Flags &= ~SHFL_CF_CANCEL_NEXT_WAIT;
+ rc = VERR_CANCELLED;
+ }
+ else if (fRestored)
+ {
+ rc = VINF_TRY_AGAIN;
+ if (pParm->u.uint32 == uCurVersion)
+ uCurVersion = uCurVersion != UINT32_C(0x55555555) ? UINT32_C(0x55555555) : UINT32_C(0x99999999);
+ }
+ Log(("vbsfMappingsWaitForChanges: Version %#x -> %#x, returning %Rrc immediately.\n", pParm->u.uint32, uCurVersion, rc));
+ pParm->u.uint32 = uCurVersion;
+ return rc;
+ }
+
+ /*
+ * Setup a wait if we can.
+ */
+ if (g_cMappingChangeWaiters < 64)
+ {
+ PSHFLMAPPINGSWAIT pWait = (PSHFLMAPPINGSWAIT)RTMemAlloc(sizeof(*pWait));
+ if (pWait)
+ {
+ pWait->pClient = pClient;
+ pWait->hCall = hCall;
+ pWait->pParm = pParm;
+
+ RTListAppend(&g_MappingsChangeWaiters, &pWait->ListEntry);
+ g_cMappingChangeWaiters += 1;
+ return VINF_HGCM_ASYNC_EXECUTE;
+ }
+ return VERR_NO_MEMORY;
+ }
+ LogRelMax(32, ("vbsfMappingsWaitForChanges: Too many threads waiting for changes!\n"));
+ return VERR_OUT_OF_RESOURCES;
+}
+
+/**
+ * SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS implementation.
+ *
+ * @returns VINF_SUCCESS
+ * @param pClient The calling client to cancel all waits for.
+ * @since VBox 6.0
+ */
+int vbsfMappingsCancelChangesWaits(PSHFLCLIENTDATA pClient)
+{
+ uint32_t const uCurVersion = g_uFolderMappingsVersion;
+
+ PSHFLMAPPINGSWAIT pCur, pNext;
+ RTListForEachSafe(&g_MappingsChangeWaiters, pCur, pNext, SHFLMAPPINGSWAIT, ListEntry)
+ {
+ if (pCur->pClient == pClient)
+ {
+ RTListNodeRemove(&pCur->ListEntry);
+ pCur->pParm->u.uint32 = uCurVersion;
+ g_pHelpers->pfnCallComplete(pCur->hCall, VERR_CANCELLED);
+ RTMemFree(pCur);
+ }
+ }
+
+ /* Set a flag to make sure the next SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES doesn't block.
+ This should help deal with races between this call and a thread about to do a wait. */
+ pClient->fu32Flags |= SHFL_CF_CANCEL_NEXT_WAIT;
+
+ return VINF_SUCCESS;
+}
+
+/**
+ * Wakes up all clients waiting on
+ */
+static void vbsfMappingsWakeupAllWaiters(void)
+{
+ uint32_t const uCurVersion = ++g_uFolderMappingsVersion;
+
+ PSHFLMAPPINGSWAIT pCur, pNext;
+ RTListForEachSafe(&g_MappingsChangeWaiters, pCur, pNext, SHFLMAPPINGSWAIT, ListEntry)
+ {
+ RTListNodeRemove(&pCur->ListEntry);
+ pCur->pParm->u.uint32 = uCurVersion;
+ g_pHelpers->pfnCallComplete(pCur->hCall, VERR_CANCELLED);
+ RTMemFree(pCur);
+ }
+}
+
diff --git a/src/VBox/HostServices/SharedFolders/mappings.h b/src/VBox/HostServices/SharedFolders/mappings.h
new file mode 100644
index 00000000..11840835
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/mappings.h
@@ -0,0 +1,80 @@
+/* $Id: mappings.h $ */
+/** @file
+ * Shared folders service - Mappings header.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_mappings_h
+#define VBOX_INCLUDED_SRC_SharedFolders_mappings_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "shfl.h"
+#include <VBox/shflsvc.h>
+
+typedef struct
+{
+ char *pszFolderName; /**< Directory at the host to share with the guest. */
+ PSHFLSTRING pMapName; /**< Share name for the guest. */
+ uint32_t cMappings; /**< Number of mappings. */
+ bool fValid; /**< Mapping entry is used/valid. */
+ bool fHostCaseSensitive; /**< Host file name space is case-sensitive. */
+ bool fGuestCaseSensitive; /**< Guest file name space is case-sensitive. */
+ bool fWritable; /**< Folder is writable for the guest. */
+ PSHFLSTRING pAutoMountPoint; /**< Where the guest should try auto-mount the folder. */
+ bool fAutoMount; /**< Folder will be auto-mounted by the guest. */
+ bool fSymlinksCreate; /**< Guest is able to create symlinks. */
+ bool fMissing; /**< Mapping not invalid but host path does not exist.
+ Any guest operation on such a folder fails! */
+ bool fPlaceholder; /**< Mapping does not exist in the VM settings but the guest
+ still has. fMissing is always true for this mapping. */
+ bool fLoadedRootId; /**< Set if vbsfMappingLoaded has found this mapping already. */
+} MAPPING;
+/** Pointer to a MAPPING structure. */
+typedef MAPPING *PMAPPING;
+
+void vbsfMappingInit(void);
+
+bool vbsfMappingQuery(uint32_t iMapping, PMAPPING *pMapping);
+
+int vbsfMappingsAdd(const char *pszFolderName, PSHFLSTRING pMapName, bool fWritable,
+ bool fAutoMount, PSHFLSTRING pAutoMountPoint, bool fCreateSymlinks, bool fMissing, bool fPlaceholder);
+int vbsfMappingsRemove(PSHFLSTRING pMapName);
+
+int vbsfMappingsQuery(PSHFLCLIENTDATA pClient, bool fOnlyAutoMounts, PSHFLMAPPING pMappings, uint32_t *pcMappings);
+int vbsfMappingsQueryName(PSHFLCLIENTDATA pClient, SHFLROOT root, SHFLSTRING *pString);
+int vbsfMappingsQueryWritable(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fWritable);
+int vbsfMappingsQueryAutoMount(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fAutoMount);
+int vbsfMappingsQuerySymlinksCreate(PSHFLCLIENTDATA pClient, SHFLROOT root, bool *fSymlinksCreate);
+int vbsfMappingsQueryInfo(PSHFLCLIENTDATA pClient, SHFLROOT root, PSHFLSTRING pNameBuf, PSHFLSTRING pMntPtBuf,
+ uint64_t *pfFlags, uint32_t *puVersion);
+
+int vbsfMapFolder(PSHFLCLIENTDATA pClient, PSHFLSTRING pszMapName, RTUTF16 delimiter,
+ bool fCaseSensitive, SHFLROOT *pRoot);
+int vbsfUnmapFolder(PSHFLCLIENTDATA pClient, SHFLROOT root);
+
+int vbsfMappingsWaitForChanges(PSHFLCLIENTDATA pClient, VBOXHGCMCALLHANDLE hCall, PVBOXHGCMSVCPARM pParm, bool fRestored);
+int vbsfMappingsCancelChangesWaits(PSHFLCLIENTDATA pClient);
+
+const char* vbsfMappingsQueryHostRoot(SHFLROOT root);
+int vbsfMappingsQueryHostRootEx(SHFLROOT hRoot, const char **ppszRoot, uint32_t *pcbRootLen);
+bool vbsfIsGuestMappingCaseSensitive(SHFLROOT root);
+bool vbsfIsHostMappingCaseSensitive(SHFLROOT root);
+
+int vbsfMappingLoaded(MAPPING const *pLoadedMapping, SHFLROOT root);
+PMAPPING vbsfMappingGetByRoot(SHFLROOT root);
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_mappings_h */
+
diff --git a/src/VBox/HostServices/SharedFolders/shfl.h b/src/VBox/HostServices/SharedFolders/shfl.h
new file mode 100644
index 00000000..fa120af2
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/shfl.h
@@ -0,0 +1,73 @@
+/** @file
+ * Shared Folders: Main header - Common data and function prototypes definitions.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_shfl_h
+#define VBOX_INCLUDED_SRC_SharedFolders_shfl_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <VBox/err.h>
+#include <VBox/hgcmsvc.h>
+#include <VBox/shflsvc.h>
+
+#include <VBox/log.h>
+
+/**
+ * Shared Folders client flags.
+ * @{
+ */
+
+/** Client has queried mappings at least once and, therefore,
+ * the service can process its other requests too.
+ */
+#define SHFL_CF_MAPPINGS_QUERIED (0x00000001)
+
+/** Mappings have been changed since last query. */
+#define SHFL_CF_MAPPINGS_CHANGED (0x00000002)
+
+/** Client uses UTF8 encoding, if not set then unicode 16 bit (UCS2) is used. */
+#define SHFL_CF_UTF8 (0x00000004)
+
+/** Client both supports and wants to use symlinks. */
+#define SHFL_CF_SYMLINKS (0x00000008)
+
+/** The call to SHFL_FN_WAIT_FOR_MAPPINGS_CHANGES will return immediately
+ * because of a SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS call. */
+#define SHFL_CF_CANCEL_NEXT_WAIT (0x00000010)
+
+/** @} */
+
+typedef struct _SHFLCLIENTDATA
+{
+ /** Client flags */
+ uint32_t fu32Flags;
+ /** Path delimiter. */
+ RTUTF16 PathDelimiter;
+ /** Currently unused. */
+ uint8_t bPadding;
+ /** Set if the client has mapping usage counts.
+ * This is for helping with saved state. */
+ uint8_t fHasMappingCounts;
+ /** Mapping counts for each root ID so we can unmap the folders when the
+ * session disconnects or the VM resets. */
+ uint16_t acMappings[SHFL_MAX_MAPPINGS];
+} SHFLCLIENTDATA;
+/** Pointer to a SHFLCLIENTDATA structure. */
+typedef SHFLCLIENTDATA *PSHFLCLIENTDATA;
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_shfl_h */
+
diff --git a/src/VBox/HostServices/SharedFolders/shflhandle.cpp b/src/VBox/HostServices/SharedFolders/shflhandle.cpp
new file mode 100644
index 00000000..ece13819
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/shflhandle.cpp
@@ -0,0 +1,226 @@
+/* $Id: shflhandle.cpp $ */
+/** @file
+ * Shared Folders Service - Handles helper functions.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
+#include "shflhandle.h"
+#include <iprt/alloc.h>
+#include <iprt/assert.h>
+#include <iprt/critsect.h>
+
+
+/*********************************************************************************************************************************
+* Structures and Typedefs *
+*********************************************************************************************************************************/
+/**
+ * Very basic and primitive handle management. Should be sufficient for our needs.
+ * Handle allocation can be rather slow, but at least lookup is fast.
+ */
+typedef struct
+{
+ uint32_t uFlags;
+ uintptr_t pvUserData;
+ PSHFLCLIENTDATA pClient;
+} SHFLINTHANDLE, *PSHFLINTHANDLE;
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+static SHFLINTHANDLE *g_pHandles = NULL;
+static int32_t gLastHandleIndex = 0;
+static RTCRITSECT gLock;
+
+
+int vbsfInitHandleTable()
+{
+ g_pHandles = (SHFLINTHANDLE *)RTMemAllocZ (sizeof (SHFLINTHANDLE) * SHFLHANDLE_MAX);
+ if (!g_pHandles)
+ {
+ AssertFailed();
+ return VERR_NO_MEMORY;
+ }
+
+ /* Never return handle 0 */
+ g_pHandles[0].uFlags = SHFL_HF_TYPE_DONTUSE;
+ gLastHandleIndex = 1;
+
+ return RTCritSectInit(&gLock);
+}
+
+int vbsfFreeHandleTable()
+{
+ if (g_pHandles)
+ RTMemFree(g_pHandles);
+
+ g_pHandles = NULL;
+
+ if (RTCritSectIsInitialized(&gLock))
+ RTCritSectDelete(&gLock);
+
+ return VINF_SUCCESS;
+}
+
+SHFLHANDLE vbsfAllocHandle(PSHFLCLIENTDATA pClient, uint32_t uType,
+ uintptr_t pvUserData)
+{
+ SHFLHANDLE handle;
+
+ Assert((uType & SHFL_HF_TYPE_MASK) != 0 && pvUserData);
+
+ RTCritSectEnter(&gLock);
+
+ /* Find next free handle */
+ if (gLastHandleIndex >= SHFLHANDLE_MAX-1)
+ gLastHandleIndex = 1;
+
+ /* Nice linear search */
+ for(handle=gLastHandleIndex;handle<SHFLHANDLE_MAX;handle++)
+ {
+ if (g_pHandles[handle].pvUserData == 0)
+ {
+ gLastHandleIndex = handle;
+ break;
+ }
+ }
+
+ if (handle == SHFLHANDLE_MAX)
+ {
+ /* Try once more from the start */
+ for(handle=1;handle<SHFLHANDLE_MAX;handle++)
+ {
+ if (g_pHandles[handle].pvUserData == 0)
+ {
+ gLastHandleIndex = handle;
+ break;
+ }
+ }
+ if (handle == SHFLHANDLE_MAX)
+ {
+ /* Out of handles */
+ RTCritSectLeave(&gLock);
+ AssertFailed();
+ return SHFL_HANDLE_NIL;
+ }
+ }
+ g_pHandles[handle].uFlags = (uType & SHFL_HF_TYPE_MASK) | SHFL_HF_VALID;
+ g_pHandles[handle].pvUserData = pvUserData;
+ g_pHandles[handle].pClient = pClient;
+
+ gLastHandleIndex++;
+
+ RTCritSectLeave(&gLock);
+
+ return handle;
+}
+
+static int vbsfFreeHandle(PSHFLCLIENTDATA pClient, SHFLHANDLE handle)
+{
+ if ( handle < SHFLHANDLE_MAX
+ && (g_pHandles[handle].uFlags & SHFL_HF_VALID)
+ && g_pHandles[handle].pClient == pClient)
+ {
+ g_pHandles[handle].uFlags = 0;
+ g_pHandles[handle].pvUserData = 0;
+ g_pHandles[handle].pClient = 0;
+ return VINF_SUCCESS;
+ }
+ return VERR_INVALID_HANDLE;
+}
+
+uintptr_t vbsfQueryHandle(PSHFLCLIENTDATA pClient, SHFLHANDLE handle,
+ uint32_t uType)
+{
+ if ( handle < SHFLHANDLE_MAX
+ && (g_pHandles[handle].uFlags & SHFL_HF_VALID)
+ && g_pHandles[handle].pClient == pClient)
+ {
+ Assert((uType & SHFL_HF_TYPE_MASK) != 0);
+
+ if (g_pHandles[handle].uFlags & uType)
+ return g_pHandles[handle].pvUserData;
+ }
+ return 0;
+}
+
+SHFLFILEHANDLE *vbsfQueryFileHandle(PSHFLCLIENTDATA pClient, SHFLHANDLE handle)
+{
+ return (SHFLFILEHANDLE *)vbsfQueryHandle(pClient, handle,
+ SHFL_HF_TYPE_FILE);
+}
+
+SHFLFILEHANDLE *vbsfQueryDirHandle(PSHFLCLIENTDATA pClient, SHFLHANDLE handle)
+{
+ return (SHFLFILEHANDLE *)vbsfQueryHandle(pClient, handle,
+ SHFL_HF_TYPE_DIR);
+}
+
+uint32_t vbsfQueryHandleType(PSHFLCLIENTDATA pClient, SHFLHANDLE handle)
+{
+ if ( handle < SHFLHANDLE_MAX
+ && (g_pHandles[handle].uFlags & SHFL_HF_VALID)
+ && g_pHandles[handle].pClient == pClient)
+ return g_pHandles[handle].uFlags & SHFL_HF_TYPE_MASK;
+
+ return 0;
+}
+
+SHFLHANDLE vbsfAllocDirHandle(PSHFLCLIENTDATA pClient)
+{
+ SHFLFILEHANDLE *pHandle = (SHFLFILEHANDLE *)RTMemAllocZ (sizeof (SHFLFILEHANDLE));
+
+ if (pHandle)
+ {
+ pHandle->Header.u32Flags = SHFL_HF_TYPE_DIR;
+ return vbsfAllocHandle(pClient, pHandle->Header.u32Flags,
+ (uintptr_t)pHandle);
+ }
+
+ return SHFL_HANDLE_NIL;
+}
+
+SHFLHANDLE vbsfAllocFileHandle(PSHFLCLIENTDATA pClient)
+{
+ SHFLFILEHANDLE *pHandle = (SHFLFILEHANDLE *)RTMemAllocZ (sizeof (SHFLFILEHANDLE));
+
+ if (pHandle)
+ {
+ pHandle->Header.u32Flags = SHFL_HF_TYPE_FILE;
+ return vbsfAllocHandle(pClient, pHandle->Header.u32Flags,
+ (uintptr_t)pHandle);
+ }
+
+ return SHFL_HANDLE_NIL;
+}
+
+void vbsfFreeFileHandle(PSHFLCLIENTDATA pClient, SHFLHANDLE hHandle)
+{
+ SHFLFILEHANDLE *pHandle = (SHFLFILEHANDLE *)vbsfQueryHandle(pClient,
+ hHandle, SHFL_HF_TYPE_DIR|SHFL_HF_TYPE_FILE);
+
+ if (pHandle)
+ {
+ vbsfFreeHandle(pClient, hHandle);
+ RTMemFree (pHandle);
+ }
+ else
+ AssertFailed();
+}
+
diff --git a/src/VBox/HostServices/SharedFolders/shflhandle.h b/src/VBox/HostServices/SharedFolders/shflhandle.h
new file mode 100644
index 00000000..c300996c
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/shflhandle.h
@@ -0,0 +1,80 @@
+/* $Id: shflhandle.h $ */
+/** @file
+ * Shared Folders Host Service - Handles helper functions header.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_shflhandle_h
+#define VBOX_INCLUDED_SRC_SharedFolders_shflhandle_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "shfl.h"
+#include <VBox/shflsvc.h>
+#include <iprt/dir.h>
+
+#define SHFL_HF_TYPE_MASK (0x000000FF)
+#define SHFL_HF_TYPE_DIR (0x00000001)
+#define SHFL_HF_TYPE_FILE (0x00000002)
+#define SHFL_HF_TYPE_VOLUME (0x00000004)
+#define SHFL_HF_TYPE_DONTUSE (0x00000080)
+
+#define SHFL_HF_VALID (0x80000000)
+
+#define SHFLHANDLE_MAX (4096)
+
+typedef struct _SHFLHANDLEHDR
+{
+ uint32_t u32Flags;
+} SHFLHANDLEHDR;
+
+#define ShflHandleType(__Handle) BIT_FLAG(((SHFLHANDLEHDR *)(__Handle))->u32Flags, SHFL_HF_TYPE_MASK)
+
+typedef struct _SHFLFILEHANDLE
+{
+ SHFLHANDLEHDR Header;
+ SHFLROOT root; /* Where the handle has been opened. */
+ union
+ {
+ struct
+ {
+ RTFILE Handle;
+ } file;
+ struct
+ {
+ RTDIR Handle;
+ RTDIR SearchHandle;
+ PRTDIRENTRYEX pLastValidEntry; /* last found file in a directory search */
+ } dir;
+ };
+} SHFLFILEHANDLE;
+
+
+SHFLHANDLE vbsfAllocDirHandle(PSHFLCLIENTDATA pClient);
+SHFLHANDLE vbsfAllocFileHandle(PSHFLCLIENTDATA pClient);
+void vbsfFreeFileHandle (PSHFLCLIENTDATA pClient, SHFLHANDLE hHandle);
+
+
+int vbsfInitHandleTable();
+int vbsfFreeHandleTable();
+SHFLHANDLE vbsfAllocHandle(PSHFLCLIENTDATA pClient, uint32_t uType,
+ uintptr_t pvUserData);
+SHFLFILEHANDLE *vbsfQueryFileHandle(PSHFLCLIENTDATA pClient,
+ SHFLHANDLE handle);
+SHFLFILEHANDLE *vbsfQueryDirHandle(PSHFLCLIENTDATA pClient, SHFLHANDLE handle);
+uint32_t vbsfQueryHandleType(PSHFLCLIENTDATA pClient,
+ SHFLHANDLE handle);
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_shflhandle_h */
diff --git a/src/VBox/HostServices/SharedFolders/testcase/Makefile.kmk b/src/VBox/HostServices/SharedFolders/testcase/Makefile.kmk
new file mode 100644
index 00000000..7096d4e8
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/testcase/Makefile.kmk
@@ -0,0 +1,94 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the Shared Folders Host Service testcases.
+#
+
+#
+# Copyright (C) 2006-2019 Oracle Corporation
+#
+# This file is part of VirtualBox Open Source Edition (OSE), as
+# available from http://www.virtualbox.org. This file is free software;
+# you can redistribute it and/or modify it under the terms of the GNU
+# General Public License (GPL) as published by the Free Software
+# Foundation, in version 2 as it comes in the "COPYING" file of the
+# VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+# hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+#
+
+SUB_DEPTH = ../../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+#
+# Structure size testcase.
+#
+PROGRAMS += tstShflSizes
+TESTING += $(tstShflSizes_0_OUTDIR)/tstShflSizes.run
+ifndef VBOX_ONLY_SDK
+ ifeq ($(KBUILD_TARGET),$(KBUILD_HOST))
+ if1of ($(KBUILD_TARGET_ARCH).$(KBUILD_HOST_ARCH), x86.x86 amd64.amd64 x86.amd64)
+ OTHERS += $(tstShflSizes_0_OUTDIR)/tstShflSizes.run
+ endif
+ endif
+endif
+tstShflSizes_TEMPLATE = VBOXR3AUTOTST
+tstShflSizes_DEFS = VBOX_WITH_HGCM
+tstShflSizes_SOURCES = tstShflSizes.cpp
+tstShflSizes_CLEAN = $(tstShflSizes_0_OUTDIR)/tstShflSizes.run
+
+$$(tstShflSizes_0_OUTDIR)/tstShflSizes.run: $$(tstShflSizes_1_STAGE_TARGET)
+ $(tstShflSizes_1_STAGE_TARGET) quiet
+ $(QUIET)$(APPEND) -t "$@" "done"
+
+
+ifdef VBOX_WITH_TESTCASES
+#
+# Case conversion testcase.
+#
+PROGRAMS += tstShflCase
+tstShflCase_TEMPLATE = VBOXR3TSTEXE
+tstShflCase_DEFS = VBOX_WITH_HGCM
+tstShflCase_SOURCES = tstShflCase.cpp
+tstShflCase_LIBS = $(LIB_RUNTIME)
+
+#
+# HGCM service testcase.
+#
+
+PROGRAMS += tstSharedFolderService
+tstSharedFolderService_TEMPLATE = VBOXR3TSTEXE
+tstSharedFolderService_DEFS = VBOX_WITH_HGCM UNITTEST
+tstSharedFolderService_INCS = ..
+tstSharedFolderService_SOURCES = \
+ tstSharedFolderService.cpp \
+ ../mappings.cpp \
+ ../VBoxSharedFoldersSvc.cpp \
+ ../shflhandle.cpp \
+ ../vbsfpathabs.cpp \
+ ../vbsfpath.cpp \
+ ../vbsf.cpp
+tstSharedFolderService_LDFLAGS.darwin = \
+ -framework Carbon
+tstSharedFolderService_LIBS = $(LIB_RUNTIME)
+
+if 0 # Cannot define two RT_OS_XXX macros!
+# As there are differences between the Windows build of the service and others,
+# we do an additional build with RT_OS_WINDOWS defined on non-Windows targets.
+PROGRAMS += \
+ tstSharedFolderService \
+ $(if $(eq $(KBUILD_TARGET),win),,tstSharedFolderService-win)
+tstSharedFolderService-win_TEMPLATE = $(tstSharedFolderService_TEMPLATE)
+tstSharedFolderService-win_DEFS = \
+ $(tstSharedFolderService_DEFS) \
+ RT_OS_WINDOWS
+tstSharedFolderService-win_INCS = $(tstSharedFolderService_INCS)
+tstSharedFolderService-win_SOURCES = $(tstSharedFolderService_SOURCES)
+tstSharedFolderService-win_LDFLAGS.darwin = \
+ $(tstSharedFolderService_LDFLAGS.darwin)
+tstSharedFolderService-win_LIBS = $(tstSharedFolderService_LIBS)
+endif
+
+endif # VBOX_WITH_TESTCASES
+
+
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp b/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp
new file mode 100644
index 00000000..9706ded0
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.cpp
@@ -0,0 +1,1332 @@
+/* $Id: tstSharedFolderService.cpp $ */
+/** @file
+ * Testcase for the shared folder service vbsf API.
+ *
+ * Note that this is still very threadbare (there is an awful lot which should
+ * really be tested, but it already took too long to produce this much). The
+ * idea is that anyone who makes changes to the shared folders service and who
+ * cares about unit testing them should add tests to the skeleton framework to
+ * exercise the bits they change before and after changing them.
+ */
+
+/*
+ * Copyright (C) 2011-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+
+#include "tstSharedFolderService.h"
+#include "vbsf.h"
+
+#include <iprt/fs.h>
+#include <iprt/dir.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+#include <iprt/symlink.h>
+#include <iprt/stream.h>
+#include <iprt/test.h>
+#include <iprt/string.h>
+#include <iprt/utf16.h>
+
+#include "teststubs.h"
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+static RTTEST g_hTest = NIL_RTTEST;
+
+
+/*********************************************************************************************************************************
+* Declarations *
+*********************************************************************************************************************************/
+extern "C" DECLCALLBACK(DECLEXPORT(int)) VBoxHGCMSvcLoad (VBOXHGCMSVCFNTABLE *ptable);
+
+
+/*********************************************************************************************************************************
+* Helpers *
+*********************************************************************************************************************************/
+
+/** Simple call handle structure for the guest call completion callback */
+struct VBOXHGCMCALLHANDLE_TYPEDEF
+{
+ /** Where to store the result code */
+ int32_t rc;
+};
+
+/** Call completion callback for guest calls. */
+static DECLCALLBACK(int) callComplete(VBOXHGCMCALLHANDLE callHandle, int32_t rc)
+{
+ callHandle->rc = rc;
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) stamRegisterV(void *pvInstance, void *pvSample, STAMTYPE enmType, STAMVISIBILITY enmVisibility,
+ STAMUNIT enmUnit, const char *pszDesc, const char *pszName, va_list va)
+{
+ RT_NOREF(pvInstance, pvSample, enmType, enmVisibility, enmUnit, pszDesc, pszName, va);
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) stamDeregisterV(void *pvInstance, const char *pszPatFmt, va_list va)
+{
+ RT_NOREF(pvInstance, pszPatFmt, va);
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) infoRegister(void *pvInstance, const char *pszName, const char *pszDesc,
+ PFNDBGFHANDLEREXT pfnHandler, void *pvUser)
+{
+ RT_NOREF(pvInstance, pszName, pszDesc, pfnHandler, pvUser);
+ return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) infoDeregister(void *pvInstance, const char *pszName)
+{
+ RT_NOREF(pvInstance, pszName);
+ return VINF_SUCCESS;
+}
+
+/**
+ * Initialise the HGCM service table as much as we need to start the
+ * service
+ * @param pTable the table to initialise
+ */
+void initTable(VBOXHGCMSVCFNTABLE *pTable, VBOXHGCMSVCHELPERS *pHelpers)
+{
+ pTable->cbSize = sizeof (VBOXHGCMSVCFNTABLE);
+ pTable->u32Version = VBOX_HGCM_SVC_VERSION;
+ pHelpers->pfnCallComplete = callComplete;
+ pHelpers->pfnStamRegisterV = stamRegisterV;
+ pHelpers->pfnStamDeregisterV = stamDeregisterV;
+ pHelpers->pfnInfoRegister = infoRegister;
+ pHelpers->pfnInfoDeregister = infoDeregister;
+ pTable->pHelpers = pHelpers;
+}
+
+#define LLUIFY(a) ((unsigned long long)(a))
+
+static void bufferFromString(void *pvDest, size_t cb, const char *pcszSrc)
+{
+ char *pchDest = (char *)pvDest;
+
+ Assert((cb) > 0);
+ strncpy((pchDest), (pcszSrc), (cb) - 1);
+ (pchDest)[(cb) - 1] = 0;
+}
+
+static void bufferFromPath(void *pvDest, size_t cb, const char *pcszSrc)
+{
+ char *psz;
+
+ bufferFromString(pvDest, cb, pcszSrc);
+ for (psz = (char *)pvDest; psz && psz < (char *)pvDest + cb; ++psz)
+ if (*psz == '\\')
+ *psz = '/';
+}
+
+#define ARRAY_FROM_PATH(a, b) \
+ do { \
+ void *p=(a); NOREF(p); \
+ Assert((a) == p); /* Constant parameter */ \
+ Assert(sizeof((a)) > 0); \
+ bufferFromPath(a, sizeof(a), b); \
+ } while (0)
+
+
+/*********************************************************************************************************************************
+* Stub functions and data *
+*********************************************************************************************************************************/
+static bool g_fFailIfNotLowercase = false;
+
+static RTDIR g_testRTDirClose_hDir = NIL_RTDIR;
+
+extern int testRTDirClose(RTDIR hDir)
+{
+ /* RTPrintf("%s: hDir=%p\n", __PRETTY_FUNCTION__, hDir); */
+ g_testRTDirClose_hDir = hDir;
+ return VINF_SUCCESS;
+}
+
+static char testRTDirCreatePath[256];
+//static RTFMODE testRTDirCreateMode; - unused
+
+extern int testRTDirCreate(const char *pszPath, RTFMODE fMode, uint32_t fCreate)
+{
+ RT_NOREF2(fMode, fCreate);
+ /* RTPrintf("%s: pszPath=%s, fMode=0x%llx\n", __PRETTY_FUNCTION__, pszPath,
+ LLUIFY(fMode)); */
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ ARRAY_FROM_PATH(testRTDirCreatePath, pszPath);
+ return 0;
+}
+
+static char testRTDirOpenName[256];
+static struct TESTDIRHANDLE
+{
+ int iEntry;
+ int iDir;
+} g_aTestDirHandles[4];
+static int g_iNextDirHandle = 0;
+static RTDIR testRTDirOpen_hDir;
+
+extern int testRTDirOpen(RTDIR *phDir, const char *pszPath)
+{
+ /* RTPrintf("%s: pszPath=%s\n", __PRETTY_FUNCTION__, pszPath); */
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ ARRAY_FROM_PATH(testRTDirOpenName, pszPath);
+ *phDir = testRTDirOpen_hDir;
+ testRTDirOpen_hDir = NIL_RTDIR;
+ if (!*phDir && g_fFailIfNotLowercase)
+ *phDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
+ if (*phDir)
+ {
+ struct TESTDIRHANDLE *pRealDir = (struct TESTDIRHANDLE *)*phDir;
+ pRealDir->iEntry = 0;
+ pRealDir->iDir = 0;
+ const char *pszSlash = pszPath - 1;
+ while ((pszSlash = strpbrk(pszSlash + 1, "\\/")) != NULL)
+ pRealDir->iDir += 1;
+ /*RTPrintf("opendir %s = %d \n", pszPath, pRealDir->iDir);*/
+ }
+ return VINF_SUCCESS;
+}
+
+/** @todo Do something useful with the last two arguments. */
+extern int testRTDirOpenFiltered(RTDIR *phDir, const char *pszPath, RTDIRFILTER, uint32_t)
+{
+ /* RTPrintf("%s: pszPath=%s\n", __PRETTY_FUNCTION__, pszPath); */
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ ARRAY_FROM_PATH(testRTDirOpenName, pszPath);
+ *phDir = testRTDirOpen_hDir;
+ testRTDirOpen_hDir = NIL_RTDIR;
+ if (!*phDir && g_fFailIfNotLowercase)
+ *phDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
+ if (*phDir)
+ {
+ struct TESTDIRHANDLE *pRealDir = (struct TESTDIRHANDLE *)*phDir;
+ pRealDir->iEntry = 0;
+ pRealDir->iDir = 0;
+ const char *pszSlash = pszPath - 1;
+ while ((pszSlash = strpbrk(pszSlash + 1, "\\/")) != NULL)
+ pRealDir->iDir += 1;
+ pRealDir->iDir -= 1;
+ /*RTPrintf("openfiltered %s = %d\n", pszPath, pRealDir->iDir);*/
+ }
+ return VINF_SUCCESS;
+}
+
+static RTDIR g_testRTDirQueryInfo_hDir;
+static RTTIMESPEC testRTDirQueryInfoATime;
+
+extern int testRTDirQueryInfo(RTDIR hDir, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
+{
+ RT_NOREF1(enmAdditionalAttribs);
+ /* RTPrintf("%s: hDir=%p, enmAdditionalAttribs=0x%llx\n", __PRETTY_FUNCTION__,
+ hDir, LLUIFY(enmAdditionalAttribs)); */
+ g_testRTDirQueryInfo_hDir = hDir;
+ RT_ZERO(*pObjInfo);
+ pObjInfo->AccessTime = testRTDirQueryInfoATime;
+ RT_ZERO(testRTDirQueryInfoATime);
+ return VINF_SUCCESS;
+}
+
+extern int testRTDirRemove(const char *pszPath)
+{
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ RTPrintf("%s\n", __PRETTY_FUNCTION__);
+ return 0;
+}
+
+static RTDIR g_testRTDirReadEx_hDir;
+
+extern int testRTDirReadEx(RTDIR hDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
+ RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
+{
+ RT_NOREF4(pDirEntry, pcbDirEntry, enmAdditionalAttribs, fFlags);
+ /* RTPrintf("%s: hDir=%p, pcbDirEntry=%d, enmAdditionalAttribs=%llu, fFlags=0x%llx\n",
+ __PRETTY_FUNCTION__, hDir, pcbDirEntry ? (int) *pcbDirEntry : -1,
+ LLUIFY(enmAdditionalAttribs), LLUIFY(fFlags)); */
+ g_testRTDirReadEx_hDir = hDir;
+ if (g_fFailIfNotLowercase && hDir != NIL_RTDIR)
+ {
+ struct TESTDIRHANDLE *pRealDir = (struct TESTDIRHANDLE *)hDir;
+ if (pRealDir->iDir == 2) /* /test/mapping/ */
+ {
+ if (pRealDir->iEntry == 0)
+ {
+ pRealDir->iEntry++;
+ RT_ZERO(*pDirEntry);
+ pDirEntry->Info.Attr.fMode = RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | RTFS_UNIX_IROTH | RTFS_UNIX_IXOTH;
+ pDirEntry->cbName = 4;
+ pDirEntry->cwcShortName = 4;
+ strcpy(pDirEntry->szName, "test");
+ RTUtf16CopyAscii(pDirEntry->wszShortName, RT_ELEMENTS(pDirEntry->wszShortName), "test");
+ /*RTPrintf("readdir: 'test'\n");*/
+ return VINF_SUCCESS;
+ }
+ }
+ else if (pRealDir->iDir == 3) /* /test/mapping/test/ */
+ {
+ if (pRealDir->iEntry == 0)
+ {
+ pRealDir->iEntry++;
+ RT_ZERO(*pDirEntry);
+ pDirEntry->Info.Attr.fMode = RTFS_TYPE_FILE | RTFS_DOS_NT_NORMAL | RTFS_UNIX_IROTH | RTFS_UNIX_IXOTH;
+ pDirEntry->cbName = 4;
+ pDirEntry->cwcShortName = 4;
+ strcpy(pDirEntry->szName, "file");
+ RTUtf16CopyAscii(pDirEntry->wszShortName, RT_ELEMENTS(pDirEntry->wszShortName), "file");
+ /*RTPrintf("readdir: 'file'\n");*/
+ return VINF_SUCCESS;
+ }
+ }
+ /*else RTPrintf("%s: iDir=%d\n", pRealDir->iDir);*/
+ }
+ return VERR_NO_MORE_FILES;
+}
+
+static RTTIMESPEC testRTDirSetTimesATime;
+
+extern int testRTDirSetTimes(RTDIR hDir, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+ PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+ RT_NOREF4(hDir, pModificationTime, pChangeTime, pBirthTime);
+ /* RTPrintf("%s: hDir=%p, *pAccessTime=%lli, *pModificationTime=%lli, *pChangeTime=%lli, *pBirthTime=%lli\n",
+ __PRETTY_FUNCTION__, hDir,
+ pAccessTime ? (long long)RTTimeSpecGetNano(pAccessTime) : -1,
+ pModificationTime
+ ? (long long)RTTimeSpecGetNano(pModificationTime) : -1,
+ pChangeTime ? (long long)RTTimeSpecGetNano(pChangeTime) : -1,
+ pBirthTime ? (long long)RTTimeSpecGetNano(pBirthTime) : -1); */
+ if (pAccessTime)
+ testRTDirSetTimesATime = *pAccessTime;
+ else
+ RT_ZERO(testRTDirSetTimesATime);
+ return VINF_SUCCESS;
+}
+
+static RTFILE g_testRTFileCloseFile;
+
+extern int testRTFileClose(RTFILE File)
+{
+ /* RTPrintf("%s: File=%p\n", __PRETTY_FUNCTION__, File); */
+ g_testRTFileCloseFile = File;
+ return 0;
+}
+
+extern int testRTFileDelete(const char *pszFilename)
+{
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszFilename, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ RTPrintf("%s\n", __PRETTY_FUNCTION__);
+ return 0;
+}
+
+static RTFILE g_testRTFileFlushFile;
+
+extern int testRTFileFlush(RTFILE File)
+{
+ /* RTPrintf("%s: File=%p\n", __PRETTY_FUNCTION__, File); */
+ g_testRTFileFlushFile = File;
+ return VINF_SUCCESS;
+}
+
+static RTFILE g_testRTFileLockFile;
+static unsigned testRTFileLockfLock;
+static int64_t testRTFileLockOffset;
+static uint64_t testRTFileLockSize;
+
+extern int testRTFileLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock)
+{
+ /* RTPrintf("%s: hFile=%p, fLock=%u, offLock=%lli, cbLock=%llu\n",
+ __PRETTY_FUNCTION__, hFile, fLock, (long long) offLock,
+ LLUIFY(cbLock)); */
+ g_testRTFileLockFile = hFile;
+ testRTFileLockfLock = fLock;
+ testRTFileLockOffset = offLock;
+ testRTFileLockSize = cbLock;
+ return VINF_SUCCESS;
+}
+
+static char testRTFileOpenName[256];
+static uint64_t testRTFileOpenFlags;
+static RTFILE testRTFileOpenpFile;
+
+extern int testRTFileOpen(PRTFILE pFile, const char *pszFilename, uint64_t fOpen)
+{
+ /* RTPrintf("%s, pszFilename=%s, fOpen=0x%llx\n", __PRETTY_FUNCTION__,
+ pszFilename, LLUIFY(fOpen)); */
+ ARRAY_FROM_PATH(testRTFileOpenName, pszFilename);
+ testRTFileOpenFlags = fOpen;
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszFilename, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ *pFile = testRTFileOpenpFile;
+ testRTFileOpenpFile = 0;
+ return VINF_SUCCESS;
+}
+
+static RTFILE g_testRTFileQueryInfoFile;
+static RTTIMESPEC testRTFileQueryInfoATime;
+static uint32_t testRTFileQueryInfoFMode;
+
+extern int testRTFileQueryInfo(RTFILE hFile, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
+{
+ RT_NOREF1(enmAdditionalAttribs);
+ /* RTPrintf("%s, hFile=%p, enmAdditionalAttribs=0x%llx\n",
+ __PRETTY_FUNCTION__, hFile, LLUIFY(enmAdditionalAttribs)); */
+ g_testRTFileQueryInfoFile = hFile;
+ RT_ZERO(*pObjInfo);
+ pObjInfo->AccessTime = testRTFileQueryInfoATime;
+ RT_ZERO(testRTDirQueryInfoATime);
+ pObjInfo->Attr.fMode = testRTFileQueryInfoFMode;
+ testRTFileQueryInfoFMode = 0;
+ return VINF_SUCCESS;
+}
+
+static const char *testRTFileReadData;
+
+extern int testRTFileRead(RTFILE File, void *pvBuf, size_t cbToRead, size_t *pcbRead)
+{
+ RT_NOREF1(File);
+ /* RTPrintf("%s : File=%p, cbToRead=%llu\n", __PRETTY_FUNCTION__, File,
+ LLUIFY(cbToRead)); */
+ bufferFromPath(pvBuf, cbToRead, testRTFileReadData);
+ if (pcbRead)
+ *pcbRead = RT_MIN(cbToRead, strlen(testRTFileReadData) + 1);
+ testRTFileReadData = 0;
+ return VINF_SUCCESS;
+}
+
+extern int testRTFileSeek(RTFILE hFile, int64_t offSeek, unsigned uMethod, uint64_t *poffActual)
+{
+ RT_NOREF3(hFile, offSeek, uMethod);
+ /* RTPrintf("%s : hFile=%p, offSeek=%llu, uMethod=%u\n", __PRETTY_FUNCTION__,
+ hFile, LLUIFY(offSeek), uMethod); */
+ if (poffActual)
+ *poffActual = 0;
+ return VINF_SUCCESS;
+}
+
+static uint64_t testRTFileSetFMode;
+
+extern int testRTFileSetMode(RTFILE File, RTFMODE fMode)
+{
+ RT_NOREF1(File);
+ /* RTPrintf("%s: fMode=%llu\n", __PRETTY_FUNCTION__, LLUIFY(fMode)); */
+ testRTFileSetFMode = fMode;
+ return VINF_SUCCESS;
+}
+
+static RTFILE g_testRTFileSetSizeFile;
+static RTFOFF testRTFileSetSizeSize;
+
+extern int testRTFileSetSize(RTFILE File, uint64_t cbSize)
+{
+ /* RTPrintf("%s: File=%llu, cbSize=%llu\n", __PRETTY_FUNCTION__, LLUIFY(File),
+ LLUIFY(cbSize)); */
+ g_testRTFileSetSizeFile = File;
+ testRTFileSetSizeSize = (RTFOFF) cbSize; /* Why was this signed before? */
+ return VINF_SUCCESS;
+}
+
+static RTTIMESPEC testRTFileSetTimesATime;
+
+extern int testRTFileSetTimes(RTFILE File, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
+ PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
+{
+ RT_NOREF4(File, pModificationTime, pChangeTime, pBirthTime);
+ /* RTPrintf("%s: pFile=%p, *pAccessTime=%lli, *pModificationTime=%lli, *pChangeTime=%lli, *pBirthTime=%lli\n",
+ __PRETTY_FUNCTION__,
+ pAccessTime ? (long long)RTTimeSpecGetNano(pAccessTime) : -1,
+ pModificationTime
+ ? (long long)RTTimeSpecGetNano(pModificationTime) : -1,
+ pChangeTime ? (long long)RTTimeSpecGetNano(pChangeTime) : -1,
+ pBirthTime ? (long long)RTTimeSpecGetNano(pBirthTime) : -1); */
+ if (pAccessTime)
+ testRTFileSetTimesATime = *pAccessTime;
+ else
+ RT_ZERO(testRTFileSetTimesATime);
+ return VINF_SUCCESS;
+}
+
+static RTFILE g_testRTFileUnlockFile;
+static int64_t testRTFileUnlockOffset;
+static uint64_t testRTFileUnlockSize;
+
+extern int testRTFileUnlock(RTFILE File, int64_t offLock, uint64_t cbLock)
+{
+ /* RTPrintf("%s: hFile=%p, ofLock=%lli, cbLock=%llu\n", __PRETTY_FUNCTION__,
+ File, (long long) offLock, LLUIFY(cbLock)); */
+ g_testRTFileUnlockFile = File;
+ testRTFileUnlockOffset = offLock;
+ testRTFileUnlockSize = cbLock;
+ return VINF_SUCCESS;
+}
+
+static char testRTFileWriteData[256];
+
+extern int testRTFileWrite(RTFILE File, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten)
+{
+ RT_NOREF2(File, cbToWrite);
+ /* RTPrintf("%s: File=%p, pvBuf=%.*s, cbToWrite=%llu\n", __PRETTY_FUNCTION__,
+ File, cbToWrite, (const char *)pvBuf, LLUIFY(cbToWrite)); */
+ ARRAY_FROM_PATH(testRTFileWriteData, (const char *)pvBuf);
+ if (pcbWritten)
+ *pcbWritten = strlen(testRTFileWriteData) + 1;
+ return VINF_SUCCESS;
+}
+
+extern int testRTFsQueryProperties(const char *pszFsPath, PRTFSPROPERTIES pProperties)
+{
+ RT_NOREF1(pszFsPath);
+ /* RTPrintf("%s, pszFsPath=%s\n", __PRETTY_FUNCTION__, pszFsPath);
+ RT_ZERO(*pProperties); */
+ pProperties->cbMaxComponent = 256;
+ pProperties->fCaseSensitive = true;
+ return VINF_SUCCESS;
+}
+
+extern int testRTFsQuerySerial(const char *pszFsPath, uint32_t *pu32Serial)
+{
+ RT_NOREF2(pszFsPath, pu32Serial);
+ RTPrintf("%s\n", __PRETTY_FUNCTION__);
+ return 0;
+}
+extern int testRTFsQuerySizes(const char *pszFsPath, PRTFOFF pcbTotal, RTFOFF *pcbFree, uint32_t *pcbBlock, uint32_t *pcbSector)
+{
+ RT_NOREF5(pszFsPath, pcbTotal, pcbFree, pcbBlock, pcbSector);
+ RTPrintf("%s\n", __PRETTY_FUNCTION__);
+ return 0;
+}
+
+extern int testRTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
+{
+ RT_NOREF2(enmAdditionalAttribs, fFlags);
+ /* RTPrintf("%s: pszPath=%s, enmAdditionalAttribs=0x%x, fFlags=0x%x\n",
+ __PRETTY_FUNCTION__, pszPath, (unsigned) enmAdditionalAttribs,
+ (unsigned) fFlags); */
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszPath, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ RT_ZERO(*pObjInfo);
+ return VINF_SUCCESS;
+}
+
+extern int testRTSymlinkDelete(const char *pszSymlink, uint32_t fDelete)
+{
+ RT_NOREF2(pszSymlink, fDelete);
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszSymlink, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ RTPrintf("%s\n", __PRETTY_FUNCTION__);
+ return 0;
+}
+
+extern int testRTSymlinkRead(const char *pszSymlink, char *pszTarget, size_t cbTarget, uint32_t fRead)
+{
+ if (g_fFailIfNotLowercase && !RTStrIsLowerCased(strpbrk(pszSymlink, "/\\")))
+ return VERR_FILE_NOT_FOUND;
+ RT_NOREF4(pszSymlink, pszTarget, cbTarget, fRead);
+ RTPrintf("%s\n", __PRETTY_FUNCTION__);
+ return 0;
+}
+
+
+/*********************************************************************************************************************************
+* Tests *
+*********************************************************************************************************************************/
+
+/* Sub-tests for testMappingsQuery(). */
+void testMappingsQuerySimple(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMappingsQueryTooFewBuffers(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMappingsQueryAutoMount(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMappingsQueryArrayWrongSize(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testMappingsQueryName(). */
+void testMappingsQueryNameValid(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMappingsQueryNameInvalid(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMappingsQueryNameBadBuffer(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testMapFolder(). */
+void testMapFolderValid(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMapFolderInvalid(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMapFolderTwice(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMapFolderDelimiter(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMapFolderCaseSensitive(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMapFolderCaseInsensitive(RTTEST hTest) { RT_NOREF1(hTest); }
+void testMapFolderBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testUnmapFolder(). */
+void testUnmapFolderValid(RTTEST hTest) { RT_NOREF1(hTest); }
+void testUnmapFolderInvalid(RTTEST hTest) { RT_NOREF1(hTest); }
+void testUnmapFolderBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testCreate(). */
+void testCreateBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testClose(). */
+void testCloseBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testRead(). */
+void testReadBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testWrite(). */
+void testWriteBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testLock(). */
+void testLockBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testFlush(). */
+void testFlushBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testDirList(). */
+void testDirListBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testReadLink(). */
+void testReadLinkBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testFSInfo(). */
+void testFSInfoBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testRemove(). */
+void testRemoveBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testRename(). */
+void testRenameBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testSymlink(). */
+void testSymlinkBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testMappingsAdd(). */
+void testMappingsAddBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+/* Sub-tests for testMappingsRemove(). */
+void testMappingsRemoveBadParameters(RTTEST hTest) { RT_NOREF1(hTest); }
+
+union TESTSHFLSTRING
+{
+ SHFLSTRING string;
+ char acData[256];
+};
+
+static void fillTestShflString(union TESTSHFLSTRING *pDest,
+ const char *pcszSource)
+{
+ const size_t cchSource = strlen(pcszSource);
+ AssertRelease( cchSource * 2 + 2
+ < sizeof(*pDest) - RT_UOFFSETOF(SHFLSTRING, String));
+ pDest->string.u16Length = (uint16_t)(cchSource * sizeof(RTUTF16));
+ pDest->string.u16Size = pDest->string.u16Length + sizeof(RTUTF16);
+ /* Copy pcszSource ASCIIZ, including the trailing 0, to the UTF16 pDest->string.String.ucs2. */
+ for (unsigned i = 0; i <= cchSource; ++i)
+ pDest->string.String.ucs2[i] = (uint16_t)pcszSource[i];
+}
+
+static SHFLROOT initWithWritableMapping(RTTEST hTest,
+ VBOXHGCMSVCFNTABLE *psvcTable,
+ VBOXHGCMSVCHELPERS *psvcHelpers,
+ const char *pcszFolderName,
+ const char *pcszMapping,
+ bool fCaseSensitive = true)
+{
+ VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_ADD_MAPPING,
+ SHFL_CPARMS_MAP_FOLDER)];
+ union TESTSHFLSTRING FolderName;
+ union TESTSHFLSTRING Mapping;
+ union TESTSHFLSTRING AutoMountPoint;
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+ int rc;
+
+ initTable(psvcTable, psvcHelpers);
+ AssertReleaseRC(VBoxHGCMSvcLoad(psvcTable));
+ AssertRelease( psvcTable->pvService
+ = RTTestGuardedAllocTail(hTest, psvcTable->cbClient));
+ RT_BZERO(psvcTable->pvService, psvcTable->cbClient);
+ fillTestShflString(&FolderName, pcszFolderName);
+ fillTestShflString(&Mapping, pcszMapping);
+ fillTestShflString(&AutoMountPoint, "");
+ HGCMSvcSetPv(&aParms[0], &FolderName, RT_UOFFSETOF(SHFLSTRING, String)
+ + FolderName.string.u16Size);
+ HGCMSvcSetPv(&aParms[1], &Mapping, RT_UOFFSETOF(SHFLSTRING, String)
+ + Mapping.string.u16Size);
+ HGCMSvcSetU32(&aParms[2], 1);
+ HGCMSvcSetPv(&aParms[3], &AutoMountPoint, SHFLSTRING_HEADER_SIZE + AutoMountPoint.string.u16Size);
+ rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_ADD_MAPPING,
+ SHFL_CPARMS_ADD_MAPPING, aParms);
+ AssertReleaseRC(rc);
+ HGCMSvcSetPv(&aParms[0], &Mapping, RT_UOFFSETOF(SHFLSTRING, String)
+ + Mapping.string.u16Size);
+ HGCMSvcSetU32(&aParms[1], 0); /* root */
+ HGCMSvcSetU32(&aParms[2], '/'); /* delimiter */
+ HGCMSvcSetU32(&aParms[3], fCaseSensitive);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_MAP_FOLDER,
+ SHFL_CPARMS_MAP_FOLDER, aParms, 0);
+ AssertReleaseRC(callHandle.rc);
+ return aParms[1].u.uint32;
+}
+
+/** @todo Mappings should be automatically removed by unloading the service,
+ * but unloading is currently a no-op! */
+static void unmapAndRemoveMapping(RTTEST hTest, VBOXHGCMSVCFNTABLE *psvcTable,
+ SHFLROOT root, const char *pcszFolderName)
+{
+ RT_NOREF1(hTest);
+ VBOXHGCMSVCPARM aParms[RT_MAX(SHFL_CPARMS_UNMAP_FOLDER,
+ SHFL_CPARMS_REMOVE_MAPPING)];
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+ union TESTSHFLSTRING FolderName;
+ int rc;
+
+ HGCMSvcSetU32(&aParms[0], root);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_UNMAP_FOLDER,
+ SHFL_CPARMS_UNMAP_FOLDER, aParms, 0);
+ AssertReleaseRC(callHandle.rc);
+ fillTestShflString(&FolderName, pcszFolderName);
+ HGCMSvcSetPv(&aParms[0], &FolderName, RT_UOFFSETOF(SHFLSTRING, String)
+ + FolderName.string.u16Size);
+ rc = psvcTable->pfnHostCall(psvcTable->pvService, SHFL_FN_REMOVE_MAPPING,
+ SHFL_CPARMS_REMOVE_MAPPING, aParms);
+ AssertReleaseRC(rc);
+}
+
+static int createFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
+ const char *pcszFilename, uint32_t fCreateFlags,
+ SHFLHANDLE *pHandle, SHFLCREATERESULT *pResult)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_CREATE];
+ union TESTSHFLSTRING Path;
+ SHFLCREATEPARMS CreateParms;
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ fillTestShflString(&Path, pcszFilename);
+ RT_ZERO(CreateParms);
+ CreateParms.CreateFlags = fCreateFlags;
+ HGCMSvcSetU32(&aParms[0], Root);
+ HGCMSvcSetPv(&aParms[1], &Path, RT_UOFFSETOF(SHFLSTRING, String)
+ + Path.string.u16Size);
+ HGCMSvcSetPv(&aParms[2], &CreateParms, sizeof(CreateParms));
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_CREATE,
+ RT_ELEMENTS(aParms), aParms, 0);
+ if (RT_FAILURE(callHandle.rc))
+ return callHandle.rc;
+ if (pHandle)
+ *pHandle = CreateParms.Handle;
+ if (pResult)
+ *pResult = CreateParms.Result;
+ return VINF_SUCCESS;
+}
+
+static int readFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
+ SHFLHANDLE hFile, uint64_t offSeek, uint32_t cbRead,
+ uint32_t *pcbRead, void *pvBuf, uint32_t cbBuf)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_READ];
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ HGCMSvcSetU32(&aParms[0], Root);
+ HGCMSvcSetU64(&aParms[1], (uint64_t) hFile);
+ HGCMSvcSetU64(&aParms[2], offSeek);
+ HGCMSvcSetU32(&aParms[3], cbRead);
+ HGCMSvcSetPv(&aParms[4], pvBuf, cbBuf);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_READ,
+ RT_ELEMENTS(aParms), aParms, 0);
+ if (pcbRead)
+ *pcbRead = aParms[3].u.uint32;
+ return callHandle.rc;
+}
+
+static int writeFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT Root,
+ SHFLHANDLE hFile, uint64_t offSeek, uint32_t cbWrite,
+ uint32_t *pcbWritten, const void *pvBuf, uint32_t cbBuf)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_WRITE];
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ HGCMSvcSetU32(&aParms[0], Root);
+ HGCMSvcSetU64(&aParms[1], (uint64_t) hFile);
+ HGCMSvcSetU64(&aParms[2], offSeek);
+ HGCMSvcSetU32(&aParms[3], cbWrite);
+ HGCMSvcSetPv(&aParms[4], (void *)pvBuf, cbBuf);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_WRITE,
+ RT_ELEMENTS(aParms), aParms, 0);
+ if (pcbWritten)
+ *pcbWritten = aParms[3].u.uint32;
+ return callHandle.rc;
+}
+
+static int flushFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
+ SHFLHANDLE handle)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_FLUSH];
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ HGCMSvcSetU32(&aParms[0], root);
+ HGCMSvcSetU64(&aParms[1], handle);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_FLUSH,
+ SHFL_CPARMS_FLUSH, aParms, 0);
+ return callHandle.rc;
+}
+
+static int listDir(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
+ SHFLHANDLE handle, uint32_t fFlags,
+ const char *pcszPath, void *pvBuf, uint32_t cbBuf,
+ uint32_t resumePoint, uint32_t *pcFiles)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_LIST];
+ union TESTSHFLSTRING Path;
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ HGCMSvcSetU32(&aParms[0], root);
+ HGCMSvcSetU64(&aParms[1], handle);
+ HGCMSvcSetU32(&aParms[2], fFlags);
+ HGCMSvcSetU32(&aParms[3], cbBuf);
+ if (pcszPath)
+ {
+ fillTestShflString(&Path, pcszPath);
+ HGCMSvcSetPv(&aParms[4], &Path, RT_UOFFSETOF(SHFLSTRING, String)
+ + Path.string.u16Size);
+ }
+ else
+ HGCMSvcSetPv(&aParms[4], NULL, 0);
+ HGCMSvcSetPv(&aParms[5], pvBuf, cbBuf);
+ HGCMSvcSetU32(&aParms[6], resumePoint);
+ HGCMSvcSetU32(&aParms[7], 0);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_LIST,
+ RT_ELEMENTS(aParms), aParms, 0);
+ if (pcFiles)
+ *pcFiles = aParms[7].u.uint32;
+ return callHandle.rc;
+}
+
+static int sfInformation(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
+ SHFLHANDLE handle, uint32_t fFlags, uint32_t cb,
+ SHFLFSOBJINFO *pInfo)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_INFORMATION];
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ HGCMSvcSetU32(&aParms[0], root);
+ HGCMSvcSetU64(&aParms[1], handle);
+ HGCMSvcSetU32(&aParms[2], fFlags);
+ HGCMSvcSetU32(&aParms[3], cb);
+ HGCMSvcSetPv(&aParms[4], pInfo, cb);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_INFORMATION,
+ RT_ELEMENTS(aParms), aParms, 0);
+ return callHandle.rc;
+}
+
+static int lockFile(VBOXHGCMSVCFNTABLE *psvcTable, SHFLROOT root,
+ SHFLHANDLE handle, int64_t offLock, uint64_t cbLock,
+ uint32_t fFlags)
+{
+ VBOXHGCMSVCPARM aParms[SHFL_CPARMS_LOCK];
+ VBOXHGCMCALLHANDLE_TYPEDEF callHandle = { VINF_SUCCESS };
+
+ HGCMSvcSetU32(&aParms[0], root);
+ HGCMSvcSetU64(&aParms[1], handle);
+ HGCMSvcSetU64(&aParms[2], offLock);
+ HGCMSvcSetU64(&aParms[3], cbLock);
+ HGCMSvcSetU32(&aParms[4], fFlags);
+ psvcTable->pfnCall(psvcTable->pvService, &callHandle, 0,
+ psvcTable->pvService, SHFL_FN_LOCK,
+ RT_ELEMENTS(aParms), aParms, 0);
+ return callHandle.rc;
+}
+
+void testCreateFileSimple(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ SHFLCREATERESULT Result;
+ int rc;
+
+ RTTestSub(hTest, "Create file simple");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ, NULL,
+ &Result);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest,
+ !strcmp(&testRTFileOpenName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
+ "/test/mapping/test/file"),
+ (hTest, "pszFilename=%s\n", &testRTFileOpenName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
+ RTTEST_CHECK_MSG(hTest, testRTFileOpenFlags == 0x181,
+ (hTest, "fOpen=%llu\n", LLUIFY(testRTFileOpenFlags)));
+ RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,
+ (hTest, "Result=%d\n", (int) Result));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile,
+ (hTest, "File=%u\n", (uintptr_t)g_testRTFileCloseFile));
+}
+
+void testCreateFileSimpleCaseInsensitive(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ SHFLCREATERESULT Result;
+ int rc;
+
+ g_fFailIfNotLowercase = true;
+
+ RTTestSub(hTest, "Create file case insensitive");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname", false /*fCaseSensitive*/);
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/TesT/FilE", SHFL_CF_ACCESS_READ, NULL,
+ &Result);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+
+ RTTEST_CHECK_MSG(hTest,
+ !strcmp(&testRTFileOpenName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
+ "/test/mapping/test/file"),
+ (hTest, "pszFilename=%s\n", &testRTFileOpenName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
+ RTTEST_CHECK_MSG(hTest, testRTFileOpenFlags == 0x181,
+ (hTest, "fOpen=%llu\n", LLUIFY(testRTFileOpenFlags)));
+ RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,
+ (hTest, "Result=%d\n", (int) Result));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile,
+ (hTest, "File=%u\n", (uintptr_t)g_testRTFileCloseFile));
+
+ g_fFailIfNotLowercase = false;
+}
+
+void testCreateDirSimple(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ RTDIR hDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
+ SHFLCREATERESULT Result;
+ int rc;
+
+ RTTestSub(hTest, "Create directory simple");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTDirOpen_hDir = hDir;
+ rc = createFile(&svcTable, Root, "test/dir",
+ SHFL_CF_DIRECTORY | SHFL_CF_ACCESS_READ, NULL, &Result);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest,
+ !strcmp(&testRTDirCreatePath[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
+ "/test/mapping/test/dir"),
+ (hTest, "pszPath=%s\n", &testRTDirCreatePath[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
+ RTTEST_CHECK_MSG(hTest,
+ !strcmp(&testRTDirOpenName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0],
+ "/test/mapping/test/dir"),
+ (hTest, "pszFilename=%s\n", &testRTDirOpenName[RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS ? 2 : 0]));
+ RTTEST_CHECK_MSG(hTest, Result == SHFL_FILE_CREATED,
+ (hTest, "Result=%d\n", (int) Result));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTDirClose_hDir == hDir, (hTest, "hDir=%p\n", g_testRTDirClose_hDir));
+}
+
+void testReadFileSimple(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ SHFLHANDLE Handle;
+ const char *pcszReadData = "Data to read";
+ char acBuf[sizeof(pcszReadData) + 10];
+ uint32_t cbRead;
+ int rc;
+
+ RTTestSub(hTest, "Read file simple");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ testRTFileReadData = pcszReadData;
+ rc = readFile(&svcTable, Root, Handle, 0, (uint32_t)strlen(pcszReadData) + 1,
+ &cbRead, acBuf, (uint32_t)sizeof(acBuf));
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest,
+ !strncmp(acBuf, pcszReadData, sizeof(acBuf)),
+ (hTest, "pvBuf=%.*s\n", sizeof(acBuf), acBuf));
+ RTTEST_CHECK_MSG(hTest, cbRead == strlen(pcszReadData) + 1,
+ (hTest, "cbRead=%llu\n", LLUIFY(cbRead)));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+}
+
+void testWriteFileSimple(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ SHFLHANDLE Handle;
+ const char *pcszWrittenData = "Data to write";
+ uint32_t cbToWrite = (uint32_t)strlen(pcszWrittenData) + 1;
+ uint32_t cbWritten;
+ int rc;
+
+ RTTestSub(hTest, "Write file simple");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ rc = writeFile(&svcTable, Root, Handle, 0, cbToWrite, &cbWritten,
+ pcszWrittenData, cbToWrite);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest,
+ !strcmp(testRTFileWriteData, pcszWrittenData),
+ (hTest, "pvBuf=%s\n", testRTFileWriteData));
+ RTTEST_CHECK_MSG(hTest, cbWritten == cbToWrite,
+ (hTest, "cbWritten=%llu\n", LLUIFY(cbWritten)));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+}
+
+void testFlushFileSimple(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ SHFLHANDLE Handle;
+ int rc;
+
+ RTTestSub(hTest, "Flush file simple");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ rc = flushFile(&svcTable, Root, Handle);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileFlushFile == hcFile, (hTest, "File=%u\n", g_testRTFileFlushFile));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+}
+
+void testDirListEmpty(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ RTDIR hDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
+ SHFLHANDLE Handle;
+ union
+ {
+ SHFLDIRINFO DirInfo;
+ uint8_t abBuffer[sizeof(SHFLDIRINFO) + 2 * sizeof(RTUTF16)];
+ } Buf;
+ uint32_t cFiles;
+ int rc;
+
+ RTTestSub(hTest, "List empty directory");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTDirOpen_hDir = hDir;
+ rc = createFile(&svcTable, Root, "test/dir",
+ SHFL_CF_DIRECTORY | SHFL_CF_ACCESS_READ, &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ rc = listDir(&svcTable, Root, Handle, 0, NULL, &Buf.DirInfo, sizeof(Buf), 0, &cFiles);
+ RTTEST_CHECK_RC(hTest, rc, VERR_NO_MORE_FILES);
+ RTTEST_CHECK_MSG(hTest, g_testRTDirReadEx_hDir == hDir, (hTest, "Dir=%p\n", g_testRTDirReadEx_hDir));
+ RTTEST_CHECK_MSG(hTest, cFiles == 0,
+ (hTest, "cFiles=%llu\n", LLUIFY(cFiles)));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTDirClose_hDir == hDir, (hTest, "hDir=%p\n", g_testRTDirClose_hDir));
+}
+
+void testFSInfoQuerySetFMode(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ const uint32_t fMode = 0660;
+ SHFLFSOBJINFO Info;
+ int rc;
+
+ RTTestSub(hTest, "Query and set file size");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ SHFLHANDLE Handle = SHFL_HANDLE_NIL;
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK_RETV(hTest, rc);
+
+ RT_ZERO(Info);
+ testRTFileQueryInfoFMode = fMode;
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),
+ &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileQueryInfoFile == hcFile, (hTest, "File=%u\n", g_testRTFileQueryInfoFile));
+ RTTEST_CHECK_MSG(hTest, Info.Attr.fMode == fMode,
+ (hTest, "cbObject=%llu\n", LLUIFY(Info.cbObject)));
+ RT_ZERO(Info);
+ Info.Attr.fMode = fMode;
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET | SHFL_INFO_FILE,
+ sizeof(Info), &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, testRTFileSetFMode == fMode,
+ (hTest, "Size=%llu\n", LLUIFY(testRTFileSetFMode)));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+}
+
+void testFSInfoQuerySetDirATime(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTDIR hDir = (RTDIR)&g_aTestDirHandles[g_iNextDirHandle++ % RT_ELEMENTS(g_aTestDirHandles)];
+ const int64_t ccAtimeNano = 100000;
+ SHFLFSOBJINFO Info;
+ SHFLHANDLE Handle;
+ int rc;
+
+ RTTestSub(hTest, "Query and set directory atime");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTDirOpen_hDir = hDir;
+ rc = createFile(&svcTable, Root, "test/dir",
+ SHFL_CF_DIRECTORY | SHFL_CF_ACCESS_READ, &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RT_ZERO(Info);
+ RTTimeSpecSetNano(&testRTDirQueryInfoATime, ccAtimeNano);
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),
+ &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, g_testRTDirQueryInfo_hDir == hDir, (hTest, "Dir=%p\n", g_testRTDirQueryInfo_hDir));
+ RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&Info.AccessTime) == ccAtimeNano,
+ (hTest, "ATime=%llu\n",
+ LLUIFY(RTTimeSpecGetNano(&Info.AccessTime))));
+ RT_ZERO(Info);
+ RTTimeSpecSetNano(&Info.AccessTime, ccAtimeNano);
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET | SHFL_INFO_FILE,
+ sizeof(Info), &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&testRTDirSetTimesATime)
+ == ccAtimeNano,
+ (hTest, "ATime=%llu\n",
+ LLUIFY(RTTimeSpecGetNano(&testRTDirSetTimesATime))));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTDirClose_hDir == hDir, (hTest, "hDir=%p\n", g_testRTDirClose_hDir));
+}
+
+void testFSInfoQuerySetFileATime(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ const int64_t ccAtimeNano = 100000;
+ SHFLFSOBJINFO Info;
+ SHFLHANDLE Handle;
+ int rc;
+
+ RTTestSub(hTest, "Query and set file atime");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RT_ZERO(Info);
+ RTTimeSpecSetNano(&testRTFileQueryInfoATime, ccAtimeNano);
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_FILE, sizeof(Info),
+ &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileQueryInfoFile == hcFile, (hTest, "File=%u\n", g_testRTFileQueryInfoFile));
+ RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&Info.AccessTime) == ccAtimeNano,
+ (hTest, "ATime=%llu\n",
+ LLUIFY(RTTimeSpecGetNano(&Info.AccessTime))));
+ RT_ZERO(Info);
+ RTTimeSpecSetNano(&Info.AccessTime, ccAtimeNano);
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET | SHFL_INFO_FILE,
+ sizeof(Info), &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, RTTimeSpecGetNano(&testRTFileSetTimesATime)
+ == ccAtimeNano,
+ (hTest, "ATime=%llu\n",
+ LLUIFY(RTTimeSpecGetNano(&testRTFileSetTimesATime))));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+}
+
+void testFSInfoQuerySetEndOfFile(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ const RTFOFF cbNew = 50000;
+ SHFLFSOBJINFO Info;
+ SHFLHANDLE Handle;
+ int rc;
+
+ RTTestSub(hTest, "Set end of file position");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RT_ZERO(Info);
+ Info.cbObject = cbNew;
+ rc = sfInformation(&svcTable, Root, Handle, SHFL_INFO_SET | SHFL_INFO_SIZE,
+ sizeof(Info), &Info);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileSetSizeFile == hcFile, (hTest, "File=%u\n", g_testRTFileSetSizeFile));
+ RTTEST_CHECK_MSG(hTest, testRTFileSetSizeSize == cbNew,
+ (hTest, "Size=%llu\n", LLUIFY(testRTFileSetSizeSize)));
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+}
+
+void testLockFileSimple(RTTEST hTest)
+{
+ VBOXHGCMSVCFNTABLE svcTable;
+ VBOXHGCMSVCHELPERS svcHelpers;
+ SHFLROOT Root;
+ const RTFILE hcFile = (RTFILE) 0x10000;
+ const int64_t offLock = 50000;
+ const uint64_t cbLock = 4000;
+ SHFLHANDLE Handle;
+ int rc;
+
+ RTTestSub(hTest, "Simple file lock and unlock");
+ Root = initWithWritableMapping(hTest, &svcTable, &svcHelpers,
+ "/test/mapping", "testname");
+ testRTFileOpenpFile = hcFile;
+ rc = createFile(&svcTable, Root, "/test/file", SHFL_CF_ACCESS_READ,
+ &Handle, NULL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+ rc = lockFile(&svcTable, Root, Handle, offLock, cbLock, SHFL_LOCK_SHARED);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+#ifdef RT_OS_WINDOWS /* Locking is a no-op elsewhere. */
+ RTTEST_CHECK_MSG(hTest, g_testRTFileLockFile == hcFile, (hTest, "File=%u\n", g_testRTFileLockFile));
+ RTTEST_CHECK_MSG(hTest, testRTFileLockfLock == 0,
+ (hTest, "fLock=%u\n", testRTFileLockfLock));
+ RTTEST_CHECK_MSG(hTest, testRTFileLockOffset == offLock,
+ (hTest, "Offs=%llu\n", (long long) testRTFileLockOffset));
+ RTTEST_CHECK_MSG(hTest, testRTFileLockSize == cbLock,
+ (hTest, "Size=%llu\n", LLUIFY(testRTFileLockSize)));
+#endif
+ rc = lockFile(&svcTable, Root, Handle, offLock, cbLock, SHFL_LOCK_CANCEL);
+ RTTEST_CHECK_RC_OK(hTest, rc);
+#ifdef RT_OS_WINDOWS
+ RTTEST_CHECK_MSG(hTest, g_testRTFileUnlockFile == hcFile, (hTest, "File=%u\n", g_testRTFileUnlockFile));
+ RTTEST_CHECK_MSG(hTest, testRTFileUnlockOffset == offLock,
+ (hTest, "Offs=%llu\n",
+ (long long) testRTFileUnlockOffset));
+ RTTEST_CHECK_MSG(hTest, testRTFileUnlockSize == cbLock,
+ (hTest, "Size=%llu\n", LLUIFY(testRTFileUnlockSize)));
+#endif
+ unmapAndRemoveMapping(hTest, &svcTable, Root, "testname");
+ AssertReleaseRC(svcTable.pfnDisconnect(NULL, 0, svcTable.pvService));
+ AssertReleaseRC(svcTable.pfnUnload(NULL));
+ RTTestGuardedFree(hTest, svcTable.pvService);
+ RTTEST_CHECK_MSG(hTest, g_testRTFileCloseFile == hcFile, (hTest, "File=%u\n", g_testRTFileCloseFile));
+}
+
+
+/*********************************************************************************************************************************
+* Main code *
+*********************************************************************************************************************************/
+
+static void testAPI(RTTEST hTest)
+{
+ testMappingsQuery(hTest);
+ testMappingsQueryName(hTest);
+ testMapFolder(hTest);
+ testUnmapFolder(hTest);
+ testCreate(hTest);
+ testClose(hTest);
+ testRead(hTest);
+ testWrite(hTest);
+ testLock(hTest);
+ testFlush(hTest);
+ testDirList(hTest);
+ testReadLink(hTest);
+ testFSInfo(hTest);
+ testRemove(hTest);
+ testRename(hTest);
+ testSymlink(hTest);
+ testMappingsAdd(hTest);
+ testMappingsRemove(hTest);
+ /* testSetStatusLed(hTest); */
+}
+
+int main(int argc, char **argv)
+{
+ RT_NOREF1(argc);
+ RTEXITCODE rcExit = RTTestInitAndCreate(RTPathFilename(argv[0]), &g_hTest);
+ if (rcExit != RTEXITCODE_SUCCESS)
+ return rcExit;
+ RTTestBanner(g_hTest);
+ testAPI(g_hTest);
+ return RTTestSummaryAndDestroy(g_hTest);
+}
diff --git a/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.h b/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.h
new file mode 100644
index 00000000..93a9995a
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/testcase/tstSharedFolderService.h
@@ -0,0 +1,130 @@
+/** @file
+ * VBox Shared Folders testcase stub redefinitions.
+ */
+
+/*
+ * Copyright (C) 2011-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_testcase_tstSharedFolderService_h
+#define VBOX_INCLUDED_SRC_SharedFolders_testcase_tstSharedFolderService_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+/* Grumble... if the coding style let us use the anonymous "struct RTTESTINT *"
+ * instead of "PRTTEST" here we wouldn't need to unnecessarily include this. */
+#include <iprt/test.h>
+
+void testMappingsQuery(RTTEST hTest);
+/* Sub-tests for testMappingsQuery(). */
+void testMappingsQuerySimple(RTTEST hTest);
+void testMappingsQueryTooFewBuffers(RTTEST hTest);
+void testMappingsQueryAutoMount(RTTEST hTest);
+void testMappingsQueryArrayWrongSize(RTTEST hTest);
+
+void testMappingsQueryName(RTTEST hTest);
+/* Sub-tests for testMappingsQueryName(). */
+void testMappingsQueryNameValid(RTTEST hTest);
+void testMappingsQueryNameInvalid(RTTEST hTest);
+void testMappingsQueryNameBadBuffer(RTTEST hTest);
+
+void testMapFolder(RTTEST hTest);
+/* Sub-tests for testMapFolder(). */
+void testMapFolderValid(RTTEST hTest);
+void testMapFolderInvalid(RTTEST hTest);
+void testMapFolderTwice(RTTEST hTest);
+void testMapFolderDelimiter(RTTEST hTest);
+void testMapFolderCaseSensitive(RTTEST hTest);
+void testMapFolderCaseInsensitive(RTTEST hTest);
+void testMapFolderBadParameters(RTTEST hTest);
+
+void testUnmapFolder(RTTEST hTest);
+/* Sub-tests for testUnmapFolder(). */
+void testUnmapFolderValid(RTTEST hTest);
+void testUnmapFolderInvalid(RTTEST hTest);
+void testUnmapFolderBadParameters(RTTEST hTest);
+
+void testCreate(RTTEST hTest);
+/* Sub-tests for testCreate(). */
+void testCreateFileSimple(RTTEST hTest);
+void testCreateFileSimpleCaseInsensitive(RTTEST hTest);
+void testCreateDirSimple(RTTEST hTest);
+void testCreateBadParameters(RTTEST hTest);
+
+void testClose(RTTEST hTest);
+/* Sub-tests for testClose(). */
+void testCloseBadParameters(RTTEST hTest);
+
+void testRead(RTTEST hTest);
+/* Sub-tests for testRead(). */
+void testReadBadParameters(RTTEST hTest);
+void testReadFileSimple(RTTEST hTest);
+
+void testWrite(RTTEST hTest);
+/* Sub-tests for testWrite(). */
+void testWriteBadParameters(RTTEST hTest);
+void testWriteFileSimple(RTTEST hTest);
+
+void testLock(RTTEST hTest);
+/* Sub-tests for testLock(). */
+void testLockBadParameters(RTTEST hTest);
+void testLockFileSimple(RTTEST hTest);
+
+void testFlush(RTTEST hTest);
+/* Sub-tests for testFlush(). */
+void testFlushBadParameters(RTTEST hTest);
+void testFlushFileSimple(RTTEST hTest);
+
+void testDirList(RTTEST hTest);
+/* Sub-tests for testDirList(). */
+void testDirListBadParameters(RTTEST hTest);
+void testDirListEmpty(RTTEST hTest);
+
+void testReadLink(RTTEST hTest);
+/* Sub-tests for testReadLink(). */
+void testReadLinkBadParameters(RTTEST hTest);
+
+void testFSInfo(RTTEST hTest);
+/* Sub-tests for testFSInfo(). */
+void testFSInfoBadParameters(RTTEST hTest);
+void testFSInfoQuerySetFMode(RTTEST hTest);
+void testFSInfoQuerySetDirATime(RTTEST hTest);
+void testFSInfoQuerySetFileATime(RTTEST hTest);
+void testFSInfoQuerySetEndOfFile(RTTEST hTest);
+
+void testRemove(RTTEST hTest);
+/* Sub-tests for testRemove(). */
+void testRemoveBadParameters(RTTEST hTest);
+
+void testRename(RTTEST hTest);
+/* Sub-tests for testRename(). */
+void testRenameBadParameters(RTTEST hTest);
+
+void testSymlink(RTTEST hTest);
+/* Sub-tests for testSymlink(). */
+void testSymlinkBadParameters(RTTEST hTest);
+
+void testMappingsAdd(RTTEST hTest);
+/* Sub-tests for testMappingsAdd(). */
+void testMappingsAddBadParameters(RTTEST hTest);
+
+void testMappingsRemove(RTTEST hTest);
+/* Sub-tests for testMappingsRemove(). */
+void testMappingsRemoveBadParameters(RTTEST hTest);
+
+#if 0 /* Where should this go? */
+void testSetStatusLed(RTTEST hTest);
+/* Sub-tests for testStatusLed(). */
+void testSetStatusLedBadParameters(RTTEST hTest);
+#endif
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_testcase_tstSharedFolderService_h */
diff --git a/src/VBox/HostServices/SharedFolders/testcase/tstShflCase.cpp b/src/VBox/HostServices/SharedFolders/testcase/tstShflCase.cpp
new file mode 100644
index 00000000..6920f8dd
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/testcase/tstShflCase.cpp
@@ -0,0 +1,442 @@
+/** @file
+ * Testcase for shared folder case conversion code.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_MISC
+#define LOG_ENABLED
+#include <VBox/shflsvc.h>
+#include <VBox/log.h>
+#include <iprt/assert.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/fs.h>
+#include <iprt/dir.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <iprt/uni.h>
+#include <stdio.h>
+
+
+/*********************************************************************************************************************************
+* Defined Constants And Macros *
+*********************************************************************************************************************************/
+/* Override slash for non-windows hosts. */
+#undef RTPATH_DELIMITER
+#define RTPATH_DELIMITER '\\'
+
+/* Use our own RTPath and RTDir methods. */
+#define RTPathQueryInfo rtPathQueryInfo
+#define RTDirOpenFiltered rtDirOpenFiltered
+#define RTDirClose rtDirClose
+#define RTDirReadEx rtDirReadEx
+
+
+/*********************************************************************************************************************************
+* Global Variables *
+*********************************************************************************************************************************/
+static int iDirList = 0;
+static int iDirFile = 0;
+
+static const char *g_apszDirs[] =
+{
+ "c:",
+ "c:\\test dir",
+ "c:\\test dir\\SUBDIR",
+};
+
+static const char *g_apszDirsC[] =
+{
+ ".",
+ "..",
+ "test dir"
+};
+
+static const char *g_apszTestdirEntries[] =
+{
+ ".",
+ "..",
+ "SUBDIR",
+ "a.bat",
+ "aTestJe.bat",
+ "aTestje.bat",
+ "b.bat",
+ "c.bat",
+ "d.bat",
+ "e.bat",
+ "f.bat",
+ "g.bat",
+ "h.bat",
+ "x.bat",
+ "z.bat",
+};
+
+static const char *g_apszSUBDIREntries[] =
+{
+ ".",
+ "..",
+ "a.bat",
+ "aTestJe.bat",
+ "aTestje.bat",
+ "b.bat",
+ "c.bat",
+ "d.bat",
+ "e.bat",
+ "f.bat",
+ "g.bat",
+ "h.bat",
+ "x.bat",
+ "z.bat",
+};
+
+int rtDirOpenFiltered(RTDIR *phDir, const char *pszPath, RTDIRFILTER enmFilter, uint32_t fFlags)
+{
+ RT_NOREF2(enmFilter, fFlags);
+ if (!strcmp(pszPath, "c:\\*"))
+ iDirList = 1;
+ else if (!strcmp(pszPath, "c:\\test dir\\*"))
+ iDirList = 2;
+ else if (!strcmp(pszPath, "c:\\test dir\\SUBDIR\\*"))
+ iDirList = 3;
+ else
+ AssertFailed();
+
+ *phDir = (RTDIR)1;
+ return VINF_SUCCESS;
+}
+
+int rtDirClose(RTDIR hDir)
+{
+ RT_NOREF1(hDir);
+ iDirFile = 0;
+ return VINF_SUCCESS;
+}
+
+int rtDirReadEx(RTDIR hDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags)
+{
+ RT_NOREF4(hDir, pcbDirEntry, enmAdditionalAttribs, fFlags);
+ switch (iDirList)
+ {
+ case 1:
+ if (iDirFile == RT_ELEMENTS(g_apszDirsC))
+ return VERR_NO_MORE_FILES;
+ pDirEntry->cbName = (uint16_t)strlen(g_apszDirsC[iDirFile]);
+ strcpy(pDirEntry->szName, g_apszDirsC[iDirFile++]);
+ break;
+ case 2:
+ if (iDirFile == RT_ELEMENTS(g_apszTestdirEntries))
+ return VERR_NO_MORE_FILES;
+ pDirEntry->cbName = (uint16_t)strlen(g_apszTestdirEntries[iDirFile]);
+ strcpy(pDirEntry->szName, g_apszTestdirEntries[iDirFile++]);
+ break;
+ case 3:
+ if (iDirFile == RT_ELEMENTS(g_apszSUBDIREntries))
+ return VERR_NO_MORE_FILES;
+ pDirEntry->cbName = (uint16_t)strlen(g_apszSUBDIREntries[iDirFile]);
+ strcpy(pDirEntry->szName, g_apszSUBDIREntries[iDirFile++]);
+ break;
+ }
+ return VINF_SUCCESS;
+}
+
+int rtPathQueryInfo(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
+{
+ RT_NOREF2(pObjInfo, enmAdditionalAttribs);
+ int cMax;
+
+ /* first try g_apszDirs */
+ for (unsigned int i=0;i<RT_ELEMENTS(g_apszDirs);i++)
+ {
+ if(!strcmp(pszPath, g_apszDirs[i]))
+ return VINF_SUCCESS;
+ }
+
+ const char **papszDirList;
+ switch (iDirList)
+ {
+ case 1:
+ cMax = RT_ELEMENTS(g_apszDirsC);
+ papszDirList = g_apszDirsC;
+ break;
+ case 2:
+ cMax = RT_ELEMENTS(g_apszTestdirEntries);
+ papszDirList = g_apszTestdirEntries;
+ break;
+ case 3:
+ cMax = RT_ELEMENTS(g_apszSUBDIREntries);
+ papszDirList = g_apszSUBDIREntries;
+ break;
+ default:
+ return VERR_FILE_NOT_FOUND;
+ }
+ for (int i = 0; i < cMax; i++)
+ {
+ if (!strcmp(pszPath, papszDirList[i]))
+ return VINF_SUCCESS;
+ }
+ return VERR_FILE_NOT_FOUND;
+}
+
+static int vbsfCorrectCasing(char *pszFullPath, char *pszStartComponent)
+{
+ PRTDIRENTRYEX pDirEntry = NULL;
+ uint32_t cbDirEntry;
+ size_t cbComponent;
+ int rc = VERR_FILE_NOT_FOUND;
+ RTDIR hSearch = NIL_RTDIR;
+ char szWildCard[4];
+
+ Log2(("vbsfCorrectCasing: %s %s\n", pszFullPath, pszStartComponent));
+
+ cbComponent = strlen(pszStartComponent);
+
+ cbDirEntry = 4096;
+ pDirEntry = (PRTDIRENTRYEX)RTMemAlloc(cbDirEntry);
+ if (pDirEntry == 0)
+ {
+ AssertFailed();
+ return VERR_NO_MEMORY;
+ }
+
+ /** @todo this is quite inefficient, especially for directories with many files */
+ Assert(pszFullPath < pszStartComponent-1);
+ Assert(*(pszStartComponent-1) == RTPATH_DELIMITER);
+ *(pszStartComponent-1) = 0;
+ strcpy(pDirEntry->szName, pszFullPath);
+ szWildCard[0] = RTPATH_DELIMITER;
+ szWildCard[1] = '*';
+ szWildCard[2] = 0;
+ strcat(pDirEntry->szName, szWildCard);
+
+ rc = RTDirOpenFiltered(&hSearch, pDirEntry->szName, RTDIRFILTER_WINNT, 0 /*fFlags*/);
+ *(pszStartComponent-1) = RTPATH_DELIMITER;
+ if (RT_FAILURE(rc))
+ goto end;
+
+ for(;;)
+ {
+ size_t cbDirEntrySize = cbDirEntry;
+
+ rc = RTDirReadEx(hSearch, pDirEntry, &cbDirEntrySize, RTFSOBJATTRADD_NOTHING, RTPATH_F_FOLLOW_LINK);
+ if (rc == VERR_NO_MORE_FILES)
+ break;
+
+ if (VINF_SUCCESS != rc && rc != VWRN_NO_DIRENT_INFO)
+ {
+ AssertFailed();
+ if (rc != VERR_NO_TRANSLATION)
+ break;
+ else
+ continue;
+ }
+
+ Log2(("vbsfCorrectCasing: found %s\n", &pDirEntry->szName[0]));
+ if ( pDirEntry->cbName == cbComponent
+ && !RTStrICmp(pszStartComponent, &pDirEntry->szName[0]))
+ {
+ Log(("Found original name %s (%s)\n", &pDirEntry->szName[0], pszStartComponent));
+ strcpy(pszStartComponent, &pDirEntry->szName[0]);
+ rc = VINF_SUCCESS;
+ break;
+ }
+ }
+ if (RT_FAILURE(rc))
+ Log(("vbsfCorrectCasing %s failed with %d\n", pszStartComponent, rc));
+
+end:
+ if (pDirEntry)
+ RTMemFree(pDirEntry);
+
+ if (hSearch)
+ RTDirClose(hSearch);
+ return rc;
+}
+
+
+
+int testCase(char *pszFullPath, bool fWildCard = false)
+{
+ int rc;
+ RTFSOBJINFO info;
+ char *pszWildCardComponent = NULL;
+
+ if (fWildCard)
+ {
+ /* strip off the last path component, that contains the wildcard(s) */
+ size_t len = strlen(pszFullPath);
+ char *src = pszFullPath + len - 1;
+
+ while(src > pszFullPath)
+ {
+ if (*src == RTPATH_DELIMITER)
+ break;
+ src--;
+ }
+ if (*src == RTPATH_DELIMITER)
+ {
+ bool fHaveWildcards = false;
+ char *temp = src;
+
+ while(*temp)
+ {
+ char uc = *temp;
+ /** @todo should depend on the guest OS */
+ if (uc == '*' || uc == '?' || uc == '>' || uc == '<' || uc == '"')
+ {
+ fHaveWildcards = true;
+ break;
+ }
+ temp++;
+ }
+
+ if (fHaveWildcards)
+ {
+ pszWildCardComponent = src;
+ *pszWildCardComponent = 0;
+ }
+ }
+ }
+
+ rc = RTPathQueryInfo(pszFullPath, &info, RTFSOBJATTRADD_NOTHING);
+ if (rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND)
+ {
+ size_t len = strlen(pszFullPath);
+ char *src = pszFullPath + len - 1;
+
+ Log(("Handle case insensitive guest fs on top of host case sensitive fs for %s\n", pszFullPath));
+
+ /* Find partial path that's valid */
+ while(src > pszFullPath)
+ {
+ if (*src == RTPATH_DELIMITER)
+ {
+ *src = 0;
+ rc = RTPathQueryInfo (pszFullPath, &info, RTFSOBJATTRADD_NOTHING);
+ *src = RTPATH_DELIMITER;
+ if (rc == VINF_SUCCESS)
+ {
+#ifdef DEBUG
+ *src = 0;
+ Log(("Found valid partial path %s\n", pszFullPath));
+ *src = RTPATH_DELIMITER;
+#endif
+ break;
+ }
+ }
+
+ src--;
+ }
+ Assert(*src == RTPATH_DELIMITER && RT_SUCCESS(rc));
+ if ( *src == RTPATH_DELIMITER
+ && RT_SUCCESS(rc))
+ {
+ src++;
+ for(;;)
+ {
+ char *end = src;
+ bool fEndOfString = true;
+
+ while(*end)
+ {
+ if (*end == RTPATH_DELIMITER)
+ break;
+ end++;
+ }
+
+ if (*end == RTPATH_DELIMITER)
+ {
+ fEndOfString = false;
+ *end = 0;
+ rc = RTPathQueryInfo(src, &info, RTFSOBJATTRADD_NOTHING);
+ Assert(rc == VINF_SUCCESS || rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND);
+ }
+ else
+ if (end == src)
+ rc = VINF_SUCCESS; /* trailing delimiter */
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ if (rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND)
+ {
+ /* path component is invalid; try to correct the casing */
+ rc = vbsfCorrectCasing(pszFullPath, src);
+ if (RT_FAILURE(rc))
+ {
+ if (!fEndOfString)
+ *end = RTPATH_DELIMITER;
+ break;
+ }
+ }
+
+ if (fEndOfString)
+ break;
+
+ *end = RTPATH_DELIMITER;
+ src = end + 1;
+ }
+ if (RT_FAILURE(rc))
+ Log(("Unable to find suitable component rc=%d\n", rc));
+ }
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ }
+ if (pszWildCardComponent)
+ *pszWildCardComponent = RTPATH_DELIMITER;
+
+ if (RT_SUCCESS(rc))
+ Log(("New valid path %s\n", pszFullPath));
+ else
+ Log(("Old invalid path %s\n", pszFullPath));
+ return rc;
+}
+
+
+int main()
+{
+ char szTest[128];
+
+ RTR3InitExeNoArguments(0);
+ RTLogFlush(NULL);
+ RTLogDestinations(NULL, "stdout");
+ RTLogGroupSettings(NULL, "misc=~0");
+ RTLogFlags(NULL, "unbuffered");
+
+ strcpy(szTest, "c:\\test Dir\\z.bAt");
+ testCase(szTest);
+ strcpy(szTest, "c:\\test dir\\z.bAt");
+ testCase(szTest);
+ strcpy(szTest, "c:\\test dir\\SUBDIR\\z.bAt");
+ testCase(szTest);
+ strcpy(szTest, "c:\\test dir\\SUBDiR\\atestje.bat");
+ testCase(szTest);
+ strcpy(szTest, "c:\\TEST dir\\subDiR\\aTestje.baT");
+ testCase(szTest);
+ strcpy(szTest, "c:\\TEST dir\\subDiR\\*");
+ testCase(szTest, true);
+ strcpy(szTest, "c:\\TEST dir\\subDiR\\");
+ testCase(szTest ,true);
+ strcpy(szTest, "c:\\test dir\\SUBDIR\\");
+ testCase(szTest);
+ strcpy(szTest, "c:\\test dir\\invalid\\SUBDIR\\test.bat");
+ testCase(szTest);
+ return 0;
+}
+
diff --git a/src/VBox/HostServices/SharedFolders/testcase/tstShflSizes.cpp b/src/VBox/HostServices/SharedFolders/testcase/tstShflSizes.cpp
new file mode 100644
index 00000000..ab4e6a91
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/testcase/tstShflSizes.cpp
@@ -0,0 +1,134 @@
+/** @file
+ * tstShflSize - Testcase for shared folder structure sizes.
+ * Run this on Linux and Windows, then compare.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#include <VBox/shflsvc.h>
+#include <iprt/string.h>
+#include <stdio.h>
+
+#define STRUCT(t, size) \
+ do { \
+ if (fPrintChecks) \
+ printf(" STRUCT(" #t ", %d);\n", (int)sizeof(t)); \
+ else if ((size) != sizeof(t)) \
+ { \
+ printf("%30s: %d expected %d!\n", #t, (int)sizeof(t), (size)); \
+ cErrors++; \
+ } \
+ else if (!fQuiet)\
+ printf("%30s: %d\n", #t, (int)sizeof(t)); \
+ } while (0)
+
+
+int main(int argc, char **argv)
+{
+ unsigned cErrors = 0;
+
+ /*
+ * Prints the code below if any argument was giving.
+ */
+ bool fQuiet = argc == 2 && !strcmp(argv[1], "quiet");
+ bool fPrintChecks = !fQuiet && argc != 1;
+
+ printf("tstShflSizes: TESTING\n");
+
+ /*
+ * The checks.
+ */
+ STRUCT(SHFLROOT, 4);
+ STRUCT(SHFLHANDLE, 8);
+ STRUCT(SHFLSTRING, 6);
+ STRUCT(SHFLCREATERESULT, 4);
+ STRUCT(SHFLCREATEPARMS, 108);
+ STRUCT(SHFLMAPPING, 8);
+ STRUCT(SHFLDIRINFO, 128);
+ STRUCT(SHFLVOLINFO, 40);
+ STRUCT(SHFLFSOBJATTR, 44);
+ STRUCT(SHFLFSOBJINFO, 92);
+#ifdef VBOX_WITH_64_BITS_GUESTS
+/* The size of the guest structures depends on the current architecture bit count (ARCH_BITS)
+ * because the HGCMFunctionParameter structure differs in 32 and 64 bit guests.
+ * The host VMMDev device takes care about this.
+ *
+ * Therefore this testcase verifies whether structure sizes are correct for the current ARCH_BITS.
+ */
+# if ARCH_BITS == 64
+ STRUCT(VBoxSFQueryMappings, 88);
+ STRUCT(VBoxSFQueryMapName, 72);
+ STRUCT(VBoxSFMapFolder_Old, 88);
+ STRUCT(VBoxSFMapFolder, 104);
+ STRUCT(VBoxSFUnmapFolder, 56);
+ STRUCT(VBoxSFCreate, 88);
+ STRUCT(VBoxSFClose, 72);
+ STRUCT(VBoxSFRead, 120);
+ STRUCT(VBoxSFWrite, 120);
+ STRUCT(VBoxSFLock, 120);
+ STRUCT(VBoxSFFlush, 72);
+ STRUCT(VBoxSFList, 168);
+ STRUCT(VBoxSFInformation, 120);
+ STRUCT(VBoxSFRemove, 88);
+ STRUCT(VBoxSFRename, 104);
+# elif ARCH_BITS == 32
+ STRUCT(VBoxSFQueryMappings, 24+52);
+ STRUCT(VBoxSFQueryMapName, 24+40); /* this was changed from 52 in 21976 after VBox-1.4. */
+ STRUCT(VBoxSFMapFolder_Old, 24+52);
+ STRUCT(VBoxSFMapFolder, 24+64);
+ STRUCT(VBoxSFUnmapFolder, 24+28);
+ STRUCT(VBoxSFCreate, 24+52);
+ STRUCT(VBoxSFClose, 24+40);
+ STRUCT(VBoxSFRead, 24+76);
+ STRUCT(VBoxSFWrite, 24+76);
+ STRUCT(VBoxSFLock, 24+76);
+ STRUCT(VBoxSFFlush, 24+40);
+ STRUCT(VBoxSFList, 24+112);
+ STRUCT(VBoxSFInformation, 24+76);
+ STRUCT(VBoxSFRemove, 24+52);
+ STRUCT(VBoxSFRename, 24+64);
+# else
+# error "Unsupported ARCH_BITS"
+# endif /* ARCH_BITS */
+#else
+ STRUCT(VBoxSFQueryMappings, 24+52);
+ STRUCT(VBoxSFQueryMapName, 24+40); /* this was changed from 52 in 21976 after VBox-1.4. */
+ STRUCT(VBoxSFMapFolder_Old, 24+52);
+ STRUCT(VBoxSFMapFolder, 24+64);
+ STRUCT(VBoxSFUnmapFolder, 24+28);
+ STRUCT(VBoxSFCreate, 24+52);
+ STRUCT(VBoxSFClose, 24+40);
+ STRUCT(VBoxSFRead, 24+76);
+ STRUCT(VBoxSFWrite, 24+76);
+ STRUCT(VBoxSFLock, 24+76);
+ STRUCT(VBoxSFFlush, 24+40);
+ STRUCT(VBoxSFList, 24+112);
+ STRUCT(VBoxSFInformation, 24+76);
+ STRUCT(VBoxSFRemove, 24+52);
+ STRUCT(VBoxSFRename, 24+64);
+#endif /* VBOX_WITH_64_BITS_GUESTS */
+
+ /*
+ * The summary.
+ */
+ if (!cErrors)
+ printf("tstShflSizes: SUCCESS\n");
+ else
+ printf("tstShflSizes: FAILURE - %d errors\n", cErrors);
+ return !!cErrors;
+}
+
diff --git a/src/VBox/HostServices/SharedFolders/teststubs.h b/src/VBox/HostServices/SharedFolders/teststubs.h
new file mode 100644
index 00000000..13d5ebee
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/teststubs.h
@@ -0,0 +1,87 @@
+/** @file
+ * VBox Shared Folders testcase stub redefinitions.
+ */
+
+/*
+ * Copyright (C) 2011-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+/**
+ * Macros for renaming iprt file operations to redirect them to testcase
+ * stub functions (mocks). The religiously correct way to do this would be
+ * to make the service use a file operations structure with function pointers
+ * but I'm not sure that would be universally appreciated. */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_teststubs_h
+#define VBOX_INCLUDED_SRC_SharedFolders_teststubs_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include <iprt/dir.h>
+#include <iprt/time.h>
+
+#define RTDirClose testRTDirClose
+extern int testRTDirClose(RTDIR hDir);
+#define RTDirCreate testRTDirCreate
+extern int testRTDirCreate(const char *pszPath, RTFMODE fMode, uint32_t fCreate);
+#define RTDirOpen testRTDirOpen
+extern int testRTDirOpen(RTDIR *phDir, const char *pszPath);
+#define RTDirOpenFiltered testRTDirOpenFiltered
+extern int testRTDirOpenFiltered(RTDIR *phDir, const char *pszPath, RTDIRFILTER enmFilter, uint32_t fFlags);
+#define RTDirQueryInfo testRTDirQueryInfo
+extern int testRTDirQueryInfo(RTDIR hDir, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs);
+#define RTDirRemove testRTDirRemove
+extern int testRTDirRemove(const char *pszPath);
+#define RTDirReadEx testRTDirReadEx
+extern int testRTDirReadEx(RTDIR hDir, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags);
+#define RTDirSetTimes testRTDirSetTimes
+extern int testRTDirSetTimes(RTDIR hDir, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime);
+#define RTFileClose testRTFileClose
+extern int testRTFileClose(RTFILE hFile);
+#define RTFileDelete testRTFileDelete
+extern int testRTFileDelete(const char *pszFilename);
+#define RTFileFlush testRTFileFlush
+extern int testRTFileFlush(RTFILE hFile);
+#define RTFileLock testRTFileLock
+extern int testRTFileLock(RTFILE hFile, unsigned fLock, int64_t offLock, uint64_t cbLock);
+#define RTFileOpen testRTFileOpen
+extern int testRTFileOpen(PRTFILE pFile, const char *pszFilename, uint64_t fOpen);
+#define RTFileQueryInfo testRTFileQueryInfo
+extern int testRTFileQueryInfo(RTFILE hFile, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs);
+#define RTFileRead testRTFileRead
+extern int testRTFileRead(RTFILE hFile, void *pvBuf, size_t cbToRead, size_t *pcbRead);
+#define RTFileSetMode testRTFileSetMode
+extern int testRTFileSetMode(RTFILE hFile, RTFMODE fMode);
+#define RTFileSetSize testRTFileSetSize
+extern int testRTFileSetSize(RTFILE hFile, uint64_t cbSize);
+#define RTFileSetTimes testRTFileSetTimes
+extern int testRTFileSetTimes(RTFILE hFile, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime);
+#define RTFileSeek testRTFileSeek
+extern int testRTFileSeek(RTFILE hFile, int64_t offSeek, unsigned uMethod, uint64_t *poffActual);
+#define RTFileUnlock testRTFileUnlock
+extern int testRTFileUnlock(RTFILE hFile, int64_t offLock, uint64_t cbLock);
+#define RTFileWrite testRTFileWrite
+extern int testRTFileWrite(RTFILE hFile, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten);
+#define RTFsQueryProperties testRTFsQueryProperties
+extern int testRTFsQueryProperties(const char *pszFsPath, PRTFSPROPERTIES pProperties);
+#define RTFsQuerySerial testRTFsQuerySerial
+extern int testRTFsQuerySerial(const char *pszFsPath, uint32_t *pu32Serial);
+#define RTFsQuerySizes testRTFsQuerySizes
+extern int testRTFsQuerySizes(const char *pszFsPath, RTFOFF *pcbTotal, RTFOFF *pcbFree, uint32_t *pcbBlock, uint32_t *pcbSector);
+#define RTPathQueryInfoEx testRTPathQueryInfoEx
+extern int testRTPathQueryInfoEx(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs, uint32_t fFlags);
+#define RTSymlinkDelete testRTSymlinkDelete
+extern int testRTSymlinkDelete(const char *pszSymlink, uint32_t fDelete);
+#define RTSymlinkRead testRTSymlinkRead
+extern int testRTSymlinkRead(const char *pszSymlink, char *pszTarget, size_t cbTarget, uint32_t fRead);
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_teststubs_h */
diff --git a/src/VBox/HostServices/SharedFolders/vbsf.cpp b/src/VBox/HostServices/SharedFolders/vbsf.cpp
new file mode 100644
index 00000000..e346b3f8
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/vbsf.cpp
@@ -0,0 +1,2107 @@
+/* $Id: vbsf.cpp $ */
+/** @file
+ * Shared Folders - VBox Shared Folders.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
+#ifdef UNITTEST
+# include "testcase/tstSharedFolderService.h"
+#endif
+
+#include "vbsfpath.h"
+#include "mappings.h"
+#include "vbsf.h"
+#include "shflhandle.h"
+
+#include <VBox/AssertGuest.h>
+#include <iprt/alloc.h>
+#include <iprt/assert.h>
+#include <iprt/asm.h>
+#include <iprt/fs.h>
+#include <iprt/dir.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <iprt/symlink.h>
+#include <iprt/uni.h>
+#include <iprt/stream.h>
+#ifdef RT_OS_DARWIN
+# include <Carbon/Carbon.h>
+#endif
+
+#ifdef UNITTEST
+# include "teststubs.h"
+#endif
+
+
+/*********************************************************************************************************************************
+* Defined Constants And Macros *
+*********************************************************************************************************************************/
+#define SHFL_RT_LINK(pClient) ((pClient)->fu32Flags & SHFL_CF_SYMLINKS ? RTPATH_F_ON_LINK : RTPATH_F_FOLLOW_LINK)
+
+
+/**
+ * @todo find a better solution for supporting the execute bit for non-windows
+ * guests on windows host. Search for "0111" to find all the relevant places.
+ */
+
+void vbsfStripLastComponent(char *pszFullPath, uint32_t cbFullPathRoot)
+{
+ RTUNICP cp;
+
+ /* Do not strip root. */
+ char *s = pszFullPath + cbFullPathRoot;
+ char *delimSecondLast = NULL;
+ char *delimLast = NULL;
+
+ LogFlowFunc(("%s -> %s\n", pszFullPath, s));
+
+ for (;;)
+ {
+ cp = RTStrGetCp(s);
+
+ if (cp == RTUNICP_INVALID || cp == 0)
+ {
+ break;
+ }
+
+ if (cp == RTPATH_DELIMITER)
+ {
+ if (delimLast != NULL)
+ {
+ delimSecondLast = delimLast;
+ }
+
+ delimLast = s;
+ }
+
+ s = RTStrNextCp(s);
+ }
+
+ if (cp == 0)
+ {
+ if (delimLast + 1 == s)
+ {
+ if (delimSecondLast)
+ {
+ *delimSecondLast = 0;
+ }
+ else if (delimLast)
+ {
+ *delimLast = 0;
+ }
+ }
+ else
+ {
+ if (delimLast)
+ {
+ *delimLast = 0;
+ }
+ }
+ }
+
+ LogFlowFunc(("%s, %s, %s\n", pszFullPath, delimLast, delimSecondLast));
+}
+
+static int vbsfBuildFullPath(SHFLCLIENTDATA *pClient, SHFLROOT root, PSHFLSTRING pPath,
+ uint32_t cbPath, char **ppszFullPath, uint32_t *pcbFullPathRoot,
+ bool fWildCard = false, bool fPreserveLastComponent = false)
+{
+ char *pszHostPath = NULL;
+ uint32_t fu32PathFlags = 0;
+ uint32_t fu32Options = VBSF_O_PATH_CHECK_ROOT_ESCAPE
+ | (fWildCard? VBSF_O_PATH_WILDCARD: 0)
+ | (fPreserveLastComponent? VBSF_O_PATH_PRESERVE_LAST_COMPONENT: 0);
+
+ int rc = vbsfPathGuestToHost(pClient, root, pPath, cbPath,
+ &pszHostPath, pcbFullPathRoot, fu32Options, &fu32PathFlags);
+ if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ {
+ LogRel2(("SharedFolders: GuestToHost 0x%RX32 [%.*s]->[%s] %Rrc\n", fu32PathFlags, pPath->u16Length, &pPath->String.utf8[0], pszHostPath, rc));
+ }
+ else
+ {
+ LogRel2(("SharedFolders: GuestToHost 0x%RX32 [%.*ls]->[%s] %Rrc\n", fu32PathFlags, pPath->u16Length / 2, &pPath->String.ucs2[0], pszHostPath, rc));
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ if (ppszFullPath)
+ *ppszFullPath = pszHostPath;
+ }
+ return rc;
+}
+
+static void vbsfFreeFullPath(char *pszFullPath)
+{
+ vbsfFreeHostPath(pszFullPath);
+}
+
+typedef enum VBSFCHECKACCESS
+{
+ VBSF_CHECK_ACCESS_READ = 0,
+ VBSF_CHECK_ACCESS_WRITE = 1
+} VBSFCHECKACCESS;
+
+/**
+ * Check if the handle data is valid and the operation is allowed on the shared folder.
+ *
+ * @returns IPRT status code
+ * @param pClient Data structure describing the client accessing the shared folder
+ * @param root The index of the shared folder in the table of mappings.
+ * @param pHandle Information about the file or directory object.
+ * @param enmCheckAccess Whether the operation needs read only or write access.
+ */
+static int vbsfCheckHandleAccess(SHFLCLIENTDATA *pClient, SHFLROOT root,
+ SHFLFILEHANDLE *pHandle, VBSFCHECKACCESS enmCheckAccess)
+{
+ /* Handle from the same 'root' index? */
+ if (RT_LIKELY(RT_VALID_PTR(pHandle) && root == pHandle->root))
+ { /* likely */ }
+ else
+ return VERR_INVALID_HANDLE;
+
+ /* Check if the guest is still allowed to access this share.
+ * vbsfMappingsQueryWritable returns error if the shared folder has been removed from the VM settings.
+ */
+ bool fWritable;
+ int rc = vbsfMappingsQueryWritable(pClient, root, &fWritable);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return VERR_ACCESS_DENIED;
+
+ if (enmCheckAccess == VBSF_CHECK_ACCESS_WRITE)
+ {
+ /* Operation requires write access. Check if the shared folder is writable too. */
+ if (RT_LIKELY(fWritable))
+ { /* likely */ }
+ else
+ return VERR_WRITE_PROTECT;
+ }
+
+ return VINF_SUCCESS;
+}
+
+/**
+ * Convert shared folder create flags (see include/iprt/shflsvc.h) into iprt create flags.
+ *
+ * @returns iprt status code
+ * @param fWritable whether the shared folder is writable
+ * @param fShflFlags shared folder create flags
+ * @param fMode file attributes
+ * @param handleInitial initial handle
+ * @retval pfOpen iprt create flags
+ */
+static int vbsfConvertFileOpenFlags(bool fWritable, unsigned fShflFlags, RTFMODE fMode, SHFLHANDLE handleInitial, uint32_t *pfOpen)
+{
+ uint32_t fOpen = 0;
+ int rc = VINF_SUCCESS;
+
+ if ( (fMode & RTFS_DOS_MASK) != 0
+ && (fMode & RTFS_UNIX_MASK) == 0)
+ {
+ /* A DOS/Windows guest, make RTFS_UNIX_* from RTFS_DOS_*.
+ * @todo this is based on rtFsModeNormalize/rtFsModeFromDos.
+ * May be better to use RTFsModeNormalize here.
+ */
+ fMode |= RTFS_UNIX_IRUSR | RTFS_UNIX_IRGRP | RTFS_UNIX_IROTH;
+ /* x for directories. */
+ if (fMode & RTFS_DOS_DIRECTORY)
+ fMode |= RTFS_TYPE_DIRECTORY | RTFS_UNIX_IXUSR | RTFS_UNIX_IXGRP | RTFS_UNIX_IXOTH;
+ /* writable? */
+ if (!(fMode & RTFS_DOS_READONLY))
+ fMode |= RTFS_UNIX_IWUSR | RTFS_UNIX_IWGRP | RTFS_UNIX_IWOTH;
+
+ /* Set the requested mode using only allowed bits. */
+ fOpen |= ((fMode & RTFS_UNIX_MASK) << RTFILE_O_CREATE_MODE_SHIFT) & RTFILE_O_CREATE_MODE_MASK;
+ }
+ else
+ {
+ /* Old linux and solaris additions did not initialize the Info.Attr.fMode field
+ * and it contained random bits from stack. Detect this using the handle field value
+ * passed from the guest: old additions set it (incorrectly) to 0, new additions
+ * set it to SHFL_HANDLE_NIL(~0).
+ */
+ if (handleInitial == 0)
+ {
+ /* Old additions. Do nothing, use default mode. */
+ }
+ else
+ {
+ /* New additions or Windows additions. Set the requested mode using only allowed bits.
+ * Note: Windows guest set RTFS_UNIX_MASK bits to 0, which means a default mode
+ * will be set in fOpen.
+ */
+ fOpen |= ((fMode & RTFS_UNIX_MASK) << RTFILE_O_CREATE_MODE_SHIFT) & RTFILE_O_CREATE_MODE_MASK;
+ }
+ }
+
+ switch (BIT_FLAG(fShflFlags, SHFL_CF_ACCESS_MASK_RW))
+ {
+ default:
+ case SHFL_CF_ACCESS_NONE:
+ {
+#ifdef RT_OS_WINDOWS
+ if (BIT_FLAG(fShflFlags, SHFL_CF_ACCESS_MASK_ATTR) != SHFL_CF_ACCESS_ATTR_NONE)
+ fOpen |= RTFILE_O_ATTR_ONLY;
+ else
+#endif
+ fOpen |= RTFILE_O_READ;
+ Log(("FLAG: SHFL_CF_ACCESS_NONE\n"));
+ break;
+ }
+
+ case SHFL_CF_ACCESS_READ:
+ {
+ fOpen |= RTFILE_O_READ;
+ Log(("FLAG: SHFL_CF_ACCESS_READ\n"));
+ break;
+ }
+
+ case SHFL_CF_ACCESS_WRITE:
+ {
+ fOpen |= RTFILE_O_WRITE;
+ Log(("FLAG: SHFL_CF_ACCESS_WRITE\n"));
+ break;
+ }
+
+ case SHFL_CF_ACCESS_READWRITE:
+ {
+ fOpen |= RTFILE_O_READWRITE;
+ Log(("FLAG: SHFL_CF_ACCESS_READWRITE\n"));
+ break;
+ }
+ }
+
+ if (fShflFlags & SHFL_CF_ACCESS_APPEND)
+ {
+ fOpen |= RTFILE_O_APPEND;
+ }
+
+ switch (BIT_FLAG(fShflFlags, SHFL_CF_ACCESS_MASK_ATTR))
+ {
+ default:
+ case SHFL_CF_ACCESS_ATTR_NONE:
+ {
+ fOpen |= RTFILE_O_ACCESS_ATTR_DEFAULT;
+ Log(("FLAG: SHFL_CF_ACCESS_ATTR_NONE\n"));
+ break;
+ }
+
+ case SHFL_CF_ACCESS_ATTR_READ:
+ {
+ fOpen |= RTFILE_O_ACCESS_ATTR_READ;
+ Log(("FLAG: SHFL_CF_ACCESS_ATTR_READ\n"));
+ break;
+ }
+
+ case SHFL_CF_ACCESS_ATTR_WRITE:
+ {
+ fOpen |= RTFILE_O_ACCESS_ATTR_WRITE;
+ Log(("FLAG: SHFL_CF_ACCESS_ATTR_WRITE\n"));
+ break;
+ }
+
+ case SHFL_CF_ACCESS_ATTR_READWRITE:
+ {
+ fOpen |= RTFILE_O_ACCESS_ATTR_READWRITE;
+ Log(("FLAG: SHFL_CF_ACCESS_ATTR_READWRITE\n"));
+ break;
+ }
+ }
+
+ /* Sharing mask */
+ switch (BIT_FLAG(fShflFlags, SHFL_CF_ACCESS_MASK_DENY))
+ {
+ default:
+ case SHFL_CF_ACCESS_DENYNONE:
+ fOpen |= RTFILE_O_DENY_NONE;
+ Log(("FLAG: SHFL_CF_ACCESS_DENYNONE\n"));
+ break;
+
+ case SHFL_CF_ACCESS_DENYREAD:
+ fOpen |= RTFILE_O_DENY_READ;
+ Log(("FLAG: SHFL_CF_ACCESS_DENYREAD\n"));
+ break;
+
+ case SHFL_CF_ACCESS_DENYWRITE:
+ fOpen |= RTFILE_O_DENY_WRITE;
+ Log(("FLAG: SHFL_CF_ACCESS_DENYWRITE\n"));
+ break;
+
+ case SHFL_CF_ACCESS_DENYALL:
+ fOpen |= RTFILE_O_DENY_ALL;
+ Log(("FLAG: SHFL_CF_ACCESS_DENYALL\n"));
+ break;
+ }
+
+ /* Open/Create action mask */
+ switch (BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_EXISTS))
+ {
+ case SHFL_CF_ACT_OPEN_IF_EXISTS:
+ if (SHFL_CF_ACT_CREATE_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_OPEN_CREATE;
+ Log(("FLAGS: SHFL_CF_ACT_OPEN_IF_EXISTS and SHFL_CF_ACT_CREATE_IF_NEW\n"));
+ }
+ else if (SHFL_CF_ACT_FAIL_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_OPEN;
+ Log(("FLAGS: SHFL_CF_ACT_OPEN_IF_EXISTS and SHFL_CF_ACT_FAIL_IF_NEW\n"));
+ }
+ else
+ {
+ Log(("FLAGS: invalid open/create action combination\n"));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ break;
+ case SHFL_CF_ACT_FAIL_IF_EXISTS:
+ if (SHFL_CF_ACT_CREATE_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_CREATE;
+ Log(("FLAGS: SHFL_CF_ACT_FAIL_IF_EXISTS and SHFL_CF_ACT_CREATE_IF_NEW\n"));
+ }
+ else
+ {
+ Log(("FLAGS: invalid open/create action combination\n"));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ break;
+ case SHFL_CF_ACT_REPLACE_IF_EXISTS:
+ if (SHFL_CF_ACT_CREATE_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_CREATE_REPLACE;
+ Log(("FLAGS: SHFL_CF_ACT_REPLACE_IF_EXISTS and SHFL_CF_ACT_CREATE_IF_NEW\n"));
+ }
+ else if (SHFL_CF_ACT_FAIL_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE;
+ Log(("FLAGS: SHFL_CF_ACT_REPLACE_IF_EXISTS and SHFL_CF_ACT_FAIL_IF_NEW\n"));
+ }
+ else
+ {
+ Log(("FLAGS: invalid open/create action combination\n"));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ break;
+ case SHFL_CF_ACT_OVERWRITE_IF_EXISTS:
+ if (SHFL_CF_ACT_CREATE_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_CREATE_REPLACE;
+ Log(("FLAGS: SHFL_CF_ACT_OVERWRITE_IF_EXISTS and SHFL_CF_ACT_CREATE_IF_NEW\n"));
+ }
+ else if (SHFL_CF_ACT_FAIL_IF_NEW == BIT_FLAG(fShflFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ fOpen |= RTFILE_O_OPEN | RTFILE_O_TRUNCATE;
+ Log(("FLAGS: SHFL_CF_ACT_OVERWRITE_IF_EXISTS and SHFL_CF_ACT_FAIL_IF_NEW\n"));
+ }
+ else
+ {
+ Log(("FLAGS: invalid open/create action combination\n"));
+ rc = VERR_INVALID_PARAMETER;
+ }
+ break;
+ default:
+ rc = VERR_INVALID_PARAMETER;
+ Log(("FLAG: SHFL_CF_ACT_MASK_IF_EXISTS - invalid parameter\n"));
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ if (!fWritable)
+ fOpen &= ~RTFILE_O_WRITE;
+
+ *pfOpen = fOpen;
+ }
+ return rc;
+}
+
+/**
+ * Open a file or create and open a new one.
+ *
+ * @returns IPRT status code
+ * @param pClient Data structure describing the client accessing the shared folder
+ * @param root The index of the shared folder in the table of mappings.
+ * @param pszPath Path to the file or folder on the host.
+ * @param pParms @a CreateFlags Creation or open parameters, see include/VBox/shflsvc.h
+ * @param pParms @a Info When a new file is created this specifies the initial parameters.
+ * When a file is created or overwritten, it also specifies the
+ * initial size.
+ * @retval pParms @a Resulte Shared folder status code, see include/VBox/shflsvc.h
+ * @retval pParms @a Handle On success the (shared folder) handle of the file opened or
+ * created
+ * @retval pParms @a Info On success the parameters of the file opened or created
+ */
+static int vbsfOpenFile(SHFLCLIENTDATA *pClient, SHFLROOT root, const char *pszPath, SHFLCREATEPARMS *pParms)
+{
+ LogFlow(("vbsfOpenFile: pszPath = %s, pParms = %p\n", pszPath, pParms));
+ Log(("SHFL create flags %08x\n", pParms->CreateFlags));
+
+ SHFLHANDLE handle = SHFL_HANDLE_NIL;
+ SHFLFILEHANDLE *pHandle = 0;
+ /* Open or create a file. */
+ uint32_t fOpen = 0;
+ bool fNoError = false;
+ static int cErrors;
+
+ /* is the guest allowed to write to this share? */
+ bool fWritable;
+ int rc = vbsfMappingsQueryWritable(pClient, root, &fWritable);
+ if (RT_FAILURE(rc))
+ fWritable = false;
+
+ rc = vbsfConvertFileOpenFlags(fWritable, pParms->CreateFlags, pParms->Info.Attr.fMode, pParms->Handle, &fOpen);
+ if (RT_SUCCESS(rc))
+ {
+ rc = VERR_NO_MEMORY; /* Default error. */
+ handle = vbsfAllocFileHandle(pClient);
+ if (handle != SHFL_HANDLE_NIL)
+ {
+ pHandle = vbsfQueryFileHandle(pClient, handle);
+ if (pHandle)
+ {
+ pHandle->root = root;
+ rc = RTFileOpen(&pHandle->file.Handle, pszPath, fOpen);
+ }
+ }
+ }
+ if (RT_FAILURE(rc))
+ {
+ switch (rc)
+ {
+ case VERR_FILE_NOT_FOUND:
+ pParms->Result = SHFL_FILE_NOT_FOUND;
+
+ /* This actually isn't an error, so correct the rc before return later,
+ because the driver (VBoxSF.sys) expects rc = VINF_SUCCESS and checks the result code. */
+ fNoError = true;
+ break;
+ case VERR_PATH_NOT_FOUND:
+ pParms->Result = SHFL_PATH_NOT_FOUND;
+
+ /* This actually isn't an error, so correct the rc before return later,
+ because the driver (VBoxSF.sys) expects rc = VINF_SUCCESS and checks the result code. */
+ fNoError = true;
+ break;
+ case VERR_ALREADY_EXISTS:
+ RTFSOBJINFO info;
+
+ /** @todo Possible race left here. */
+ if (RT_SUCCESS(RTPathQueryInfoEx(pszPath, &info, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient))))
+ {
+#ifdef RT_OS_WINDOWS
+ info.Attr.fMode |= 0111;
+#endif
+ vbfsCopyFsObjInfoFromIprt(&pParms->Info, &info);
+ }
+ pParms->Result = SHFL_FILE_EXISTS;
+
+ /* This actually isn't an error, so correct the rc before return later,
+ because the driver (VBoxSF.sys) expects rc = VINF_SUCCESS and checks the result code. */
+ fNoError = true;
+ break;
+ case VERR_TOO_MANY_OPEN_FILES:
+ if (cErrors < 32)
+ {
+ LogRel(("SharedFolders host service: Cannot open '%s' -- too many open files.\n", pszPath));
+#if defined RT_OS_LINUX || defined(RT_OS_SOLARIS)
+ if (cErrors < 1)
+ LogRel(("SharedFolders host service: Try to increase the limit for open files (ulimit -n)\n"));
+#endif
+ cErrors++;
+ }
+ pParms->Result = SHFL_NO_RESULT;
+ break;
+ default:
+ pParms->Result = SHFL_NO_RESULT;
+ }
+ }
+ else
+ {
+ /** @note The shared folder status code is very approximate, as the runtime
+ * does not really provide this information. */
+ pParms->Result = SHFL_FILE_EXISTS; /* We lost the information as to whether it was
+ created when we eliminated the race. */
+ if ( ( SHFL_CF_ACT_REPLACE_IF_EXISTS
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_EXISTS))
+ || ( SHFL_CF_ACT_OVERWRITE_IF_EXISTS
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_EXISTS)))
+ {
+ /* For now, we do not treat a failure here as fatal. */
+ /** @todo Also set the size for SHFL_CF_ACT_CREATE_IF_NEW if
+ SHFL_CF_ACT_FAIL_IF_EXISTS is set. */
+ RTFileSetSize(pHandle->file.Handle, pParms->Info.cbObject);
+ pParms->Result = SHFL_FILE_REPLACED;
+ }
+ if ( ( SHFL_CF_ACT_FAIL_IF_EXISTS
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_EXISTS))
+ || ( SHFL_CF_ACT_CREATE_IF_NEW
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_NEW)))
+ {
+ pParms->Result = SHFL_FILE_CREATED;
+ }
+#if 0
+ /** @todo */
+ /* Set new attributes. */
+ if ( ( SHFL_CF_ACT_REPLACE_IF_EXISTS
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_EXISTS))
+ || ( SHFL_CF_ACT_CREATE_IF_NEW
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_NEW)))
+ {
+ RTFileSetTimes(pHandle->file.Handle,
+ &pParms->Info.AccessTime,
+ &pParms->Info.ModificationTime,
+ &pParms->Info.ChangeTime,
+ &pParms->Info.BirthTime
+ );
+
+ RTFileSetMode (pHandle->file.Handle, pParms->Info.Attr.fMode);
+ }
+#endif
+ RTFSOBJINFO info;
+
+ /* Get file information */
+ rc = RTFileQueryInfo(pHandle->file.Handle, &info, RTFSOBJATTRADD_NOTHING);
+ if (RT_SUCCESS(rc))
+ {
+#ifdef RT_OS_WINDOWS
+ info.Attr.fMode |= 0111;
+#endif
+ vbfsCopyFsObjInfoFromIprt(&pParms->Info, &info);
+ }
+ }
+ /* Free resources if any part of the function has failed. */
+ if (RT_FAILURE(rc))
+ {
+ if ( (0 != pHandle)
+ && (NIL_RTFILE != pHandle->file.Handle)
+ && (0 != pHandle->file.Handle))
+ {
+ RTFileClose(pHandle->file.Handle);
+ pHandle->file.Handle = NIL_RTFILE;
+ }
+ if (SHFL_HANDLE_NIL != handle)
+ {
+ vbsfFreeFileHandle(pClient, handle);
+ }
+ pParms->Handle = SHFL_HANDLE_NIL;
+ }
+ else
+ {
+ pParms->Handle = handle;
+ }
+
+ /* Report the driver that all is okay, we're done here */
+ if (fNoError)
+ rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfOpenFile: rc = %Rrc\n", rc));
+ return rc;
+}
+
+/**
+ * Open a folder or create and open a new one.
+ *
+ * @returns IPRT status code
+ * @param pClient Data structure describing the client accessing the shared folder
+ * @param root The index of the shared folder in the table of mappings.
+ * @param pszPath Path to the file or folder on the host.
+ * @param pParms @a CreateFlags Creation or open parameters, see include/VBox/shflsvc.h
+ * @retval pParms @a Result Shared folder status code, see include/VBox/shflsvc.h
+ * @retval pParms @a Handle On success the (shared folder) handle of the folder opened or
+ * created
+ * @retval pParms @a Info On success the parameters of the folder opened or created
+ *
+ * @note folders are created with fMode = 0777
+ */
+static int vbsfOpenDir(SHFLCLIENTDATA *pClient, SHFLROOT root, const char *pszPath,
+ SHFLCREATEPARMS *pParms)
+{
+ LogFlow(("vbsfOpenDir: pszPath = %s, pParms = %p\n", pszPath, pParms));
+ Log(("SHFL create flags %08x\n", pParms->CreateFlags));
+
+ int rc = VERR_NO_MEMORY;
+ SHFLHANDLE handle = vbsfAllocDirHandle(pClient);
+ SHFLFILEHANDLE *pHandle = vbsfQueryDirHandle(pClient, handle);
+ if (0 != pHandle)
+ {
+ pHandle->root = root;
+ rc = VINF_SUCCESS;
+ pParms->Result = SHFL_FILE_EXISTS; /* May be overwritten with SHFL_FILE_CREATED. */
+ /** @todo Can anyone think of a sensible, race-less way to do this? Although
+ I suspect that the race is inherent, due to the API available... */
+ /* Try to create the folder first if "create if new" is specified. If this
+ fails, and "open if exists" is specified, then we ignore the failure and try
+ to open the folder anyway. */
+ if ( SHFL_CF_ACT_CREATE_IF_NEW
+ == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_NEW))
+ {
+ /** @todo render supplied attributes.
+ * bird: The guest should specify this. For windows guests RTFS_DOS_DIRECTORY should suffice. */
+ RTFMODE fMode = 0777;
+
+ pParms->Result = SHFL_FILE_CREATED;
+ rc = RTDirCreate(pszPath, fMode, 0);
+ if (RT_FAILURE(rc))
+ {
+ switch (rc)
+ {
+ case VERR_ALREADY_EXISTS:
+ pParms->Result = SHFL_FILE_EXISTS;
+ break;
+ case VERR_PATH_NOT_FOUND:
+ pParms->Result = SHFL_PATH_NOT_FOUND;
+ break;
+ default:
+ pParms->Result = SHFL_NO_RESULT;
+ }
+ }
+ }
+ if ( RT_SUCCESS(rc)
+ || (SHFL_CF_ACT_OPEN_IF_EXISTS == BIT_FLAG(pParms->CreateFlags, SHFL_CF_ACT_MASK_IF_EXISTS)))
+ {
+ /* Open the directory now */
+ rc = RTDirOpenFiltered(&pHandle->dir.Handle, pszPath, RTDIRFILTER_NONE, 0 /*fFlags*/);
+ if (RT_SUCCESS(rc))
+ {
+ RTFSOBJINFO info;
+
+ rc = RTDirQueryInfo(pHandle->dir.Handle, &info, RTFSOBJATTRADD_NOTHING);
+ if (RT_SUCCESS(rc))
+ {
+ vbfsCopyFsObjInfoFromIprt(&pParms->Info, &info);
+ }
+ }
+ else
+ {
+ switch (rc)
+ {
+ case VERR_FILE_NOT_FOUND: /* Does this make sense? */
+ pParms->Result = SHFL_FILE_NOT_FOUND;
+ break;
+ case VERR_PATH_NOT_FOUND:
+ pParms->Result = SHFL_PATH_NOT_FOUND;
+ break;
+ case VERR_ACCESS_DENIED:
+ pParms->Result = SHFL_FILE_EXISTS;
+ break;
+ default:
+ pParms->Result = SHFL_NO_RESULT;
+ }
+ }
+ }
+ }
+ if (RT_FAILURE(rc))
+ {
+ if ( (0 != pHandle)
+ && (0 != pHandle->dir.Handle))
+ {
+ RTDirClose(pHandle->dir.Handle);
+ pHandle->dir.Handle = 0;
+ }
+ if (SHFL_HANDLE_NIL != handle)
+ {
+ vbsfFreeFileHandle(pClient, handle);
+ }
+ pParms->Handle = SHFL_HANDLE_NIL;
+ }
+ else
+ {
+ pParms->Handle = handle;
+ }
+ LogFlow(("vbsfOpenDir: rc = %Rrc\n", rc));
+ return rc;
+}
+
+static int vbsfCloseDir(SHFLFILEHANDLE *pHandle)
+{
+ int rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfCloseDir: Handle = %08X Search Handle = %08X\n",
+ pHandle->dir.Handle, pHandle->dir.SearchHandle));
+
+ RTDirClose(pHandle->dir.Handle);
+
+ if (pHandle->dir.SearchHandle)
+ RTDirClose(pHandle->dir.SearchHandle);
+
+ if (pHandle->dir.pLastValidEntry)
+ {
+ RTMemFree(pHandle->dir.pLastValidEntry);
+ pHandle->dir.pLastValidEntry = NULL;
+ }
+
+ LogFlow(("vbsfCloseDir: rc = %d\n", rc));
+
+ return rc;
+}
+
+
+static int vbsfCloseFile(SHFLFILEHANDLE *pHandle)
+{
+ int rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfCloseFile: Handle = %08X\n",
+ pHandle->file.Handle));
+
+ rc = RTFileClose(pHandle->file.Handle);
+
+ LogFlow(("vbsfCloseFile: rc = %d\n", rc));
+
+ return rc;
+}
+
+/**
+ * Look up file or folder information by host path.
+ *
+ * @returns iprt status code (currently VINF_SUCCESS)
+ * @param pClient client data
+ * @param pszPath The path of the file to be looked up
+ * @retval pParms->Result Status of the operation (success or error)
+ * @retval pParms->Info On success, information returned about the file
+ */
+static int vbsfLookupFile(SHFLCLIENTDATA *pClient, char *pszPath, SHFLCREATEPARMS *pParms)
+{
+ RTFSOBJINFO info;
+ int rc;
+
+ rc = RTPathQueryInfoEx(pszPath, &info, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient));
+ LogFlow(("SHFL_CF_LOOKUP\n"));
+ /* Client just wants to know if the object exists. */
+ switch (rc)
+ {
+ case VINF_SUCCESS:
+ {
+#ifdef RT_OS_WINDOWS
+ info.Attr.fMode |= 0111;
+#endif
+ vbfsCopyFsObjInfoFromIprt(&pParms->Info, &info);
+ pParms->Result = SHFL_FILE_EXISTS;
+ break;
+ }
+
+ case VERR_FILE_NOT_FOUND:
+ {
+ pParms->Result = SHFL_FILE_NOT_FOUND;
+ rc = VINF_SUCCESS;
+ break;
+ }
+
+ case VERR_PATH_NOT_FOUND:
+ {
+ pParms->Result = SHFL_PATH_NOT_FOUND;
+ rc = VINF_SUCCESS;
+ break;
+ }
+ }
+ pParms->Handle = SHFL_HANDLE_NIL;
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_CREATE API. Located here as a form of API
+ * documentation. */
+void testCreate(RTTEST hTest)
+{
+ /* Simple opening of an existing file. */
+ testCreateFileSimple(hTest);
+ testCreateFileSimpleCaseInsensitive(hTest);
+ /* Simple opening of an existing directory. */
+ /** @todo How do wildcards in the path name work? */
+ testCreateDirSimple(hTest);
+ /* If the number or types of parameters are wrong the API should fail. */
+ testCreateBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+
+/**
+ * Create or open a file or folder. Perform character set and case
+ * conversion on the file name if necessary.
+ *
+ * @returns IPRT status code, but see note below
+ * @param pClient Data structure describing the client accessing the shared
+ * folder
+ * @param root The index of the shared folder in the table of mappings.
+ * The host path of the shared folder is found using this.
+ * @param pPath The path of the file or folder relative to the host path
+ * indexed by root.
+ * @param cbPath Presumably the length of the path in pPath. Actually
+ * ignored, as pPath contains a length parameter.
+ * @param pParms @a Info If a new file is created or an old one overwritten, set
+ * these attributes
+ * @retval pParms @a Result Shared folder result code, see include/VBox/shflsvc.h
+ * @retval pParms @a Handle Shared folder handle to the newly opened file
+ * @retval pParms @a Info Attributes of the file or folder opened
+ *
+ * @note This function returns success if a "non-exceptional" error occurred,
+ * such as "no such file". In this case, the caller should check the
+ * pParms->Result return value and whether pParms->Handle is valid.
+ */
+int vbsfCreate(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pPath, uint32_t cbPath, SHFLCREATEPARMS *pParms)
+{
+ int rc = VINF_SUCCESS;
+
+ LogFlow(("vbsfCreate: pClient = %p, pPath = %p, cbPath = %d, pParms = %p CreateFlags=%x\n",
+ pClient, pPath, cbPath, pParms, pParms->CreateFlags));
+
+ /* Check the client access rights to the root. */
+ /** @todo */
+
+ /* Build a host full path for the given path, handle file name case issues (if the guest
+ * expects case-insensitive paths but the host is case-sensitive) and convert ucs2 to utf8 if
+ * necessary.
+ */
+ char *pszFullPath = NULL;
+ uint32_t cbFullPathRoot = 0;
+
+ rc = vbsfBuildFullPath(pClient, root, pPath, cbPath, &pszFullPath, &cbFullPathRoot);
+ if (RT_SUCCESS(rc))
+ {
+ /* Reset return value in case client forgot to do so.
+ * pParms->Handle must not be reset here, as it is used
+ * in vbsfOpenFile to detect old additions.
+ */
+ pParms->Result = SHFL_NO_RESULT;
+
+ if (BIT_FLAG(pParms->CreateFlags, SHFL_CF_LOOKUP))
+ {
+ rc = vbsfLookupFile(pClient, pszFullPath, pParms);
+ }
+ else
+ {
+ /* Query path information. */
+ RTFSOBJINFO info;
+
+ rc = RTPathQueryInfoEx(pszFullPath, &info, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient));
+ LogFlow(("RTPathQueryInfoEx returned %Rrc\n", rc));
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Mark it as a directory in case the caller didn't. */
+ /**
+ * @todo I left this in in order not to change the behaviour of the
+ * function too much. Is it really needed, and should it really be
+ * here?
+ */
+ if (BIT_FLAG(info.Attr.fMode, RTFS_DOS_DIRECTORY))
+ {
+ pParms->CreateFlags |= SHFL_CF_DIRECTORY;
+ }
+
+ /**
+ * @todo This should be in the Windows Guest Additions, as no-one else
+ * needs it.
+ */
+ if (BIT_FLAG(pParms->CreateFlags, SHFL_CF_OPEN_TARGET_DIRECTORY))
+ {
+ vbsfStripLastComponent(pszFullPath, cbFullPathRoot);
+ pParms->CreateFlags &= ~SHFL_CF_ACT_MASK_IF_EXISTS;
+ pParms->CreateFlags &= ~SHFL_CF_ACT_MASK_IF_NEW;
+ pParms->CreateFlags |= SHFL_CF_DIRECTORY;
+ pParms->CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+ pParms->CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
+ }
+ }
+
+ rc = VINF_SUCCESS;
+
+ /* Note: do not check the SHFL_CF_ACCESS_WRITE here, only check if the open operation
+ * will cause changes.
+ *
+ * Actual operations (write, set attr, etc), which can write to a shared folder, have
+ * the check and will return VERR_WRITE_PROTECT if the folder is not writable.
+ */
+ if ( (pParms->CreateFlags & SHFL_CF_ACT_MASK_IF_EXISTS) == SHFL_CF_ACT_REPLACE_IF_EXISTS
+ || (pParms->CreateFlags & SHFL_CF_ACT_MASK_IF_EXISTS) == SHFL_CF_ACT_OVERWRITE_IF_EXISTS
+ || (pParms->CreateFlags & SHFL_CF_ACT_MASK_IF_NEW) == SHFL_CF_ACT_CREATE_IF_NEW
+ )
+ {
+ /* is the guest allowed to write to this share? */
+ bool fWritable;
+ rc = vbsfMappingsQueryWritable(pClient, root, &fWritable);
+ if (RT_FAILURE(rc) || !fWritable)
+ rc = VERR_WRITE_PROTECT;
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ if (BIT_FLAG(pParms->CreateFlags, SHFL_CF_DIRECTORY))
+ {
+ rc = vbsfOpenDir(pClient, root, pszFullPath, pParms);
+ }
+ else
+ {
+ rc = vbsfOpenFile(pClient, root, pszFullPath, pParms);
+ }
+ }
+ else
+ {
+ pParms->Handle = SHFL_HANDLE_NIL;
+ }
+ }
+
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPath);
+ }
+
+ Log(("vbsfCreate: handle = %RX64 rc = %Rrc result=%x\n", (uint64_t)pParms->Handle, rc, pParms->Result));
+
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_CLOSE API. Located here as a form of API
+ * documentation. */
+void testClose(RTTEST hTest)
+{
+ /* If the API parameters are invalid the API should fail. */
+ testCloseBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+
+int vbsfClose(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle)
+{
+ LogFunc(("pClient = %p, root 0x%RX32, Handle = 0x%RX64\n",
+ pClient, root, Handle));
+
+ int rc = VERR_INVALID_HANDLE;
+ uint32_t type = vbsfQueryHandleType(pClient, Handle);
+ Assert((type & ~(SHFL_HF_TYPE_DIR | SHFL_HF_TYPE_FILE)) == 0);
+ switch (type & (SHFL_HF_TYPE_DIR | SHFL_HF_TYPE_FILE))
+ {
+ case SHFL_HF_TYPE_DIR:
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryDirHandle(pClient, Handle);
+ if (RT_LIKELY(pHandle && root == pHandle->root))
+ {
+ rc = vbsfCloseDir(pHandle);
+ vbsfFreeFileHandle(pClient, Handle);
+ }
+ break;
+ }
+ case SHFL_HF_TYPE_FILE:
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ if (RT_LIKELY(pHandle && root == pHandle->root))
+ {
+ rc = vbsfCloseFile(pHandle);
+ vbsfFreeFileHandle(pClient, Handle);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+
+ LogFunc(("rc = %Rrc\n", rc));
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_READ API. Located here as a form of API
+ * documentation. */
+void testRead(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testReadBadParameters(hTest);
+ /* Basic reading from a file. */
+ testReadFileSimple(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfRead(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ LogFunc(("pClient %p, root 0x%RX32, Handle 0x%RX64, offset 0x%RX64, bytes 0x%RX32\n",
+ pClient, root, Handle, offset, pcbBuffer? *pcbBuffer: 0));
+
+ AssertPtrReturn(pClient, VERR_INVALID_PARAMETER);
+
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_READ);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ if (RT_LIKELY(*pcbBuffer != 0))
+ {
+ rc = RTFileSeek(pHandle->file.Handle, offset, RTFILE_SEEK_BEGIN, NULL);
+ if (RT_SUCCESS(rc))
+ {
+ size_t count = 0;
+ rc = RTFileRead(pHandle->file.Handle, pBuffer, *pcbBuffer, &count);
+ *pcbBuffer = (uint32_t)count;
+ }
+ else
+ AssertRC(rc);
+ }
+ else
+ {
+ /* Reading zero bytes always succeeds. */
+ rc = VINF_SUCCESS;
+ }
+
+ LogFunc(("%Rrc bytes read 0x%RX32\n", rc, *pcbBuffer));
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_WRITE API. Located here as a form of API
+ * documentation. */
+void testWrite(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testWriteBadParameters(hTest);
+ /* Simple test of writing to a file. */
+ testWriteFileSimple(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfWrite(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ LogFunc(("pClient %p, root 0x%RX32, Handle 0x%RX64, offset 0x%RX64, bytes 0x%RX32\n",
+ pClient, root, Handle, offset, pcbBuffer? *pcbBuffer: 0));
+
+ AssertPtrReturn(pClient, VERR_INVALID_PARAMETER);
+
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ if (RT_LIKELY(*pcbBuffer != 0))
+ {
+ rc = RTFileSeek(pHandle->file.Handle, offset, RTFILE_SEEK_BEGIN, NULL);
+ if (RT_SUCCESS(rc))
+ {
+ size_t count = 0;
+ rc = RTFileWrite(pHandle->file.Handle, pBuffer, *pcbBuffer, &count);
+ *pcbBuffer = (uint32_t)count;
+ }
+ else
+ AssertRC(rc);
+ }
+ else
+ {
+ /** @todo What writing zero bytes should do? */
+ rc = VINF_SUCCESS;
+ }
+
+ LogFunc(("%Rrc bytes written 0x%RX32\n", rc, *pcbBuffer));
+ return rc;
+}
+
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_FLUSH API. Located here as a form of API
+ * documentation. */
+void testFlush(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testFlushBadParameters(hTest);
+ /* Simple opening and flushing of a file. */
+ testFlushFileSimple(hTest);
+ /* Add tests as required... */
+}
+#endif
+
+int vbsfFlush(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle)
+{
+ LogFunc(("pClient %p, root 0x%RX32, Handle 0x%RX64\n",
+ pClient, root, Handle));
+
+ AssertPtrReturn(pClient, VERR_INVALID_PARAMETER);
+
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ rc = RTFileFlush(pHandle->file.Handle);
+
+ LogFunc(("%Rrc\n", rc));
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_LIST API. Located here as a form of API
+ * documentation. */
+void testDirList(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testDirListBadParameters(hTest);
+ /* Test listing an empty directory (simple edge case). */
+ testDirListEmpty(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfDirList(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, SHFLSTRING *pPath, uint32_t flags,
+ uint32_t *pcbBuffer, uint8_t *pBuffer, uint32_t *pIndex, uint32_t *pcFiles)
+{
+ PRTDIRENTRYEX pDirEntry = 0, pDirEntryOrg;
+ uint32_t cbDirEntry, cbBufferOrg;
+ PSHFLDIRINFO pSFDEntry;
+ PRTUTF16 pwszString;
+ RTDIR hDir;
+ const bool fUtf8 = BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8) != 0;
+
+ AssertPtrReturn(pClient, VERR_INVALID_PARAMETER);
+
+ SHFLFILEHANDLE *pHandle = vbsfQueryDirHandle(pClient, Handle);
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_READ);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ Assert(*pIndex == 0);
+
+ cbDirEntry = 4096;
+ pDirEntryOrg = pDirEntry = (PRTDIRENTRYEX)RTMemAlloc(cbDirEntry);
+ if (pDirEntry == 0)
+ {
+ AssertFailed();
+ return VERR_NO_MEMORY;
+ }
+
+ cbBufferOrg = *pcbBuffer;
+ *pcbBuffer = 0;
+ pSFDEntry = (PSHFLDIRINFO)pBuffer;
+
+ *pIndex = 1; /* not yet complete */
+ *pcFiles = 0;
+
+ if (!pPath)
+ hDir = pHandle->dir.Handle;
+ else
+ {
+ if (pHandle->dir.SearchHandle == 0)
+ {
+ /* Build a host full path for the given path
+ * and convert ucs2 to utf8 if necessary.
+ */
+ char *pszFullPath = NULL;
+
+ Assert(pHandle->dir.pLastValidEntry == 0);
+
+ rc = vbsfBuildFullPath(pClient, root, pPath, pPath->u16Size + SHFLSTRING_HEADER_SIZE, &pszFullPath, NULL, true);
+
+ if (RT_SUCCESS(rc))
+ {
+ rc = RTDirOpenFiltered(&pHandle->dir.SearchHandle, pszFullPath, RTDIRFILTER_WINNT, 0 /*fFlags*/);
+
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPath);
+
+ if (RT_FAILURE(rc))
+ goto end;
+ }
+ else
+ goto end;
+ flags &= ~SHFL_LIST_RESTART;
+ }
+ Assert(pHandle->dir.SearchHandle);
+ hDir = pHandle->dir.SearchHandle;
+ }
+
+ if (flags & SHFL_LIST_RESTART)
+ {
+ rc = RTDirRewind(hDir);
+ if (RT_FAILURE(rc))
+ goto end;
+ }
+
+ while (cbBufferOrg)
+ {
+ size_t cbDirEntrySize = cbDirEntry;
+ uint32_t cbNeeded;
+
+ /* Do we still have a valid last entry for the active search? If so, then return it here */
+ if (pHandle->dir.pLastValidEntry)
+ {
+ pDirEntry = pHandle->dir.pLastValidEntry;
+ }
+ else
+ {
+ pDirEntry = pDirEntryOrg;
+
+ rc = RTDirReadEx(hDir, pDirEntry, &cbDirEntrySize, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient));
+ if (rc == VERR_NO_MORE_FILES)
+ {
+ *pIndex = 0; /* listing completed */
+ break;
+ }
+
+ if ( rc != VINF_SUCCESS
+ && rc != VWRN_NO_DIRENT_INFO)
+ {
+ //AssertFailed();
+ if ( rc == VERR_NO_TRANSLATION
+ || rc == VERR_INVALID_UTF8_ENCODING)
+ continue;
+ break;
+ }
+ }
+
+ cbNeeded = RT_OFFSETOF(SHFLDIRINFO, name.String);
+ if (fUtf8)
+ cbNeeded += pDirEntry->cbName + 1;
+ else
+ /* Overestimating, but that's ok */
+ cbNeeded += (pDirEntry->cbName + 1) * 2;
+
+ if (cbBufferOrg < cbNeeded)
+ {
+ /* No room, so save this directory entry, or else it's lost forever */
+ pHandle->dir.pLastValidEntry = pDirEntry;
+
+ if (*pcFiles == 0)
+ {
+ AssertFailed();
+ return VINF_BUFFER_OVERFLOW; /* Return directly and don't free pDirEntry */
+ }
+ return VINF_SUCCESS; /* Return directly and don't free pDirEntry */
+ }
+
+#ifdef RT_OS_WINDOWS
+ pDirEntry->Info.Attr.fMode |= 0111;
+#endif
+ vbfsCopyFsObjInfoFromIprt(&pSFDEntry->Info, &pDirEntry->Info);
+ pSFDEntry->cucShortName = 0;
+
+ if (fUtf8)
+ {
+ void *src, *dst;
+
+ src = &pDirEntry->szName[0];
+ dst = &pSFDEntry->name.String.utf8[0];
+
+ memcpy(dst, src, pDirEntry->cbName + 1);
+
+ pSFDEntry->name.u16Size = pDirEntry->cbName + 1;
+ pSFDEntry->name.u16Length = pDirEntry->cbName;
+ }
+ else
+ {
+ pSFDEntry->name.String.ucs2[0] = 0;
+ pwszString = pSFDEntry->name.String.ucs2;
+ int rc2 = RTStrToUtf16Ex(pDirEntry->szName, RTSTR_MAX, &pwszString, pDirEntry->cbName+1, NULL);
+ AssertRC(rc2);
+
+#ifdef RT_OS_DARWIN
+/** @todo This belongs in rtPathToNative or in the windows shared folder file system driver...
+ * The question is simply whether the NFD normalization is actually applied on a (virtual) file
+ * system level in darwin, or just by the user mode application libs. */
+ {
+ // Convert to
+ // Normalization Form C (composed Unicode). We need this because
+ // Mac OS X file system uses NFD (Normalization Form D :decomposed Unicode)
+ // while most other OS', server-side programs usually expect NFC.
+ uint16_t ucs2Length;
+ CFRange rangeCharacters;
+ CFMutableStringRef inStr = ::CFStringCreateMutable(NULL, 0);
+
+ ::CFStringAppendCharacters(inStr, (UniChar *)pwszString, RTUtf16Len(pwszString));
+ ::CFStringNormalize(inStr, kCFStringNormalizationFormC);
+ ucs2Length = ::CFStringGetLength(inStr);
+
+ rangeCharacters.location = 0;
+ rangeCharacters.length = ucs2Length;
+ ::CFStringGetCharacters(inStr, rangeCharacters, pwszString);
+ pwszString[ucs2Length] = 0x0000; // NULL terminated
+
+ CFRelease(inStr);
+ }
+#endif
+ pSFDEntry->name.u16Length = (uint32_t)RTUtf16Len(pSFDEntry->name.String.ucs2) * 2;
+ pSFDEntry->name.u16Size = pSFDEntry->name.u16Length + 2;
+
+ Log(("SHFL: File name size %d\n", pSFDEntry->name.u16Size));
+ Log(("SHFL: File name %ls\n", &pSFDEntry->name.String.ucs2));
+
+ // adjust cbNeeded (it was overestimated before)
+ cbNeeded = RT_OFFSETOF(SHFLDIRINFO, name.String) + pSFDEntry->name.u16Size;
+ }
+
+ pSFDEntry = (PSHFLDIRINFO)((uintptr_t)pSFDEntry + cbNeeded);
+ *pcbBuffer += cbNeeded;
+ cbBufferOrg-= cbNeeded;
+
+ *pcFiles += 1;
+
+ /* Free the saved last entry, that we've just returned */
+ if (pHandle->dir.pLastValidEntry)
+ {
+ RTMemFree(pHandle->dir.pLastValidEntry);
+ pHandle->dir.pLastValidEntry = NULL;
+
+ /* And use the newly allocated buffer from now. */
+ pDirEntry = pDirEntryOrg;
+ }
+
+ if (flags & SHFL_LIST_RETURN_ONE)
+ break; /* we're done */
+ }
+ Assert(rc != VINF_SUCCESS || *pcbBuffer > 0);
+
+end:
+ if (pDirEntry)
+ RTMemFree(pDirEntry);
+
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_READLINK API. Located here as a form of API
+ * documentation. */
+void testReadLink(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testReadLinkBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfReadLink(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pPath, uint32_t cbPath, uint8_t *pBuffer, uint32_t cbBuffer)
+{
+ int rc = VINF_SUCCESS;
+
+ if (pPath == 0 || pBuffer == 0)
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ /* Build a host full path for the given path, handle file name case issues
+ * (if the guest expects case-insensitive paths but the host is
+ * case-sensitive) and convert ucs2 to utf8 if necessary.
+ */
+ char *pszFullPath = NULL;
+ uint32_t cbFullPathRoot = 0;
+
+ rc = vbsfBuildFullPath(pClient, root, pPath, cbPath, &pszFullPath, &cbFullPathRoot);
+
+ if (RT_SUCCESS(rc))
+ {
+ rc = RTSymlinkRead(pszFullPath, (char *) pBuffer, cbBuffer, 0);
+ if (RT_SUCCESS(rc))
+ {
+ /* Convert the slashes in the link target to the guest path separator characters. */
+ char *psz = (char *)pBuffer;
+ while (*psz != '\0')
+ {
+ if (*psz == RTPATH_DELIMITER)
+ *psz = pClient->PathDelimiter;
+ psz++;
+ }
+ }
+
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPath);
+ }
+
+ return rc;
+}
+
+int vbsfQueryFileInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags,
+ uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ RT_NOREF1(flags);
+ uint32_t type = vbsfQueryHandleType(pClient, Handle);
+ int rc = VINF_SUCCESS;
+ SHFLFSOBJINFO *pObjInfo = (SHFLFSOBJINFO *)pBuffer;
+ RTFSOBJINFO fileinfo;
+
+
+ AssertReturn(type == SHFL_HF_TYPE_DIR || type == SHFL_HF_TYPE_FILE, VERR_INVALID_PARAMETER);
+ AssertReturn(pcbBuffer != NULL, VERR_INVALID_PARAMETER);
+ AssertReturn(pObjInfo != NULL, VERR_INVALID_PARAMETER);
+ AssertReturn(*pcbBuffer >= sizeof(SHFLFSOBJINFO), VERR_INVALID_PARAMETER);
+
+ /** @todo other options */
+ Assert(flags == (SHFL_INFO_GET|SHFL_INFO_FILE));
+
+ *pcbBuffer = 0;
+
+ if (type == SHFL_HF_TYPE_DIR)
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryDirHandle(pClient, Handle);
+ rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_READ);
+ if (RT_SUCCESS(rc))
+ rc = RTDirQueryInfo(pHandle->dir.Handle, &fileinfo, RTFSOBJATTRADD_NOTHING);
+ }
+ else
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_READ);
+ if (RT_SUCCESS(rc))
+ rc = RTFileQueryInfo(pHandle->file.Handle, &fileinfo, RTFSOBJATTRADD_NOTHING);
+#ifdef RT_OS_WINDOWS
+ if (RT_SUCCESS(rc) && RTFS_IS_FILE(pObjInfo->Attr.fMode))
+ pObjInfo->Attr.fMode |= 0111;
+#endif
+ }
+ if (rc == VINF_SUCCESS)
+ {
+ vbfsCopyFsObjInfoFromIprt(pObjInfo, &fileinfo);
+ *pcbBuffer = sizeof(SHFLFSOBJINFO);
+ }
+ else
+ AssertFailed();
+
+ return rc;
+}
+
+static int vbsfSetFileInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags,
+ uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ RT_NOREF1(flags);
+ uint32_t type = vbsfQueryHandleType(pClient, Handle);
+ int rc = VINF_SUCCESS;
+ SHFLFSOBJINFO *pSFDEntry;
+
+ if ( !(type == SHFL_HF_TYPE_DIR || type == SHFL_HF_TYPE_FILE)
+ || pcbBuffer == 0
+ || pBuffer == 0
+ || *pcbBuffer < sizeof(SHFLFSOBJINFO))
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ *pcbBuffer = 0;
+ pSFDEntry = (SHFLFSOBJINFO *)pBuffer;
+
+ Assert(flags == (SHFL_INFO_SET | SHFL_INFO_FILE));
+
+ /* Change only the time values that are not zero */
+ if (type == SHFL_HF_TYPE_DIR)
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryDirHandle(pClient, Handle);
+ rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ rc = RTDirSetTimes(pHandle->dir.Handle,
+ (RTTimeSpecGetNano(&pSFDEntry->AccessTime)) ? &pSFDEntry->AccessTime : NULL,
+ (RTTimeSpecGetNano(&pSFDEntry->ModificationTime)) ? &pSFDEntry->ModificationTime: NULL,
+ (RTTimeSpecGetNano(&pSFDEntry->ChangeTime)) ? &pSFDEntry->ChangeTime: NULL,
+ (RTTimeSpecGetNano(&pSFDEntry->BirthTime)) ? &pSFDEntry->BirthTime: NULL
+ );
+ }
+ else
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ rc = RTFileSetTimes(pHandle->file.Handle,
+ (RTTimeSpecGetNano(&pSFDEntry->AccessTime)) ? &pSFDEntry->AccessTime : NULL,
+ (RTTimeSpecGetNano(&pSFDEntry->ModificationTime)) ? &pSFDEntry->ModificationTime: NULL,
+ (RTTimeSpecGetNano(&pSFDEntry->ChangeTime)) ? &pSFDEntry->ChangeTime: NULL,
+ (RTTimeSpecGetNano(&pSFDEntry->BirthTime)) ? &pSFDEntry->BirthTime: NULL
+ );
+ }
+ if (rc != VINF_SUCCESS)
+ {
+ Log(("RTFileSetTimes failed with %Rrc\n", rc));
+ Log(("AccessTime %RX64\n", RTTimeSpecGetNano(&pSFDEntry->AccessTime)));
+ Log(("ModificationTime %RX64\n", RTTimeSpecGetNano(&pSFDEntry->ModificationTime)));
+ Log(("ChangeTime %RX64\n", RTTimeSpecGetNano(&pSFDEntry->ChangeTime)));
+ Log(("BirthTime %RX64\n", RTTimeSpecGetNano(&pSFDEntry->BirthTime)));
+ /* temporary hack */
+ rc = VINF_SUCCESS;
+ }
+
+ if (type == SHFL_HF_TYPE_FILE)
+ {
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ {
+ /* Change file attributes if necessary */
+ if (pSFDEntry->Attr.fMode)
+ {
+ RTFMODE fMode = pSFDEntry->Attr.fMode;
+
+#ifndef RT_OS_WINDOWS
+ /* Don't allow the guest to clear the own bit, otherwise the guest wouldn't be
+ * able to access this file anymore. Only for guests, which set the UNIX mode.
+ * Also, clear bits which we don't pass through for security reasons. */
+ if (fMode & RTFS_UNIX_MASK)
+ {
+ fMode |= RTFS_UNIX_IRUSR;
+ fMode &= ~(RTFS_UNIX_ISUID | RTFS_UNIX_ISGID | RTFS_UNIX_ISTXT);
+ }
+#endif
+
+ rc = RTFileSetMode(pHandle->file.Handle, fMode);
+ if (rc != VINF_SUCCESS)
+ {
+ Log(("RTFileSetMode %x failed with %Rrc\n", fMode, rc));
+ /* silent failure, because this tends to fail with e.g. windows guest & linux host */
+ rc = VINF_SUCCESS;
+ }
+ }
+ }
+ }
+ /** @todo mode for directories */
+
+ if (rc == VINF_SUCCESS)
+ {
+ uint32_t bufsize = sizeof(*pSFDEntry);
+
+ rc = vbsfQueryFileInfo(pClient, root, Handle, SHFL_INFO_GET|SHFL_INFO_FILE, &bufsize, (uint8_t *)pSFDEntry);
+ if (rc == VINF_SUCCESS)
+ {
+ *pcbBuffer = sizeof(SHFLFSOBJINFO);
+ }
+ else
+ AssertFailed();
+ }
+
+ return rc;
+}
+
+
+/**
+ * Handles SHFL_FN_SET_FILE_SIZE.
+ */
+int vbsfSetFileSize(SHFLCLIENTDATA *pClient, SHFLROOT idRoot, SHFLHANDLE hHandle, uint64_t cbNewSize)
+{
+ /*
+ * Resolve handle and validate write access.
+ */
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, hHandle);
+ ASSERT_GUEST_RETURN(pHandle, VERR_INVALID_HANDLE);
+
+ int rc = vbsfCheckHandleAccess(pClient, idRoot, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ {
+ /*
+ * Execute the request.
+ */
+ rc = RTFileSetSize(pHandle->file.Handle, cbNewSize);
+ }
+ return rc;
+}
+
+
+static int vbsfSetEndOfFile(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags,
+ uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ RT_NOREF1(flags);
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ SHFLFSOBJINFO *pSFDEntry;
+
+ if (pHandle == 0 || pcbBuffer == 0 || pBuffer == 0 || *pcbBuffer < sizeof(SHFLFSOBJINFO))
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_WRITE);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ *pcbBuffer = 0;
+ pSFDEntry = (SHFLFSOBJINFO *)pBuffer;
+
+ if (flags & SHFL_INFO_SIZE)
+ {
+ rc = RTFileSetSize(pHandle->file.Handle, pSFDEntry->cbObject);
+ if (rc != VINF_SUCCESS)
+ AssertFailed();
+ }
+ else
+ AssertFailed();
+
+ if (rc == VINF_SUCCESS)
+ {
+ RTFSOBJINFO fileinfo;
+
+ /* Query the new object info and return it */
+ rc = RTFileQueryInfo(pHandle->file.Handle, &fileinfo, RTFSOBJATTRADD_NOTHING);
+ if (rc == VINF_SUCCESS)
+ {
+#ifdef RT_OS_WINDOWS
+ fileinfo.Attr.fMode |= 0111;
+#endif
+ vbfsCopyFsObjInfoFromIprt(pSFDEntry, &fileinfo);
+ *pcbBuffer = sizeof(SHFLFSOBJINFO);
+ }
+ else
+ AssertFailed();
+ }
+
+ return rc;
+}
+
+int vbsfQueryVolumeInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ RT_NOREF2(root, flags);
+ int rc = VINF_SUCCESS;
+ SHFLVOLINFO *pSFDEntry;
+ char *pszFullPath = NULL;
+ union
+ {
+ SHFLSTRING Dummy;
+ uint8_t abDummy[SHFLSTRING_HEADER_SIZE + sizeof(RTUTF16)];
+ } Buf;
+
+ if (pcbBuffer == 0 || pBuffer == 0 || *pcbBuffer < sizeof(SHFLVOLINFO))
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ /** @todo other options */
+ Assert(flags == (SHFL_INFO_GET|SHFL_INFO_VOLUME));
+
+ *pcbBuffer = 0;
+ pSFDEntry = (PSHFLVOLINFO)pBuffer;
+
+ ShflStringInitBuffer(&Buf.Dummy, sizeof(Buf));
+ Buf.Dummy.String.ucs2[0] = '\0';
+ rc = vbsfBuildFullPath(pClient, root, &Buf.Dummy, sizeof(Buf), &pszFullPath, NULL);
+
+ if (RT_SUCCESS(rc))
+ {
+ rc = RTFsQuerySizes(pszFullPath, &pSFDEntry->ullTotalAllocationBytes, &pSFDEntry->ullAvailableAllocationBytes, &pSFDEntry->ulBytesPerAllocationUnit, &pSFDEntry->ulBytesPerSector);
+ if (rc != VINF_SUCCESS)
+ goto exit;
+
+ rc = RTFsQuerySerial(pszFullPath, &pSFDEntry->ulSerial);
+ if (rc != VINF_SUCCESS)
+ goto exit;
+
+ RTFSPROPERTIES FsProperties;
+ rc = RTFsQueryProperties(pszFullPath, &FsProperties);
+ if (rc != VINF_SUCCESS)
+ goto exit;
+ vbfsCopyFsPropertiesFromIprt(&pSFDEntry->fsProperties, &FsProperties);
+
+ *pcbBuffer = sizeof(SHFLVOLINFO);
+ }
+ else AssertFailed();
+
+exit:
+ AssertMsg(rc == VINF_SUCCESS, ("failure: rc = %Rrc\n", rc));
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPath);
+ return rc;
+}
+
+int vbsfQueryFSInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ if (pcbBuffer == 0 || pBuffer == 0)
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ if (flags & SHFL_INFO_FILE)
+ return vbsfQueryFileInfo(pClient, root, Handle, flags, pcbBuffer, pBuffer);
+
+ if (flags & SHFL_INFO_VOLUME)
+ return vbsfQueryVolumeInfo(pClient, root, flags, pcbBuffer, pBuffer);
+
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_INFORMATION API. Located here as a form of API
+ * documentation. */
+void testFSInfo(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testFSInfoBadParameters(hTest);
+ /* Basic get and set file size test. */
+ testFSInfoQuerySetFMode(hTest);
+ /* Basic get and set dir atime test. */
+ testFSInfoQuerySetDirATime(hTest);
+ /* Basic get and set file atime test. */
+ testFSInfoQuerySetFileATime(hTest);
+ /* Basic set end of file. */
+ testFSInfoQuerySetEndOfFile(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfSetFSInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer)
+{
+ uint32_t type = vbsfQueryHandleType(pClient, Handle)
+ & (SHFL_HF_TYPE_DIR|SHFL_HF_TYPE_FILE|SHFL_HF_TYPE_VOLUME);
+
+ if (type == 0 || pcbBuffer == 0 || pBuffer == 0)
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ if (flags & SHFL_INFO_FILE)
+ return vbsfSetFileInfo(pClient, root, Handle, flags, pcbBuffer, pBuffer);
+
+ if (flags & SHFL_INFO_SIZE)
+ return vbsfSetEndOfFile(pClient, root, Handle, flags, pcbBuffer, pBuffer);
+
+// if (flags & SHFL_INFO_VOLUME)
+// return vbsfVolumeInfo(pClient, root, Handle, flags, pcbBuffer, pBuffer);
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_LOCK API. Located here as a form of API
+ * documentation. */
+void testLock(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testLockBadParameters(hTest);
+ /* Simple file locking and unlocking test. */
+ testLockFileSimple(hTest);
+ /* Add tests as required... */
+}
+#endif
+
+int vbsfLock(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint64_t length, uint32_t flags)
+{
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+ uint32_t fRTLock = 0;
+
+ Assert((flags & SHFL_LOCK_MODE_MASK) != SHFL_LOCK_CANCEL);
+
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_READ);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ if ( ((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL)
+ || (flags & SHFL_LOCK_ENTIRE)
+ )
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ /* Lock type */
+ switch(flags & SHFL_LOCK_MODE_MASK)
+ {
+ case SHFL_LOCK_SHARED:
+ fRTLock = RTFILE_LOCK_READ;
+ break;
+
+ case SHFL_LOCK_EXCLUSIVE:
+ fRTLock = RTFILE_LOCK_READ | RTFILE_LOCK_WRITE;
+ break;
+
+ default:
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ /* Lock wait type */
+ if (flags & SHFL_LOCK_WAIT)
+ fRTLock |= RTFILE_LOCK_WAIT;
+ else
+ fRTLock |= RTFILE_LOCK_IMMEDIATELY;
+
+#ifdef RT_OS_WINDOWS
+ rc = RTFileLock(pHandle->file.Handle, fRTLock, offset, length);
+ if (rc != VINF_SUCCESS)
+ Log(("RTFileLock %RTfile %RX64 %RX64 failed with %Rrc\n", pHandle->file.Handle, offset, length, rc));
+#else
+ Log(("vbsfLock: Pretend success handle=%x\n", Handle));
+ rc = VINF_SUCCESS;
+ RT_NOREF2(offset, length);
+#endif
+ return rc;
+}
+
+int vbsfUnlock(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint64_t length, uint32_t flags)
+{
+ SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, Handle);
+
+ Assert((flags & SHFL_LOCK_MODE_MASK) == SHFL_LOCK_CANCEL);
+
+ int rc = vbsfCheckHandleAccess(pClient, root, pHandle, VBSF_CHECK_ACCESS_READ);
+ if (RT_SUCCESS(rc))
+ { /* likely */ }
+ else
+ return rc;
+
+ if ( ((flags & SHFL_LOCK_MODE_MASK) != SHFL_LOCK_CANCEL)
+ || (flags & SHFL_LOCK_ENTIRE)
+ )
+ {
+ return VERR_INVALID_PARAMETER;
+ }
+
+#ifdef RT_OS_WINDOWS
+ rc = RTFileUnlock(pHandle->file.Handle, offset, length);
+ if (rc != VINF_SUCCESS)
+ Log(("RTFileUnlock %RTfile %RX64 %RTX64 failed with %Rrc\n", pHandle->file.Handle, offset, length, rc));
+#else
+ Log(("vbsfUnlock: Pretend success handle=%x\n", Handle));
+ rc = VINF_SUCCESS;
+ RT_NOREF2(offset, length);
+#endif
+
+ return rc;
+}
+
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_REMOVE API. Located here as a form of API
+ * documentation. */
+void testRemove(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testRemoveBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfRemove(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pPath, uint32_t cbPath, uint32_t flags)
+{
+ int rc = VINF_SUCCESS;
+
+ /* Validate input */
+ if ( flags & ~(SHFL_REMOVE_FILE|SHFL_REMOVE_DIR|SHFL_REMOVE_SYMLINK)
+ || cbPath == 0
+ || pPath == 0)
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ /* Build a host full path for the given path
+ * and convert ucs2 to utf8 if necessary.
+ */
+ char *pszFullPath = NULL;
+
+ rc = vbsfBuildFullPath(pClient, root, pPath, cbPath, &pszFullPath, NULL);
+ if (RT_SUCCESS(rc))
+ {
+ /* is the guest allowed to write to this share? */
+ bool fWritable;
+ rc = vbsfMappingsQueryWritable(pClient, root, &fWritable);
+ if (RT_FAILURE(rc) || !fWritable)
+ rc = VERR_WRITE_PROTECT;
+
+ if (RT_SUCCESS(rc))
+ {
+ if (flags & SHFL_REMOVE_SYMLINK)
+ rc = RTSymlinkDelete(pszFullPath, 0);
+ else if (flags & SHFL_REMOVE_FILE)
+ rc = RTFileDelete(pszFullPath);
+ else
+ rc = RTDirRemove(pszFullPath);
+ }
+
+#ifndef DEBUG_dmik
+ // VERR_ACCESS_DENIED for example?
+ // Assert(rc == VINF_SUCCESS || rc == VERR_DIR_NOT_EMPTY);
+#endif
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPath);
+ }
+ return rc;
+}
+
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_RENAME API. Located here as a form of API
+ * documentation. */
+void testRename(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testRenameBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfRename(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pSrc, SHFLSTRING *pDest, uint32_t flags)
+{
+ int rc = VINF_SUCCESS;
+
+ /* Validate input */
+ if ( flags & ~(SHFL_RENAME_FILE|SHFL_RENAME_DIR|SHFL_RENAME_REPLACE_IF_EXISTS)
+ || pSrc == 0
+ || pDest == 0)
+ {
+ AssertFailed();
+ return VERR_INVALID_PARAMETER;
+ }
+
+ /* Build a host full path for the given path
+ * and convert ucs2 to utf8 if necessary.
+ */
+ char *pszFullPathSrc = NULL;
+ char *pszFullPathDest = NULL;
+
+ rc = vbsfBuildFullPath(pClient, root, pSrc, pSrc->u16Size + SHFLSTRING_HEADER_SIZE, &pszFullPathSrc, NULL);
+ if (rc != VINF_SUCCESS)
+ return rc;
+
+ rc = vbsfBuildFullPath(pClient, root, pDest, pDest->u16Size + SHFLSTRING_HEADER_SIZE, &pszFullPathDest, NULL, false, true);
+ if (RT_SUCCESS (rc))
+ {
+ Log(("Rename %s to %s\n", pszFullPathSrc, pszFullPathDest));
+
+ /* is the guest allowed to write to this share? */
+ bool fWritable;
+ rc = vbsfMappingsQueryWritable(pClient, root, &fWritable);
+ if (RT_FAILURE(rc) || !fWritable)
+ rc = VERR_WRITE_PROTECT;
+
+ if (RT_SUCCESS(rc))
+ {
+ if ((flags & (SHFL_RENAME_FILE | SHFL_RENAME_DIR)) == (SHFL_RENAME_FILE | SHFL_RENAME_DIR))
+ {
+ rc = RTPathRename(pszFullPathSrc, pszFullPathDest,
+ flags & SHFL_RENAME_REPLACE_IF_EXISTS ? RTPATHRENAME_FLAGS_REPLACE : 0);
+ }
+ else if (flags & SHFL_RENAME_FILE)
+ {
+ rc = RTFileMove(pszFullPathSrc, pszFullPathDest,
+ ((flags & SHFL_RENAME_REPLACE_IF_EXISTS) ? RTFILEMOVE_FLAGS_REPLACE : 0));
+ }
+ else
+ {
+ /* NT ignores the REPLACE flag and simply return and already exists error. */
+ rc = RTDirRename(pszFullPathSrc, pszFullPathDest,
+ ((flags & SHFL_RENAME_REPLACE_IF_EXISTS) ? RTPATHRENAME_FLAGS_REPLACE : 0));
+ }
+ }
+
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPathDest);
+ }
+ /* free the path string */
+ vbsfFreeFullPath(pszFullPathSrc);
+ return rc;
+}
+
+#ifdef UNITTEST
+/** Unit test the SHFL_FN_SYMLINK API. Located here as a form of API
+ * documentation. */
+void testSymlink(RTTEST hTest)
+{
+ /* If the number or types of parameters are wrong the API should fail. */
+ testSymlinkBadParameters(hTest);
+ /* Add tests as required... */
+}
+#endif
+int vbsfSymlink(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pNewPath, SHFLSTRING *pOldPath, SHFLFSOBJINFO *pInfo)
+{
+ int rc = VINF_SUCCESS;
+
+ char *pszFullNewPath = NULL;
+ char *pszFullOldPath = NULL;
+
+ /* XXX: no support for UCS2 at the moment. */
+ if (!BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ return VERR_NOT_IMPLEMENTED;
+
+ bool fSymlinksCreate;
+ rc = vbsfMappingsQuerySymlinksCreate(pClient, root, &fSymlinksCreate);
+ AssertRCReturn(rc, rc);
+ if (!fSymlinksCreate)
+ return VERR_WRITE_PROTECT; /* XXX or VERR_TOO_MANY_SYMLINKS? */
+
+ rc = vbsfBuildFullPath(pClient, root, pNewPath, pNewPath->u16Size + SHFLSTRING_HEADER_SIZE, &pszFullNewPath, NULL);
+ AssertRCReturn(rc, rc);
+
+ /* Verify that the link target can be a valid host path, i.e. does not contain invalid characters. */
+ uint32_t fu32PathFlags = 0;
+ uint32_t fu32Options = 0;
+ rc = vbsfPathGuestToHost(pClient, root, pOldPath, pOldPath->u16Size + SHFLSTRING_HEADER_SIZE,
+ &pszFullOldPath, NULL, fu32Options, &fu32PathFlags);
+ if (RT_FAILURE(rc))
+ {
+ vbsfFreeFullPath(pszFullNewPath);
+ return rc;
+ }
+
+ rc = RTSymlinkCreate(pszFullNewPath, (const char *)pOldPath->String.utf8,
+ RTSYMLINKTYPE_UNKNOWN, 0);
+ if (RT_SUCCESS(rc))
+ {
+ RTFSOBJINFO info;
+ rc = RTPathQueryInfoEx(pszFullNewPath, &info, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient));
+ if (RT_SUCCESS(rc))
+ vbfsCopyFsObjInfoFromIprt(pInfo, &info);
+ }
+
+ vbsfFreeFullPath(pszFullOldPath);
+ vbsfFreeFullPath(pszFullNewPath);
+
+ return rc;
+}
+
+/*
+ * Clean up our mess by freeing all handles that are still valid.
+ *
+ */
+int vbsfDisconnect(SHFLCLIENTDATA *pClient)
+{
+ for (int i = 0; i < SHFLHANDLE_MAX; ++i)
+ {
+ SHFLFILEHANDLE *pHandle = NULL;
+ SHFLHANDLE Handle = (SHFLHANDLE)i;
+
+ uint32_t type = vbsfQueryHandleType(pClient, Handle);
+ switch (type & (SHFL_HF_TYPE_DIR | SHFL_HF_TYPE_FILE))
+ {
+ case SHFL_HF_TYPE_DIR:
+ {
+ pHandle = vbsfQueryDirHandle(pClient, Handle);
+ break;
+ }
+ case SHFL_HF_TYPE_FILE:
+ {
+ pHandle = vbsfQueryFileHandle(pClient, Handle);
+ break;
+ }
+ default:
+ break;
+ }
+
+ if (pHandle)
+ {
+ LogFunc(("Opened handle 0x%08x\n", i));
+ vbsfClose(pClient, pHandle->root, Handle);
+ }
+ }
+
+ for (uint32_t i = 0; i < RT_ELEMENTS(pClient->acMappings); i++)
+ if (pClient->acMappings[i])
+ {
+ uint16_t cMappings = pClient->acMappings[i];
+ while (cMappings-- > 0)
+ vbsfUnmapFolder(pClient, i);
+ }
+
+ return VINF_SUCCESS;
+}
diff --git a/src/VBox/HostServices/SharedFolders/vbsf.h b/src/VBox/HostServices/SharedFolders/vbsf.h
new file mode 100644
index 00000000..9a91d512
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/vbsf.h
@@ -0,0 +1,49 @@
+/* $Id: vbsf.h $ */
+/** @file
+ * VBox Shared Folders header.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_vbsf_h
+#define VBOX_INCLUDED_SRC_SharedFolders_vbsf_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "shfl.h"
+#include <VBox/shflsvc.h>
+
+int vbsfCreate (SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pPath, uint32_t cbPath, SHFLCREATEPARMS *pParms);
+
+int vbsfClose (SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle);
+
+int vbsfRead(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer);
+int vbsfWrite(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint32_t *pcbBuffer, uint8_t *pBuffer);
+int vbsfLock(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint64_t length, uint32_t flags);
+int vbsfUnlock(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint64_t offset, uint64_t length, uint32_t flags);
+int vbsfRemove(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pPath, uint32_t cbPath, uint32_t flags);
+int vbsfRename(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pSrc, SHFLSTRING *pDest, uint32_t flags);
+int vbsfDirList(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, SHFLSTRING *pPath, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer, uint32_t *pIndex, uint32_t *pcFiles);
+int vbsfFileInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer);
+int vbsfSetFileSize(SHFLCLIENTDATA *pClient, SHFLROOT idRoot, SHFLHANDLE hHandle, uint64_t cbNewSize);
+int vbsfQueryFSInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer);
+int vbsfSetFSInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer);
+int vbsfFlush(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle);
+int vbsfDisconnect(SHFLCLIENTDATA *pClient);
+int vbsfQueryFileInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer);
+int vbsfReadLink(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pPath, uint32_t cbPath, uint8_t *pBuffer, uint32_t cbBuffer);
+int vbsfSymlink(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLSTRING *pNewPath, SHFLSTRING *pOldPath, SHFLFSOBJINFO *pInfo);
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_vbsf_h */
+
diff --git a/src/VBox/HostServices/SharedFolders/vbsfpath.cpp b/src/VBox/HostServices/SharedFolders/vbsfpath.cpp
new file mode 100644
index 00000000..509ff18f
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/vbsfpath.cpp
@@ -0,0 +1,701 @@
+/* $Id: vbsfpath.cpp $ */
+/** @file
+ * Shared Folders Service - guest/host path convertion and verification.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
+#ifdef UNITTEST
+# include "testcase/tstSharedFolderService.h"
+#endif
+
+#include "vbsfpath.h"
+#include "mappings.h"
+#include "vbsf.h"
+#include "shflhandle.h"
+
+#include <iprt/alloc.h>
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/fs.h>
+#include <iprt/dir.h>
+#include <iprt/file.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+#include <iprt/symlink.h>
+#include <iprt/uni.h>
+#include <iprt/stream.h>
+#ifdef RT_OS_DARWIN
+# include <Carbon/Carbon.h>
+#endif
+
+#ifdef UNITTEST
+# include "teststubs.h"
+#endif
+
+
+/*********************************************************************************************************************************
+* Defined Constants And Macros *
+*********************************************************************************************************************************/
+#define SHFL_RT_LINK(pClient) ((pClient)->fu32Flags & SHFL_CF_SYMLINKS ? RTPATH_F_ON_LINK : RTPATH_F_FOLLOW_LINK)
+
+
+/**
+ * @todo find a better solution for supporting the execute bit for non-windows
+ * guests on windows host. Search for "0111" to find all the relevant places.
+ */
+
+/**
+ * Corrects the casing of the final component
+ *
+ * @returns
+ * @param pClient .
+ * @param pszFullPath .
+ * @param pszStartComponent .
+ */
+static int vbsfCorrectCasing(SHFLCLIENTDATA *pClient, char *pszFullPath, char *pszStartComponent)
+{
+ Log2(("vbsfCorrectCasing: %s %s\n", pszFullPath, pszStartComponent));
+
+ AssertReturn((uintptr_t)pszFullPath < (uintptr_t)pszStartComponent - 1U, VERR_INTERNAL_ERROR_2);
+ AssertReturn(pszStartComponent[-1] == RTPATH_DELIMITER, VERR_INTERNAL_ERROR_5);
+
+ /*
+ * Allocate a buffer that can hold really long file name entries as well as
+ * the initial search pattern.
+ */
+ size_t cchComponent = strlen(pszStartComponent);
+ size_t cchParentDir = pszStartComponent - pszFullPath;
+ size_t cchFullPath = cchParentDir + cchComponent;
+ Assert(strlen(pszFullPath) == cchFullPath);
+
+ size_t cbDirEntry = 4096;
+ if (cchFullPath + 4 > cbDirEntry - RT_OFFSETOF(RTDIRENTRYEX, szName))
+ cbDirEntry = RT_OFFSETOF(RTDIRENTRYEX, szName) + cchFullPath + 4;
+
+ PRTDIRENTRYEX pDirEntry = (PRTDIRENTRYEX)RTMemAlloc(cbDirEntry);
+ if (pDirEntry == NULL)
+ return VERR_NO_MEMORY;
+
+ /*
+ * Construct the search criteria in the szName member of pDirEntry.
+ */
+ /** @todo This is quite inefficient, especially for directories with many
+ * files. If any of the typically case sensitive host systems start
+ * supporting opendir wildcard filters, it would make sense to build
+ * one here with '?' for case foldable charaters. */
+ /** @todo Use RTDirOpen here and drop the whole uncessary path copying? */
+ int rc = RTPathJoinEx(pDirEntry->szName, cbDirEntry - RT_OFFSETOF(RTDIRENTRYEX, szName),
+ pszFullPath, cchParentDir,
+ RT_STR_TUPLE("*"));
+ AssertRC(rc);
+ if (RT_SUCCESS(rc))
+ {
+ RTDIR hSearch = NULL;
+ rc = RTDirOpenFiltered(&hSearch, pDirEntry->szName, RTDIRFILTER_WINNT, 0 /*fFlags*/);
+ if (RT_SUCCESS(rc))
+ {
+ for (;;)
+ {
+ size_t cbDirEntrySize = cbDirEntry;
+
+ rc = RTDirReadEx(hSearch, pDirEntry, &cbDirEntrySize, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient));
+ if (rc == VERR_NO_MORE_FILES)
+ break;
+
+ if ( rc != VINF_SUCCESS
+ && rc != VWRN_NO_DIRENT_INFO)
+ {
+ if ( rc == VERR_NO_TRANSLATION
+ || rc == VERR_INVALID_UTF8_ENCODING)
+ continue;
+ AssertMsgFailed(("%Rrc\n", rc));
+ break;
+ }
+
+ Log2(("vbsfCorrectCasing: found %s\n", &pDirEntry->szName[0]));
+ if ( pDirEntry->cbName == cchComponent
+ && !RTStrICmp(pszStartComponent, &pDirEntry->szName[0]))
+ {
+ Log(("Found original name %s (%s)\n", &pDirEntry->szName[0], pszStartComponent));
+ strcpy(pszStartComponent, &pDirEntry->szName[0]);
+ rc = VINF_SUCCESS;
+ break;
+ }
+ }
+
+ RTDirClose(hSearch);
+ }
+ }
+
+ if (RT_FAILURE(rc))
+ Log(("vbsfCorrectCasing %s failed with %Rrc\n", pszStartComponent, rc));
+
+ RTMemFree(pDirEntry);
+
+ return rc;
+}
+
+/* Temporary stand-in for RTPathExistEx. */
+static int vbsfQueryExistsEx(const char *pszPath, uint32_t fFlags)
+{
+#if 0 /** @todo Fix the symlink issue on windows! */
+ return RTPathExistsEx(pszPath, fFlags);
+#else
+ RTFSOBJINFO IgnInfo;
+ return RTPathQueryInfoEx(pszPath, &IgnInfo, RTFSOBJATTRADD_NOTHING, fFlags);
+#endif
+}
+
+/**
+ * Helper for vbsfBuildFullPath that performs case corrections on the path
+ * that's being build.
+ *
+ * @returns VINF_SUCCESS at the moment.
+ * @param pClient The client data.
+ * @param pszFullPath Pointer to the full path. This is the path
+ * which may need case corrections. The
+ * corrections will be applied in place.
+ * @param cchFullPath The length of the full path.
+ * @param fWildCard Whether the last component may contain
+ * wildcards and thus might require exclusion
+ * from the case correction.
+ * @param fPreserveLastComponent Always exclude the last component from case
+ * correction if set.
+ */
+static int vbsfCorrectPathCasing(SHFLCLIENTDATA *pClient, char *pszFullPath, size_t cchFullPath,
+ bool fWildCard, bool fPreserveLastComponent)
+{
+ /*
+ * Hide the last path component if it needs preserving. This is required
+ * in the following cases:
+ * - Contains the wildcard(s).
+ * - Is a 'rename' target.
+ */
+ char *pszLastComponent = NULL;
+ if (fWildCard || fPreserveLastComponent)
+ {
+ char *pszSrc = pszFullPath + cchFullPath - 1;
+ Assert(strchr(pszFullPath, '\0') == pszSrc + 1);
+ while ((uintptr_t)pszSrc > (uintptr_t)pszFullPath)
+ {
+ if (*pszSrc == RTPATH_DELIMITER)
+ break;
+ pszSrc--;
+ }
+ if (*pszSrc == RTPATH_DELIMITER)
+ {
+ if ( fPreserveLastComponent
+ /* Or does it really have wildcards? */
+ || strchr(pszSrc + 1, '*') != NULL
+ || strchr(pszSrc + 1, '?') != NULL
+ || strchr(pszSrc + 1, '>') != NULL
+ || strchr(pszSrc + 1, '<') != NULL
+ || strchr(pszSrc + 1, '"') != NULL )
+ {
+ pszLastComponent = pszSrc;
+ *pszLastComponent = '\0';
+ }
+ }
+ }
+
+ /*
+ * If the path/file doesn't exist, we need to attempt case correcting it.
+ */
+ /** @todo Don't check when creating files or directories; waste of time. */
+ int rc = vbsfQueryExistsEx(pszFullPath, SHFL_RT_LINK(pClient));
+ if (rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND)
+ {
+ Log(("Handle case insensitive guest fs on top of host case sensitive fs for %s\n", pszFullPath));
+
+ /*
+ * Work from the end of the path to find a partial path that's valid.
+ */
+ char *pszSrc = pszLastComponent ? pszLastComponent - 1 : pszFullPath + cchFullPath - 1;
+ Assert(strchr(pszFullPath, '\0') == pszSrc + 1);
+
+ while ((uintptr_t)pszSrc > (uintptr_t)pszFullPath)
+ {
+ if (*pszSrc == RTPATH_DELIMITER)
+ {
+ *pszSrc = '\0';
+ rc = vbsfQueryExistsEx(pszFullPath, SHFL_RT_LINK(pClient));
+ *pszSrc = RTPATH_DELIMITER;
+ if (RT_SUCCESS(rc))
+ {
+#ifdef DEBUG
+ *pszSrc = '\0';
+ Log(("Found valid partial path %s\n", pszFullPath));
+ *pszSrc = RTPATH_DELIMITER;
+#endif
+ break;
+ }
+ }
+
+ pszSrc--;
+ }
+ Assert(*pszSrc == RTPATH_DELIMITER && RT_SUCCESS(rc));
+ if ( *pszSrc == RTPATH_DELIMITER
+ && RT_SUCCESS(rc))
+ {
+ /*
+ * Turn around and work the other way case correcting the components.
+ */
+ pszSrc++;
+ for (;;)
+ {
+ bool fEndOfString = true;
+
+ /* Find the end of the component. */
+ char *pszEnd = pszSrc;
+ while (*pszEnd)
+ {
+ if (*pszEnd == RTPATH_DELIMITER)
+ break;
+ pszEnd++;
+ }
+
+ if (*pszEnd == RTPATH_DELIMITER)
+ {
+ fEndOfString = false;
+ *pszEnd = '\0';
+#if 0 /** @todo Please, double check this. The original code is in the #if 0, what I hold as correct is in the #else. */
+ rc = RTPathQueryInfoEx(pszSrc, &info, RTFSOBJATTRADD_NOTHING, SHFL_RT_LINK(pClient));
+#else
+ rc = vbsfQueryExistsEx(pszFullPath, SHFL_RT_LINK(pClient));
+#endif
+ Assert(rc == VINF_SUCCESS || rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND);
+ }
+ else if (pszEnd == pszSrc)
+ rc = VINF_SUCCESS; /* trailing delimiter */
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ if (rc == VERR_FILE_NOT_FOUND || rc == VERR_PATH_NOT_FOUND)
+ {
+ /* Path component is invalid; try to correct the casing. */
+ rc = vbsfCorrectCasing(pClient, pszFullPath, pszSrc);
+ if (RT_FAILURE(rc))
+ {
+ /* Failed, so don't bother trying any further components. */
+ if (!fEndOfString)
+ *pszEnd = RTPATH_DELIMITER; /* Restore the original full path. */
+ break;
+ }
+ }
+
+ /* Next (if any). */
+ if (fEndOfString)
+ break;
+
+ *pszEnd = RTPATH_DELIMITER;
+ pszSrc = pszEnd + 1;
+ }
+ if (RT_FAILURE(rc))
+ Log(("Unable to find suitable component rc=%d\n", rc));
+ }
+ else
+ rc = VERR_FILE_NOT_FOUND;
+
+ }
+
+ /* Restore the final component if it was dropped. */
+ if (pszLastComponent)
+ *pszLastComponent = RTPATH_DELIMITER;
+
+ /* might be a new file so don't fail here! */
+ return VINF_SUCCESS;
+}
+
+
+#ifdef RT_OS_DARWIN
+/* Misplaced hack! See todo! */
+
+/** Normalize the string using kCFStringNormalizationFormD.
+ *
+ * @param pwszSrc The input UTF-16 string.
+ * @param cwcSrc Length of the input string in characters.
+ * @param ppwszDst Where to store the pointer to the resulting normalized string.
+ * @param pcwcDst Where to store length of the normalized string in characters (without the trailing nul).
+ */
+static int vbsfNormalizeStringDarwin(const PRTUTF16 pwszSrc, uint32_t cwcSrc, PRTUTF16 *ppwszDst, uint32_t *pcwcDst)
+{
+ /** @todo This belongs in rtPathToNative or in the windows shared folder file system driver...
+ * The question is simply whether the NFD normalization is actually applied on a (virtual) file
+ * system level in darwin, or just by the user mode application libs. */
+
+ PRTUTF16 pwszNFD;
+ uint32_t cwcNFD;
+
+ CFMutableStringRef inStr = ::CFStringCreateMutable(NULL, 0);
+
+ /* Is 8 times length enough for decomposed in worst case...? */
+ size_t cbNFDAlloc = cwcSrc * 8 + 2;
+ pwszNFD = (PRTUTF16)RTMemAllocZ(cbNFDAlloc);
+ if (!pwszNFD)
+ {
+ return VERR_NO_MEMORY;
+ }
+
+ ::CFStringAppendCharacters(inStr, (UniChar*)pwszSrc, cwcSrc);
+ ::CFStringNormalize(inStr, kCFStringNormalizationFormD);
+ cwcNFD = ::CFStringGetLength(inStr);
+
+ CFRange rangeCharacters;
+ rangeCharacters.location = 0;
+ rangeCharacters.length = cwcNFD;
+ ::CFStringGetCharacters(inStr, rangeCharacters, pwszNFD);
+
+ pwszNFD[cwcNFD] = 0x0000; /* NULL terminated */
+
+ CFRelease(inStr);
+
+ *ppwszDst = pwszNFD;
+ *pcwcDst = cwcNFD;
+ return VINF_SUCCESS;
+}
+#endif
+
+
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+/* See MSDN "Naming Files, Paths, and Namespaces".
+ * '<', '>' and '"' are allowed as possible wildcards (see ANSI_DOS_STAR, etc in ntifs.h)
+ */
+static const char sachCharBlackList[] = ":/\\|";
+#else
+/* Something else. */
+static const char sachCharBlackList[] = "/";
+#endif
+
+/** Verify if the character can be used in a host file name.
+ * Wildcard characters ('?', '*') are allowed.
+ *
+ * @param c Character to verify.
+ */
+static bool vbsfPathIsValidNameChar(unsigned char c)
+{
+ /* Character 0 is not allowed too. */
+ if (c == 0 || strchr(sachCharBlackList, c))
+ {
+ return false;
+ }
+
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+ /* Characters less than 32 are not allowed. */
+ if (c < 32)
+ {
+ return false;
+ }
+#endif
+
+ return true;
+}
+
+/** Verify if the character is a wildcard.
+ *
+ * @param c Character to verify.
+ */
+static bool vbsfPathIsWildcardChar(char c)
+{
+ if ( c == '*'
+ || c == '?'
+#ifdef RT_OS_WINDOWS /* See ntifs.h */
+ || c == '<' /* ANSI_DOS_STAR */
+ || c == '>' /* ANSI_DOS_QM */
+ || c == '"' /* ANSI_DOS_DOT */
+#endif
+ )
+ {
+ return true;
+ }
+
+ return false;
+}
+
+int vbsfPathGuestToHost(SHFLCLIENTDATA *pClient, SHFLROOT hRoot,
+ PSHFLSTRING pGuestString, uint32_t cbGuestString,
+ char **ppszHostPath, uint32_t *pcbHostPathRoot,
+ uint32_t fu32Options,
+ uint32_t *pfu32PathFlags)
+{
+#ifdef VBOX_STRICT
+ /*
+ * Check that the pGuestPath has correct size and encoding.
+ */
+ if (ShflStringIsValidIn(pGuestString, cbGuestString, RT_BOOL(pClient->fu32Flags & SHFL_CF_UTF8)) == false)
+ {
+ LogFunc(("Invalid input string\n"));
+ return VERR_INTERNAL_ERROR;
+ }
+#else
+ NOREF(cbGuestString);
+#endif
+
+ /*
+ * Resolve the root handle into a string.
+ */
+ uint32_t cbRootLen = 0;
+ const char *pszRoot = NULL;
+ int rc = vbsfMappingsQueryHostRootEx(hRoot, &pszRoot, &cbRootLen);
+ if (RT_FAILURE(rc))
+ {
+ LogFunc(("invalid root\n"));
+ return rc;
+ }
+
+ AssertReturn(cbRootLen > 0, VERR_INTERNAL_ERROR_2); /* vbsfMappingsQueryHostRootEx ensures this. */
+
+ /*
+ * Get the UTF8 string with the relative path provided by the guest.
+ * If guest uses UTF-16 then convert it to UTF-8.
+ */
+ uint32_t cbGuestPath = 0; /* Shut up MSC */
+ const char *pchGuestPath = NULL; /* Ditto. */
+ char *pchGuestPathAllocated = NULL; /* Converted from UTF-16. */
+ if (BIT_FLAG(pClient->fu32Flags, SHFL_CF_UTF8))
+ {
+ /* UTF-8 */
+ cbGuestPath = pGuestString->u16Length;
+ pchGuestPath = (char *)&pGuestString->String.utf8[0];
+ }
+ else
+ {
+ /* UTF-16 */
+ uint32_t cwcSrc;
+ PRTUTF16 pwszSrc;
+
+#ifdef RT_OS_DARWIN /* Misplaced hack! See todo! */
+ cwcSrc = 0;
+ pwszSrc = NULL;
+ rc = vbsfNormalizeStringDarwin(&pGuestString->String.ucs2[0],
+ pGuestString->u16Length / sizeof(RTUTF16),
+ &pwszSrc, &cwcSrc);
+#else
+ cwcSrc = pGuestString->u16Length / sizeof(RTUTF16);
+ pwszSrc = &pGuestString->String.ucs2[0];
+#endif
+
+ if (RT_SUCCESS(rc))
+ {
+ size_t cbPathAsUtf8 = RTUtf16CalcUtf8Len(pwszSrc);
+ if (cbPathAsUtf8 >= cwcSrc)
+ {
+ /* Allocate buffer that will be able to contain the converted UTF-8 string. */
+ pchGuestPathAllocated = (char *)RTMemAlloc(cbPathAsUtf8 + 1);
+ if (RT_LIKELY(pchGuestPathAllocated != NULL))
+ {
+ if (RT_LIKELY(cbPathAsUtf8))
+ {
+ size_t cchActual;
+ char *pszDst = pchGuestPathAllocated;
+ rc = RTUtf16ToUtf8Ex(pwszSrc, cwcSrc, &pszDst, cbPathAsUtf8 + 1, &cchActual);
+ AssertRC(rc);
+ AssertStmt(RT_FAILURE(rc) || cchActual == cbPathAsUtf8, rc = VERR_INTERNAL_ERROR_4);
+ Assert(strlen(pszDst) == cbPathAsUtf8);
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ /* Terminate the string. */
+ pchGuestPathAllocated[cbPathAsUtf8] = '\0';
+
+ cbGuestPath = (uint32_t)cbPathAsUtf8; Assert(cbGuestPath == cbPathAsUtf8);
+ pchGuestPath = pchGuestPathAllocated;
+ }
+ }
+ else
+ {
+ rc = VERR_NO_MEMORY;
+ }
+ }
+ else
+ {
+ AssertFailed();
+ rc = VERR_INTERNAL_ERROR_3;
+ }
+
+#ifdef RT_OS_DARWIN
+ RTMemFree(pwszSrc);
+#endif
+ }
+ }
+
+ char *pszFullPath = NULL;
+
+ if (RT_SUCCESS(rc))
+ {
+ LogFlowFunc(("Root %s path %.*s\n", pszRoot, cbGuestPath, pchGuestPath));
+
+ /*
+ * Allocate enough memory to build the host full path from the root and the relative path.
+ */
+ const uint32_t cbFullPathAlloc = cbRootLen + 1 + cbGuestPath + 1; /* root + possible_slash + relative + 0 */
+ pszFullPath = (char *)RTMemAlloc(cbFullPathAlloc);
+ if (RT_LIKELY(pszFullPath != NULL))
+ {
+ /* Buffer for the verified guest path. */
+ char *pchVerifiedPath = (char *)RTMemAlloc(cbGuestPath + 1);
+ if (RT_LIKELY(pchVerifiedPath != NULL))
+ {
+ /* Init the pointer for the guest relative path. */
+ uint32_t cbSrc = cbGuestPath;
+ const char *pchSrc = pchGuestPath;
+
+ /* Strip leading delimiters from the path the guest specified. */
+ while ( cbSrc > 0
+ && *pchSrc == pClient->PathDelimiter)
+ {
+ ++pchSrc;
+ --cbSrc;
+ }
+
+ /*
+ * Iterate the guest path components, verify each of them replacing delimiters with the host slash.
+ */
+ char *pchDst = pchVerifiedPath;
+ bool fLastComponentHasWildcard = false;
+ for (; cbSrc > 0; --cbSrc, ++pchSrc)
+ {
+ if (RT_LIKELY(*pchSrc != pClient->PathDelimiter))
+ {
+ if (RT_LIKELY(vbsfPathIsValidNameChar(*pchSrc)))
+ {
+ if (pfu32PathFlags && vbsfPathIsWildcardChar(*pchSrc))
+ {
+ fLastComponentHasWildcard = true;
+ }
+
+ *pchDst++ = *pchSrc;
+ }
+ else
+ {
+ rc = VERR_INVALID_NAME;
+ break;
+ }
+ }
+ else
+ {
+ /* Replace with the host slash. */
+ *pchDst++ = RTPATH_SLASH;
+
+ if (pfu32PathFlags && fLastComponentHasWildcard && cbSrc > 1)
+ {
+ /* Processed component has a wildcard and there are more characters in the path. */
+ *pfu32PathFlags |= VBSF_F_PATH_HAS_WILDCARD_IN_PREFIX;
+ }
+ fLastComponentHasWildcard = false;
+ }
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ *pchDst++ = 0;
+
+ /* Construct the full host path removing '.' and '..'. */
+ rc = vbsfPathAbs(pszRoot, pchVerifiedPath, pszFullPath, cbFullPathAlloc);
+ if (RT_SUCCESS(rc))
+ {
+ if (pfu32PathFlags && fLastComponentHasWildcard)
+ {
+ *pfu32PathFlags |= VBSF_F_PATH_HAS_WILDCARD_IN_LAST;
+ }
+
+ /* Check if the full path is still within the shared folder. */
+ if (fu32Options & VBSF_O_PATH_CHECK_ROOT_ESCAPE)
+ {
+ if (!RTPathStartsWith(pszFullPath, pszRoot))
+ {
+ rc = VERR_INVALID_NAME;
+ }
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ /*
+ * If the host file system is case sensitive and the guest expects
+ * a case insensitive fs, then correct the path components casing.
+ */
+ if ( vbsfIsHostMappingCaseSensitive(hRoot)
+ && !vbsfIsGuestMappingCaseSensitive(hRoot))
+ {
+ const bool fWildCard = RT_BOOL(fu32Options & VBSF_O_PATH_WILDCARD);
+ const bool fPreserveLastComponent = RT_BOOL(fu32Options & VBSF_O_PATH_PRESERVE_LAST_COMPONENT);
+ rc = vbsfCorrectPathCasing(pClient, pszFullPath, strlen(pszFullPath),
+ fWildCard, fPreserveLastComponent);
+ }
+
+ if (RT_SUCCESS(rc))
+ {
+ LogFlowFunc(("%s\n", pszFullPath));
+
+ /* Return the full host path. */
+ *ppszHostPath = pszFullPath;
+
+ if (pcbHostPathRoot)
+ {
+ /* Return the length of the root path without the trailing slash. */
+ *pcbHostPathRoot = RTPATH_IS_SLASH(pszFullPath[cbRootLen - 1]) ?
+ cbRootLen - 1 : /* pszRoot already had the trailing slash. */
+ cbRootLen; /* pszRoot did not have the trailing slash. */
+ }
+ }
+ }
+ }
+ else
+ {
+ LogFunc(("vbsfPathAbs %Rrc\n", rc));
+ }
+ }
+
+ RTMemFree(pchVerifiedPath);
+ }
+ else
+ {
+ rc = VERR_NO_MEMORY;
+ }
+ }
+ else
+ {
+ rc = VERR_NO_MEMORY;
+ }
+ }
+
+ /*
+ * Cleanup.
+ */
+ RTMemFree(pchGuestPathAllocated);
+
+ if (RT_SUCCESS(rc))
+ {
+ return rc;
+ }
+
+ /*
+ * Cleanup on failure.
+ */
+ RTMemFree(pszFullPath);
+
+ LogFunc(("%Rrc\n", rc));
+ return rc;
+}
+
+void vbsfFreeHostPath(char *pszHostPath)
+{
+ RTMemFree(pszHostPath);
+}
+
diff --git a/src/VBox/HostServices/SharedFolders/vbsfpath.h b/src/VBox/HostServices/SharedFolders/vbsfpath.h
new file mode 100644
index 00000000..cec601c4
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/vbsfpath.h
@@ -0,0 +1,70 @@
+/* $Id: vbsfpath.h $ */
+/** @file
+ * Shared Folders Service - Guest/host path convertion and verification.
+ */
+
+/*
+ * Copyright (C) 2006-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+#ifndef VBOX_INCLUDED_SRC_SharedFolders_vbsfpath_h
+#define VBOX_INCLUDED_SRC_SharedFolders_vbsfpath_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#include "shfl.h"
+#include <VBox/shflsvc.h>
+
+#define VBSF_O_PATH_WILDCARD UINT32_C(0x00000001)
+#define VBSF_O_PATH_PRESERVE_LAST_COMPONENT UINT32_C(0x00000002)
+#define VBSF_O_PATH_CHECK_ROOT_ESCAPE UINT32_C(0x00000004)
+
+#define VBSF_F_PATH_HAS_WILDCARD_IN_PREFIX UINT32_C(0x00000001) /* A component before the last one contains a wildcard. */
+#define VBSF_F_PATH_HAS_WILDCARD_IN_LAST UINT32_C(0x00000002) /* The last component contains a wildcard. */
+
+/**
+ *
+ * @param pClient Shared folder client.
+ * @param hRoot Root handle.
+ * @param pGuestString Guest want to access the path.
+ * @param cbGuestString Size of pGuestString memory buffer.
+ * @param ppszHostPath Returned full host path: root prefix + guest path.
+ * @param pcbHostPathRoot Length of the root prefix in bytes. Optional, can be NULL.
+ * @param fu32Options Options.
+ * @param pfu32PathFlags VBSF_F_PATH_* flags. Optional, can be NULL.
+ */
+int vbsfPathGuestToHost(SHFLCLIENTDATA *pClient, SHFLROOT hRoot,
+ PSHFLSTRING pGuestString, uint32_t cbGuestString,
+ char **ppszHostPath, uint32_t *pcbHostPathRoot,
+ uint32_t fu32Options, uint32_t *pfu32PathFlags);
+
+/** Free the host path returned by vbsfPathGuestToHost.
+ *
+ * @param pszHostPath Host path string.
+ */
+void vbsfFreeHostPath(char *pszHostPath);
+
+/**
+ * Build the absolute path by combining an absolute pszRoot and a relative pszPath.
+ * The resulting path does not contain '.' and '..' components.
+ * Similar to RTPathAbsEx but with support for Windows extended-length paths ("\\?\" prefix).
+ * Uses RTPathAbsEx for regular paths and on non-Windows hosts.
+ *
+ * @param pszRoot The absolute prefix. It is copied to the pszAbsPath without any processing.
+ * If NULL then the pszPath must be converted to the absolute path.
+ * @param pszPath The relative path to be appended to pszRoot. Already has correct delimiters (RTPATH_SLASH).
+ * @param pszAbsPath Where to store the resulting absolute path.
+ * @param cbAbsPath Size of pszAbsBuffer in bytes.
+ */
+int vbsfPathAbs(const char *pszRoot, const char *pszPath, char *pszAbsPath, size_t cbAbsPath);
+
+#endif /* !VBOX_INCLUDED_SRC_SharedFolders_vbsfpath_h */
diff --git a/src/VBox/HostServices/SharedFolders/vbsfpathabs.cpp b/src/VBox/HostServices/SharedFolders/vbsfpathabs.cpp
new file mode 100644
index 00000000..096e193d
--- /dev/null
+++ b/src/VBox/HostServices/SharedFolders/vbsfpathabs.cpp
@@ -0,0 +1,185 @@
+/* $Id: vbsfpathabs.cpp $ */
+/** @file
+ * Shared Folders Service - guest/host path convertion and verification.
+ */
+
+/*
+ * Copyright (C) 2017-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ */
+
+
+/*********************************************************************************************************************************
+* Header Files *
+*********************************************************************************************************************************/
+#define LOG_GROUP LOG_GROUP_SHARED_FOLDERS
+#include <iprt/err.h>
+#include <iprt/path.h>
+#include <iprt/string.h>
+
+
+#if defined(RT_OS_WINDOWS)
+static void vbsfPathResolveRelative(char *pszPathBegin)
+{
+ char *pszCur = pszPathBegin;
+ char * const pszTop = pszCur;
+
+ /*
+ * Get rid of double dot path components by evaluating them.
+ */
+ for (;;)
+ {
+ char const chFirst = pszCur[0];
+ if ( chFirst == '.'
+ && pszCur[1] == '.'
+ && (!pszCur[2] || pszCur[2] == RTPATH_SLASH))
+ {
+ /* rewind to the previous component if any */
+ char *pszPrev = pszCur;
+ if ((uintptr_t)pszPrev > (uintptr_t)pszTop)
+ {
+ pszPrev--;
+ while ( (uintptr_t)pszPrev > (uintptr_t)pszTop
+ && pszPrev[-1] != RTPATH_SLASH)
+ pszPrev--;
+ }
+ if (!pszCur[2])
+ {
+ if (pszPrev != pszTop)
+ pszPrev[-1] = '\0';
+ else
+ *pszPrev = '\0';
+ break;
+ }
+ Assert(pszPrev[-1] == RTPATH_SLASH);
+ memmove(pszPrev, pszCur + 3, strlen(pszCur + 3) + 1);
+ pszCur = pszPrev - 1;
+ }
+ else if ( chFirst == '.'
+ && (!pszCur[1] || pszCur[1] == RTPATH_SLASH))
+ {
+ /* remove unnecessary '.' */
+ if (!pszCur[1])
+ {
+ if (pszCur != pszTop)
+ pszCur[-1] = '\0';
+ else
+ *pszCur = '\0';
+ break;
+ }
+ memmove(pszCur, pszCur + 2, strlen(pszCur + 2) + 1);
+ continue;
+ }
+ else
+ {
+ /* advance to end of component. */
+ while (*pszCur && *pszCur != RTPATH_SLASH)
+ pszCur++;
+ }
+
+ if (!*pszCur)
+ break;
+
+ /* skip the slash */
+ ++pszCur;
+ }
+}
+#endif /* RT_OS_WINDOWS */
+
+int vbsfPathAbs(const char *pszRoot, const char *pszPath, char *pszAbsPath, size_t cbAbsPath)
+{
+#if defined(RT_OS_WINDOWS)
+ const char *pszPathStart = pszRoot? pszRoot: pszPath;
+
+ /* Windows extended-length paths. */
+ if ( RTPATH_IS_SLASH(pszPathStart[0])
+ && RTPATH_IS_SLASH(pszPathStart[1])
+ && pszPathStart[2] == '?'
+ && RTPATH_IS_SLASH(pszPathStart[3])
+ )
+ {
+ /* Maximum total path length of 32,767 characters. */
+ if (cbAbsPath > _32K)
+ cbAbsPath = _32K;
+
+ /* Copy the root to pszAbsPath buffer. */
+ size_t cchRoot = pszRoot? strlen(pszRoot): 0;
+ if (cchRoot >= cbAbsPath)
+ return VERR_FILENAME_TOO_LONG;
+
+ if (pszRoot)
+ {
+ /* Caller must ensure that the path is relative, without the leading path separator. */
+ if (RTPATH_IS_SLASH(pszPath[0]))
+ return VERR_INVALID_PARAMETER;
+
+ if (cchRoot)
+ memcpy(pszAbsPath, pszRoot, cchRoot);
+
+ if (cchRoot == 0 || !RTPATH_IS_SLASH(pszAbsPath[cchRoot - 1]))
+ {
+ /* Append path separator after the root. */
+ ++cchRoot;
+ if (cchRoot >= cbAbsPath)
+ return VERR_FILENAME_TOO_LONG;
+
+ pszAbsPath[cchRoot - 1] = RTPATH_SLASH;
+ }
+ }
+
+ /* Append the path to the pszAbsPath buffer. */
+ const size_t cchPath = strlen(pszPath);
+ if (cchRoot + cchPath >= cbAbsPath)
+ return VERR_FILENAME_TOO_LONG;
+
+ memcpy(&pszAbsPath[cchRoot], pszPath, cchPath + 1); /* Including trailing 0. */
+
+ /* Find out where the actual path begins, i.e. skip the root spec. */
+ char *pszPathBegin = &pszAbsPath[4]; /* Skip the extended-length path prefix "\\?\" */
+ if ( pszPathBegin[0]
+ && RTPATH_IS_VOLSEP(pszPathBegin[1])
+ && pszPathBegin[2] == RTPATH_SLASH)
+ {
+ /* "\\?\C:\" */
+ pszPathBegin += 3;
+ }
+ else if ( pszPathBegin[0] == 'U'
+ && pszPathBegin[1] == 'N'
+ && pszPathBegin[2] == 'C'
+ && pszPathBegin[3] == RTPATH_SLASH)
+ {
+ /* "\\?\UNC\server\share" */
+ pszPathBegin += 4;
+
+ /* Skip "server\share" too. */
+ while (*pszPathBegin != RTPATH_SLASH && *pszPathBegin)
+ ++pszPathBegin;
+ if (*pszPathBegin == RTPATH_SLASH)
+ {
+ ++pszPathBegin;
+ while (*pszPathBegin != RTPATH_SLASH && *pszPathBegin)
+ ++pszPathBegin;
+ if (*pszPathBegin == RTPATH_SLASH)
+ ++pszPathBegin;
+ }
+ }
+ else
+ return VERR_INVALID_NAME;
+
+ /* Process pszAbsPath in place. */
+ vbsfPathResolveRelative(pszPathBegin);
+
+ return VINF_SUCCESS;
+ }
+#endif /* RT_OS_WINDOWS */
+
+ /* Fallback for the common paths. */
+ return RTPathAbsEx(pszRoot, pszPath, pszAbsPath, cbAbsPath);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 16:36:04 +0000