[31202] | 1 | /* $Id: VBoxServiceAutoMount.cpp 100331 2023-06-29 12:11:23Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
[58029] | 3 | * VBoxService - Auto-mounting for Shared Folders, only Linux & Solaris atm.
|
---|
[31202] | 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2010-2023 Oracle and/or its affiliates.
|
---|
[31202] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[31202] | 26 | */
|
---|
| 27 |
|
---|
| 28 |
|
---|
[58052] | 29 | /** @page pg_vgsvc_automount VBoxService - Shared Folder Automounter
|
---|
| 30 | *
|
---|
| 31 | * The Shared Folder Automounter subservice mounts shared folders upon request
|
---|
| 32 | * from the host.
|
---|
| 33 | *
|
---|
| 34 | * This retrieves shared folder automount requests from Main via the VMMDev.
|
---|
| 35 | * The current implemention only does this once, for some inexplicable reason,
|
---|
| 36 | * so the run-time addition of automounted shared folders are not heeded.
|
---|
| 37 | *
|
---|
| 38 | * This subservice is only used on linux and solaris. On Windows the current
|
---|
| 39 | * thinking is this is better of done from VBoxTray, some one argue that for
|
---|
| 40 | * drive letter assigned shared folders it would be better to do some magic here
|
---|
| 41 | * (obviously not involving NDAddConnection).
|
---|
| 42 | *
|
---|
| 43 | */
|
---|
| 44 |
|
---|
| 45 |
|
---|
[57358] | 46 | /*********************************************************************************************************************************
|
---|
| 47 | * Header Files *
|
---|
| 48 | *********************************************************************************************************************************/
|
---|
[31202] | 49 | #include <iprt/assert.h>
|
---|
[75407] | 50 | #include <iprt/ctype.h>
|
---|
[31202] | 51 | #include <iprt/dir.h>
|
---|
| 52 | #include <iprt/mem.h>
|
---|
[31311] | 53 | #include <iprt/path.h>
|
---|
[75407] | 54 | #include <iprt/semaphore.h>
|
---|
| 55 | #include <iprt/sort.h>
|
---|
[31202] | 56 | #include <iprt/string.h>
|
---|
[100317] | 57 | #include <iprt/system.h>
|
---|
[76419] | 58 | #include <VBox/err.h>
|
---|
[31202] | 59 | #include <VBox/VBoxGuestLib.h>
|
---|
[75407] | 60 | #include <VBox/shflsvc.h>
|
---|
[31202] | 61 | #include "VBoxServiceInternal.h"
|
---|
| 62 | #include "VBoxServiceUtils.h"
|
---|
| 63 |
|
---|
[75407] | 64 | #ifdef RT_OS_WINDOWS
|
---|
| 65 | #elif defined(RT_OS_OS2)
|
---|
[75467] | 66 | # define INCL_DOSFILEMGR
|
---|
| 67 | # define INCL_ERRORS
|
---|
[75469] | 68 | # define OS2EMX_PLAIN_CHAR
|
---|
[75467] | 69 | # include <os2emx.h>
|
---|
[33837] | 70 | #else
|
---|
[100317] | 71 | # include <alloca.h>
|
---|
[75407] | 72 | # include <errno.h>
|
---|
| 73 | # include <grp.h>
|
---|
| 74 | # include <sys/mount.h>
|
---|
| 75 | # ifdef RT_OS_SOLARIS
|
---|
| 76 | # include <sys/mntent.h>
|
---|
| 77 | # include <sys/mnttab.h>
|
---|
| 78 | # include <sys/vfs.h>
|
---|
| 79 | # elif defined(RT_OS_LINUX)
|
---|
| 80 | # include <mntent.h>
|
---|
| 81 | # include <paths.h>
|
---|
[87463] | 82 | # include <sys/utsname.h>
|
---|
[31317] | 83 | RT_C_DECLS_BEGIN
|
---|
[75407] | 84 | # include "../../linux/sharedfolders/vbsfmount.h"
|
---|
[31317] | 85 | RT_C_DECLS_END
|
---|
[75407] | 86 | # else
|
---|
| 87 | # error "Port me!"
|
---|
| 88 | # endif
|
---|
| 89 | # include <unistd.h>
|
---|
| 90 | #endif
|
---|
[31202] | 91 |
|
---|
[75407] | 92 |
|
---|
| 93 |
|
---|
| 94 | /*********************************************************************************************************************************
|
---|
| 95 | * Defined Constants And Macros *
|
---|
| 96 | *********************************************************************************************************************************/
|
---|
| 97 | /** @def VBOXSERVICE_AUTOMOUNT_DEFAULT_DIR
|
---|
| 98 | * Default mount directory (unix only).
|
---|
| 99 | */
|
---|
| 100 | #ifndef VBOXSERVICE_AUTOMOUNT_DEFAULT_DIR
|
---|
[75946] | 101 | # define VBOXSERVICE_AUTOMOUNT_DEFAULT_DIR "/media"
|
---|
[32704] | 102 | #endif
|
---|
| 103 |
|
---|
[75407] | 104 | /** @def VBOXSERVICE_AUTOMOUNT_DEFAULT_PREFIX
|
---|
| 105 | * Default mount prefix (unix only).
|
---|
| 106 | */
|
---|
| 107 | #ifndef VBOXSERVICE_AUTOMOUNT_DEFAULT_PREFIX
|
---|
| 108 | # define VBOXSERVICE_AUTOMOUNT_DEFAULT_PREFIX "sf_"
|
---|
| 109 | #endif
|
---|
| 110 |
|
---|
[33837] | 111 | #ifndef _PATH_MOUNTED
|
---|
[58029] | 112 | # ifdef RT_OS_SOLARIS
|
---|
| 113 | # define _PATH_MOUNTED "/etc/mnttab"
|
---|
| 114 | # else
|
---|
| 115 | # define _PATH_MOUNTED "/etc/mtab"
|
---|
| 116 | # endif
|
---|
[33837] | 117 | #endif
|
---|
| 118 |
|
---|
[75407] | 119 | /** @def VBOXSERVICE_AUTOMOUNT_MIQF
|
---|
| 120 | * The drive letter / path mount point flag. */
|
---|
| 121 | #if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
|
---|
| 122 | # define VBOXSERVICE_AUTOMOUNT_MIQF SHFL_MIQF_DRIVE_LETTER
|
---|
| 123 | #else
|
---|
| 124 | # define VBOXSERVICE_AUTOMOUNT_MIQF SHFL_MIQF_PATH
|
---|
| 125 | #endif
|
---|
[57358] | 126 |
|
---|
[75407] | 127 |
|
---|
[57358] | 128 | /*********************************************************************************************************************************
|
---|
[75407] | 129 | * Structures and Typedefs *
|
---|
| 130 | *********************************************************************************************************************************/
|
---|
| 131 | /**
|
---|
| 132 | * Automounter mount table entry.
|
---|
| 133 | *
|
---|
| 134 | * This holds the information returned by SHFL_FN_QUERY_MAP_INFO and
|
---|
| 135 | * additional mount state info. We only keep entries for mounted mappings.
|
---|
| 136 | */
|
---|
| 137 | typedef struct VBSVCAUTOMOUNTERENTRY
|
---|
| 138 | {
|
---|
| 139 | /** The root ID. */
|
---|
| 140 | uint32_t idRoot;
|
---|
| 141 | /** The root ID version. */
|
---|
| 142 | uint32_t uRootIdVersion;
|
---|
| 143 | /** Map info flags, SHFL_MIF_XXX. */
|
---|
| 144 | uint64_t fFlags;
|
---|
| 145 | /** The shared folder (mapping) name. */
|
---|
| 146 | char *pszName;
|
---|
| 147 | /** The configured mount point, NULL if none. */
|
---|
| 148 | char *pszMountPoint;
|
---|
| 149 | /** The actual mount point, NULL if not mount. */
|
---|
| 150 | char *pszActualMountPoint;
|
---|
| 151 | } VBSVCAUTOMOUNTERENTRY;
|
---|
| 152 | /** Pointer to an automounter entry. */
|
---|
| 153 | typedef VBSVCAUTOMOUNTERENTRY *PVBSVCAUTOMOUNTERENTRY;
|
---|
| 154 |
|
---|
| 155 | /** Automounter mount table. */
|
---|
| 156 | typedef struct VBSVCAUTOMOUNTERTABLE
|
---|
| 157 | {
|
---|
| 158 | /** Current number of entries in the array. */
|
---|
| 159 | uint32_t cEntries;
|
---|
| 160 | /** Max number of entries the array can hold w/o growing it. */
|
---|
| 161 | uint32_t cAllocated;
|
---|
| 162 | /** Pointer to an array of entry pointers. */
|
---|
| 163 | PVBSVCAUTOMOUNTERENTRY *papEntries;
|
---|
| 164 | } VBSVCAUTOMOUNTERTABLE;
|
---|
| 165 | /** Pointer to an automounter mount table. */
|
---|
| 166 | typedef VBSVCAUTOMOUNTERTABLE *PVBSVCAUTOMOUNTERTABLE;
|
---|
| 167 |
|
---|
| 168 |
|
---|
| 169 | /*********************************************************************************************************************************
|
---|
[57358] | 170 | * Global Variables *
|
---|
| 171 | *********************************************************************************************************************************/
|
---|
[31202] | 172 | /** The semaphore we're blocking on. */
|
---|
[75407] | 173 | static RTSEMEVENTMULTI g_hAutoMountEvent = NIL_RTSEMEVENTMULTI;
|
---|
[35060] | 174 | /** The Shared Folders service client ID. */
|
---|
[75407] | 175 | static uint32_t g_idClientSharedFolders = 0;
|
---|
| 176 | /** Set if we can wait on changes to the mappings. */
|
---|
| 177 | static bool g_fHostSupportsWaitAndInfoQuery = false;
|
---|
[31202] | 178 |
|
---|
[75407] | 179 | #ifdef RT_OS_OS2
|
---|
| 180 | /** The attachment tag we use to identify attchments that belongs to us. */
|
---|
| 181 | static char const g_szTag[] = "VBoxAutomounter";
|
---|
[75433] | 182 | #elif defined(RT_OS_LINUX)
|
---|
| 183 | /** Tag option value that lets us identify mounts that belongs to us. */
|
---|
| 184 | static char const g_szTag[] = "VBoxAutomounter";
|
---|
[75407] | 185 | #elif defined(RT_OS_SOLARIS)
|
---|
| 186 | /** Dummy mount option that lets us identify mounts that belongs to us. */
|
---|
[75444] | 187 | static char const g_szTag[] = "VBoxAutomounter";
|
---|
[75407] | 188 | #endif
|
---|
[51564] | 189 |
|
---|
[75407] | 190 |
|
---|
| 191 |
|
---|
[58029] | 192 | /**
|
---|
| 193 | * @interface_method_impl{VBOXSERVICE,pfnInit}
|
---|
| 194 | */
|
---|
[75407] | 195 | static DECLCALLBACK(int) vbsvcAutomounterInit(void)
|
---|
[31202] | 196 | {
|
---|
[75407] | 197 | VGSvcVerbose(3, "vbsvcAutomounterInit\n");
|
---|
[31202] | 198 |
|
---|
[75407] | 199 | int rc = RTSemEventMultiCreate(&g_hAutoMountEvent);
|
---|
[31202] | 200 | AssertRCReturn(rc, rc);
|
---|
| 201 |
|
---|
[75407] | 202 | rc = VbglR3SharedFolderConnect(&g_idClientSharedFolders);
|
---|
[35058] | 203 | if (RT_SUCCESS(rc))
|
---|
| 204 | {
|
---|
[75407] | 205 | VGSvcVerbose(3, "vbsvcAutomounterInit: Service Client ID: %#x\n", g_idClientSharedFolders);
|
---|
| 206 | g_fHostSupportsWaitAndInfoQuery = RT_SUCCESS(VbglR3SharedFolderCancelMappingsChangesWaits(g_idClientSharedFolders));
|
---|
[35058] | 207 | }
|
---|
| 208 | else
|
---|
| 209 | {
|
---|
| 210 | /* If the service was not found, we disable this service without
|
---|
| 211 | causing VBoxService to fail. */
|
---|
| 212 | if (rc == VERR_HGCM_SERVICE_NOT_FOUND) /* Host service is not available. */
|
---|
| 213 | {
|
---|
[75407] | 214 | VGSvcVerbose(0, "vbsvcAutomounterInit: Shared Folders service is not available\n");
|
---|
[35058] | 215 | rc = VERR_SERVICE_DISABLED;
|
---|
| 216 | }
|
---|
| 217 | else
|
---|
[58029] | 218 | VGSvcError("Control: Failed to connect to the Shared Folders service! Error: %Rrc\n", rc);
|
---|
[75407] | 219 | RTSemEventMultiDestroy(g_hAutoMountEvent);
|
---|
| 220 | g_hAutoMountEvent = NIL_RTSEMEVENTMULTI;
|
---|
[35058] | 221 | }
|
---|
| 222 |
|
---|
[31202] | 223 | return rc;
|
---|
| 224 | }
|
---|
| 225 |
|
---|
| 226 |
|
---|
[75407] | 227 | #if defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) /* The old code: */
|
---|
| 228 |
|
---|
[58029] | 229 | /**
|
---|
| 230 | * @todo Integrate into RTFsQueryMountpoint()?
|
---|
| 231 | */
|
---|
[75407] | 232 | static bool vbsvcAutoMountShareIsMountedOld(const char *pszShare, char *pszMountPoint, size_t cbMountPoint)
|
---|
[31202] | 233 | {
|
---|
[75407] | 234 | AssertPtrReturn(pszShare, false);
|
---|
| 235 | AssertPtrReturn(pszMountPoint, false);
|
---|
| 236 | AssertReturn(cbMountPoint, false);
|
---|
[31311] | 237 |
|
---|
[33834] | 238 | bool fMounted = false;
|
---|
[75407] | 239 |
|
---|
| 240 | # if defined(RT_OS_SOLARIS)
|
---|
[58029] | 241 | /** @todo What to do if we have a relative path in mtab instead
|
---|
[33834] | 242 | * of an absolute one ("temp" vs. "/media/temp")?
|
---|
| 243 | * procfs contains the full path but not the actual share name ...
|
---|
| 244 | * FILE *pFh = setmntent("/proc/mounts", "r+t"); */
|
---|
[33856] | 245 | FILE *pFh = fopen(_PATH_MOUNTED, "r");
|
---|
| 246 | if (!pFh)
|
---|
[75407] | 247 | VGSvcError("vbsvcAutoMountShareIsMountedOld: Could not open mount tab '%s'!\n", _PATH_MOUNTED);
|
---|
[33856] | 248 | else
|
---|
| 249 | {
|
---|
| 250 | mnttab mntTab;
|
---|
[33857] | 251 | while ((getmntent(pFh, &mntTab)))
|
---|
[33856] | 252 | {
|
---|
[33858] | 253 | if (!RTStrICmp(mntTab.mnt_special, pszShare))
|
---|
[33856] | 254 | {
|
---|
[33858] | 255 | fMounted = RTStrPrintf(pszMountPoint, cbMountPoint, "%s", mntTab.mnt_mountp)
|
---|
[33856] | 256 | ? true : false;
|
---|
| 257 | break;
|
---|
| 258 | }
|
---|
| 259 | }
|
---|
| 260 | fclose(pFh);
|
---|
| 261 | }
|
---|
[75407] | 262 | # elif defined(RT_OS_LINUX)
|
---|
[58029] | 263 | FILE *pFh = setmntent(_PATH_MOUNTED, "r+t"); /** @todo r=bird: why open it for writing? (the '+') */
|
---|
[33834] | 264 | if (pFh == NULL)
|
---|
[75407] | 265 | VGSvcError("vbsvcAutoMountShareIsMountedOld: Could not open mount tab '%s'!\n", _PATH_MOUNTED);
|
---|
[33834] | 266 | else
|
---|
| 267 | {
|
---|
| 268 | mntent *pMntEnt;
|
---|
| 269 | while ((pMntEnt = getmntent(pFh)))
|
---|
| 270 | {
|
---|
| 271 | if (!RTStrICmp(pMntEnt->mnt_fsname, pszShare))
|
---|
| 272 | {
|
---|
[33837] | 273 | fMounted = RTStrPrintf(pszMountPoint, cbMountPoint, "%s", pMntEnt->mnt_dir)
|
---|
| 274 | ? true : false;
|
---|
[33834] | 275 | break;
|
---|
[33837] | 276 | }
|
---|
| 277 | }
|
---|
[33834] | 278 | endmntent(pFh);
|
---|
| 279 | }
|
---|
[75407] | 280 | # else
|
---|
| 281 | # error "PORTME!"
|
---|
| 282 | # endif
|
---|
[35055] | 283 |
|
---|
[75407] | 284 | VGSvcVerbose(4, "vbsvcAutoMountShareIsMountedOld: Share '%s' at mount point '%s' = %s\n",
|
---|
[35055] | 285 | pszShare, fMounted ? pszMountPoint : "<None>", fMounted ? "Yes" : "No");
|
---|
[33834] | 286 | return fMounted;
|
---|
| 287 | }
|
---|
| 288 |
|
---|
| 289 |
|
---|
[58029] | 290 | /**
|
---|
| 291 | * Unmounts a shared folder.
|
---|
| 292 | *
|
---|
| 293 | * @returns VBox status code
|
---|
| 294 | * @param pszMountPoint The shared folder mount point.
|
---|
| 295 | */
|
---|
[75407] | 296 | static int vbsvcAutoMountUnmountOld(const char *pszMountPoint)
|
---|
[33834] | 297 | {
|
---|
| 298 | AssertPtrReturn(pszMountPoint, VERR_INVALID_PARAMETER);
|
---|
| 299 |
|
---|
| 300 | int rc = VINF_SUCCESS;
|
---|
| 301 | uint8_t uTries = 0;
|
---|
| 302 | int r;
|
---|
| 303 | while (uTries++ < 3)
|
---|
| 304 | {
|
---|
| 305 | r = umount(pszMountPoint);
|
---|
| 306 | if (r == 0)
|
---|
[33837] | 307 | break;
|
---|
[58029] | 308 | /** @todo r=bird: Why do sleep 5 seconds after the final retry?
|
---|
| 309 | * May also be a good idea to check for EINVAL or other signs that someone
|
---|
| 310 | * else have already unmounted the share. */
|
---|
[33834] | 311 | RTThreadSleep(5000); /* Wait a while ... */
|
---|
| 312 | }
|
---|
[58029] | 313 | if (r == -1) /** @todo r=bird: RTThreadSleep set errno. */
|
---|
[33834] | 314 | rc = RTErrConvertFromErrno(errno);
|
---|
[33837] | 315 | return rc;
|
---|
[33834] | 316 | }
|
---|
| 317 |
|
---|
| 318 |
|
---|
[58029] | 319 | /**
|
---|
| 320 | * Prepares a mount point (create it, set group and mode).
|
---|
| 321 | *
|
---|
| 322 | * @returns VBox status code
|
---|
| 323 | * @param pszMountPoint The mount point.
|
---|
| 324 | * @param pszShareName Unused.
|
---|
[87463] | 325 | * @param gidGroup The group ID.
|
---|
[58029] | 326 | */
|
---|
[87463] | 327 | static int vbsvcAutoMountPrepareMountPointOld(const char *pszMountPoint, const char *pszShareName, RTGID gidGroup)
|
---|
[33834] | 328 | {
|
---|
| 329 | AssertPtrReturn(pszMountPoint, VERR_INVALID_PARAMETER);
|
---|
| 330 | AssertPtrReturn(pszShareName, VERR_INVALID_PARAMETER);
|
---|
| 331 |
|
---|
[87463] | 332 | /** @todo r=bird: There is no reason why gidGroup should have write access?
|
---|
| 333 | * Seriously, what kind of non-sense is this? */
|
---|
| 334 |
|
---|
[33834] | 335 | RTFMODE fMode = RTFS_UNIX_IRWXU | RTFS_UNIX_IRWXG; /* Owner (=root) and the group (=vboxsf) have full access. */
|
---|
[31311] | 336 | int rc = RTDirCreateFullPath(pszMountPoint, fMode);
|
---|
| 337 | if (RT_SUCCESS(rc))
|
---|
[31202] | 338 | {
|
---|
[87463] | 339 | rc = RTPathSetOwnerEx(pszMountPoint, NIL_RTUID /* Owner, unchanged */, gidGroup, RTPATH_F_ON_LINK);
|
---|
[31311] | 340 | if (RT_SUCCESS(rc))
|
---|
| 341 | {
|
---|
| 342 | rc = RTPathSetMode(pszMountPoint, fMode);
|
---|
| 343 | if (RT_FAILURE(rc))
|
---|
[35055] | 344 | {
|
---|
| 345 | if (rc == VERR_WRITE_PROTECT)
|
---|
| 346 | {
|
---|
[75407] | 347 | VGSvcVerbose(3, "vbsvcAutoMountPrepareMountPointOld: Mount directory '%s' already is used/mounted\n",
|
---|
| 348 | pszMountPoint);
|
---|
[35055] | 349 | rc = VINF_SUCCESS;
|
---|
| 350 | }
|
---|
| 351 | else
|
---|
[75407] | 352 | VGSvcError("vbsvcAutoMountPrepareMountPointOld: Could not set mode %RTfmode for mount directory '%s', rc = %Rrc\n",
|
---|
| 353 | fMode, pszMountPoint, rc);
|
---|
[35055] | 354 | }
|
---|
[31311] | 355 | }
|
---|
| 356 | else
|
---|
[75407] | 357 | VGSvcError("vbsvcAutoMountPrepareMountPointOld: Could not set permissions for mount directory '%s', rc = %Rrc\n",
|
---|
| 358 | pszMountPoint, rc);
|
---|
[31202] | 359 | }
|
---|
| 360 | else
|
---|
[75407] | 361 | VGSvcError("vbsvcAutoMountPrepareMountPointOld: Could not create mount directory '%s' with mode %RTfmode, rc = %Rrc\n",
|
---|
| 362 | pszMountPoint, fMode, rc);
|
---|
[31311] | 363 | return rc;
|
---|
| 364 | }
|
---|
| 365 |
|
---|
| 366 |
|
---|
[58029] | 367 | /**
|
---|
| 368 | * Mounts a shared folder.
|
---|
| 369 | *
|
---|
| 370 | * @returns VBox status code reflecting unmount and mount point preparation
|
---|
| 371 | * results, but not actual mounting
|
---|
| 372 | *
|
---|
| 373 | * @param pszShareName The shared folder name.
|
---|
| 374 | * @param pszMountPoint The mount point.
|
---|
| 375 | */
|
---|
[75407] | 376 | static int vbsvcAutoMountSharedFolderOld(const char *pszShareName, const char *pszMountPoint)
|
---|
[31311] | 377 | {
|
---|
[75407] | 378 | /*
|
---|
| 379 | * Linux and solaris share the same mount structure.
|
---|
| 380 | */
|
---|
| 381 | struct group *grp_vboxsf = getgrnam("vboxsf");
|
---|
| 382 | if (!grp_vboxsf)
|
---|
[33834] | 383 | {
|
---|
[75407] | 384 | VGSvcError("vbsvcAutoMountWorker: Group 'vboxsf' does not exist\n");
|
---|
| 385 | return VINF_SUCCESS;
|
---|
[33834] | 386 | }
|
---|
| 387 |
|
---|
[87463] | 388 | int rc = vbsvcAutoMountPrepareMountPointOld(pszMountPoint, pszShareName, grp_vboxsf->gr_gid);
|
---|
[75407] | 389 | if (RT_SUCCESS(rc))
|
---|
| 390 | {
|
---|
[100317] | 391 | uint32_t cbOpts = RTSystemGetPageSize();
|
---|
| 392 | char *pszOpts = (char *)alloca(cbOpts);
|
---|
| 393 | RT_BZERO(pszOpts, cbOpts);
|
---|
| 394 |
|
---|
[75407] | 395 | # ifdef RT_OS_SOLARIS
|
---|
[87463] | 396 | int const fFlags = MS_OPTIONSTR;
|
---|
[100331] | 397 | RTStrPrintf(pszOpts, cbOpts, "uid=0,gid=%d,dmode=0770,fmode=0770,dmask=0000,fmask=0000", grp_vboxsf->gr_gid);
|
---|
[31311] | 398 | int r = mount(pszShareName,
|
---|
| 399 | pszMountPoint,
|
---|
[87463] | 400 | fFlags,
|
---|
[37826] | 401 | "vboxfs",
|
---|
[31311] | 402 | NULL, /* char *dataptr */
|
---|
| 403 | 0, /* int datalen */
|
---|
[100317] | 404 | pszOpts,
|
---|
| 405 | cbOpts);
|
---|
[31311] | 406 | if (r == 0)
|
---|
[58029] | 407 | VGSvcVerbose(0, "vbsvcAutoMountWorker: Shared folder '%s' was mounted to '%s'\n", pszShareName, pszMountPoint);
|
---|
| 408 | else if (errno != EBUSY) /* Share is already mounted? Then skip error msg. */
|
---|
| 409 | VGSvcError("vbsvcAutoMountWorker: Could not mount shared folder '%s' to '%s', error = %s\n",
|
---|
[75407] | 410 | pszShareName, pszMountPoint, strerror(errno));
|
---|
[31211] | 411 |
|
---|
[75407] | 412 | # else /* RT_OS_LINUX */
|
---|
[87463] | 413 | struct utsname uts;
|
---|
| 414 | AssertStmt(uname(&uts) != -1, strcpy(uts.release, "4.4.0"));
|
---|
[58029] | 415 |
|
---|
[87463] | 416 | unsigned long const fFlags = MS_NODEV;
|
---|
[100317] | 417 | ssize_t cchOpts = RTStrPrintf2(pszOpts, cbOpts, "uid=0,gid=%d,dmode=0770,fmode=0770,dmask=0000,fmask=0000",
|
---|
[87463] | 418 | grp_vboxsf->gr_gid);
|
---|
| 419 | if (cchOpts > 0 && RTStrVersionCompare(uts.release, "2.6.0") < 0)
|
---|
[100317] | 420 | cchOpts = RTStrPrintf2(&pszOpts[cchOpts], cbOpts - cchOpts, ",sf_name=%s", pszShareName);
|
---|
[87463] | 421 | if (cchOpts <= 0)
|
---|
| 422 | {
|
---|
[100317] | 423 | VGSvcError("vbsvcAutomounterMountIt: pszOpts overflow! %zd (share %s)\n", cchOpts, pszShareName);
|
---|
[87463] | 424 | return VERR_BUFFER_OVERFLOW;
|
---|
| 425 | }
|
---|
[31202] | 426 |
|
---|
[58717] | 427 | int r = mount(pszShareName,
|
---|
[31311] | 428 | pszMountPoint,
|
---|
| 429 | "vboxsf",
|
---|
[58029] | 430 | fFlags,
|
---|
[100317] | 431 | pszOpts);
|
---|
[31311] | 432 | if (r == 0)
|
---|
[31202] | 433 | {
|
---|
[58030] | 434 | VGSvcVerbose(0, "vbsvcAutoMountWorker: Shared folder '%s' was mounted to '%s'\n", pszShareName, pszMountPoint);
|
---|
[31202] | 435 |
|
---|
[100317] | 436 | r = vbsfmount_complete(pszShareName, pszMountPoint, fFlags, pszOpts);
|
---|
[31311] | 437 | switch (r)
|
---|
| 438 | {
|
---|
| 439 | case 0: /* Success. */
|
---|
| 440 | errno = 0; /* Clear all errors/warnings. */
|
---|
| 441 | break;
|
---|
| 442 | case 1:
|
---|
[87463] | 443 | VGSvcError("vbsvcAutoMountWorker: Could not update mount table (malloc failure)\n");
|
---|
[31311] | 444 | break;
|
---|
| 445 | case 2:
|
---|
[58029] | 446 | VGSvcError("vbsvcAutoMountWorker: Could not open mount table for update: %s\n", strerror(errno));
|
---|
[31311] | 447 | break;
|
---|
| 448 | case 3:
|
---|
[58029] | 449 | /* VGSvcError("vbsvcAutoMountWorker: Could not add an entry to the mount table: %s\n", strerror(errno)); */
|
---|
[38898] | 450 | errno = 0;
|
---|
[31311] | 451 | break;
|
---|
| 452 | default:
|
---|
[58029] | 453 | VGSvcError("vbsvcAutoMountWorker: Unknown error while completing mount operation: %d\n", r);
|
---|
[31311] | 454 | break;
|
---|
| 455 | }
|
---|
[31202] | 456 | }
|
---|
[33834] | 457 | else /* r == -1, we got some error in errno. */
|
---|
[31202] | 458 | {
|
---|
[87463] | 459 | switch (errno)
|
---|
[31202] | 460 | {
|
---|
[87463] | 461 | /* If we get EINVAL here, the system already has mounted the Shared Folder to another
|
---|
| 462 | * mount point. */
|
---|
| 463 | case EINVAL:
|
---|
| 464 | VGSvcVerbose(0, "vbsvcAutoMountWorker: Shared folder '%s' is already mounted!\n", pszShareName);
|
---|
| 465 | /* Ignore this error! */
|
---|
| 466 | break;
|
---|
| 467 | case EBUSY:
|
---|
| 468 | /* Ignore these errors! */
|
---|
| 469 | break;
|
---|
| 470 | default:
|
---|
| 471 | VGSvcError("vbsvcAutoMountWorker: Could not mount shared folder '%s' to '%s': %s (%d)\n",
|
---|
| 472 | pszShareName, pszMountPoint, strerror(errno), errno);
|
---|
| 473 | rc = RTErrConvertFromErrno(errno);
|
---|
| 474 | break;
|
---|
[31202] | 475 | }
|
---|
| 476 | }
|
---|
[75407] | 477 | # endif
|
---|
[31202] | 478 | }
|
---|
[58029] | 479 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Mounting returned with rc=%Rrc\n", rc);
|
---|
[33834] | 480 | return rc;
|
---|
[31202] | 481 | }
|
---|
| 482 |
|
---|
[58029] | 483 |
|
---|
| 484 | /**
|
---|
| 485 | * Processes shared folder mappings retrieved from the host.
|
---|
| 486 | *
|
---|
| 487 | * @returns VBox status code.
|
---|
| 488 | * @param paMappings The mappings.
|
---|
| 489 | * @param cMappings The number of mappings.
|
---|
| 490 | * @param pszMountDir The mount directory.
|
---|
| 491 | * @param pszSharePrefix The share prefix.
|
---|
| 492 | * @param uClientID The shared folder service (HGCM) client ID.
|
---|
| 493 | */
|
---|
[75407] | 494 | static int vbsvcAutoMountProcessMappingsOld(PCVBGLR3SHAREDFOLDERMAPPING paMappings, uint32_t cMappings,
|
---|
| 495 | const char *pszMountDir, const char *pszSharePrefix, uint32_t uClientID)
|
---|
[35016] | 496 | {
|
---|
| 497 | if (cMappings == 0)
|
---|
| 498 | return VINF_SUCCESS;
|
---|
| 499 | AssertPtrReturn(paMappings, VERR_INVALID_PARAMETER);
|
---|
| 500 | AssertPtrReturn(pszMountDir, VERR_INVALID_PARAMETER);
|
---|
| 501 | AssertPtrReturn(pszSharePrefix, VERR_INVALID_PARAMETER);
|
---|
| 502 | AssertReturn(uClientID > 0, VERR_INVALID_PARAMETER);
|
---|
[31202] | 503 |
|
---|
[58029] | 504 | /** @todo r=bird: Why is this loop schitzoid about status codes? It quits if
|
---|
| 505 | * RTPathJoin fails (i.e. if the user specifies a very long name), but happily
|
---|
| 506 | * continues if RTStrAPrintf failes (mem alloc).
|
---|
| 507 | *
|
---|
| 508 | * It also happily continues if the 'vboxsf' group is missing, which is a waste
|
---|
| 509 | * of effort... In fact, retrieving the group ID could probably be done up
|
---|
| 510 | * front, outside the loop. */
|
---|
[35016] | 511 | int rc = VINF_SUCCESS;
|
---|
| 512 | for (uint32_t i = 0; i < cMappings && RT_SUCCESS(rc); i++)
|
---|
| 513 | {
|
---|
| 514 | char *pszShareName = NULL;
|
---|
| 515 | rc = VbglR3SharedFolderGetName(uClientID, paMappings[i].u32Root, &pszShareName);
|
---|
| 516 | if ( RT_SUCCESS(rc)
|
---|
| 517 | && *pszShareName)
|
---|
| 518 | {
|
---|
[58029] | 519 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Connecting share %u (%s) ...\n", i+1, pszShareName);
|
---|
[35016] | 520 |
|
---|
[58029] | 521 | /** @todo r=bird: why do you copy things twice here and waste heap space?
|
---|
| 522 | * szMountPoint has a fixed size.
|
---|
| 523 | * @code
|
---|
| 524 | * char szMountPoint[RTPATH_MAX];
|
---|
| 525 | * rc = RTPathJoin(szMountPoint, sizeof(szMountPoint), pszMountDir, *pszSharePrefix ? pszSharePrefix : pszShareName);
|
---|
| 526 | * if (RT_SUCCESS(rc) && *pszSharePrefix)
|
---|
| 527 | * rc = RTStrCat(szMountPoint, sizeof(szMountPoint), pszShareName);
|
---|
| 528 | * @endcode */
|
---|
[35016] | 529 | char *pszShareNameFull = NULL;
|
---|
| 530 | if (RTStrAPrintf(&pszShareNameFull, "%s%s", pszSharePrefix, pszShareName) > 0)
|
---|
[35055] | 531 | {
|
---|
[35016] | 532 | char szMountPoint[RTPATH_MAX];
|
---|
| 533 | rc = RTPathJoin(szMountPoint, sizeof(szMountPoint), pszMountDir, pszShareNameFull);
|
---|
| 534 | if (RT_SUCCESS(rc))
|
---|
| 535 | {
|
---|
[58029] | 536 | VGSvcVerbose(4, "vbsvcAutoMountWorker: Processing mount point '%s'\n", szMountPoint);
|
---|
[35055] | 537 |
|
---|
[75407] | 538 | /*
|
---|
| 539 | * Already mounted?
|
---|
| 540 | */
|
---|
| 541 | /** @todo r-bird: this does not take into account that a shared folder could
|
---|
| 542 | * be mounted twice... We're really just interested in whether the
|
---|
| 543 | * folder is mounted on 'szMountPoint', no where else... */
|
---|
| 544 | bool fSkip = false;
|
---|
| 545 | char szAlreadyMountedOn[RTPATH_MAX];
|
---|
| 546 | if (vbsvcAutoMountShareIsMountedOld(pszShareName, szAlreadyMountedOn, sizeof(szAlreadyMountedOn)))
|
---|
[35016] | 547 | {
|
---|
[75407] | 548 | /* Do if it not mounted to our desired mount point */
|
---|
| 549 | if (RTStrICmp(szMountPoint, szAlreadyMountedOn))
|
---|
[35016] | 550 | {
|
---|
[75407] | 551 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Shared folder '%s' already mounted on '%s', unmounting ...\n",
|
---|
| 552 | pszShareName, szAlreadyMountedOn);
|
---|
| 553 | rc = vbsvcAutoMountUnmountOld(szAlreadyMountedOn);
|
---|
| 554 | if (RT_SUCCESS(rc))
|
---|
| 555 | fSkip = false;
|
---|
| 556 | else
|
---|
| 557 | VGSvcError("vbsvcAutoMountWorker: Failed to unmount '%s', %s (%d)! (rc=%Rrc)\n",
|
---|
| 558 | szAlreadyMountedOn, strerror(errno), errno, rc); /** @todo errno isn't reliable at this point */
|
---|
| 559 | }
|
---|
| 560 | if (fSkip)
|
---|
| 561 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Shared folder '%s' already mounted on '%s', skipping\n",
|
---|
| 562 | pszShareName, szAlreadyMountedOn);
|
---|
[35016] | 563 | }
|
---|
[75407] | 564 | if (!fSkip)
|
---|
| 565 | {
|
---|
| 566 | /*
|
---|
| 567 | * Mount it.
|
---|
| 568 | */
|
---|
| 569 | rc = vbsvcAutoMountSharedFolderOld(pszShareName, szMountPoint);
|
---|
| 570 | }
|
---|
[35016] | 571 | }
|
---|
| 572 | else
|
---|
[58029] | 573 | VGSvcError("vbsvcAutoMountWorker: Unable to join mount point/prefix/shrae, rc = %Rrc\n", rc);
|
---|
[35016] | 574 | RTStrFree(pszShareNameFull);
|
---|
| 575 | }
|
---|
| 576 | else
|
---|
[58029] | 577 | VGSvcError("vbsvcAutoMountWorker: Unable to allocate full share name\n");
|
---|
[35016] | 578 | RTStrFree(pszShareName);
|
---|
| 579 | }
|
---|
| 580 | else
|
---|
[58029] | 581 | VGSvcError("vbsvcAutoMountWorker: Error while getting the shared folder name for root node = %u, rc = %Rrc\n",
|
---|
[35016] | 582 | paMappings[i].u32Root, rc);
|
---|
| 583 | } /* for cMappings. */
|
---|
| 584 | return rc;
|
---|
| 585 | }
|
---|
| 586 |
|
---|
[75407] | 587 | #endif /* defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) - the old code*/
|
---|
[35016] | 588 |
|
---|
[75407] | 589 |
|
---|
[58029] | 590 | /**
|
---|
[75407] | 591 | * Service worker function for old host.
|
---|
| 592 | *
|
---|
| 593 | * This only mount stuff on startup.
|
---|
| 594 | *
|
---|
| 595 | * @returns VBox status code.
|
---|
| 596 | * @param pfShutdown Shutdown indicator.
|
---|
[58029] | 597 | */
|
---|
[75407] | 598 | static int vbsvcAutoMountWorkerOld(bool volatile *pfShutdown)
|
---|
[31202] | 599 | {
|
---|
[75407] | 600 | #if defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX)
|
---|
[31202] | 601 | /*
|
---|
[75407] | 602 | * We only do a single pass here.
|
---|
[31202] | 603 | */
|
---|
[35058] | 604 | uint32_t cMappings;
|
---|
| 605 | PVBGLR3SHAREDFOLDERMAPPING paMappings;
|
---|
[75407] | 606 | int rc = VbglR3SharedFolderGetMappings(g_idClientSharedFolders, true /* Only process auto-mounted folders */,
|
---|
[35058] | 607 | &paMappings, &cMappings);
|
---|
| 608 | if ( RT_SUCCESS(rc)
|
---|
| 609 | && cMappings)
|
---|
[31202] | 610 | {
|
---|
[35058] | 611 | char *pszMountDir;
|
---|
| 612 | rc = VbglR3SharedFolderGetMountDir(&pszMountDir);
|
---|
| 613 | if (rc == VERR_NOT_FOUND)
|
---|
| 614 | rc = RTStrDupEx(&pszMountDir, VBOXSERVICE_AUTOMOUNT_DEFAULT_DIR);
|
---|
| 615 | if (RT_SUCCESS(rc))
|
---|
| 616 | {
|
---|
[58029] | 617 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Shared folder mount dir set to '%s'\n", pszMountDir);
|
---|
[31202] | 618 |
|
---|
[35058] | 619 | char *pszSharePrefix;
|
---|
| 620 | rc = VbglR3SharedFolderGetMountPrefix(&pszSharePrefix);
|
---|
[31355] | 621 | if (RT_SUCCESS(rc))
|
---|
| 622 | {
|
---|
[58029] | 623 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Shared folder mount prefix set to '%s'\n", pszSharePrefix);
|
---|
[75407] | 624 | # ifdef USE_VIRTUAL_SHARES
|
---|
[35058] | 625 | /* Check for a fixed/virtual auto-mount share. */
|
---|
[75407] | 626 | if (VbglR3SharedFolderExists(g_idClientSharedFolders, "vbsfAutoMount"))
|
---|
[58029] | 627 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Host supports auto-mount root\n");
|
---|
[35016] | 628 | else
|
---|
[35058] | 629 | {
|
---|
[75407] | 630 | # endif
|
---|
[58029] | 631 | VGSvcVerbose(3, "vbsvcAutoMountWorker: Got %u shared folder mappings\n", cMappings);
|
---|
[75407] | 632 | rc = vbsvcAutoMountProcessMappingsOld(paMappings, cMappings, pszMountDir, pszSharePrefix,
|
---|
| 633 | g_idClientSharedFolders);
|
---|
| 634 | # ifdef USE_VIRTUAL_SHARES
|
---|
[35058] | 635 | }
|
---|
[75407] | 636 | # endif
|
---|
[35058] | 637 | RTStrFree(pszSharePrefix);
|
---|
| 638 | } /* Mount share prefix. */
|
---|
[31355] | 639 | else
|
---|
[58029] | 640 | VGSvcError("vbsvcAutoMountWorker: Error while getting the shared folder mount prefix, rc = %Rrc\n", rc);
|
---|
[35058] | 641 | RTStrFree(pszMountDir);
|
---|
[31202] | 642 | }
|
---|
| 643 | else
|
---|
[58029] | 644 | VGSvcError("vbsvcAutoMountWorker: Error while getting the shared folder directory, rc = %Rrc\n", rc);
|
---|
[35058] | 645 | VbglR3SharedFolderFreeMappings(paMappings);
|
---|
[31202] | 646 | }
|
---|
[41443] | 647 | else if (RT_FAILURE(rc))
|
---|
[58029] | 648 | VGSvcError("vbsvcAutoMountWorker: Error while getting the shared folder mappings, rc = %Rrc\n", rc);
|
---|
[35058] | 649 | else
|
---|
[58029] | 650 | VGSvcVerbose(3, "vbsvcAutoMountWorker: No shared folder mappings found\n");
|
---|
[31202] | 651 |
|
---|
[75407] | 652 | #else
|
---|
| 653 | int rc = VINF_SUCCESS;
|
---|
| 654 | #endif /* defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) */
|
---|
| 655 |
|
---|
| 656 |
|
---|
[35077] | 657 | /*
|
---|
[75407] | 658 | * Wait on shutdown (this used to be a silly RTThreadSleep(500) loop).
|
---|
| 659 | */
|
---|
| 660 | while (!*pfShutdown)
|
---|
| 661 | {
|
---|
| 662 | rc = RTSemEventMultiWait(g_hAutoMountEvent, RT_MS_1MIN);
|
---|
| 663 | if (rc != VERR_TIMEOUT)
|
---|
| 664 | break;
|
---|
| 665 | }
|
---|
| 666 |
|
---|
| 667 | VGSvcVerbose(3, "vbsvcAutoMountWorkerOld: Finished with rc=%Rrc\n", rc);
|
---|
| 668 | return rc;
|
---|
| 669 | }
|
---|
| 670 |
|
---|
| 671 | #if !defined(RT_OS_WINDOWS) && !defined(RT_OS_OS2)
|
---|
| 672 | /**
|
---|
| 673 | * Assembles the mount directory and prefix into @a pszDst.
|
---|
| 674 | *
|
---|
| 675 | * Will fall back on defaults if we have trouble with the configuration from the
|
---|
| 676 | * host. This ASSUMES that @a cbDst is rather large and won't cause trouble
|
---|
| 677 | * with the default.
|
---|
| 678 | *
|
---|
| 679 | * @returns IPRT status code.
|
---|
| 680 | * @param pszDst Where to return the prefix.
|
---|
| 681 | * @param cbDst The size of the prefix buffer.
|
---|
| 682 | */
|
---|
| 683 | static int vbsvcAutomounterQueryMountDirAndPrefix(char *pszDst, size_t cbDst)
|
---|
| 684 | {
|
---|
| 685 | /*
|
---|
| 686 | * Query the config first.
|
---|
| 687 | */
|
---|
| 688 | /* Mount directory: */
|
---|
| 689 | const char *pszDir = VBOXSERVICE_AUTOMOUNT_DEFAULT_DIR;
|
---|
| 690 | char *pszCfgDir;
|
---|
| 691 | int rc = VbglR3SharedFolderGetMountDir(&pszCfgDir);
|
---|
| 692 | if (RT_SUCCESS(rc))
|
---|
| 693 | {
|
---|
| 694 | if (*pszCfgDir == '/')
|
---|
| 695 | pszDir = pszCfgDir;
|
---|
| 696 | }
|
---|
| 697 | else
|
---|
| 698 | pszCfgDir = NULL;
|
---|
| 699 |
|
---|
| 700 | /* Prefix: */
|
---|
| 701 | const char *pszPrefix = VBOXSERVICE_AUTOMOUNT_DEFAULT_PREFIX;
|
---|
| 702 | char *pszCfgPrefix;
|
---|
| 703 | rc = VbglR3SharedFolderGetMountPrefix(&pszCfgPrefix);
|
---|
| 704 | if (RT_SUCCESS(rc))
|
---|
| 705 | {
|
---|
| 706 | if ( strchr(pszCfgPrefix, '/') == NULL
|
---|
| 707 | && strchr(pszCfgPrefix, '\\') == NULL
|
---|
| 708 | && strcmp(pszCfgPrefix, "..") != 0)
|
---|
| 709 | pszPrefix = pszCfgPrefix;
|
---|
| 710 | }
|
---|
| 711 | else
|
---|
| 712 | pszCfgPrefix = NULL;
|
---|
| 713 |
|
---|
| 714 | /*
|
---|
| 715 | * Try combine the two.
|
---|
| 716 | */
|
---|
| 717 | rc = RTPathAbs(pszDir, pszDst, cbDst);
|
---|
| 718 | if (RT_SUCCESS(rc))
|
---|
| 719 | {
|
---|
| 720 | if (*pszPrefix)
|
---|
| 721 | {
|
---|
| 722 | rc = RTPathAppend(pszDst, cbDst, pszPrefix);
|
---|
| 723 | if (RT_FAILURE(rc))
|
---|
| 724 | VGSvcError("vbsvcAutomounterQueryMountDirAndPrefix: RTPathAppend(%s,,%s) -> %Rrc\n", pszDst, pszPrefix, rc);
|
---|
| 725 | }
|
---|
| 726 | else
|
---|
| 727 | {
|
---|
| 728 | rc = RTPathEnsureTrailingSeparator(pszDst, cbDst);
|
---|
| 729 | if (RT_FAILURE(rc))
|
---|
| 730 | VGSvcError("vbsvcAutomounterQueryMountDirAndPrefix: RTPathEnsureTrailingSeparator(%s) -> %Rrc\n", pszDst, rc);
|
---|
| 731 | }
|
---|
| 732 | }
|
---|
| 733 | else
|
---|
[75858] | 734 | VGSvcError("vbsvcAutomounterQueryMountDirAndPrefix: RTPathAbs(%s) -> %Rrc\n", pszDir, rc);
|
---|
[75407] | 735 |
|
---|
| 736 |
|
---|
| 737 | /*
|
---|
| 738 | * Return the default dir + prefix if the above failed.
|
---|
| 739 | */
|
---|
| 740 | if (RT_FAILURE(rc))
|
---|
| 741 | {
|
---|
| 742 | rc = RTStrCopy(pszDst, cbDst, VBOXSERVICE_AUTOMOUNT_DEFAULT_DIR "/" VBOXSERVICE_AUTOMOUNT_DEFAULT_PREFIX);
|
---|
| 743 | AssertRC(rc);
|
---|
| 744 | }
|
---|
| 745 |
|
---|
| 746 | RTStrFree(pszCfgDir);
|
---|
| 747 | RTStrFree(pszCfgPrefix);
|
---|
| 748 | return rc;
|
---|
| 749 | }
|
---|
| 750 | #endif /* !RT_OS_WINDOW && !RT_OS_OS2 */
|
---|
| 751 |
|
---|
| 752 |
|
---|
| 753 | /**
|
---|
| 754 | * @callback_method_impl{FNRTSORTCMP, For sorting mount table by root ID. }
|
---|
| 755 | */
|
---|
| 756 | static DECLCALLBACK(int) vbsvcAutomounterCompareEntry(void const *pvElement1, void const *pvElement2, void *pvUser)
|
---|
| 757 | {
|
---|
| 758 | RT_NOREF_PV(pvUser);
|
---|
| 759 | PVBSVCAUTOMOUNTERENTRY pEntry1 = (PVBSVCAUTOMOUNTERENTRY)pvElement1;
|
---|
| 760 | PVBSVCAUTOMOUNTERENTRY pEntry2 = (PVBSVCAUTOMOUNTERENTRY)pvElement2;
|
---|
| 761 | return pEntry1->idRoot < pEntry2->idRoot ? -1
|
---|
| 762 | : pEntry1->idRoot > pEntry2->idRoot ? 1 : 0;
|
---|
| 763 | }
|
---|
| 764 |
|
---|
| 765 |
|
---|
| 766 | /**
|
---|
| 767 | * Worker for vbsvcAutomounterPopulateTable for adding discovered entries.
|
---|
| 768 | *
|
---|
| 769 | * This is puts dummies in for missing values, depending on
|
---|
| 770 | * vbsvcAutomounterPopulateTable to query them later.
|
---|
| 771 | *
|
---|
| 772 | * @returns VINF_SUCCESS or VERR_NO_MEMORY;
|
---|
| 773 | * @param pMountTable The mount table to add an entry to.
|
---|
| 774 | * @param pszName The shared folder name.
|
---|
| 775 | * @param pszMountPoint The mount point.
|
---|
| 776 | */
|
---|
| 777 | static int vbsvcAutomounterAddEntry(PVBSVCAUTOMOUNTERTABLE pMountTable, const char *pszName, const char *pszMountPoint)
|
---|
| 778 | {
|
---|
| 779 | VGSvcVerbose(2, "vbsvcAutomounterAddEntry: %s -> %s\n", pszMountPoint, pszName);
|
---|
| 780 | PVBSVCAUTOMOUNTERENTRY pEntry = (PVBSVCAUTOMOUNTERENTRY)RTMemAlloc(sizeof(*pEntry));
|
---|
| 781 | pEntry->idRoot = UINT32_MAX;
|
---|
| 782 | pEntry->uRootIdVersion = UINT32_MAX;
|
---|
| 783 | pEntry->fFlags = UINT64_MAX;
|
---|
| 784 | pEntry->pszName = RTStrDup(pszName);
|
---|
| 785 | pEntry->pszMountPoint = NULL;
|
---|
| 786 | pEntry->pszActualMountPoint = RTStrDup(pszMountPoint);
|
---|
| 787 | if (pEntry->pszName && pEntry->pszActualMountPoint)
|
---|
| 788 | {
|
---|
| 789 | if (pMountTable->cEntries + 1 <= pMountTable->cAllocated)
|
---|
| 790 | {
|
---|
| 791 | pMountTable->papEntries[pMountTable->cEntries++] = pEntry;
|
---|
| 792 | return VINF_SUCCESS;
|
---|
| 793 | }
|
---|
| 794 |
|
---|
| 795 | void *pvNew = RTMemRealloc(pMountTable->papEntries, (pMountTable->cAllocated + 8) * sizeof(pMountTable->papEntries[0]));
|
---|
| 796 | if (pvNew)
|
---|
| 797 | {
|
---|
| 798 | pMountTable->cAllocated += 8;
|
---|
| 799 | pMountTable->papEntries = (PVBSVCAUTOMOUNTERENTRY *)pvNew;
|
---|
| 800 |
|
---|
| 801 | pMountTable->papEntries[pMountTable->cEntries++] = pEntry;
|
---|
| 802 | return VINF_SUCCESS;
|
---|
| 803 | }
|
---|
| 804 | }
|
---|
| 805 | RTMemFree(pEntry->pszActualMountPoint);
|
---|
| 806 | RTMemFree(pEntry->pszName);
|
---|
| 807 | RTMemFree(pEntry);
|
---|
| 808 | return VERR_NO_MEMORY;
|
---|
| 809 | }
|
---|
| 810 |
|
---|
| 811 |
|
---|
| 812 | /**
|
---|
| 813 | * Populates the mount table as best we can with existing automount entries.
|
---|
| 814 | *
|
---|
| 815 | * @returns VINF_SUCCESS or VERR_NO_MEMORY;
|
---|
| 816 | * @param pMountTable The mount table (empty).
|
---|
| 817 | */
|
---|
| 818 | static int vbsvcAutomounterPopulateTable(PVBSVCAUTOMOUNTERTABLE pMountTable)
|
---|
| 819 | {
|
---|
| 820 | int rc;
|
---|
| 821 |
|
---|
| 822 | #ifdef RT_OS_WINDOWS
|
---|
| 823 | /*
|
---|
| 824 | * Loop thru the drive letters and check out each of them using QueryDosDeviceW.
|
---|
| 825 | */
|
---|
| 826 | static const char s_szDevicePath[] = "\\Device\\VBoxMiniRdr\\;";
|
---|
| 827 | for (char chDrive = 'Z'; chDrive >= 'A'; chDrive--)
|
---|
| 828 | {
|
---|
[83822] | 829 | RTUTF16 const wszMountPoint[4] = { (RTUTF16)chDrive, ':', '\0', '\0' };
|
---|
[75407] | 830 | RTUTF16 wszTargetPath[RTPATH_MAX];
|
---|
| 831 | DWORD const cwcResult = QueryDosDeviceW(wszMountPoint, wszTargetPath, RT_ELEMENTS(wszTargetPath));
|
---|
| 832 | if ( cwcResult > sizeof(s_szDevicePath)
|
---|
| 833 | && RTUtf16NICmpAscii(wszTargetPath, RT_STR_TUPLE(s_szDevicePath)) == 0)
|
---|
| 834 | {
|
---|
| 835 | PCRTUTF16 pwsz = &wszTargetPath[RT_ELEMENTS(s_szDevicePath) - 1];
|
---|
| 836 | Assert(pwsz[-1] == ';');
|
---|
| 837 | if ( (pwsz[0] & ~(RTUTF16)0x20) == chDrive
|
---|
| 838 | && pwsz[1] == ':'
|
---|
| 839 | && pwsz[2] == '\\')
|
---|
| 840 | {
|
---|
| 841 | /* For now we'll just use the special capitalization of the
|
---|
| 842 | "server" name to identify it as our work. We could check
|
---|
| 843 | if the symlink is from \Global?? or \??, but that trick does
|
---|
| 844 | work for older OS versions (<= XP) or when running the
|
---|
| 845 | service manually for testing/wathever purposes. */
|
---|
| 846 | /** @todo Modify the windows shared folder driver to allow tagging drives.*/
|
---|
| 847 | if (RTUtf16NCmpAscii(&pwsz[3], RT_STR_TUPLE("VBoxSvr\\")) == 0)
|
---|
| 848 | {
|
---|
| 849 | pwsz += 3 + 8;
|
---|
| 850 | if (*pwsz != '\\' && *pwsz)
|
---|
| 851 | {
|
---|
| 852 | /* The shared folder name should follow immediately after the server prefix. */
|
---|
| 853 | char *pszMountedName = NULL;
|
---|
| 854 | rc = RTUtf16ToUtf8(pwsz, &pszMountedName);
|
---|
| 855 | if (RT_SUCCESS(rc))
|
---|
| 856 | {
|
---|
| 857 | char const szMountPoint[4] = { chDrive, ':', '\0', '\0' };
|
---|
| 858 | rc = vbsvcAutomounterAddEntry(pMountTable, pszMountedName, szMountPoint);
|
---|
| 859 | RTStrFree(pszMountedName);
|
---|
| 860 | }
|
---|
| 861 | if (RT_FAILURE(rc))
|
---|
| 862 | return rc;
|
---|
| 863 | }
|
---|
| 864 | else
|
---|
| 865 | VGSvcVerbose(2, "vbsvcAutomounterPopulateTable: Malformed, not ours: %ls -> %ls\n",
|
---|
| 866 | wszMountPoint, wszTargetPath);
|
---|
| 867 | }
|
---|
| 868 | else
|
---|
| 869 | VGSvcVerbose(3, "vbsvcAutomounterPopulateTable: Not ours: %ls -> %ls\n", wszMountPoint, wszTargetPath);
|
---|
| 870 | }
|
---|
| 871 | }
|
---|
| 872 | }
|
---|
| 873 |
|
---|
| 874 | #elif defined(RT_OS_OS2)
|
---|
| 875 | /*
|
---|
| 876 | * Just loop thru the drive letters and check the attachment of each.
|
---|
| 877 | */
|
---|
| 878 | for (char chDrive = 'Z'; chDrive >= 'A'; chDrive--)
|
---|
| 879 | {
|
---|
| 880 | char const szMountPoint[4] = { chDrive, ':', '\0', '\0' };
|
---|
| 881 | union
|
---|
| 882 | {
|
---|
| 883 | FSQBUFFER2 FsQueryBuf;
|
---|
| 884 | char achPadding[1024];
|
---|
| 885 | } uBuf;
|
---|
| 886 | RT_ZERO(uBuf);
|
---|
| 887 | ULONG cbBuf = sizeof(uBuf) - 2;
|
---|
[75469] | 888 | APIRET rcOs2 = DosQueryFSAttach(szMountPoint, 0, FSAIL_QUERYNAME, &uBuf.FsQueryBuf, &cbBuf);
|
---|
[75407] | 889 | if (rcOs2 == NO_ERROR)
|
---|
| 890 | {
|
---|
[75469] | 891 | const char *pszFsdName = (const char *)&uBuf.FsQueryBuf.szName[uBuf.FsQueryBuf.cbName + 1];
|
---|
[75407] | 892 | if ( uBuf.FsQueryBuf.iType == FSAT_REMOTEDRV
|
---|
| 893 | && RTStrICmpAscii(pszFsdName, "VBOXSF") == 0)
|
---|
| 894 | {
|
---|
[75469] | 895 | const char *pszMountedName = (const char *)&pszFsdName[uBuf.FsQueryBuf.cbFSDName + 1];
|
---|
| 896 | const char *pszTag = pszMountedName + strlen(pszMountedName) + 1; /* (Safe. Always two trailing zero bytes, see above.) */
|
---|
[75407] | 897 | if (strcmp(pszTag, g_szTag) == 0)
|
---|
| 898 | {
|
---|
| 899 | rc = vbsvcAutomounterAddEntry(pMountTable, pszMountedName, szMountPoint);
|
---|
| 900 | if (RT_FAILURE(rc))
|
---|
| 901 | return rc;
|
---|
| 902 | }
|
---|
| 903 | }
|
---|
| 904 | }
|
---|
| 905 | }
|
---|
| 906 |
|
---|
| 907 | #elif defined(RT_OS_LINUX)
|
---|
| 908 | /*
|
---|
| 909 | * Scan the mount table file for the mount point and then match file system
|
---|
| 910 | * and device/share. We identify our mounts by mount path + prefix for now,
|
---|
| 911 | * but later we may use the same approach as on solaris.
|
---|
| 912 | */
|
---|
[75433] | 913 | FILE *pFile = setmntent("/proc/mounts", "r");
|
---|
[75858] | 914 | int iErrMounts = errno;
|
---|
[75433] | 915 | if (!pFile)
|
---|
| 916 | pFile = setmntent("/etc/mtab", "r");
|
---|
[75407] | 917 | if (pFile)
|
---|
| 918 | {
|
---|
| 919 | rc = VWRN_NOT_FOUND;
|
---|
| 920 | struct mntent *pEntry;
|
---|
| 921 | while ((pEntry = getmntent(pFile)) != NULL)
|
---|
| 922 | if (strcmp(pEntry->mnt_type, "vboxsf") == 0)
|
---|
[75433] | 923 | if (strstr(pEntry->mnt_opts, g_szTag) != NULL)
|
---|
[75407] | 924 | {
|
---|
| 925 | rc = vbsvcAutomounterAddEntry(pMountTable, pEntry->mnt_fsname, pEntry->mnt_dir);
|
---|
| 926 | if (RT_FAILURE(rc))
|
---|
| 927 | {
|
---|
| 928 | endmntent(pFile);
|
---|
| 929 | return rc;
|
---|
| 930 | }
|
---|
| 931 | }
|
---|
| 932 | endmntent(pFile);
|
---|
| 933 | }
|
---|
| 934 | else
|
---|
| 935 | VGSvcError("vbsvcAutomounterQueryMountPoint: Could not open mount tab '%s' (errno=%d) or '/proc/mounts' (errno=%d)\n",
|
---|
[75858] | 936 | _PATH_MOUNTED, errno, iErrMounts);
|
---|
[75407] | 937 |
|
---|
| 938 | #elif defined(RT_OS_SOLARIS)
|
---|
| 939 | /*
|
---|
| 940 | * Look thru the system mount table and inspect the vboxsf mounts.
|
---|
| 941 | */
|
---|
| 942 | FILE *pFile = fopen(_PATH_MOUNTED, "r");
|
---|
| 943 | if (pFile)
|
---|
| 944 | {
|
---|
| 945 | rc = VINF_SUCCESS;
|
---|
| 946 | struct mnttab Entry;
|
---|
| 947 | while (getmntent(pFile, &Entry) == 0)
|
---|
[75451] | 948 | if (strcmp(Entry.mnt_fstype, "vboxfs") == 0)
|
---|
[75407] | 949 | {
|
---|
| 950 | /* Look for the dummy automounter option. */
|
---|
[75411] | 951 | if ( Entry.mnt_mntopts != NULL
|
---|
| 952 | && strstr(Entry.mnt_mntopts, g_szTag) != NULL)
|
---|
[75407] | 953 | {
|
---|
| 954 | rc = vbsvcAutomounterAddEntry(pMountTable, Entry.mnt_special, Entry.mnt_mountp);
|
---|
| 955 | if (RT_FAILURE(rc))
|
---|
| 956 | {
|
---|
| 957 | fclose(pFile);
|
---|
| 958 | return rc;
|
---|
| 959 | }
|
---|
| 960 | }
|
---|
| 961 | }
|
---|
| 962 | fclose(pFile);
|
---|
| 963 | }
|
---|
| 964 | else
|
---|
| 965 | VGSvcError("vbsvcAutomounterQueryMountPoint: Could not open mount tab '%s' (errno=%d)\n", _PATH_MOUNTED, errno);
|
---|
| 966 |
|
---|
| 967 | #else
|
---|
| 968 | # error "PORTME!"
|
---|
| 969 | #endif
|
---|
| 970 |
|
---|
| 971 | /*
|
---|
| 972 | * Try reconcile the detected folders with data from the host.
|
---|
| 973 | */
|
---|
| 974 | uint32_t cMappings = 0;
|
---|
| 975 | PVBGLR3SHAREDFOLDERMAPPING paMappings = NULL;
|
---|
| 976 | rc = VbglR3SharedFolderGetMappings(g_idClientSharedFolders, true /*fAutoMountOnly*/, &paMappings, &cMappings);
|
---|
| 977 | if (RT_SUCCESS(rc))
|
---|
| 978 | {
|
---|
| 979 | for (uint32_t i = 0; i < cMappings && RT_SUCCESS(rc); i++)
|
---|
| 980 | {
|
---|
| 981 | uint32_t const idRootSrc = paMappings[i].u32Root;
|
---|
| 982 |
|
---|
| 983 | uint32_t uRootIdVer = UINT32_MAX;
|
---|
| 984 | uint64_t fFlags = 0;
|
---|
| 985 | char *pszName = NULL;
|
---|
| 986 | char *pszMntPt = NULL;
|
---|
| 987 | int rc2 = VbglR3SharedFolderQueryFolderInfo(g_idClientSharedFolders, idRootSrc, VBOXSERVICE_AUTOMOUNT_MIQF,
|
---|
| 988 | &pszName, &pszMntPt, &fFlags, &uRootIdVer);
|
---|
| 989 | if (RT_SUCCESS(rc2))
|
---|
| 990 | {
|
---|
| 991 | uint32_t iPrevHit = UINT32_MAX;
|
---|
| 992 | for (uint32_t iTable = 0; iTable < pMountTable->cEntries; iTable++)
|
---|
| 993 | {
|
---|
| 994 | PVBSVCAUTOMOUNTERENTRY pEntry = pMountTable->papEntries[iTable];
|
---|
| 995 | if (RTStrICmp(pEntry->pszName, pszName) == 0)
|
---|
| 996 | {
|
---|
| 997 | VGSvcVerbose(2, "vbsvcAutomounterPopulateTable: Identified %s -> %s: idRoot=%u ver=%u fFlags=%#x AutoMntPt=%s\n",
|
---|
| 998 | pEntry->pszActualMountPoint, pEntry->pszName, idRootSrc, uRootIdVer, fFlags, pszMntPt);
|
---|
| 999 | pEntry->fFlags = fFlags;
|
---|
| 1000 | pEntry->idRoot = idRootSrc;
|
---|
| 1001 | pEntry->uRootIdVersion = uRootIdVer;
|
---|
| 1002 | RTStrFree(pEntry->pszMountPoint);
|
---|
| 1003 | pEntry->pszMountPoint = RTStrDup(pszMntPt);
|
---|
| 1004 | if (!pEntry->pszMountPoint)
|
---|
| 1005 | {
|
---|
| 1006 | rc = VERR_NO_MEMORY;
|
---|
| 1007 | break;
|
---|
| 1008 | }
|
---|
| 1009 |
|
---|
| 1010 | /* If multiple mappings of the same folder, pick the first or the one
|
---|
| 1011 | with matching mount point. */
|
---|
| 1012 | if (iPrevHit == UINT32_MAX)
|
---|
| 1013 | iPrevHit = iTable;
|
---|
| 1014 | else if (RTPathCompare(pszMntPt, pEntry->pszActualMountPoint) == 0)
|
---|
| 1015 | {
|
---|
| 1016 | if (iPrevHit != UINT32_MAX)
|
---|
| 1017 | pMountTable->papEntries[iPrevHit]->uRootIdVersion -= 1;
|
---|
| 1018 | iPrevHit = iTable;
|
---|
| 1019 | }
|
---|
| 1020 | else
|
---|
| 1021 | pEntry->uRootIdVersion -= 1;
|
---|
| 1022 | }
|
---|
| 1023 | }
|
---|
| 1024 |
|
---|
| 1025 | RTStrFree(pszName);
|
---|
| 1026 | RTStrFree(pszMntPt);
|
---|
| 1027 | }
|
---|
| 1028 | else
|
---|
| 1029 | VGSvcError("vbsvcAutomounterPopulateTable: VbglR3SharedFolderQueryFolderInfo(%u) failed: %Rrc\n", idRootSrc, rc2);
|
---|
| 1030 | }
|
---|
| 1031 |
|
---|
| 1032 | VbglR3SharedFolderFreeMappings(paMappings);
|
---|
| 1033 |
|
---|
| 1034 | /*
|
---|
| 1035 | * Sort the table by root ID.
|
---|
| 1036 | */
|
---|
| 1037 | if (pMountTable->cEntries > 1)
|
---|
| 1038 | RTSortApvShell((void **)pMountTable->papEntries, pMountTable->cEntries, vbsvcAutomounterCompareEntry, NULL);
|
---|
| 1039 |
|
---|
| 1040 | for (uint32_t iTable = 0; iTable < pMountTable->cEntries; iTable++)
|
---|
| 1041 | {
|
---|
| 1042 | PVBSVCAUTOMOUNTERENTRY pEntry = pMountTable->papEntries[iTable];
|
---|
| 1043 | if (pMountTable->papEntries[iTable]->idRoot != UINT32_MAX)
|
---|
| 1044 | VGSvcVerbose(1, "vbsvcAutomounterPopulateTable: #%u: %s -> %s idRoot=%u ver=%u fFlags=%#x AutoMntPt=%s\n",
|
---|
| 1045 | iTable, pEntry->pszActualMountPoint, pEntry->pszName, pEntry->idRoot, pEntry->uRootIdVersion,
|
---|
| 1046 | pEntry->fFlags, pEntry->pszMountPoint);
|
---|
| 1047 | else
|
---|
| 1048 | VGSvcVerbose(1, "vbsvcAutomounterPopulateTable: #%u: %s -> %s - not identified!\n",
|
---|
| 1049 | iTable, pEntry->pszActualMountPoint, pEntry->pszName);
|
---|
| 1050 | }
|
---|
| 1051 | }
|
---|
| 1052 | else
|
---|
| 1053 | VGSvcError("vbsvcAutomounterPopulateTable: VbglR3SharedFolderGetMappings failed: %Rrc\n", rc);
|
---|
| 1054 | return rc;
|
---|
| 1055 | }
|
---|
| 1056 |
|
---|
| 1057 |
|
---|
| 1058 | /**
|
---|
| 1059 | * Checks whether the shared folder @a pszName is mounted on @a pszMountPoint.
|
---|
| 1060 | *
|
---|
| 1061 | * @returns Exactly one of the following IPRT status codes;
|
---|
| 1062 | * @retval VINF_SUCCESS if mounted
|
---|
| 1063 | * @retval VWRN_NOT_FOUND if nothing is mounted at @a pszMountPoint.
|
---|
| 1064 | * @retval VERR_RESOURCE_BUSY if a different shared folder is mounted there.
|
---|
| 1065 | * @retval VERR_ACCESS_DENIED if a non-shared folder file system is mounted
|
---|
| 1066 | * there.
|
---|
| 1067 | *
|
---|
| 1068 | * @param pszMountPoint The mount point to check.
|
---|
| 1069 | * @param pszName The name of the shared folder (mapping).
|
---|
| 1070 | */
|
---|
| 1071 | static int vbsvcAutomounterQueryMountPoint(const char *pszMountPoint, const char *pszName)
|
---|
| 1072 | {
|
---|
| 1073 | VGSvcVerbose(4, "vbsvcAutomounterQueryMountPoint: pszMountPoint=%s pszName=%s\n", pszMountPoint, pszName);
|
---|
| 1074 |
|
---|
| 1075 | #ifdef RT_OS_WINDOWS
|
---|
| 1076 | /*
|
---|
| 1077 | * We could've used RTFsQueryType here but would then have to
|
---|
| 1078 | * calling RTFsQueryLabel for the share name hint, ending up
|
---|
| 1079 | * doing the same work twice. We could also use QueryDosDeviceW,
|
---|
| 1080 | * but output is less clear...
|
---|
| 1081 | */
|
---|
| 1082 | PRTUTF16 pwszMountPoint = NULL;
|
---|
| 1083 | int rc = RTStrToUtf16(pszMountPoint, &pwszMountPoint);
|
---|
| 1084 | if (RT_SUCCESS(rc))
|
---|
| 1085 | {
|
---|
| 1086 | DWORD uSerial = 0;
|
---|
| 1087 | DWORD cchCompMax = 0;
|
---|
| 1088 | DWORD fFlags = 0;
|
---|
| 1089 | RTUTF16 wszLabel[512];
|
---|
| 1090 | RTUTF16 wszFileSystem[256];
|
---|
| 1091 | RT_ZERO(wszLabel);
|
---|
| 1092 | RT_ZERO(wszFileSystem);
|
---|
| 1093 | if (GetVolumeInformationW(pwszMountPoint, wszLabel, RT_ELEMENTS(wszLabel) - 1, &uSerial, &cchCompMax, &fFlags,
|
---|
| 1094 | wszFileSystem, RT_ELEMENTS(wszFileSystem) - 1))
|
---|
| 1095 | {
|
---|
| 1096 | if (RTUtf16ICmpAscii(wszFileSystem, "VBoxSharedFolderFS") == 0)
|
---|
| 1097 | {
|
---|
| 1098 | char *pszLabel = NULL;
|
---|
| 1099 | rc = RTUtf16ToUtf8(wszLabel, &pszLabel);
|
---|
| 1100 | if (RT_SUCCESS(rc))
|
---|
| 1101 | {
|
---|
| 1102 | const char *pszMountedName = pszLabel;
|
---|
| 1103 | if (RTStrStartsWith(pszMountedName, "VBOX_"))
|
---|
| 1104 | pszMountedName += sizeof("VBOX_") - 1;
|
---|
| 1105 | if (RTStrICmp(pszMountedName, pszName) == 0)
|
---|
| 1106 | {
|
---|
[75433] | 1107 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s'.\n",
|
---|
[75451] | 1108 | pszName, pszMountPoint);
|
---|
[75407] | 1109 | rc = VINF_SUCCESS;
|
---|
| 1110 | }
|
---|
| 1111 | else
|
---|
| 1112 | {
|
---|
| 1113 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s', not '%s'...\n",
|
---|
| 1114 | pszMountedName, pszMountPoint, pszName);
|
---|
| 1115 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1116 | }
|
---|
| 1117 | RTStrFree(pszLabel);
|
---|
| 1118 | }
|
---|
| 1119 | else
|
---|
| 1120 | {
|
---|
| 1121 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: RTUtf16ToUtf8(%ls,) failed: %Rrc\n", wszLabel, rc);
|
---|
| 1122 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1123 | }
|
---|
| 1124 | }
|
---|
| 1125 | else
|
---|
| 1126 | {
|
---|
| 1127 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found a '%ls' with label '%ls' mount at '%s', not '%s'...\n",
|
---|
| 1128 | wszFileSystem, wszLabel, pszMountPoint, pszName);
|
---|
| 1129 | rc = VERR_ACCESS_DENIED;
|
---|
| 1130 | }
|
---|
| 1131 | }
|
---|
| 1132 | else
|
---|
| 1133 | {
|
---|
| 1134 | rc = GetLastError();
|
---|
| 1135 | if (rc != ERROR_PATH_NOT_FOUND || g_cVerbosity >= 4)
|
---|
| 1136 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: GetVolumeInformationW('%ls',,,,) failed: %u\n", pwszMountPoint, rc);
|
---|
[83718] | 1137 | if (rc == ERROR_PATH_NOT_FOUND)
|
---|
| 1138 | rc = VWRN_NOT_FOUND;
|
---|
| 1139 | else if ( RT_C_IS_ALPHA(pszMountPoint[0])
|
---|
| 1140 | && pszMountPoint[1] == ':'
|
---|
| 1141 | && ( pszMountPoint[2] == '\0'
|
---|
| 1142 | || (RTPATH_IS_SLASH(pszMountPoint[2]) && pszMountPoint[3] == '\0')))
|
---|
| 1143 | {
|
---|
| 1144 | /* See whether QueryDosDeviceW thinks its a malfunctioning shared folder or
|
---|
| 1145 | something else (it doesn't access the file system). We've seen
|
---|
| 1146 | VERR_NET_HOST_NOT_FOUND here for shared folders that was removed on the
|
---|
| 1147 | host side.
|
---|
| 1148 |
|
---|
| 1149 | Note! This duplicates code from vbsvcAutomounterPopulateTable. */
|
---|
| 1150 | rc = VERR_ACCESS_DENIED;
|
---|
| 1151 | static const char s_szDevicePath[] = "\\Device\\VBoxMiniRdr\\;";
|
---|
| 1152 | wszFileSystem[0] = pwszMountPoint[0];
|
---|
| 1153 | wszFileSystem[1] = pwszMountPoint[1];
|
---|
| 1154 | wszFileSystem[2] = '\0';
|
---|
| 1155 | DWORD const cwcResult = QueryDosDeviceW(wszFileSystem, wszLabel, RT_ELEMENTS(wszLabel));
|
---|
| 1156 | if ( cwcResult > sizeof(s_szDevicePath)
|
---|
| 1157 | && RTUtf16NICmpAscii(wszLabel, RT_STR_TUPLE(s_szDevicePath)) == 0)
|
---|
| 1158 | {
|
---|
| 1159 | PCRTUTF16 pwsz = &wszLabel[RT_ELEMENTS(s_szDevicePath) - 1];
|
---|
| 1160 | Assert(pwsz[-1] == ';');
|
---|
| 1161 | if ( (pwsz[0] & ~(RTUTF16)0x20) == (wszFileSystem[0] & ~(RTUTF16)0x20)
|
---|
| 1162 | && pwsz[1] == ':'
|
---|
| 1163 | && pwsz[2] == '\\')
|
---|
| 1164 | {
|
---|
| 1165 | if (RTUtf16NICmpAscii(&pwsz[3], RT_STR_TUPLE("VBoxSvr\\")) == 0)
|
---|
| 1166 | {
|
---|
| 1167 | pwsz += 3 + 8;
|
---|
| 1168 | char *pszMountedName = NULL;
|
---|
| 1169 | rc = RTUtf16ToUtf8(pwsz, &pszMountedName);
|
---|
| 1170 | if (RT_SUCCESS(rc))
|
---|
| 1171 | {
|
---|
| 1172 | if (RTStrICmp(pszMountedName, pszName) == 0)
|
---|
| 1173 | {
|
---|
| 1174 | rc = VINF_SUCCESS;
|
---|
| 1175 | VGSvcVerbose(2, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s' (using QueryDosDeviceW).\n",
|
---|
| 1176 | pszName, pszMountPoint);
|
---|
| 1177 | }
|
---|
| 1178 | else
|
---|
| 1179 | {
|
---|
| 1180 | VGSvcVerbose(2, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s' (using QueryDosDeviceW), not '%s'...\n",
|
---|
| 1181 | pszMountedName, pszMountPoint, pszName);
|
---|
| 1182 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1183 | }
|
---|
| 1184 | RTStrFree(pszMountedName);
|
---|
| 1185 | }
|
---|
| 1186 | else
|
---|
| 1187 | {
|
---|
| 1188 | VGSvcVerbose(2, "vbsvcAutomounterQueryMountPoint: RTUtf16ToUtf8 failed: %Rrc\n", rc);
|
---|
| 1189 | AssertRC(rc);
|
---|
| 1190 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1191 | }
|
---|
| 1192 | }
|
---|
| 1193 | }
|
---|
| 1194 | }
|
---|
| 1195 | }
|
---|
| 1196 | else
|
---|
| 1197 | rc = VERR_ACCESS_DENIED;
|
---|
[75407] | 1198 | }
|
---|
| 1199 | RTUtf16Free(pwszMountPoint);
|
---|
| 1200 | }
|
---|
| 1201 | else
|
---|
| 1202 | {
|
---|
| 1203 | VGSvcError("vbsvcAutomounterQueryMountPoint: RTStrToUtf16(%s,) -> %Rrc\n", pszMountPoint, rc);
|
---|
| 1204 | rc = VWRN_NOT_FOUND;
|
---|
| 1205 | }
|
---|
| 1206 | return rc;
|
---|
| 1207 |
|
---|
| 1208 | #elif defined(RT_OS_OS2)
|
---|
| 1209 | /*
|
---|
| 1210 | * Query file system attachment info for the given drive letter.
|
---|
| 1211 | */
|
---|
| 1212 | union
|
---|
| 1213 | {
|
---|
| 1214 | FSQBUFFER2 FsQueryBuf;
|
---|
| 1215 | char achPadding[512];
|
---|
| 1216 | } uBuf;
|
---|
| 1217 | RT_ZERO(uBuf);
|
---|
| 1218 |
|
---|
| 1219 | ULONG cbBuf = sizeof(uBuf);
|
---|
[75469] | 1220 | APIRET rcOs2 = DosQueryFSAttach(pszMountPoint, 0, FSAIL_QUERYNAME, &uBuf.FsQueryBuf, &cbBuf);
|
---|
[75407] | 1221 | int rc;
|
---|
| 1222 | if (rcOs2 == NO_ERROR)
|
---|
| 1223 | {
|
---|
[75469] | 1224 | const char *pszFsdName = (const char *)&uBuf.FsQueryBuf.szName[uBuf.FsQueryBuf.cbName + 1];
|
---|
[75407] | 1225 | if ( uBuf.FsQueryBuf.iType == FSAT_REMOTEDRV
|
---|
| 1226 | && RTStrICmpAscii(pszFsdName, "VBOXSF") == 0)
|
---|
| 1227 | {
|
---|
[75469] | 1228 | const char *pszMountedName = (const char *)&pszFsdName[uBuf.FsQueryBuf.cbFSDName + 1];
|
---|
[75407] | 1229 | if (RTStrICmp(pszMountedName, pszName) == 0)
|
---|
| 1230 | {
|
---|
[75433] | 1231 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s'.\n",
|
---|
[75451] | 1232 | pszName, pszMountPoint);
|
---|
[75407] | 1233 | rc = VINF_SUCCESS;
|
---|
| 1234 | }
|
---|
| 1235 | else
|
---|
| 1236 | {
|
---|
| 1237 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s', not '%s'...\n",
|
---|
| 1238 | pszMountedName, pszMountPoint, pszName);
|
---|
| 1239 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1240 | }
|
---|
| 1241 | }
|
---|
| 1242 | else
|
---|
| 1243 | {
|
---|
| 1244 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found a '%s' type %u mount at '%s', not '%s'...\n",
|
---|
| 1245 | pszFsdName, uBuf.FsQueryBuf.iType, pszMountPoint, pszName);
|
---|
| 1246 | rc = VERR_ACCESS_DENIED;
|
---|
| 1247 | }
|
---|
| 1248 | }
|
---|
| 1249 | else
|
---|
| 1250 | {
|
---|
| 1251 | rc = VWRN_NOT_FOUND;
|
---|
| 1252 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: DosQueryFSAttach(%s) -> %u\n", pszMountPoint, rcOs2);
|
---|
| 1253 | AssertMsgStmt(rcOs2 != ERROR_BUFFER_OVERFLOW && rcOs2 != ERROR_INVALID_PARAMETER,
|
---|
| 1254 | ("%s -> %u\n", pszMountPoint, rcOs2), rc = VERR_ACCESS_DENIED);
|
---|
| 1255 | }
|
---|
| 1256 | return rc;
|
---|
| 1257 |
|
---|
| 1258 | #elif defined(RT_OS_LINUX)
|
---|
| 1259 | /*
|
---|
| 1260 | * Scan one of the mount table file for the mount point and then
|
---|
| 1261 | * match file system and device/share.
|
---|
| 1262 | */
|
---|
[75433] | 1263 | FILE *pFile = setmntent("/proc/mounts", "r");
|
---|
[75407] | 1264 | int rc = errno;
|
---|
| 1265 | if (!pFile)
|
---|
[75433] | 1266 | pFile = setmntent(_PATH_MOUNTED, "r");
|
---|
[75407] | 1267 | if (pFile)
|
---|
| 1268 | {
|
---|
| 1269 | rc = VWRN_NOT_FOUND;
|
---|
| 1270 | struct mntent *pEntry;
|
---|
| 1271 | while ((pEntry = getmntent(pFile)) != NULL)
|
---|
| 1272 | if (RTPathCompare(pEntry->mnt_dir, pszMountPoint) == 0)
|
---|
| 1273 | {
|
---|
| 1274 | if (strcmp(pEntry->mnt_type, "vboxsf") == 0)
|
---|
| 1275 | {
|
---|
| 1276 | if (RTStrICmp(pEntry->mnt_fsname, pszName) == 0)
|
---|
| 1277 | {
|
---|
[75433] | 1278 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s'.\n",
|
---|
[75451] | 1279 | pszName, pszMountPoint);
|
---|
[75407] | 1280 | rc = VINF_SUCCESS;
|
---|
| 1281 | }
|
---|
| 1282 | else
|
---|
| 1283 | {
|
---|
| 1284 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s', not '%s'...\n",
|
---|
| 1285 | pEntry->mnt_fsname, pszMountPoint, pszName);
|
---|
| 1286 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1287 | }
|
---|
| 1288 | }
|
---|
| 1289 | else
|
---|
| 1290 | {
|
---|
| 1291 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found a '%s' mount of '%s' at '%s', not '%s'...\n",
|
---|
| 1292 | pEntry->mnt_type, pEntry->mnt_fsname, pszMountPoint, pszName);
|
---|
| 1293 | rc = VERR_ACCESS_DENIED;
|
---|
| 1294 | }
|
---|
| 1295 | /* We continue searching in case of stacked mounts, we want the last one. */
|
---|
| 1296 | }
|
---|
| 1297 | endmntent(pFile);
|
---|
| 1298 | }
|
---|
| 1299 | else
|
---|
| 1300 | {
|
---|
[75433] | 1301 | VGSvcError("vbsvcAutomounterQueryMountPoint: Could not open mount tab '/proc/mounts' (errno=%d) or '%s' (errno=%d)\n",
|
---|
| 1302 | rc, _PATH_MOUNTED, errno);
|
---|
[75407] | 1303 | rc = VERR_ACCESS_DENIED;
|
---|
| 1304 | }
|
---|
| 1305 | return rc;
|
---|
| 1306 |
|
---|
| 1307 | #elif defined(RT_OS_SOLARIS)
|
---|
| 1308 | /*
|
---|
| 1309 | * Similar to linux.
|
---|
| 1310 | */
|
---|
| 1311 | int rc;
|
---|
| 1312 | FILE *pFile = fopen(_PATH_MOUNTED, "r");
|
---|
| 1313 | if (pFile)
|
---|
| 1314 | {
|
---|
| 1315 | rc = VWRN_NOT_FOUND;
|
---|
| 1316 | struct mnttab Entry;
|
---|
| 1317 | while (getmntent(pFile, &Entry) == 0)
|
---|
| 1318 | if (RTPathCompare(Entry.mnt_mountp, pszMountPoint) == 0)
|
---|
| 1319 | {
|
---|
[75446] | 1320 | if (strcmp(Entry.mnt_fstype, "vboxfs") == 0)
|
---|
[75407] | 1321 | {
|
---|
| 1322 | if (RTStrICmp(Entry.mnt_special, pszName) == 0)
|
---|
| 1323 | {
|
---|
[75433] | 1324 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s'.\n",
|
---|
[75451] | 1325 | pszName, pszMountPoint);
|
---|
[75407] | 1326 | rc = VINF_SUCCESS;
|
---|
| 1327 | }
|
---|
| 1328 | else
|
---|
| 1329 | {
|
---|
| 1330 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found shared folder '%s' at '%s', not '%s'...\n",
|
---|
| 1331 | Entry.mnt_special, pszMountPoint, pszName);
|
---|
| 1332 | rc = VERR_RESOURCE_BUSY;
|
---|
| 1333 | }
|
---|
| 1334 | }
|
---|
| 1335 | else
|
---|
| 1336 | {
|
---|
| 1337 | VGSvcVerbose(3, "vbsvcAutomounterQueryMountPoint: Found a '%s' mount of '%s' at '%s', not '%s'...\n",
|
---|
| 1338 | Entry.mnt_fstype, Entry.mnt_special, pszMountPoint, pszName);
|
---|
| 1339 | rc = VERR_ACCESS_DENIED;
|
---|
| 1340 | }
|
---|
| 1341 | /* We continue searching in case of stacked mounts, we want the last one. */
|
---|
| 1342 | }
|
---|
| 1343 | fclose(pFile);
|
---|
| 1344 | }
|
---|
| 1345 | else
|
---|
| 1346 | {
|
---|
| 1347 | VGSvcError("vbsvcAutomounterQueryMountPoint: Could not open mount tab '%s' (errno=%d)\n", _PATH_MOUNTED, errno);
|
---|
| 1348 | rc = VERR_ACCESS_DENIED;
|
---|
| 1349 | }
|
---|
| 1350 | return rc;
|
---|
| 1351 | #else
|
---|
| 1352 | # error "PORTME"
|
---|
| 1353 | #endif
|
---|
| 1354 | }
|
---|
| 1355 |
|
---|
| 1356 |
|
---|
| 1357 | /**
|
---|
| 1358 | * Worker for vbsvcAutomounterMountNewEntry that does the OS mounting.
|
---|
| 1359 | *
|
---|
| 1360 | * @returns IPRT status code.
|
---|
| 1361 | * @param pEntry The entry to try mount.
|
---|
| 1362 | */
|
---|
| 1363 | static int vbsvcAutomounterMountIt(PVBSVCAUTOMOUNTERENTRY pEntry)
|
---|
| 1364 | {
|
---|
| 1365 | VGSvcVerbose(3, "vbsvcAutomounterMountIt: Trying to mount '%s' (idRoot=%#x) on '%s'...\n",
|
---|
| 1366 | pEntry->pszName, pEntry->idRoot, pEntry->pszActualMountPoint);
|
---|
| 1367 | #ifdef RT_OS_WINDOWS
|
---|
| 1368 | /*
|
---|
| 1369 | * Attach the shared folder using WNetAddConnection2W.
|
---|
[35077] | 1370 | *
|
---|
[75407] | 1371 | * According to google we should get a drive symlink in \\GLOBAL?? when
|
---|
[83708] | 1372 | * we are running under the system account. Otherwise it will be a session
|
---|
[75407] | 1373 | * local link (\\??).
|
---|
| 1374 | */
|
---|
| 1375 | Assert(RT_C_IS_UPPER(pEntry->pszActualMountPoint[0]) && pEntry->pszActualMountPoint[1] == ':' && pEntry->pszActualMountPoint[2] == '\0');
|
---|
[83822] | 1376 | RTUTF16 wszDrive[4] = { (RTUTF16)pEntry->pszActualMountPoint[0], ':', '\0', '\0' };
|
---|
[75407] | 1377 |
|
---|
| 1378 | RTUTF16 wszPrefixedName[RTPATH_MAX];
|
---|
| 1379 | int rc = RTUtf16CopyAscii(wszPrefixedName, RT_ELEMENTS(wszPrefixedName), "\\\\VBoxSvr\\");
|
---|
| 1380 | AssertRC(rc);
|
---|
| 1381 |
|
---|
[75947] | 1382 | size_t const offName = RTUtf16Len(wszPrefixedName);
|
---|
| 1383 | PRTUTF16 pwszName = &wszPrefixedName[offName];
|
---|
| 1384 | rc = RTStrToUtf16Ex(pEntry->pszName, RTSTR_MAX, &pwszName, sizeof(wszPrefixedName) - offName, NULL);
|
---|
[75407] | 1385 | if (RT_FAILURE(rc))
|
---|
| 1386 | {
|
---|
| 1387 | VGSvcError("vbsvcAutomounterMountIt: RTStrToUtf16Ex failed on '%s': %Rrc\n", pEntry->pszName, rc);
|
---|
| 1388 | return rc;
|
---|
| 1389 | }
|
---|
| 1390 |
|
---|
[83708] | 1391 | VGSvcVerbose(3, "vbsvcAutomounterMountIt: wszDrive='%ls', wszPrefixedName='%ls'\n",
|
---|
| 1392 | wszDrive, wszPrefixedName);
|
---|
| 1393 |
|
---|
[75407] | 1394 | NETRESOURCEW NetRsrc;
|
---|
| 1395 | RT_ZERO(NetRsrc);
|
---|
| 1396 | NetRsrc.dwType = RESOURCETYPE_DISK;
|
---|
| 1397 | NetRsrc.lpLocalName = wszDrive;
|
---|
| 1398 | NetRsrc.lpRemoteName = wszPrefixedName;
|
---|
[99828] | 1399 | NetRsrc.lpProvider = (PWSTR)L"VirtualBox Shared Folders"; /* Only try our provider. */
|
---|
[75407] | 1400 | NetRsrc.lpComment = pwszName;
|
---|
| 1401 |
|
---|
| 1402 | DWORD dwErr = WNetAddConnection2W(&NetRsrc, NULL /*pwszPassword*/, NULL /*pwszUserName*/, 0 /*dwFlags*/);
|
---|
| 1403 | if (dwErr == NO_ERROR)
|
---|
| 1404 | {
|
---|
| 1405 | VGSvcVerbose(0, "vbsvcAutomounterMountIt: Successfully mounted '%s' on '%s'\n",
|
---|
| 1406 | pEntry->pszName, pEntry->pszActualMountPoint);
|
---|
| 1407 | return VINF_SUCCESS;
|
---|
| 1408 | }
|
---|
[83708] | 1409 | VGSvcError("vbsvcAutomounterMountIt: Failed to attach '%s' to '%s': %Rrc (%u)\n",
|
---|
| 1410 | pEntry->pszName, pEntry->pszActualMountPoint, RTErrConvertFromWin32(dwErr), dwErr);
|
---|
[75407] | 1411 | return VERR_OPEN_FAILED;
|
---|
| 1412 |
|
---|
| 1413 | #elif defined(RT_OS_OS2)
|
---|
| 1414 | /*
|
---|
| 1415 | * It's a rather simple affair on OS/2.
|
---|
[35077] | 1416 | *
|
---|
[75407] | 1417 | * In order to be able to detect our mounts we add a 2nd string after
|
---|
| 1418 | * the folder name that tags the attachment. The IFS will remember this
|
---|
| 1419 | * and return it when DosQueryFSAttach is called.
|
---|
| 1420 | *
|
---|
| 1421 | * Note! Kernel currently accepts limited 7-bit ASCII names. We could
|
---|
| 1422 | * change that to UTF-8 if we like as that means no extra string
|
---|
| 1423 | * encoding conversion fun here.
|
---|
[35077] | 1424 | */
|
---|
[75407] | 1425 | char szzNameAndTag[256];
|
---|
| 1426 | size_t cchName = strlen(pEntry->pszName);
|
---|
| 1427 | if (cchName + 1 + sizeof(g_szTag) <= sizeof(szzNameAndTag))
|
---|
| 1428 | {
|
---|
| 1429 | memcpy(szzNameAndTag, pEntry->pszName, cchName);
|
---|
| 1430 | szzNameAndTag[cchName] = '\0';
|
---|
| 1431 | memcpy(&szzNameAndTag[cchName + 1], g_szTag, sizeof(g_szTag));
|
---|
| 1432 |
|
---|
[75467] | 1433 | APIRET rc = DosFSAttach(pEntry->pszActualMountPoint, "VBOXSF", szzNameAndTag, cchName + 1 + sizeof(g_szTag), FS_ATTACH);
|
---|
[75407] | 1434 | if (rc == NO_ERROR)
|
---|
| 1435 | {
|
---|
| 1436 | VGSvcVerbose(0, "vbsvcAutomounterMountIt: Successfully mounted '%s' on '%s'\n",
|
---|
| 1437 | pEntry->pszName, pEntry->pszActualMountPoint);
|
---|
| 1438 | return VINF_SUCCESS;
|
---|
| 1439 | }
|
---|
| 1440 | VGSvcError("vbsvcAutomounterMountIt: DosFSAttach failed to attach '%s' to '%s': %u\n",
|
---|
| 1441 | pEntry->pszName, pEntry->pszActualMountPoint, rc);
|
---|
| 1442 | }
|
---|
| 1443 | else
|
---|
| 1444 | VGSvcError("vbsvcAutomounterMountIt: Share name for attach to '%s' is too long: %u chars - '%s'\n",
|
---|
[75469] | 1445 | pEntry->pszActualMountPoint, cchName, pEntry->pszName);
|
---|
[75407] | 1446 | return VERR_OPEN_FAILED;
|
---|
| 1447 |
|
---|
| 1448 | #else
|
---|
| 1449 | /*
|
---|
| 1450 | * Common work for unix-like systems: Get group, make sure mount directory exist.
|
---|
| 1451 | */
|
---|
| 1452 | int rc = RTDirCreateFullPath(pEntry->pszActualMountPoint,
|
---|
| 1453 | RTFS_UNIX_IRWXU | RTFS_UNIX_IXGRP | RTFS_UNIX_IRGRP | RTFS_UNIX_IXOTH | RTFS_UNIX_IROTH);
|
---|
| 1454 | if (RT_FAILURE(rc))
|
---|
| 1455 | {
|
---|
| 1456 | VGSvcError("vbsvcAutomounterMountIt: Failed to create mount path '%s' for share '%s': %Rrc\n",
|
---|
| 1457 | pEntry->pszActualMountPoint, pEntry->pszName, rc);
|
---|
| 1458 | return rc;
|
---|
| 1459 | }
|
---|
| 1460 |
|
---|
| 1461 | gid_t gidMount;
|
---|
| 1462 | struct group *grp_vboxsf = getgrnam("vboxsf");
|
---|
| 1463 | if (grp_vboxsf)
|
---|
| 1464 | gidMount = grp_vboxsf->gr_gid;
|
---|
| 1465 | else
|
---|
| 1466 | {
|
---|
| 1467 | VGSvcError("vbsvcAutomounterMountIt: Group 'vboxsf' does not exist\n");
|
---|
| 1468 | gidMount = 0;
|
---|
| 1469 | }
|
---|
| 1470 |
|
---|
[100317] | 1471 | /*
|
---|
| 1472 | * Allocate options string buffer which is limited to a page on most systems.
|
---|
| 1473 | */
|
---|
| 1474 | uint32_t cbOpts = RTSystemGetPageSize();
|
---|
| 1475 | char *pszOpts = (char *)alloca(cbOpts);
|
---|
| 1476 |
|
---|
[75407] | 1477 | # if defined(RT_OS_LINUX)
|
---|
| 1478 | /*
|
---|
| 1479 | * Linux a bit more work...
|
---|
| 1480 | */
|
---|
[87463] | 1481 | struct utsname uts;
|
---|
| 1482 | AssertStmt(uname(&uts) != -1, strcpy(uts.release, "4.4.0"));
|
---|
| 1483 |
|
---|
| 1484 | /* Built mount option string. Need st_name for pre 2.6.0 kernels. */
|
---|
| 1485 | unsigned long const fFlags = MS_NODEV;
|
---|
[100317] | 1486 | ssize_t cchOpts = RTStrPrintf2(pszOpts, cbOpts,
|
---|
[87463] | 1487 | "uid=0,gid=%d,dmode=0770,fmode=0770,dmask=0000,fmask=0000,tag=%s", gidMount, g_szTag);
|
---|
| 1488 | if (RTStrVersionCompare(uts.release, "2.6.0") < 0 && cchOpts > 0)
|
---|
[100317] | 1489 | cchOpts += RTStrPrintf2(&pszOpts[cchOpts], cbOpts - cchOpts, ",sf_name=%s", pEntry->pszName);
|
---|
[87463] | 1490 | if (cchOpts <= 0)
|
---|
[75407] | 1491 | {
|
---|
[100317] | 1492 | VGSvcError("vbsvcAutomounterMountIt: pszOpts overflow! %zd\n", cchOpts);
|
---|
[87463] | 1493 | return VERR_BUFFER_OVERFLOW;
|
---|
[75407] | 1494 | }
|
---|
| 1495 |
|
---|
[87463] | 1496 | /* Do the mounting. The fallback w/o tag is for the Linux vboxsf fork
|
---|
| 1497 | which lagged a lot behind when it first appeared in 5.6. */
|
---|
[75407] | 1498 | errno = 0;
|
---|
[100317] | 1499 | rc = mount(pEntry->pszName, pEntry->pszActualMountPoint, "vboxsf", fFlags, pszOpts);
|
---|
[87463] | 1500 | if (rc != 0 && errno == EINVAL && RTStrVersionCompare(uts.release, "5.6.0") >= 0)
|
---|
| 1501 | {
|
---|
| 1502 | VGSvcVerbose(2, "vbsvcAutomounterMountIt: mount returned EINVAL, retrying without the tag.\n");
|
---|
[100317] | 1503 | *strstr(pszOpts, ",tag=") = '\0';
|
---|
[87463] | 1504 | errno = 0;
|
---|
[100317] | 1505 | rc = mount(pEntry->pszName, pEntry->pszActualMountPoint, "vboxsf", fFlags, pszOpts);
|
---|
[87463] | 1506 | if (rc == 0)
|
---|
| 1507 | VGSvcVerbose(0, "vbsvcAutomounterMountIt: Running outdated vboxsf module without support for the 'tag' option?\n");
|
---|
| 1508 | }
|
---|
[75407] | 1509 | if (rc == 0)
|
---|
| 1510 | {
|
---|
| 1511 | VGSvcVerbose(0, "vbsvcAutomounterMountIt: Successfully mounted '%s' on '%s'\n",
|
---|
| 1512 | pEntry->pszName, pEntry->pszActualMountPoint);
|
---|
| 1513 |
|
---|
| 1514 | errno = 0;
|
---|
[100317] | 1515 | rc = vbsfmount_complete(pEntry->pszName, pEntry->pszActualMountPoint, fFlags, pszOpts);
|
---|
[75433] | 1516 | if (rc != 0) /* Ignorable. /etc/mtab is probably a link to /proc/mounts. */
|
---|
| 1517 | VGSvcVerbose(1, "vbsvcAutomounterMountIt: vbsfmount_complete failed: %s (%d/%d)\n",
|
---|
[87463] | 1518 | rc == 1 ? "malloc" : rc == 2 ? "setmntent" : rc == 3 ? "addmntent" : "unknown", rc, errno);
|
---|
[75433] | 1519 | return VINF_SUCCESS;
|
---|
[75407] | 1520 | }
|
---|
[87463] | 1521 |
|
---|
| 1522 | if (errno == EINVAL)
|
---|
[75407] | 1523 | VGSvcError("vbsvcAutomounterMountIt: Failed to mount '%s' on '%s' because it is probably mounted elsewhere arleady! (%d,%d)\n",
|
---|
| 1524 | pEntry->pszName, pEntry->pszActualMountPoint, rc, errno);
|
---|
| 1525 | else
|
---|
| 1526 | VGSvcError("vbsvcAutomounterMountIt: Failed to mount '%s' on '%s': %s (%d,%d)\n",
|
---|
| 1527 | pEntry->pszName, pEntry->pszActualMountPoint, strerror(errno), rc, errno);
|
---|
| 1528 | return VERR_WRITE_ERROR;
|
---|
| 1529 |
|
---|
| 1530 | # elif defined(RT_OS_SOLARIS)
|
---|
| 1531 | /*
|
---|
| 1532 | * Solaris is rather simple compared to linux.
|
---|
| 1533 | *
|
---|
| 1534 | * The ',VBoxService=auto' option (g_szTag) is ignored by the kernel but helps
|
---|
| 1535 | * us identify our own mounts on restart. See vbsvcAutomounterPopulateTable().
|
---|
[75451] | 1536 | *
|
---|
| 1537 | * Note! Must pass MAX_MNTOPT_STR rather than cchOpts to mount, as it may fail
|
---|
| 1538 | * with EOVERFLOW in vfs_buildoptionstr() during domount() otherwise.
|
---|
[75407] | 1539 | */
|
---|
[100317] | 1540 | ssize_t cchOpts = RTStrPrintf2(pszOpts, cbOpts,
|
---|
[75444] | 1541 | "uid=0,gid=%d,dmode=0770,fmode=0770,dmask=0000,fmask=0000,tag=%s", gidMount, g_szTag);
|
---|
[75407] | 1542 | if (cchOpts <= 0)
|
---|
| 1543 | {
|
---|
[100317] | 1544 | VGSvcError("vbsvcAutomounterMountIt: pszOpts overflow! %zd\n", cchOpts);
|
---|
[75407] | 1545 | return VERR_BUFFER_OVERFLOW;
|
---|
| 1546 | }
|
---|
| 1547 |
|
---|
| 1548 | rc = mount(pEntry->pszName, pEntry->pszActualMountPoint, MS_OPTIONSTR, "vboxfs",
|
---|
[100317] | 1549 | NULL /*dataptr*/, 0 /* datalen */, pszOpts, MAX_MNTOPT_STR);
|
---|
[75407] | 1550 | if (rc == 0)
|
---|
| 1551 | {
|
---|
[75411] | 1552 | VGSvcVerbose(0, "vbsvcAutomounterMountIt: Successfully mounted '%s' on '%s'\n",
|
---|
| 1553 | pEntry->pszName, pEntry->pszActualMountPoint);
|
---|
[75407] | 1554 | return VINF_SUCCESS;
|
---|
| 1555 | }
|
---|
| 1556 |
|
---|
| 1557 | rc = errno;
|
---|
[100317] | 1558 | VGSvcError("vbsvcAutomounterMountIt: mount failed for '%s' on '%s' (pszOpts=%s): %s (%d)\n",
|
---|
| 1559 | pEntry->pszName, pEntry->pszActualMountPoint, pszOpts, strerror(rc), rc);
|
---|
[75407] | 1560 | return VERR_OPEN_FAILED;
|
---|
| 1561 |
|
---|
| 1562 | # else
|
---|
| 1563 | # error "PORTME!"
|
---|
| 1564 | # endif
|
---|
| 1565 | #endif
|
---|
| 1566 | }
|
---|
| 1567 |
|
---|
| 1568 |
|
---|
| 1569 | /**
|
---|
| 1570 | * Attempts to mount the given shared folder, adding it to the mount table on
|
---|
| 1571 | * success.
|
---|
[58052] | 1572 | *
|
---|
[75407] | 1573 | * @returns iTable + 1 on success, iTable on failure.
|
---|
| 1574 | * @param pTable The mount table.
|
---|
| 1575 | * @param iTable The mount table index at which to add the mount.
|
---|
| 1576 | * @param pszName The name of the shared folder mapping.
|
---|
| 1577 | * @param pszMntPt The mount point (hint) specified by the host.
|
---|
| 1578 | * @param fFlags The shared folder flags, SHFL_MIF_XXX.
|
---|
| 1579 | * @param idRoot The root ID.
|
---|
| 1580 | * @param uRootIdVersion The root ID version.
|
---|
| 1581 | * @param fAutoMntPt Whether to try automatically assign a mount point if
|
---|
| 1582 | * pszMntPt doesn't work out. This is set in pass \#3.
|
---|
[58052] | 1583 | */
|
---|
[75407] | 1584 | static uint32_t vbsvcAutomounterMountNewEntry(PVBSVCAUTOMOUNTERTABLE pTable, uint32_t iTable,
|
---|
| 1585 | const char *pszName, const char *pszMntPt, uint64_t fFlags,
|
---|
| 1586 | uint32_t idRoot, uint32_t uRootIdVersion, bool fAutoMntPt)
|
---|
| 1587 | {
|
---|
| 1588 | VGSvcVerbose(3, "vbsvcAutomounterMountNewEntry: #%u: '%s' at '%s'%s\n",
|
---|
| 1589 | iTable, pszName, pszMntPt, fAutoMntPt ? " auto-assign" : "");
|
---|
| 1590 |
|
---|
| 1591 | /*
|
---|
| 1592 | * First we need to figure out the actual mount point.
|
---|
| 1593 | */
|
---|
| 1594 | char szActualMountPoint[RTPATH_MAX];
|
---|
| 1595 |
|
---|
| 1596 | #if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
|
---|
| 1597 | /*
|
---|
[75457] | 1598 | * Drive letter based. We only care about the first two characters
|
---|
| 1599 | * and ignore the rest (see further down).
|
---|
[75407] | 1600 | */
|
---|
| 1601 | char chNextLetter = 'Z';
|
---|
[75457] | 1602 | if (RT_C_IS_ALPHA(pszMntPt[0]) && pszMntPt[1] == ':')
|
---|
[75407] | 1603 | szActualMountPoint[0] = RT_C_TO_UPPER(pszMntPt[0]);
|
---|
| 1604 | else if (!fAutoMntPt)
|
---|
| 1605 | return iTable;
|
---|
| 1606 | else
|
---|
| 1607 | szActualMountPoint[0] = chNextLetter--;
|
---|
| 1608 | szActualMountPoint[1] = ':';
|
---|
| 1609 | szActualMountPoint[2] = '\0';
|
---|
| 1610 |
|
---|
| 1611 | int rc;
|
---|
[35077] | 1612 | for (;;)
|
---|
| 1613 | {
|
---|
[75407] | 1614 | rc = vbsvcAutomounterQueryMountPoint(szActualMountPoint, pszName);
|
---|
| 1615 | if (rc == VWRN_NOT_FOUND)
|
---|
[35077] | 1616 | break;
|
---|
| 1617 |
|
---|
[75407] | 1618 | /* next */
|
---|
| 1619 | if (chNextLetter == 'A' || !fAutoMntPt)
|
---|
| 1620 | return iTable;
|
---|
| 1621 | szActualMountPoint[0] = chNextLetter--;
|
---|
[35077] | 1622 | }
|
---|
| 1623 |
|
---|
[75407] | 1624 | #else
|
---|
| 1625 | /*
|
---|
| 1626 | * Path based #1: Host specified mount point.
|
---|
| 1627 | */
|
---|
[75457] | 1628 |
|
---|
| 1629 | /* Skip DOS drive letter if there is a UNIX mount point path following it: */
|
---|
| 1630 | if ( pszMntPt[0] != '/'
|
---|
| 1631 | && pszMntPt[0] != '\0'
|
---|
| 1632 | && pszMntPt[1] == ':'
|
---|
| 1633 | && pszMntPt[2] == '/')
|
---|
| 1634 | pszMntPt += 2;
|
---|
| 1635 |
|
---|
| 1636 | /* Try specified mount point if it starts with a UNIX slash: */
|
---|
[75407] | 1637 | int rc = VERR_ACCESS_DENIED;
|
---|
| 1638 | if (*pszMntPt == '/')
|
---|
| 1639 | {
|
---|
| 1640 | rc = RTPathAbs(pszMntPt, szActualMountPoint, sizeof(szActualMountPoint));
|
---|
| 1641 | if (RT_SUCCESS(rc))
|
---|
| 1642 | {
|
---|
| 1643 | static const char * const s_apszBlacklist[] =
|
---|
| 1644 | { "/", "/dev", "/bin", "/sbin", "/lib", "/etc", "/var", "/tmp", "/usr", "/usr/bin", "/usr/sbin", "/usr/lib" };
|
---|
| 1645 | for (size_t i = 0; i < RT_ELEMENTS(s_apszBlacklist); i++)
|
---|
| 1646 | if (strcmp(szActualMountPoint, s_apszBlacklist[i]) == 0)
|
---|
| 1647 | {
|
---|
| 1648 | rc = VERR_ACCESS_DENIED;
|
---|
| 1649 | break;
|
---|
| 1650 | }
|
---|
| 1651 | if (RT_SUCCESS(rc))
|
---|
| 1652 | rc = vbsvcAutomounterQueryMountPoint(szActualMountPoint, pszName);
|
---|
| 1653 | }
|
---|
| 1654 | }
|
---|
| 1655 | if (rc != VWRN_NOT_FOUND)
|
---|
| 1656 | {
|
---|
| 1657 | if (!fAutoMntPt)
|
---|
| 1658 | return iTable;
|
---|
| 1659 |
|
---|
| 1660 | /*
|
---|
| 1661 | * Path based #2: Mount dir + prefix + share.
|
---|
| 1662 | */
|
---|
[75433] | 1663 | rc = vbsvcAutomounterQueryMountDirAndPrefix(szActualMountPoint, sizeof(szActualMountPoint));
|
---|
[75407] | 1664 | if (RT_SUCCESS(rc))
|
---|
| 1665 | {
|
---|
[75433] | 1666 | /* Append a sanitized share name: */
|
---|
[75407] | 1667 | size_t const offShare = strlen(szActualMountPoint);
|
---|
| 1668 | size_t offDst = offShare;
|
---|
| 1669 | size_t offSrc = 0;
|
---|
| 1670 | for (;;)
|
---|
| 1671 | {
|
---|
| 1672 | char ch = pszName[offSrc++];
|
---|
| 1673 | if (ch == ' ' || ch == '/' || ch == '\\' || ch == ':' || ch == '$')
|
---|
| 1674 | ch = '_';
|
---|
| 1675 | else if (!ch)
|
---|
| 1676 | break;
|
---|
| 1677 | else if (ch < 0x20 || ch == 0x7f)
|
---|
| 1678 | continue;
|
---|
| 1679 | if (offDst < sizeof(szActualMountPoint) - 1)
|
---|
| 1680 | szActualMountPoint[offDst++] = ch;
|
---|
| 1681 | }
|
---|
| 1682 | szActualMountPoint[offDst] = '\0';
|
---|
| 1683 | if (offDst > offShare)
|
---|
| 1684 | {
|
---|
| 1685 | rc = vbsvcAutomounterQueryMountPoint(szActualMountPoint, pszName);
|
---|
| 1686 | if (rc != VWRN_NOT_FOUND)
|
---|
| 1687 | {
|
---|
| 1688 | /*
|
---|
| 1689 | * Path based #3: Mount dir + prefix + share + _ + number.
|
---|
| 1690 | */
|
---|
| 1691 | if (offDst + 2 >= sizeof(szActualMountPoint))
|
---|
| 1692 | return iTable;
|
---|
| 1693 |
|
---|
| 1694 | szActualMountPoint[offDst++] = '_';
|
---|
| 1695 | for (uint32_t iTry = 1; iTry < 10 && rc != VWRN_NOT_FOUND; iTry++)
|
---|
| 1696 | {
|
---|
| 1697 | szActualMountPoint[offDst] = '0' + iTry;
|
---|
| 1698 | szActualMountPoint[offDst + 1] = '\0';
|
---|
| 1699 | rc = vbsvcAutomounterQueryMountPoint(szActualMountPoint, pszName);
|
---|
| 1700 | }
|
---|
| 1701 | if (rc != VWRN_NOT_FOUND)
|
---|
| 1702 | return iTable;
|
---|
| 1703 | }
|
---|
| 1704 | }
|
---|
| 1705 | else
|
---|
| 1706 | VGSvcError("vbsvcAutomounterMountNewEntry: Bad share name: %.*Rhxs", strlen(pszName), pszName);
|
---|
| 1707 | }
|
---|
| 1708 | else
|
---|
| 1709 | VGSvcError("vbsvcAutomounterMountNewEntry: Failed to construct basic auto mount point for '%s'", pszName);
|
---|
| 1710 | }
|
---|
| 1711 | #endif
|
---|
| 1712 |
|
---|
| 1713 | /*
|
---|
| 1714 | * Prepare a table entry and ensure space in the table..
|
---|
| 1715 | */
|
---|
| 1716 | if (pTable->cEntries + 1 > pTable->cAllocated)
|
---|
| 1717 | {
|
---|
| 1718 | void *pvEntries = RTMemRealloc(pTable->papEntries, sizeof(pTable->papEntries[0]) * (pTable->cAllocated + 8));
|
---|
| 1719 | if (!pvEntries)
|
---|
| 1720 | {
|
---|
| 1721 | VGSvcError("vbsvcAutomounterMountNewEntry: Out of memory for growing table (size %u)\n", pTable->cAllocated);
|
---|
| 1722 | return iTable;
|
---|
| 1723 | }
|
---|
| 1724 | pTable->cAllocated += 8;
|
---|
| 1725 | pTable->papEntries = (PVBSVCAUTOMOUNTERENTRY *)pvEntries;
|
---|
| 1726 | }
|
---|
| 1727 |
|
---|
| 1728 | PVBSVCAUTOMOUNTERENTRY pEntry = (PVBSVCAUTOMOUNTERENTRY)RTMemAlloc(sizeof(*pEntry));
|
---|
| 1729 | if (pEntry)
|
---|
| 1730 | {
|
---|
| 1731 | pEntry->idRoot = idRoot;
|
---|
| 1732 | pEntry->uRootIdVersion = uRootIdVersion;
|
---|
| 1733 | pEntry->fFlags = fFlags;
|
---|
| 1734 | pEntry->pszName = RTStrDup(pszName);
|
---|
| 1735 | pEntry->pszMountPoint = RTStrDup(pszMntPt);
|
---|
| 1736 | pEntry->pszActualMountPoint = RTStrDup(szActualMountPoint);
|
---|
| 1737 | if (pEntry->pszName && pEntry->pszMountPoint && pEntry->pszActualMountPoint)
|
---|
| 1738 | {
|
---|
| 1739 | /*
|
---|
| 1740 | * Now try mount it.
|
---|
| 1741 | */
|
---|
| 1742 | rc = vbsvcAutomounterMountIt(pEntry);
|
---|
| 1743 | if (RT_SUCCESS(rc))
|
---|
| 1744 | {
|
---|
| 1745 | uint32_t cToMove = pTable->cEntries - iTable;
|
---|
| 1746 | if (cToMove > 0)
|
---|
| 1747 | memmove(&pTable->papEntries[iTable + 1], &pTable->papEntries[iTable], cToMove * sizeof(pTable->papEntries[0]));
|
---|
| 1748 | pTable->papEntries[iTable] = pEntry;
|
---|
| 1749 | pTable->cEntries++;
|
---|
| 1750 | return iTable + 1;
|
---|
| 1751 | }
|
---|
| 1752 | }
|
---|
| 1753 | else
|
---|
| 1754 | VGSvcError("vbsvcAutomounterMountNewEntry: Out of memory for table entry!\n");
|
---|
| 1755 | RTMemFree(pEntry->pszActualMountPoint);
|
---|
| 1756 | RTMemFree(pEntry->pszMountPoint);
|
---|
| 1757 | RTMemFree(pEntry->pszName);
|
---|
| 1758 | RTMemFree(pEntry);
|
---|
| 1759 | }
|
---|
| 1760 | else
|
---|
| 1761 | VGSvcError("vbsvcAutomounterMountNewEntry: Out of memory for table entry!\n");
|
---|
| 1762 | return iTable;
|
---|
[31202] | 1763 | }
|
---|
| 1764 |
|
---|
[58029] | 1765 |
|
---|
[75407] | 1766 |
|
---|
[58029] | 1767 | /**
|
---|
[75407] | 1768 | * Does the actual unmounting.
|
---|
| 1769 | *
|
---|
| 1770 | * @returns Exactly one of the following IPRT status codes;
|
---|
| 1771 | * @retval VINF_SUCCESS if successfully umounted or nothing was mounted there.
|
---|
| 1772 | * @retval VERR_TRY_AGAIN if the shared folder is busy.
|
---|
| 1773 | * @retval VERR_RESOURCE_BUSY if a different shared folder is mounted there.
|
---|
| 1774 | * @retval VERR_ACCESS_DENIED if a non-shared folder file system is mounted
|
---|
| 1775 | * there.
|
---|
| 1776 | *
|
---|
| 1777 | * @param pszMountPoint The mount point.
|
---|
| 1778 | * @param pszName The shared folder (mapping) name.
|
---|
[58029] | 1779 | */
|
---|
[75407] | 1780 | static int vbsvcAutomounterUnmount(const char *pszMountPoint, const char *pszName)
|
---|
[31202] | 1781 | {
|
---|
[75407] | 1782 | /*
|
---|
| 1783 | * Retry for 5 seconds in a hope that busy mounts will quiet down.
|
---|
| 1784 | */
|
---|
| 1785 | for (unsigned iTry = 0; ; iTry++)
|
---|
| 1786 | {
|
---|
| 1787 | /*
|
---|
| 1788 | * Check what's mounted there before we start umounting stuff.
|
---|
| 1789 | */
|
---|
| 1790 | int rc = vbsvcAutomounterQueryMountPoint(pszMountPoint, pszName);
|
---|
| 1791 | if (rc == VINF_SUCCESS)
|
---|
| 1792 | { /* pszName is mounted there */ }
|
---|
| 1793 | else if (rc == VWRN_NOT_FOUND) /* nothing mounted there */
|
---|
| 1794 | return VINF_SUCCESS;
|
---|
| 1795 | else
|
---|
| 1796 | {
|
---|
| 1797 | Assert(rc == VERR_RESOURCE_BUSY || rc == VERR_ACCESS_DENIED);
|
---|
| 1798 | return VERR_RESOURCE_BUSY;
|
---|
| 1799 | }
|
---|
[35058] | 1800 |
|
---|
[75407] | 1801 | /*
|
---|
| 1802 | * Do host specific unmounting.
|
---|
| 1803 | */
|
---|
| 1804 | #ifdef RT_OS_WINDOWS
|
---|
| 1805 | Assert(RT_C_IS_UPPER(pszMountPoint[0]) && pszMountPoint[1] == ':' && pszMountPoint[2] == '\0');
|
---|
[83822] | 1806 | RTUTF16 const wszDrive[4] = { (RTUTF16)pszMountPoint[0], ':', '\0', '\0' };
|
---|
[75407] | 1807 | DWORD dwErr = WNetCancelConnection2W(wszDrive, 0 /*dwFlags*/, FALSE /*fForce*/);
|
---|
| 1808 | if (dwErr == NO_ERROR)
|
---|
| 1809 | return VINF_SUCCESS;
|
---|
| 1810 | VGSvcVerbose(2, "vbsvcAutomounterUnmount: WNetCancelConnection2W returns %u for '%s' ('%s')\n", dwErr, pszMountPoint, pszName);
|
---|
| 1811 | if (dwErr == ERROR_NOT_CONNECTED)
|
---|
| 1812 | return VINF_SUCCESS;
|
---|
[35058] | 1813 |
|
---|
[75407] | 1814 | #elif defined(RT_OS_OS2)
|
---|
| 1815 | APIRET rcOs2 = DosFSAttach(pszMountPoint, "VBOXSF", NULL, 0, FS_DETACH);
|
---|
| 1816 | if (rcOs2 == NO_ERROR)
|
---|
| 1817 | return VINF_SUCCESS;
|
---|
| 1818 | VGSvcVerbose(2, "vbsvcAutomounterUnmount: DosFSAttach failed on '%s' ('%s'): %u\n", pszMountPoint, pszName, rcOs2);
|
---|
| 1819 | if (rcOs2 == ERROR_INVALID_FSD_NAME)
|
---|
| 1820 | return VERR_ACCESS_DENIED;
|
---|
| 1821 | if ( rcOs2 == ERROR_INVALID_DRIVE
|
---|
| 1822 | || rcOs2 == ERROR_INVALID_PATH)
|
---|
| 1823 | return VERR_TRY_AGAIN;
|
---|
| 1824 |
|
---|
| 1825 | #else
|
---|
| 1826 | int rc2 = umount(pszMountPoint);
|
---|
| 1827 | if (rc2 == 0)
|
---|
[75433] | 1828 | {
|
---|
| 1829 | /* Remove the mount directory if not directly under the root dir. */
|
---|
[84238] | 1830 | RTPATHPARSED Parsed;
|
---|
| 1831 | RT_ZERO(Parsed);
|
---|
[75433] | 1832 | RTPathParse(pszMountPoint, &Parsed, sizeof(Parsed), RTPATH_STR_F_STYLE_HOST);
|
---|
| 1833 | if (Parsed.cComps >= 3)
|
---|
| 1834 | RTDirRemove(pszMountPoint);
|
---|
| 1835 |
|
---|
[75407] | 1836 | return VINF_SUCCESS;
|
---|
[75433] | 1837 | }
|
---|
[75407] | 1838 | rc2 = errno;
|
---|
| 1839 | VGSvcVerbose(2, "vbsvcAutomounterUnmount: umount failed on '%s' ('%s'): %d\n", pszMountPoint, pszName, rc2);
|
---|
| 1840 | if (rc2 != EBUSY && rc2 != EAGAIN)
|
---|
| 1841 | return VERR_ACCESS_DENIED;
|
---|
| 1842 | #endif
|
---|
| 1843 |
|
---|
| 1844 | /*
|
---|
| 1845 | * Check what's mounted there before we start delaying.
|
---|
| 1846 | */
|
---|
| 1847 | RTThreadSleep(8); /* fudge */
|
---|
| 1848 | rc = vbsvcAutomounterQueryMountPoint(pszMountPoint, pszName);
|
---|
| 1849 | if (rc == VINF_SUCCESS)
|
---|
| 1850 | { /* pszName is mounted there */ }
|
---|
| 1851 | else if (rc == VWRN_NOT_FOUND) /* nothing mounted there */
|
---|
| 1852 | return VINF_SUCCESS;
|
---|
| 1853 | else
|
---|
| 1854 | {
|
---|
| 1855 | Assert(rc == VERR_RESOURCE_BUSY || rc == VERR_ACCESS_DENIED);
|
---|
| 1856 | return VERR_RESOURCE_BUSY;
|
---|
| 1857 | }
|
---|
| 1858 |
|
---|
| 1859 | if (iTry >= 5)
|
---|
| 1860 | return VERR_TRY_AGAIN;
|
---|
| 1861 | RTThreadSleep(1000);
|
---|
| 1862 | }
|
---|
| 1863 | }
|
---|
| 1864 |
|
---|
| 1865 |
|
---|
| 1866 | /**
|
---|
| 1867 | * Unmounts a mount table entry and evicts it from the table if successful.
|
---|
| 1868 | *
|
---|
| 1869 | * @returns The next iTable (same value on success, +1 on failure).
|
---|
| 1870 | * @param pTable The mount table.
|
---|
| 1871 | * @param iTable The table entry.
|
---|
| 1872 | * @param pszReason Why we're here.
|
---|
| 1873 | */
|
---|
| 1874 | static uint32_t vbsvcAutomounterUnmountEntry(PVBSVCAUTOMOUNTERTABLE pTable, uint32_t iTable, const char *pszReason)
|
---|
| 1875 | {
|
---|
| 1876 | Assert(iTable < pTable->cEntries);
|
---|
| 1877 | PVBSVCAUTOMOUNTERENTRY pEntry = pTable->papEntries[iTable];
|
---|
[75433] | 1878 | VGSvcVerbose(2, "vbsvcAutomounterUnmountEntry: #%u: '%s' at '%s' (reason: %s)\n",
|
---|
| 1879 | iTable, pEntry->pszName, pEntry->pszActualMountPoint, pszReason);
|
---|
[75407] | 1880 |
|
---|
| 1881 | /*
|
---|
| 1882 | * Do we need to umount the entry? Return if unmount fails and we .
|
---|
| 1883 | */
|
---|
| 1884 | if (pEntry->pszActualMountPoint)
|
---|
[35058] | 1885 | {
|
---|
[75407] | 1886 | int rc = vbsvcAutomounterUnmount(pEntry->pszActualMountPoint, pEntry->pszName);
|
---|
| 1887 | if (rc == VERR_TRY_AGAIN)
|
---|
| 1888 | {
|
---|
[75433] | 1889 | VGSvcVerbose(1, "vbsvcAutomounterUnmountEntry: Keeping '%s' -> '%s' (VERR_TRY_AGAIN)\n",
|
---|
[75407] | 1890 | pEntry->pszActualMountPoint, pEntry->pszName);
|
---|
| 1891 | return iTable + 1;
|
---|
| 1892 | }
|
---|
[35058] | 1893 | }
|
---|
[75407] | 1894 |
|
---|
| 1895 | /*
|
---|
| 1896 | * Remove the entry by shifting up the ones after it.
|
---|
| 1897 | */
|
---|
| 1898 | pTable->cEntries -= 1;
|
---|
| 1899 | uint32_t cAfter = pTable->cEntries - iTable;
|
---|
| 1900 | if (cAfter)
|
---|
| 1901 | memmove(&pTable->papEntries[iTable], &pTable->papEntries[iTable + 1], cAfter * sizeof(pTable->papEntries[0]));
|
---|
| 1902 | pTable->papEntries[pTable->cEntries] = NULL;
|
---|
| 1903 |
|
---|
| 1904 | RTStrFree(pEntry->pszActualMountPoint);
|
---|
| 1905 | pEntry->pszActualMountPoint = NULL;
|
---|
| 1906 | RTStrFree(pEntry->pszMountPoint);
|
---|
| 1907 | pEntry->pszMountPoint = NULL;
|
---|
| 1908 | RTStrFree(pEntry->pszName);
|
---|
| 1909 | pEntry->pszName = NULL;
|
---|
| 1910 | RTMemFree(pEntry);
|
---|
| 1911 |
|
---|
| 1912 | return iTable;
|
---|
[31202] | 1913 | }
|
---|
| 1914 |
|
---|
| 1915 |
|
---|
[58029] | 1916 | /**
|
---|
[75415] | 1917 | * @callback_method_impl{FNRTSORTCMP, For sorting the mappings by ID. }
|
---|
[75407] | 1918 | */
|
---|
| 1919 | static DECLCALLBACK(int) vbsvcSharedFolderMappingCompare(void const *pvElement1, void const *pvElement2, void *pvUser)
|
---|
| 1920 | {
|
---|
| 1921 | RT_NOREF_PV(pvUser);
|
---|
| 1922 | PVBGLR3SHAREDFOLDERMAPPING pMapping1 = (PVBGLR3SHAREDFOLDERMAPPING)pvElement1;
|
---|
| 1923 | PVBGLR3SHAREDFOLDERMAPPING pMapping2 = (PVBGLR3SHAREDFOLDERMAPPING)pvElement2;
|
---|
| 1924 | return pMapping1->u32Root < pMapping2->u32Root ? -1 : pMapping1->u32Root != pMapping2->u32Root ? 1 : 0;
|
---|
| 1925 | }
|
---|
| 1926 |
|
---|
| 1927 |
|
---|
| 1928 | /**
|
---|
| 1929 | * Refreshes the mount table.
|
---|
| 1930 | *
|
---|
| 1931 | * @returns true if we've processed the current config, false if we failed to
|
---|
| 1932 | * query the mappings.
|
---|
| 1933 | * @param pTable The mount table to refresh.
|
---|
| 1934 | */
|
---|
| 1935 | static bool vbsvcAutomounterRefreshTable(PVBSVCAUTOMOUNTERTABLE pTable)
|
---|
| 1936 | {
|
---|
| 1937 | /*
|
---|
| 1938 | * Query the root IDs of all auto-mountable shared folder mappings.
|
---|
| 1939 | */
|
---|
| 1940 | uint32_t cMappings = 0;
|
---|
| 1941 | PVBGLR3SHAREDFOLDERMAPPING paMappings = NULL;
|
---|
| 1942 | int rc = VbglR3SharedFolderGetMappings(g_idClientSharedFolders, true /*fAutoMountOnly*/, &paMappings, &cMappings);
|
---|
| 1943 | if (RT_FAILURE(rc))
|
---|
| 1944 | {
|
---|
| 1945 | VGSvcError("vbsvcAutomounterRefreshTable: VbglR3SharedFolderGetMappings failed: %Rrc\n", rc);
|
---|
| 1946 | return false;
|
---|
| 1947 | }
|
---|
| 1948 |
|
---|
| 1949 | /*
|
---|
| 1950 | * Walk the table and the mappings in parallel, so we have to make sure
|
---|
| 1951 | * they are both sorted by root ID.
|
---|
| 1952 | */
|
---|
| 1953 | if (cMappings > 1)
|
---|
| 1954 | RTSortShell(paMappings, cMappings, sizeof(paMappings[0]), vbsvcSharedFolderMappingCompare, NULL);
|
---|
| 1955 |
|
---|
| 1956 | /*
|
---|
| 1957 | * Pass #1: Do all the umounting.
|
---|
| 1958 | *
|
---|
| 1959 | * By doing the umount pass separately from the mount pass, we can
|
---|
| 1960 | * better handle changing involving the same mount points (switching
|
---|
| 1961 | * mount points between two shares, new share on same mount point but
|
---|
| 1962 | * with lower root ID, ++).
|
---|
| 1963 | */
|
---|
| 1964 | uint32_t iTable = 0;
|
---|
| 1965 | for (uint32_t iSrc = 0; iSrc < cMappings; iSrc++)
|
---|
| 1966 | {
|
---|
| 1967 | /*
|
---|
| 1968 | * Unmount table entries up to idRootSrc.
|
---|
| 1969 | */
|
---|
| 1970 | uint32_t const idRootSrc = paMappings[iSrc].u32Root;
|
---|
| 1971 | while ( iTable < pTable->cEntries
|
---|
| 1972 | && pTable->papEntries[iTable]->idRoot < idRootSrc)
|
---|
| 1973 | iTable = vbsvcAutomounterUnmountEntry(pTable, iTable, "dropped");
|
---|
| 1974 |
|
---|
| 1975 | /*
|
---|
| 1976 | * If the paMappings entry and the mount table entry has the same
|
---|
| 1977 | * root ID, umount if anything has changed or if we cannot query
|
---|
| 1978 | * the mapping data.
|
---|
| 1979 | */
|
---|
| 1980 | if (iTable < pTable->cEntries)
|
---|
| 1981 | {
|
---|
| 1982 | PVBSVCAUTOMOUNTERENTRY pEntry = pTable->papEntries[iTable];
|
---|
| 1983 | if (pEntry->idRoot == idRootSrc)
|
---|
| 1984 | {
|
---|
| 1985 | uint32_t uRootIdVer = UINT32_MAX;
|
---|
| 1986 | uint64_t fFlags = 0;
|
---|
| 1987 | char *pszName = NULL;
|
---|
| 1988 | char *pszMntPt = NULL;
|
---|
| 1989 | rc = VbglR3SharedFolderQueryFolderInfo(g_idClientSharedFolders, idRootSrc, VBOXSERVICE_AUTOMOUNT_MIQF,
|
---|
| 1990 | &pszName, &pszMntPt, &fFlags, &uRootIdVer);
|
---|
| 1991 | if (RT_FAILURE(rc))
|
---|
| 1992 | iTable = vbsvcAutomounterUnmountEntry(pTable, iTable, "VbglR3SharedFolderQueryFolderInfo failed");
|
---|
| 1993 | else if (pEntry->uRootIdVersion != uRootIdVer)
|
---|
| 1994 | iTable = vbsvcAutomounterUnmountEntry(pTable, iTable, "root ID version changed");
|
---|
| 1995 | else if (RTPathCompare(pEntry->pszMountPoint, pszMntPt) != 0)
|
---|
| 1996 | iTable = vbsvcAutomounterUnmountEntry(pTable, iTable, "mount point changed");
|
---|
| 1997 | else if (RTStrICmp(pEntry->pszName, pszName) != 0)
|
---|
| 1998 | iTable = vbsvcAutomounterUnmountEntry(pTable, iTable, "name changed");
|
---|
| 1999 | else
|
---|
| 2000 | {
|
---|
| 2001 | VGSvcVerbose(3, "vbsvcAutomounterRefreshTable: Unchanged: %s -> %s\n", pEntry->pszMountPoint, pEntry->pszName);
|
---|
| 2002 | iTable++;
|
---|
| 2003 | }
|
---|
| 2004 | if (RT_SUCCESS(rc))
|
---|
| 2005 | {
|
---|
| 2006 | RTStrFree(pszName);
|
---|
| 2007 | RTStrFree(pszMntPt);
|
---|
| 2008 | }
|
---|
| 2009 | }
|
---|
| 2010 | }
|
---|
| 2011 | }
|
---|
| 2012 |
|
---|
| 2013 | while (iTable < pTable->cEntries)
|
---|
| 2014 | iTable = vbsvcAutomounterUnmountEntry(pTable, iTable, "dropped (tail)");
|
---|
| 2015 |
|
---|
| 2016 | VGSvcVerbose(4, "vbsvcAutomounterRefreshTable: %u entries in mount table after pass #1.\n", pTable->cEntries);
|
---|
| 2017 |
|
---|
| 2018 | /*
|
---|
| 2019 | * Pass #2: Try mount new folders that has mount points assigned.
|
---|
| 2020 | * Pass #3: Try mount new folders not mounted in pass #2.
|
---|
| 2021 | */
|
---|
| 2022 | for (uint32_t iPass = 2; iPass <= 3; iPass++)
|
---|
| 2023 | {
|
---|
| 2024 | iTable = 0;
|
---|
| 2025 | for (uint32_t iSrc = 0; iSrc < cMappings; iSrc++)
|
---|
| 2026 | {
|
---|
| 2027 | uint32_t const idRootSrc = paMappings[iSrc].u32Root;
|
---|
| 2028 |
|
---|
| 2029 | /*
|
---|
| 2030 | * Skip tabel entries we couldn't umount in pass #1.
|
---|
| 2031 | */
|
---|
| 2032 | while ( iTable < pTable->cEntries
|
---|
| 2033 | && pTable->papEntries[iTable]->idRoot < idRootSrc)
|
---|
| 2034 | {
|
---|
| 2035 | VGSvcVerbose(4, "vbsvcAutomounterRefreshTable: %u/#%u/%#u: Skipping idRoot=%u %s\n",
|
---|
| 2036 | iPass, iSrc, iTable, pTable->papEntries[iTable]->idRoot, pTable->papEntries[iTable]->pszName);
|
---|
| 2037 | iTable++;
|
---|
| 2038 | }
|
---|
| 2039 |
|
---|
| 2040 | /*
|
---|
| 2041 | * New share?
|
---|
| 2042 | */
|
---|
| 2043 | if ( iTable >= pTable->cEntries
|
---|
| 2044 | || pTable->papEntries[iTable]->idRoot != idRootSrc)
|
---|
| 2045 | {
|
---|
| 2046 | uint32_t uRootIdVer = UINT32_MAX;
|
---|
| 2047 | uint64_t fFlags = 0;
|
---|
| 2048 | char *pszName = NULL;
|
---|
| 2049 | char *pszMntPt = NULL;
|
---|
| 2050 | rc = VbglR3SharedFolderQueryFolderInfo(g_idClientSharedFolders, idRootSrc, VBOXSERVICE_AUTOMOUNT_MIQF,
|
---|
| 2051 | &pszName, &pszMntPt, &fFlags, &uRootIdVer);
|
---|
| 2052 | if (RT_SUCCESS(rc))
|
---|
| 2053 | {
|
---|
| 2054 | VGSvcVerbose(4, "vbsvcAutomounterRefreshTable: %u/#%u/%#u: Mounting idRoot=%u/%u %s\n", iPass, iSrc, iTable,
|
---|
| 2055 | idRootSrc, iTable >= pTable->cEntries ? UINT32_MAX : pTable->papEntries[iTable]->idRoot, pszName);
|
---|
| 2056 | iTable = vbsvcAutomounterMountNewEntry(pTable, iTable, pszName, pszMntPt, fFlags,
|
---|
| 2057 | idRootSrc, uRootIdVer, iPass == 3);
|
---|
| 2058 |
|
---|
| 2059 | RTStrFree(pszName);
|
---|
| 2060 | RTStrFree(pszMntPt);
|
---|
| 2061 | }
|
---|
| 2062 | else
|
---|
| 2063 | VGSvcVerbose(1, "vbsvcAutomounterRefreshTable: VbglR3SharedFolderQueryFolderInfo failed: %Rrc\n", rc);
|
---|
| 2064 | }
|
---|
| 2065 | else
|
---|
| 2066 | VGSvcVerbose(4, "vbsvcAutomounterRefreshTable: %u/#%u/%#u: idRootSrc=%u vs idRoot=%u %s\n", iPass, iSrc,
|
---|
| 2067 | iTable, idRootSrc, pTable->papEntries[iTable]->idRoot, pTable->papEntries[iTable]->pszName);
|
---|
| 2068 | }
|
---|
| 2069 | }
|
---|
| 2070 |
|
---|
| 2071 | VbglR3SharedFolderFreeMappings(paMappings);
|
---|
| 2072 | return true;
|
---|
| 2073 | }
|
---|
| 2074 |
|
---|
| 2075 |
|
---|
| 2076 | /**
|
---|
| 2077 | * @interface_method_impl{VBOXSERVICE,pfnWorker}
|
---|
| 2078 | */
|
---|
| 2079 | static DECLCALLBACK(int) vbsvcAutomounterWorker(bool volatile *pfShutdown)
|
---|
| 2080 | {
|
---|
| 2081 | /*
|
---|
| 2082 | * Tell the control thread that it can continue spawning services.
|
---|
| 2083 | */
|
---|
| 2084 | RTThreadUserSignal(RTThreadSelf());
|
---|
| 2085 |
|
---|
| 2086 | /* Divert old hosts to original auto-mount code. */
|
---|
| 2087 | if (!g_fHostSupportsWaitAndInfoQuery)
|
---|
| 2088 | return vbsvcAutoMountWorkerOld(pfShutdown);
|
---|
| 2089 |
|
---|
| 2090 | /*
|
---|
| 2091 | * Initialize the state in case we're restarted...
|
---|
| 2092 | */
|
---|
| 2093 | VBSVCAUTOMOUNTERTABLE MountTable = { 0, 0, NULL };
|
---|
| 2094 | int rc = vbsvcAutomounterPopulateTable(&MountTable);
|
---|
| 2095 | if (RT_FAILURE(rc))
|
---|
| 2096 | {
|
---|
| 2097 | VGSvcError("vbsvcAutomounterWorker: vbsvcAutomounterPopulateTable failed (%Rrc), quitting!\n", rc);
|
---|
| 2098 | return rc;
|
---|
| 2099 | }
|
---|
| 2100 |
|
---|
| 2101 | /*
|
---|
| 2102 | * Work loop.
|
---|
| 2103 | */
|
---|
| 2104 | uint32_t uConfigVer = UINT32_MAX;
|
---|
| 2105 | uint32_t uNewVersion = 0;
|
---|
| 2106 | bool fForceRefresh = true;
|
---|
| 2107 | while (!*pfShutdown)
|
---|
| 2108 | {
|
---|
| 2109 | /*
|
---|
| 2110 | * Update the mounts.
|
---|
| 2111 | */
|
---|
| 2112 | if ( uConfigVer != uNewVersion
|
---|
| 2113 | || fForceRefresh)
|
---|
| 2114 | {
|
---|
| 2115 | fForceRefresh = !vbsvcAutomounterRefreshTable(&MountTable);
|
---|
| 2116 | uConfigVer = uNewVersion;
|
---|
| 2117 | }
|
---|
| 2118 |
|
---|
| 2119 | /*
|
---|
| 2120 | * Wait for more to do.
|
---|
| 2121 | */
|
---|
| 2122 | if (!*pfShutdown)
|
---|
| 2123 | {
|
---|
| 2124 | uNewVersion = uConfigVer - 1;
|
---|
| 2125 | VGSvcVerbose(2, "vbsvcAutomounterWorker: Waiting with uConfigVer=%u\n", uConfigVer);
|
---|
| 2126 | rc = VbglR3SharedFolderWaitForMappingsChanges(g_idClientSharedFolders, uConfigVer, &uNewVersion);
|
---|
| 2127 | VGSvcVerbose(2, "vbsvcAutomounterWorker: Woke up with uNewVersion=%u and rc=%Rrc\n", uNewVersion, rc);
|
---|
| 2128 |
|
---|
| 2129 | /* Delay a little before doing a table refresh so the GUI can finish
|
---|
| 2130 | all its updates. Delay a little longer on non-shutdown failure to
|
---|
| 2131 | avoid eating too many CPU cycles if something goes wrong here... */
|
---|
| 2132 | if (!*pfShutdown)
|
---|
| 2133 | RTSemEventMultiWait(g_hAutoMountEvent, RT_SUCCESS(rc) ? 256 : 1000);
|
---|
| 2134 | }
|
---|
| 2135 | }
|
---|
| 2136 |
|
---|
| 2137 | /*
|
---|
| 2138 | * Destroy the mount table.
|
---|
| 2139 | */
|
---|
| 2140 | while (MountTable.cEntries-- > 0)
|
---|
| 2141 | RTMemFree(MountTable.papEntries[MountTable.cEntries]);
|
---|
| 2142 | MountTable.papEntries = NULL;
|
---|
| 2143 |
|
---|
| 2144 | VGSvcVerbose(3, "vbsvcAutomounterWorker: Finished\n");
|
---|
| 2145 | return VINF_SUCCESS;
|
---|
| 2146 | }
|
---|
| 2147 |
|
---|
| 2148 |
|
---|
| 2149 | /**
|
---|
[58029] | 2150 | * @interface_method_impl{VBOXSERVICE,pfnStop}
|
---|
| 2151 | */
|
---|
[75407] | 2152 | static DECLCALLBACK(void) vbsvcAutomounterStop(void)
|
---|
[31202] | 2153 | {
|
---|
[75407] | 2154 | RTSemEventMultiSignal(g_hAutoMountEvent);
|
---|
| 2155 | if (g_fHostSupportsWaitAndInfoQuery)
|
---|
| 2156 | VbglR3SharedFolderCancelMappingsChangesWaits(g_idClientSharedFolders);
|
---|
[31202] | 2157 | }
|
---|
| 2158 |
|
---|
| 2159 |
|
---|
| 2160 | /**
|
---|
[75407] | 2161 | * @interface_method_impl{VBOXSERVICE,pfnTerm}
|
---|
| 2162 | */
|
---|
| 2163 | static DECLCALLBACK(void) vbsvcAutomounterTerm(void)
|
---|
| 2164 | {
|
---|
| 2165 | VGSvcVerbose(3, "vbsvcAutoMountTerm\n");
|
---|
| 2166 |
|
---|
| 2167 | if (g_fHostSupportsWaitAndInfoQuery)
|
---|
| 2168 | VbglR3SharedFolderCancelMappingsChangesWaits(g_idClientSharedFolders);
|
---|
| 2169 |
|
---|
| 2170 | VbglR3SharedFolderDisconnect(g_idClientSharedFolders);
|
---|
| 2171 | g_idClientSharedFolders = 0;
|
---|
| 2172 |
|
---|
| 2173 | if (g_hAutoMountEvent != NIL_RTSEMEVENTMULTI)
|
---|
| 2174 | {
|
---|
| 2175 | RTSemEventMultiDestroy(g_hAutoMountEvent);
|
---|
| 2176 | g_hAutoMountEvent = NIL_RTSEMEVENTMULTI;
|
---|
| 2177 | }
|
---|
| 2178 | }
|
---|
| 2179 |
|
---|
| 2180 |
|
---|
| 2181 | /**
|
---|
[31202] | 2182 | * The 'automount' service description.
|
---|
| 2183 | */
|
---|
| 2184 | VBOXSERVICE g_AutoMount =
|
---|
| 2185 | {
|
---|
| 2186 | /* pszName. */
|
---|
| 2187 | "automount",
|
---|
| 2188 | /* pszDescription. */
|
---|
[75407] | 2189 | "Automounter for Shared Folders",
|
---|
[31202] | 2190 | /* pszUsage. */
|
---|
| 2191 | NULL,
|
---|
| 2192 | /* pszOptions. */
|
---|
| 2193 | NULL,
|
---|
| 2194 | /* methods */
|
---|
[58029] | 2195 | VGSvcDefaultPreInit,
|
---|
| 2196 | VGSvcDefaultOption,
|
---|
[75407] | 2197 | vbsvcAutomounterInit,
|
---|
| 2198 | vbsvcAutomounterWorker,
|
---|
| 2199 | vbsvcAutomounterStop,
|
---|
| 2200 | vbsvcAutomounterTerm
|
---|
[31202] | 2201 | };
|
---|
[75407] | 2202 |
|
---|