Changeset 69826 in vbox

Timestamp:

Nov 24, 2017 3:50:00 PM (7 years ago)

Author:

vboxsync

Message:

IPRT/VFS: More path parsing work. Symlinks should work better now.

Location:

trunk

Files:

• include/iprt/vfslowlevel.h (modified) (2 diffs)
• src/VBox/Runtime/common/dvm/dvmvfs.cpp (modified) (1 diff)
• src/VBox/Runtime/common/fs/fatvfs.cpp (modified) (1 diff)
• src/VBox/Runtime/common/fs/isovfs.cpp (modified) (1 diff)
• src/VBox/Runtime/common/vfs/vfsbase.cpp (modified) (14 diffs)
• src/VBox/Runtime/common/vfs/vfsstddir.cpp (modified) (9 diffs)

trunk/include/iprt/vfslowlevel.h

@@ -551 +551 @@
      * @param   pvThis      The implementation specific directory data.
      * @param   pszEntry    The name of the immediate file to open or create.
-     * @param   fOpenFile   RTFILE_O_XXX combination.  Currently RTFILE_O_OPEN is
-     *                      required, but this may change.
+     * @param   fOpenFile   RTFILE_O_XXX combination.
      * @param   fObjFlags   More flags: RTVFSOBJ_F_XXX, RTPATH_F_XXX.
      *                      The meaning of RTPATH_F_FOLLOW_LINK differs here, if
@@ -562 +561 @@
     DECLCALLBACKMEMBER(int, pfnOpen)(void *pvThis, const char *pszEntry, uint64_t fOpenFile,
                                      uint32_t fObjFlags, PRTVFSOBJ phVfsObj);
+
+    /**
+     * Optional method for symbolic link handling in the vfsstddir.cpp.
+     *
+     * This is really just a hack to make symbolic link handling work when working
+     * with directory objects that doesn't have an associated VFS.  It also helps
+     * deal with drive letters in symbolic links on Windows and OS/2.
+     *
+     * @returns IPRT status code.
+     * @retval  VERR_PATH_IS_RELATIVE if @a pszPath isn't absolute and should be
+     *          handled using pfnOpen().
+     *
+     * @param   pvThis      The implementation specific directory data.
+     * @param   pszRoot     Path to the alleged root.
+     * @param   phVfsDir    Where to return the handle to the specified root
+     *                      directory (or may current dir on a drive letter).
+     */
+    DECLCALLBACKMEMBER(int, pfnFollowAbsoluteSymlink)(void *pvThis, const char *pszRoot, PRTVFSDIR phVfsDir);
 
     /**

trunk/src/VBox/Runtime/common/dvm/dvmvfs.cpp

@@ -995 +995 @@
     },
     rtDvmVfsDir_Open,
+    NULL /* pfnFollowAbsoluteSymlink */,
     rtDvmVfsDir_OpenFile,
     rtDvmVfsDir_OpenDir,

trunk/src/VBox/Runtime/common/fs/fatvfs.cpp

@@ -4723 +4723 @@
     },
     rtFsFatDir_Open,
+    NULL /* pfnFollowAbsoluteSymlink */,
     rtFsFatDir_OpenFile,
     rtFsFatDir_OpenDir,

trunk/src/VBox/Runtime/common/fs/isovfs.cpp

@@ -3691 +3691 @@
     },
     rtFsIsoDir_Open,
+    NULL /* pfnFollowAbsoluteSymlink */,
     rtFsIsoDir_OpenFile,
     rtFsIsoDir_OpenDir,

trunk/src/VBox/Runtime/common/vfs/vfsbase.cpp

@@ -47 +47 @@
 #include "internal/fs.h"
 #include "internal/magics.h"
+#include "internal/path.h"
 //#include "internal/vfs.h"
 
@@ -353 +354 @@
 DECLINLINE(uint32_t) rtVfsObjRelease(RTVFSOBJINTERNAL *pThis);
 static int rtVfsTraverseToParent(RTVFSINTERNAL *pThis, PRTVFSPARSEDPATH pPath, uint32_t fFlags, RTVFSDIRINTERNAL **ppVfsParentDir);
+static int rtVfsDirFollowSymlinkObjToParent(RTVFSDIRINTERNAL **ppVfsParentDir, RTVFSOBJ hVfsObj,
+                                            PRTVFSPARSEDPATH pPath, uint32_t fFlags);
 
 
@@ -1207 +1210 @@
     if (RT_SUCCESS(rc))
     {
-        if (pPath->cComponents > 0)
-        {
-            /*
-             * Tranverse the path, resolving the parent node, not
-             * checking for symbolic links in the final element.
+        /*
+         * Tranverse the path, resolving the parent node.
+         * We'll do the symbolic link checking here with help of pfnOpen.
+         */
+        RTVFSDIRINTERNAL *pVfsParentDir;
+        rc = rtVfsTraverseToParent(pThis, pPath, (fObjFlags & RTPATH_F_NO_SYMLINKS) | RTPATH_F_ON_LINK, &pVfsParentDir);
+        if (RT_SUCCESS(rc))
+        {
+
+           /*
+             * Do the opening.  Loop if we need to follow symbolic links.
              */
-            RTVFSDIRINTERNAL *pVfsParentDir;
-            rc = rtVfsTraverseToParent(pThis, pPath, RTPATH_F_ON_LINK, &pVfsParentDir);
-            if (RT_SUCCESS(rc))
+            for (uint32_t cLoops = 1; ; cLoops++)
             {
-                const char *pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
-
-                /*
-                 * If we've got a trailing directory slash, use pfnOpenDir
-                 * instead of pfnOpen.
-                 */
+                /* If we end with a directory slash, adjust open flags. */
                 if (pPath->fDirSlash)
                 {
-                    RTVFSDIR hVfsDir;
-                    RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
-                    rc = pVfsParentDir->pOps->pfnOpenDir(pVfsParentDir->Base.pvThis, pszEntryName, 0 /** @todo fFlags*/, &hVfsDir);
-                    RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
-                    if (RT_SUCCESS(rc))
-                    {
-                        *phVfsObj = RTVfsObjFromDir(hVfsDir);
-                        RTVfsDirRelease(hVfsDir);
-                        AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
-                    }
+                    fObjFlags &= ~RTVFSOBJ_F_OPEN_ANY | RTVFSOBJ_F_OPEN_DIRECTORY;
+                    if ((fObjFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_DIRECTORY)
+                        fObjFlags = (fObjFlags & ~RTVFSOBJ_F_CREATE_MASK) | RTVFSOBJ_F_CREATE_NOTHING;
                 }
+
+                /* Open it. */
+                const char *pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
+                RTVFSOBJ    hVfsObj;
+                RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
+                rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fFileOpen, fObjFlags, &hVfsObj);
+                RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
+                if (RT_FAILURE(rc))
+                    break;
+
+                /* We're done if we don't follow links or this wasn't a link. */
+                if (   !(fObjFlags & RTPATH_F_FOLLOW_LINK)
+                    || RTVfsObjGetType(*phVfsObj) != RTVFSOBJTYPE_SYMLINK)
+                {
+                    *phVfsObj = hVfsObj;
+                    break;
+                }
+
+                /* Follow symbolic link. */
+                if (cLoops < RTVFS_MAX_LINKS)
+                    rc = rtVfsDirFollowSymlinkObjToParent(&pVfsParentDir, hVfsObj, pPath, fObjFlags & RTPATH_F_MASK);
                 else
-                {
-                    RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
-                    rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fFileOpen, fObjFlags, phVfsObj);
-                    RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
-                }
-                RTVfsDirRelease(pVfsParentDir);
+                    rc = VERR_TOO_MANY_SYMLINKS;
+                RTVfsObjRelease(hVfsObj);
+                if (RT_FAILURE(rc))
+                    break;
             }
         }
-        /*
-         * The path boils down to '.', call pfnOpenDir on pThis with '.' as input.
-         * The caller may wish for a new directory instance to enumerate the entries
-         * in parallel or some such thing.
-         */
-        else
-        {
-            RTVFSDIR hVfsDir;
-            RTVfsLockAcquireRead(pThis->Base.hLock);
-            rc = pThis->pOps->pfnOpenRoot(pThis->Base.pvThis, &hVfsDir); /** @todo flags */
-            RTVfsLockReleaseRead(pThis->Base.hLock);
-            if (RT_SUCCESS(rc))
-            {
-                *phVfsObj = RTVfsObjFromDir(hVfsDir);
-                RTVfsDirRelease(hVfsDir);
-                AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
-            }
-        }
-
         RTVfsParsePathFree(pPath);
     }
@@ -1380 +1375 @@
     if (piRestartComp && *piRestartComp + 1 >= pPath->cComponents)
         *piRestartComp = pPath->cComponents > 0 ? pPath->cComponents - 1 : 0;
+
+/** @todo The '..' handling doesn't really work wrt to symbolic links in the
+ *        path.  */
 
     /*
@@ -1490 +1488 @@
 RTDECL(int) RTVfsParsePath(PRTVFSPARSEDPATH pPath, const char *pszPath, const char *pszCwd)
 {
-    if (*pszPath != '/')
+    if (*pszPath != '/' && *pszPath != '\\')
     {
         if (pszCwd)
@@ -1531 +1529 @@
         pPath->szPath[1]         = '\0';
         pPath->szPath[2]         = '\0';
-        while (pszPath[0] == '/')
+        while (pszPath[0] == '/' || pszPath[0] == '\\')
             pszPath++;
         if (!pszPath[0])
@@ -1581 +1579 @@
  *
  * @returns IPRT status code.
+ * @param   ppCurDir            The current directory variable. We change it if
+ *                              the symbolic links is absolute.
  * @param   pPath               The parsed path to update.
- * @param   piComponent         The component iterator to update.
+ * @param   iPathComponent      The current path component.
  * @param   hSymlink            The symbolic link to process.
  */
-static int rtVfsTraverseHandleSymlink(PRTVFSPARSEDPATH pPath, uint16_t *piComponent, RTVFSSYMLINK hSymlink)
-{
-    /*
-     * Read the link.
+static int rtVfsTraverseHandleSymlink(RTVFSDIRINTERNAL **ppCurDir, PRTVFSPARSEDPATH pPath,
+                                      uint16_t iPathComponent, RTVFSSYMLINK hSymlink)
+{
+    /*
+     * Read the link and append the trailing path to it.
      */
     char szPath[RTPATH_MAX];
@@ -1595 +1596 @@
     {
         szPath[sizeof(szPath) - 1] = '\0';
-        if (szPath[0] == '/')
-        {
-            /*
-             * Absolute symlink.
-             */
-            rc = RTVfsParsePath(pPath, szPath, NULL);
-            if (RT_SUCCESS(rc))
+        if (iPathComponent + 1 < pPath->cComponents)
+            rc = RTPathAppend(szPath, sizeof(szPath), &pPath->szPath[pPath->aoffComponents[iPathComponent + 1]]);
+    }
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Special hack help vfsstddir.cpp deal with symbolic links.
+         */
+        RTVFSDIRINTERNAL *pCurDir = *ppCurDir;
+        char             *pszPath = szPath;
+        if (pCurDir->pOps->pfnFollowAbsoluteSymlink)
+        {
+            size_t cchRoot = rtPathRootSpecLen(szPath);
+            if (cchRoot > 0)
             {
-                *piComponent = 0;
-                return VINF_SUCCESS;
-            }
-        }
-        else
-        {
-            /*
-             * Relative symlink, must replace the current component with the
-             * link value.  We do that by using the remainder of the symlink
-             * buffer as temporary storage.
-             */
-            uint16_t iComponent = *piComponent;
-            if (iComponent + 1 < pPath->cComponents)
-                rc = RTPathAppend(szPath, sizeof(szPath), &pPath->szPath[pPath->aoffComponents[iComponent + 1]]);
-            if (RT_SUCCESS(rc))
-            {
-                pPath->cch = pPath->aoffComponents[iComponent] - (iComponent > 0);
-                pPath->aoffComponents[iComponent + 1] = pPath->cch + 1;
-                pPath->szPath[pPath->cch]     = '\0';
-                pPath->szPath[pPath->cch + 1] = '\0';
-
-                rc = RTVfsParsePathAppend(pPath, szPath, &iComponent);
+                pszPath = &szPath[cchRoot];
+                char const chSaved = *pszPath;
+                *pszPath = '\0';
+                RTVFSDIRINTERNAL *pVfsRootDir;
+                RTVfsLockAcquireWrite(pCurDir->Base.hLock);
+                rc = pCurDir->pOps->pfnFollowAbsoluteSymlink(pCurDir, szPath, &pVfsRootDir);
+                RTVfsLockAcquireWrite(pCurDir->Base.hLock);
+                *pszPath = chSaved;
                 if (RT_SUCCESS(rc))
                 {
-                    *piComponent = iComponent;
-                    return VINF_SUCCESS;
+                    RTVfsDirRelease(pCurDir);
+                    *ppCurDir = pCurDir = pVfsRootDir;
                 }
+                else if (rc == VERR_PATH_IS_RELATIVE)
+                    pszPath = szPath;
+                else
+                    return rc;
             }
         }
-    }
+
+        rc = RTVfsParsePath(pPath, pszPath, NULL);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Deal with absolute references in a VFS setup.
+             * Note! The current approach only correctly handles this on root volumes.
+             */
+            if (   pPath->fAbsolute
+                && pCurDir->Base.hVfs != NIL_RTVFS) /** @todo This needs fixing once we implement mount points. */
+            {
+                RTVFSINTERNAL    *pVfs = pCurDir->Base.hVfs;
+                RTVFSDIRINTERNAL *pVfsRootDir;
+                RTVfsLockAcquireRead(pVfs->Base.hLock);
+                rc = pVfs->pOps->pfnOpenRoot(pVfs->Base.pvThis, &pVfsRootDir);
+                RTVfsLockReleaseRead(pVfs->Base.hLock);
+                if (RT_SUCCESS(rc))
+                {
+                    RTVfsDirRelease(pCurDir);
+                    *ppCurDir = pCurDir = pVfsRootDir;
+                }
+                else
+                    return rc;
+            }
+        }
+    }
+    else if (rc == VERR_BUFFER_OVERFLOW)
+        rc = VERR_FILENAME_TOO_LONG;
     return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc;
 }
@@ -1639 +1664 @@
 /**
  * Internal worker for various open functions as well as RTVfsTraverseToParent.
+ *
  *
  * @returns IPRT status code.
  * @param   pThis           The VFS.
  * @param   pPath           The parsed path.  This may be changed as symbolic
- *                          links are processed during the path traversal.
+ *                          links are processed during the path traversal.  If
+ *                          it contains zero components, a dummy component is
+ *                          added to assist the caller.
  * @param   fFlags          RTPATH_F_XXX.
  * @param   ppVfsParentDir  Where to return the parent directory handle
@@ -1660 +1688 @@
     AssertPtr(ppVfsParentDir);
     *ppVfsParentDir = NULL;
-    AssertReturn(pPath->cComponents > 0, VERR_INTERNAL_ERROR_3);
     Assert(RTPATH_F_IS_VALID(fFlags, 0));
 
@@ -1669 +1696 @@
         return VERR_INVALID_HANDLE;
     RTVFSDIRINTERNAL *pCurDir = pThis;
+
+    /*
+     * Special case for traversing zero components.
+     * We fake up a "./" in the pPath to help the caller along.
+     */
+    if (pPath->cComponents == 0)
+    {
+        pPath->fDirSlash         = true;
+        pPath->szPath[0]         = '.';
+        pPath->szPath[1]         = '\0';
+        pPath->szPath[2]         = '\0';
+        pPath->cch               = 1;
+        pPath->cComponents       = 1;
+        pPath->aoffComponents[0] = 0;
+        pPath->aoffComponents[1] = 1;
+        pPath->aoffComponents[2] = 1;
+
+        *ppVfsParentDir = pCurDir;
+        return VINF_SUCCESS;
+    }
+
 
     /*
@@ -1782 +1830 @@
                 break;
             }
-            uint16_t iRestartComp = iComponent;
-            rc = rtVfsTraverseHandleSymlink(pPath, &iRestartComp, hSymlink);
+            rc = rtVfsTraverseHandleSymlink(&pCurDir, pPath, iComponent, hSymlink);
             if (RT_FAILURE(rc))
                 break;
-            if (iRestartComp != iComponent)
-            {
-                /* Must restart from the root. */
-                RTVfsDirRelease(pCurDir);
-                if (RTVfsDirRetain(pThis) == UINT32_MAX)
-                {
-                    rc = VERR_INVALID_HANDLE;
-                    pCurDir = NULL;
-                    break;
-                }
-                pCurDir = pThis;
-                iComponent = 0;
-            }
+            iComponent = 0;
         }
         else
@@ -1866 +1901 @@
     return rc;
 }
+
+
+
+/**
+ * Follows a symbolic link object to the next parent directory.
+ *
+ * @returns IPRT status code
+ * @param   ppVfsParentDir  Pointer to the parent directory of @a hVfsObj on
+ *                          input, the parent directory of the link target on
+ *                          return.
+ * @param   hVfsObj         Symbolic link object handle.
+ * @param   pPath           Path buffer to use parse the symbolic link target.
+ * @param   fFlags          See rtVfsDirTraverseToParent.
+ */
+static int rtVfsDirFollowSymlinkObjToParent(RTVFSDIRINTERNAL **ppVfsParentDir, RTVFSOBJ hVfsObj,
+                                            PRTVFSPARSEDPATH pPath, uint32_t fFlags)
+{
+    RTVFSSYMLINK hVfsSymlink = RTVfsObjToSymlink(hVfsObj);
+    AssertReturn(hVfsSymlink != NIL_RTVFSSYMLINK, VERR_INTERNAL_ERROR_3);
+
+    int rc = rtVfsTraverseHandleSymlink(ppVfsParentDir, pPath, pPath->cComponents, hVfsSymlink);
+    if (RT_SUCCESS(rc))
+    {
+        RTVFSDIRINTERNAL *pVfsStartDir = *ppVfsParentDir;
+        rc = rtVfsDirTraverseToParent(pVfsStartDir, pPath, fFlags, ppVfsParentDir);
+        RTVfsDirRelease(pVfsStartDir);
+    }
+
+    RTVfsSymlinkRelease(hVfsSymlink);
+    return rc;
+}
+
 
 
@@ -2731 +2798 @@
     if (RT_SUCCESS(rc))
     {
-        if (   pPath->fDirSlash
-            || pPath->cComponents == 0)
-        {
-            fObjFlags &= ~RTVFSOBJ_F_OPEN_ANY | RTVFSOBJ_F_OPEN_DIRECTORY;
-            if ((fObjFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_DIRECTORY)
-                fObjFlags = (fObjFlags & ~RTVFSOBJ_F_CREATE_MASK) | RTVFSOBJ_F_CREATE_NOTHING;
-        }
-
         /*
-         * Tranverse the path, resolving the parent node, not checking for
-         * symbolic links in the final element.
+         * Tranverse the path, resolving the parent node.
+         * We'll do the symbolic link checking here with help of pfnOpen.
          */
-        const char       *pszEntryName;
         RTVFSDIRINTERNAL *pVfsParentDir;
-        if (pPath->cComponents > 0)
-        {
-            rc = rtVfsDirTraverseToParent(pThis, pPath, fObjFlags & RTPATH_F_MASK, &pVfsParentDir);
-            pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
-        }
-        else
-        {
-            RTVfsDirRetain(pThis);
-            pVfsParentDir = pThis;
-            pszEntryName  = ".";
-        }
+        rc = rtVfsDirTraverseToParent(pThis, pPath, (fObjFlags & RTPATH_F_NO_SYMLINKS) | RTPATH_F_ON_LINK, &pVfsParentDir);
         if (RT_SUCCESS(rc))
         {
             /*
-             * Do the opening.
+             * Do the opening.  Loop if we need to follow symbolic links.
              */
-            RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
-            rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fFileOpen, fObjFlags, phVfsObj);
-            RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
-
-            if (   (fObjFlags & RTPATH_F_FOLLOW_LINK)
-                && RTVfsObjGetType(*phVfsObj) == RTVFSOBJTYPE_SYMLINK)
+            for (uint32_t cLoops = 1; ; cLoops++)
             {
-                /** @todo implement following symbolic links. */
-                AssertFailed();
-                RTVfsObjRelease(*phVfsObj);
-                *phVfsObj = NIL_RTVFSOBJ;
-                rc = VERR_NOT_IMPLEMENTED;
+                /* If we end with a directory slash, adjust open flags. */
+                if (pPath->fDirSlash)
+                {
+                    fObjFlags &= ~RTVFSOBJ_F_OPEN_ANY | RTVFSOBJ_F_OPEN_DIRECTORY;
+                    if ((fObjFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_DIRECTORY)
+                        fObjFlags = (fObjFlags & ~RTVFSOBJ_F_CREATE_MASK) | RTVFSOBJ_F_CREATE_NOTHING;
+                }
+
+                /* Open it. */
+                const char *pszEntryName = &pPath->szPath[pPath->aoffComponents[pPath->cComponents - 1]];
+                RTVFSOBJ    hVfsObj;
+                RTVfsLockAcquireWrite(pVfsParentDir->Base.hLock);
+                rc = pVfsParentDir->pOps->pfnOpen(pVfsParentDir->Base.pvThis, pszEntryName, fFileOpen, fObjFlags, &hVfsObj);
+                RTVfsLockReleaseWrite(pVfsParentDir->Base.hLock);
+                if (RT_FAILURE(rc))
+                    break;
+
+                /* We're done if we don't follow links or this wasn't a link. */
+                if (   !(fObjFlags & RTPATH_F_FOLLOW_LINK)
+                    || RTVfsObjGetType(*phVfsObj) != RTVFSOBJTYPE_SYMLINK)
+                {
+                    *phVfsObj = hVfsObj;
+                    break;
+                }
+
+                /* Follow symbolic link. */
+                if (cLoops < RTVFS_MAX_LINKS)
+                    rc = rtVfsDirFollowSymlinkObjToParent(&pVfsParentDir, hVfsObj, pPath, fObjFlags & RTPATH_F_MASK);
+                else
+                    rc = VERR_TOO_MANY_SYMLINKS;
+                RTVfsObjRelease(hVfsObj);
+                if (RT_FAILURE(rc))
+                    break;
             }
 

trunk/src/VBox/Runtime/common/vfs/vfsstddir.cpp

@@ -255 +255 @@
  */
 static DECLCALLBACK(int) rtVfsStdDir_Open(void *pvThis, const char *pszEntry, uint64_t fFileOpen,
-                                          uint32_t fVfsFlags, PRTVFSOBJ phVfsObj)
+                                          uint32_t fObjFlags, PRTVFSOBJ phVfsObj)
 {
     PRTVFSSTDDIR pThis = (PRTVFSSTDDIR)pvThis;
@@ -270 +270 @@
         {
             case RTFS_TYPE_DIRECTORY:
-                if (!(fVfsFlags & RTVFSOBJ_F_OPEN_DIRECTORY))
+                if (fObjFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
                 {
                     if (   (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
@@ -277 +277 @@
                     {
                         RTDIR hSubDir;
-                        rc = RTDirRelDirOpenFiltered(pThis->hDir, pszEntry, RTDIRFILTER_NONE, fVfsFlags, &hSubDir);
+                        rc = RTDirRelDirOpenFiltered(pThis->hDir, pszEntry, RTDIRFILTER_NONE, 0 /*fFlags*/, &hSubDir);
                         if (RT_SUCCESS(rc))
                         {
@@ -307 +307 @@
                 {
                     case RTFS_TYPE_FILE:
-                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_FILE      ? VINF_SUCCESS : VERR_IS_A_FILE;
+                        rc = fObjFlags & RTVFSOBJ_F_OPEN_FILE      ? VINF_SUCCESS : VERR_IS_A_FILE;
                         break;
                     case RTFS_TYPE_DEV_BLOCK:
-                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_DEV_BLOCK ? VINF_SUCCESS : VERR_IS_A_BLOCK_DEVICE;
+                        rc = fObjFlags & RTVFSOBJ_F_OPEN_DEV_BLOCK ? VINF_SUCCESS : VERR_IS_A_BLOCK_DEVICE;
                         break;
                     case RTFS_TYPE_DEV_CHAR:
-                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_DEV_CHAR  ? VINF_SUCCESS : VERR_IS_A_CHAR_DEVICE;
+                        rc = fObjFlags & RTVFSOBJ_F_OPEN_DEV_CHAR  ? VINF_SUCCESS : VERR_IS_A_CHAR_DEVICE;
                         break;
                     /** @todo These two types should not result in files, but pure I/O streams.
                      *        possibly char device too.  */
                     case RTFS_TYPE_FIFO:
-                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_FIFO      ? VINF_SUCCESS : VERR_IS_A_FIFO;
+                        rc = fObjFlags & RTVFSOBJ_F_OPEN_FIFO      ? VINF_SUCCESS : VERR_IS_A_FIFO;
                         break;
                     case RTFS_TYPE_SOCKET:
-                        rc = fVfsFlags & RTVFSOBJ_F_OPEN_SOCKET    ? VINF_SUCCESS : VERR_IS_A_SOCKET;
+                        rc = fObjFlags & RTVFSOBJ_F_OPEN_SOCKET    ? VINF_SUCCESS : VERR_IS_A_SOCKET;
                         break;
                     default:
@@ -355 +355 @@
 
             case RTFS_TYPE_SYMLINK:
-                if (fVfsFlags & RTVFSOBJ_F_OPEN_SYMLINK)
+                if (fObjFlags & RTVFSOBJ_F_OPEN_SYMLINK)
                 {
                     uint32_t cRefs = RTVfsDirRetain(pThis->hSelf);
@@ -398 +398 @@
                 || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
                 || (fFileOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE)
-            && (fVfsFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_NOTHING)
+            && (fObjFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_NOTHING)
         {
 
-            if ((fVfsFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_FILE)
+            if ((fObjFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_FILE)
             {
                 RTFILE hFile;
@@ -419 +419 @@
                 }
             }
-            else if ((fVfsFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_DIRECTORY)
+            else if ((fObjFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_DIRECTORY)
             {
                 RTDIR hSubDir;
                 rc = RTDirRelDirCreate(pThis->hDir, pszEntry, (fFileOpen & RTFILE_O_CREATE_MODE_MASK) >> RTFILE_O_CREATE_MODE_SHIFT,
-                                       0 /* fVfsFlags */, &hSubDir);
+                                       0 /* fFlags */, &hSubDir);
                 if (RT_SUCCESS(rc))
                 {
@@ -449 +449 @@
 
 /**
+ * @interface_method_impl{RTVFSDIROPS,pfnFollowAbsoluteSymlink}
+ */
+static DECLCALLBACK(int) rtVfsStdDir_FollowAbsoluteSymlink(void *pvThis, const char *pszRoot, PRTVFSDIR phVfsDir)
+{
+    //PRTVFSSTDDIR pThis = (PRTVFSSTDDIR)pvThis;
+    RT_NOREF(pvThis);
+    /** @todo walking restriction. */
+    return RTVfsDirOpenNormal(pszRoot, 0 /*fFlags*/, phVfsDir);
+}
+
+
+/**
  * @interface_method_impl{RTVFSDIROPS,pfnOpenFile}
  */
@@ -668 +680 @@
     },
     rtVfsStdDir_Open,
+    rtVfsStdDir_FollowAbsoluteSymlink,
     rtVfsStdDir_OpenFile,
     rtVfsStdDir_OpenDir,