Changeset 78048 in vbox for trunk/src/VBox/Runtime

Timestamp:

Apr 9, 2019 1:21:09 AM (6 years ago)

Author:

vboxsync

Message:

IPRT: Working on new RTPathAbsEx implementation, temporarily called RTPathAbsExEx. This should fix most of the bugs in the current RTPathAbs/Ex code and do away with the fixed path buffer limitations. Also introduces a RTPATH_BIG_MAX, given that RTPATH_MAX is just a reasonable and not absolute MAX value. The new one is more or less absolute and must never be used for stack buffers. bugref:9172

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (3 diffs)
• common/path/RTPathAbsDup.cpp (modified) (2 diffs)
• common/path/RTPathAbsEx.cpp (modified) (4 diffs)
• common/path/RTPathAbsExEx.cpp (added)
• common/path/RTPathParse.cpp.h (modified) (1 diff)
• common/path/RTPathParsedReassemble.cpp (modified) (3 diffs)
• generic/RTPathAbs-generic.cpp (modified) (8 diffs)
• generic/RTPathGetCurrentDrive-generic.cpp (modified) (4 diffs)
• testcase/tstRTPath.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -512 +512 @@
         common/path/RTPathAbsEx.cpp \
         common/path/RTPathAbsExDup.cpp \
+        common/path/RTPathAbsExEx.cpp \
         common/path/RTPathAppend.cpp \
         common/path/RTPathAppendEx.cpp \
@@ -1706 +1707 @@
         common/path/RTPathAbsEx.cpp \
         common/path/RTPathAbsExDup.cpp \
+        common/path/RTPathAbsExEx.cpp \
         common/path/RTPathAppend.cpp \
         common/path/RTPathAppendEx.cpp \
@@ -2720 +2722 @@
         common/path/RTPathAbsEx.cpp \
         common/path/RTPathAbsExDup.cpp \
+        common/path/RTPathAbsExEx.cpp \
         common/path/RTPathAppend.cpp \
         common/path/RTPathAppendEx.cpp \

trunk/src/VBox/Runtime/common/path/RTPathAbsDup.cpp

@@ -31 +31 @@
 #include "internal/iprt.h"
 #include <iprt/path.h>
-#include <iprt/errcore.h>
+
+#include <iprt/err.h>
 #include <iprt/param.h>
 #include <iprt/string.h>
@@ -45 +46 @@
 RTDECL(char *) RTPathAbsDup(const char *pszPath)
 {
+    /* Try with a static buffer first. */
     char szPath[RTPATH_MAX];
     int rc = RTPathAbs(pszPath, szPath, sizeof(szPath));
     if (RT_SUCCESS(rc))
         return RTStrDup(szPath);
+
+    /* If it looks like we ran out of buffer space, double the size until
+       we reach 64 KB. */
+    if (rc == VERR_FILENAME_TOO_LONG || rc == VERR_BUFFER_OVERFLOW)
+    {
+        size_t cbBuf = RTPATH_MAX;
+        do
+        {
+            cbBuf *= 2;
+            char *pszBuf = RTStrAlloc(cbBuf);
+            if (!pszBuf)
+                break;
+            rc = RTPathAbs(pszPath, pszBuf, cbBuf);
+            if (RT_SUCCESS(rc))
+                return pszBuf;
+            RTStrFree(pszBuf);
+        } while (cbBuf <= _32K);
+    }
     return NULL;
 }

trunk/src/VBox/Runtime/common/path/RTPathAbsEx.cpp

@@ -49 +49 @@
  * @param   pszPath         The path to resolve.
  * @param   pszAbsPath      Where to store the absolute path.
- * @param   cchAbsPath      Size of the buffer.
+ * @param   cbAbsPath       Size of the buffer.
  */
-RTDECL(int) RTPathAbsEx(const char *pszBase, const char *pszPath, char *pszAbsPath, size_t cchAbsPath)
+RTDECL(int) RTPathAbsEx(const char *pszBase, const char *pszPath, char *pszAbsPath, size_t cbAbsPath)
 {
+#if 1
     if (    pszBase
         &&  pszPath
@@ -58 +59 @@
        )
     {
-#if defined(RT_OS_WINDOWS)
+# if defined(RT_OS_WINDOWS)
         /* The format for very long paths is not supported. */
         if (    RTPATH_IS_SLASH(pszBase[0])
@@ -66 +67 @@
            )
             return VERR_INVALID_NAME;
-#endif
+# endif
 
         /** @todo there are a couple of things which isn't 100% correct, although the
@@ -96 +97 @@
             memcpy(&szTmpPath[cchBase + 1], pszPath, cchPath + 1);
         }
-        return RTPathAbs(szTmpPath, pszAbsPath, cchAbsPath);
+        return RTPathAbs(szTmpPath, pszAbsPath, cbAbsPath);
     }
 
     /* Fallback to the non *Ex version */
-    return RTPathAbs(pszPath, pszAbsPath, cchAbsPath);
+    return RTPathAbs(pszPath, pszAbsPath, cbAbsPath);
+#else
+    return RTPathAbsExEx(pszBase, pszPath, RTPATH_STR_F_STYLE_HOST, pszAbsPath, &cbAbsPath);
+#endif
 }
 

trunk/src/VBox/Runtime/common/path/RTPathParse.cpp.h

@@ -59 +59 @@
         }
 #if RTPATH_STYLE == RTPATH_STR_F_STYLE_DOS
-        else if (   RTPATH_IS_SLASH(pszPath[1])
-                 && !RTPATH_IS_SLASH(pszPath[2])
-                 && pszPath[2])
-        {
-            /* UNC - skip to the end of the potential namespace or computer name. */
+        else if (RTPATH_IS_SLASH(pszPath[1]))
+        {
+            /* UNC - there are exactly two prefix slashes followed by a namespace
+               or computer name, which can be empty on windows.  */
             offCur = 2;
             while (!RTPATH_IS_SLASH(pszPath[offCur]) && pszPath[offCur])
                 offCur++;
 
-            /* If there is another slash, we considered it a valid UNC path, if
-               not it's just a root path with an extra slash thrown in. */
+            /* Special fun for windows. */
+            fProps = RTPATH_PROP_UNC | RTPATH_PROP_ABSOLUTE;
+            if (   offCur == 3
+                && (pszPath[2] == '.' || pszPath[2] == '?'))
+                fProps |= RTPATH_PROP_SPECIAL_UNC;
+
             if (RTPATH_IS_SLASH(pszPath[offCur]))
             {
-                fProps = RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_UNC | RTPATH_PROP_ABSOLUTE;
-                offCur++;
-                cchPath = offCur;
-            }
-            else
-            {
-                fProps = RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_RELATIVE;
-                offCur = 1;
-                cchPath = 1;
-            }
+                fProps |= RTPATH_PROP_ROOT_SLASH;
+                offCur++;
+            }
+            cchPath = offCur;
         }
 #endif

trunk/src/VBox/Runtime/common/path/RTPathParsedReassemble.cpp

@@ -48 +48 @@
     AssertReturn(RTPATH_STR_F_IS_VALID(fFlags, 0) && !(fFlags & RTPATH_STR_F_MIDDLE), VERR_INVALID_FLAGS);
     AssertPtrReturn(pszDstPath, VERR_INVALID_POINTER);
-    AssertReturn(cbDstPath > pParsed->cchPath, VERR_BUFFER_OVERFLOW);
+
+    /*
+     * Recalculate the length.
+     */
+    uint32_t const  cComps  = pParsed->cComps;
+    uint32_t        idxComp = 0;
+    uint32_t        cchPath = 0;
+    if (RTPATH_PROP_HAS_ROOT_SPEC(pParsed->fProps))
+    {
+        cchPath = pParsed->aComps[0].cch;
+        idxComp++;
+    }
+    bool fNeedSlash = false;
+    while (idxComp < cComps)
+    {
+        uint32_t const cchComp = pParsed->aComps[idxComp].cch;
+        idxComp++;
+        if (cchComp > 0)
+        {
+            cchPath += cchComp + fNeedSlash;
+            fNeedSlash = true;
+        }
+    }
+    if ((pParsed->fProps & RTPATH_PROP_DIR_SLASH) && fNeedSlash)
+        cchPath += 1;
+    pParsed->cchPath = cchPath;
+    if (cbDstPath > cchPath)
+    { /* likely */ }
+    else
+    {
+        if (cbDstPath)
+            *pszDstPath = '\0';
+        return VERR_BUFFER_OVERFLOW;
+    }
 
     /*
@@ -74 +107 @@
     /*
      * Do the joining.
+     * Note! Using memmove here as we want to support pszSrcPath == pszDstPath.
      */
-    uint32_t const  cchOrgPath = pParsed->cchPath;
-    uint32_t        cchDstPath = 0;
-    uint32_t const  cComps     = pParsed->cComps;
-    uint32_t        idxComp    = 0;
-    char           *pszDst     = pszDstPath;
-    uint32_t        cchComp;
+    char *pszDst = pszDstPath;
+    idxComp      = 0;
+    fNeedSlash   = false;
 
     if (RTPATH_PROP_HAS_ROOT_SPEC(pParsed->fProps))
     {
-        cchComp = pParsed->aComps[0].cch;
-        cchDstPath += cchComp;
-        AssertReturn(cchDstPath <= cchOrgPath, VERR_INVALID_PARAMETER);
-        memcpy(pszDst, &pszSrcPath[pParsed->aComps[0].off], cchComp);
+        uint32_t cchComp = pParsed->aComps[0].cch;
+        memmove(pszDst, &pszSrcPath[pParsed->aComps[0].off], cchComp);
 
-        /* fix the slashes */
+        /* fix the slashes (harmless for unix style) */
         char chOtherSlash = chSlash == '\\' ? '/' : '\\';
         while (cchComp-- > 0)
@@ -102 +131 @@
     while (idxComp < cComps)
     {
-        cchComp = pParsed->aComps[idxComp].cch;
-        cchDstPath += cchComp;
-        AssertReturn(cchDstPath <= cchOrgPath, VERR_INVALID_PARAMETER);
-        memcpy(pszDst, &pszSrcPath[pParsed->aComps[idxComp].off], cchComp);
-        pszDst += cchComp;
+        uint32_t const cchComp = pParsed->aComps[idxComp].cch;
+        if (cchComp > 0)
+        {
+            if (fNeedSlash)
+                *pszDst++ = chSlash;
+            fNeedSlash = true;
+            memmove(pszDst, &pszSrcPath[pParsed->aComps[idxComp].off], cchComp);
+            pszDst += cchComp;
+        }
         idxComp++;
-        if (idxComp != cComps || (pParsed->fProps & RTPATH_PROP_DIR_SLASH))
-        {
-            cchDstPath++;
-            AssertReturn(cchDstPath <= cchOrgPath, VERR_INVALID_PARAMETER);
-            *pszDst++ = chSlash;
-        }
     }
 
+    if ((pParsed->fProps & RTPATH_PROP_DIR_SLASH) && fNeedSlash)
+        *pszDst++ = chSlash;
     *pszDst = '\0';
 

trunk/src/VBox/Runtime/generic/RTPathAbs-generic.cpp

@@ -40 +40 @@
 #include "internal/fs.h"
 
+#if 1
 
 static char *rtPathSkipRootSpec(char *pszCur)
@@ -145 +146 @@
 
 
-RTDECL(int) RTPathAbs(const char *pszPath, char *pszAbsPath, size_t cchAbsPath)
+RTDECL(int) RTPathAbs(const char *pszPath, char *pszAbsPath, size_t cbAbsPath)
 {
     int rc;
@@ -163 +164 @@
     if (cchPath >= RTPATH_MAX)
     {
-        LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath, cchAbsPath, VERR_FILENAME_TOO_LONG));
+        LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath, cbAbsPath, VERR_FILENAME_TOO_LONG));
         return VERR_FILENAME_TOO_LONG;
     }
@@ -179 +180 @@
             || (cchTmpPath == 2 && szTmpPath[1] == RTPATH_SLASH))
         {
-            rc = RTPathGetCurrent(pszAbsPath, cchAbsPath);
+            rc = RTPathGetCurrent(pszAbsPath, cbAbsPath);
             if (RT_SUCCESS(rc))
             {
@@ -191 +192 @@
                     && (uintptr_t)&pszAbsPath[cch - 1] > (uintptr_t)pszTop && pszAbsPath[cch - 1] != RTPATH_SLASH)
                 {
-                    if (cch + 1 < cchAbsPath)
+                    if (cch + 1 < cbAbsPath)
                     {
                         pszAbsPath[cch++] = RTPATH_SLASH;
@@ -274 +275 @@
         if (RT_FAILURE(rc))
         {
-            LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath, cchAbsPath, rc));
+            LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath, cbAbsPath, rc));
             return rc;
         }
@@ -360 +361 @@
      * Copy the result to the user buffer.
      */
-    if (cchTmpPath < cchAbsPath)
+    if (cchTmpPath < cbAbsPath)
     {
         memcpy(pszAbsPath, szTmpPath, cchTmpPath + 1);
@@ -369 +370 @@
 
     LogFlow(("RTPathAbs(%p:{%s}, %p:{%s}, %d): returns %Rrc\n", pszPath, pszPath, pszAbsPath,
-             RT_SUCCESS(rc) ? pszAbsPath : "<failed>", cchAbsPath, rc));
+             RT_SUCCESS(rc) ? pszAbsPath : "<failed>", cbAbsPath, rc));
     return rc;
 }
 
+#else
+
+RTDECL(int) RTPathAbs(const char *pszPath, char *pszAbsPath, size_t cbAbsPath)
+{
+    return RTPathAbsExEx(NULL, pszPath, RTPATH_STR_F_STYLE_HOST, pszAbsPath, &cbAbsPath);
+}
+
+#endif
+

trunk/src/VBox/Runtime/generic/RTPathGetCurrentDrive-generic.cpp

@@ -35 +35 @@
 #include <iprt/ctype.h>
 #include <iprt/err.h>
+#include <iprt/mem.h>
 #include <iprt/string.h>
 #include "internal/path.h"
@@ -45 +46 @@
      * Query the current directroy and extract the wanted information from it.
      */
-    int rc = RTPathGetCurrent(pszPath, cbPath);
+    char *pszPathFree = NULL;
+    char *pszCwd = pszPath;
+    int rc = RTPathGetCurrent(pszCwd, cbPath);
+    if (RT_SUCCESS(rc))
+    { /* likely */ }
+    else if (rc != VERR_BUFFER_OVERFLOW)
+        return rc;
+    else
+    {
+        pszPathFree = pszCwd = (char *)RTMemTmpAlloc(RTPATH_BIG_MAX);
+        AssertReturn(pszPathFree, VERR_NO_TMP_MEMORY);
+        rc = RTPathGetCurrent(pszCwd, RTPATH_BIG_MAX);
+    }
     if (RT_SUCCESS(rc))
     {
@@ -51 +64 @@
          * Drive letter? Chop off at root slash.
          */
-        if (pszPath[0] && RTPATH_IS_VOLSEP(pszPath[1]))
-        {
-            pszPath[2] = '\0';
-            return rc;
-        }
-
+        if (pszCwd[0] && RTPATH_IS_VOLSEP(pszCwd[1]))
+            pszCwd[2] = '\0';
         /*
          * UNC? Chop off after share.
          */
-        if (   RTPATH_IS_SLASH(pszPath[0])
-            && RTPATH_IS_SLASH(pszPath[1])
-            && !RTPATH_IS_SLASH(pszPath[2])
-            && pszPath[2])
+        else if (   RTPATH_IS_SLASH(pszCwd[0])
+                 && RTPATH_IS_SLASH(pszCwd[1])
+                 && !RTPATH_IS_SLASH(pszCwd[2])
+                 && pszCwd[2])
         {
             /* Work thru the server name. */
             size_t off = 3;
-            while (!RTPATH_IS_SLASH(pszPath[off]) && pszPath[off])
+            while (!RTPATH_IS_SLASH(pszCwd[off]) && pszCwd[off])
                 off++;
             size_t offServerSlash = off;
 
             /* Is there a share name? */
-            if (RTPATH_IS_SLASH(pszPath[off]))
+            if (RTPATH_IS_SLASH(pszCwd[off]))
             {
-                while (RTPATH_IS_SLASH(pszPath[off]))
+                while (RTPATH_IS_SLASH(pszCwd[off]))
                     off++;
-                if (pszPath[off])
+                if (pszCwd[off])
                 {
                     /* Work thru the share name. */
-                    while (!RTPATH_IS_SLASH(pszPath[off]) && pszPath[off])
+                    while (!RTPATH_IS_SLASH(pszCwd[off]) && pszCwd[off])
                         off++;
                 }
@@ -86 +95 @@
                     off = offServerSlash;
             }
+            pszCwd[off] = '\0';
         }
-        return VERR_INTERNAL_ERROR_4;
+        else
+            rc = VERR_INTERNAL_ERROR_4;
+    }
+    if (pszPathFree)
+    {
+        if (RT_SUCCESS(rc))
+            rc = RTStrCopy(pszPath, cbPath, pszCwd);
+        RTMemTmpFree(pszPathFree);
     }
     return rc;

trunk/src/VBox/Runtime/testcase/tstRTPath.cpp

@@ -57 +57 @@
         { 2, 12,  8,  "C:Config.sys",     RTPATH_PROP_VOLUME | RTPATH_PROP_RELATIVE | RTPATH_PROP_FILENAME | RTPATH_PROP_SUFFIX,                                RTPATH_STR_F_STYLE_DOS },
         { 1, 10,  6,  "Config.sys",       RTPATH_PROP_RELATIVE | RTPATH_PROP_FILENAME | RTPATH_PROP_SUFFIX,                                                     RTPATH_STR_F_STYLE_DOS },
-        { 1,  4,  4,  "//./",             RTPATH_PROP_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE,                                                      RTPATH_STR_F_STYLE_DOS },
-        { 2,  5,  5,  "//./f",            RTPATH_PROP_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME,                               RTPATH_STR_F_STYLE_DOS },
-        { 2,  5,  6,  "//.//f",           RTPATH_PROP_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_EXTRA_SLASHES,   RTPATH_STR_F_STYLE_DOS },
-        { 3,  7,  7,  "//././f",          RTPATH_PROP_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_DOT_REFS,        RTPATH_STR_F_STYLE_DOS },
+        { 1,  4,  4,  "//./",             RTPATH_PROP_UNC | RTPATH_PROP_SPECIAL_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE,                                                      RTPATH_STR_F_STYLE_DOS },
+        { 2,  5,  5,  "//./f",            RTPATH_PROP_UNC | RTPATH_PROP_SPECIAL_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME,                               RTPATH_STR_F_STYLE_DOS },
+        { 2,  5,  6,  "//.//f",           RTPATH_PROP_UNC | RTPATH_PROP_SPECIAL_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_EXTRA_SLASHES,   RTPATH_STR_F_STYLE_DOS },
+        { 3,  7,  7,  "//././f",          RTPATH_PROP_UNC | RTPATH_PROP_SPECIAL_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_DOT_REFS,        RTPATH_STR_F_STYLE_DOS },
         { 3,  8,  8,  "//.././f",         RTPATH_PROP_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_ABSOLUTE | RTPATH_PROP_FILENAME | RTPATH_PROP_DOT_REFS,        RTPATH_STR_F_STYLE_DOS },
         { 3,  9,  9,  "//../../f",        RTPATH_PROP_UNC | RTPATH_PROP_ROOT_SLASH | RTPATH_PROP_RELATIVE | RTPATH_PROP_FILENAME | RTPATH_PROP_DOTDOT_REFS,     RTPATH_STR_F_STYLE_DOS },
@@ -398 +398 @@
         }
     }
+
+    /*
+     * RTPathAbsExEx - will replace RTPathAbsEx shortly.
+     */
+    RTTestSub(hTest, "RTPathAbsExEx");
+    static const struct
+    {
+        uint32_t    fFlags;
+        const char *pcszInputBase;
+        const char *pcszInputPath;
+        int rc;
+        const char *pcszOutput;
+    }
+    s_aRTPathAbsExExTests[] =
+    {
+        { RTPATH_STR_F_STYLE_HOST,  NULL, "", VERR_PATH_ZERO_LENGTH, NULL },
+        { RTPATH_STR_F_STYLE_HOST,  NULL, ".", VINF_SUCCESS, "%p" },
+#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\", VINF_SUCCESS, "%d\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\..", VINF_SUCCESS, "%d\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "/absolute/..", VINF_SUCCESS, "%d\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "/absolute\\\\../..", VINF_SUCCESS, "%d\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "/absolute//../path\\", VINF_SUCCESS, "%d\\path\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "/absolute/../../path", VINF_SUCCESS, "%d\\path" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p\\dir\\file.txt" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\data\\", VINF_SUCCESS, "%d\\data\\" },
+        { RTPATH_STR_F_STYLE_DOS,   "relative_base/dir\\", "\\from_root", VINF_SUCCESS, "%d\\from_root" },
+        { RTPATH_STR_F_STYLE_DOS,   "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p\\relative_base\\dir\\relative_also" },
+#else
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, ".", VINF_SUCCESS, "%p" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "relative/../dir/./././file.txt", VINF_SUCCESS, "%p/dir/file.txt" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p/dir\\.\\.\\.\\file.txt" },  /* linux-specific */
+        { RTPATH_STR_F_STYLE_UNIX,  "relative_base/dir/", "/from_root", VINF_SUCCESS, "/from_root" },
+        { RTPATH_STR_F_STYLE_UNIX,  "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p/relative_base/dir/relative_also" },
+#endif
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/", VINF_SUCCESS, "/" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/..", VINF_SUCCESS, "/" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/absolute/..", VINF_SUCCESS, "/" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/absolute\\\\../..", VINF_SUCCESS, "/" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/absolute//../path/", VINF_SUCCESS, "/path/" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/absolute/../../path", VINF_SUCCESS, "/path" },
+        { RTPATH_STR_F_STYLE_UNIX,  NULL, "/data/", VINF_SUCCESS, "/data/" },
+#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "C:\\", VINF_SUCCESS, "C:\\" },
+        { RTPATH_STR_F_STYLE_DOS,   "C:\\", "..", VINF_SUCCESS, "C:\\" },
+        { RTPATH_STR_F_STYLE_DOS,   "C:\\temp", "..", VINF_SUCCESS, "C:\\" },
+        { RTPATH_STR_F_STYLE_DOS,   "C:\\VirtualBox/Machines", "..\\VirtualBox.xml", VINF_SUCCESS, "C:\\VirtualBox\\VirtualBox.xml" },
+        { RTPATH_STR_F_STYLE_DOS,   "C:\\MustDie", "\\from_root/dir/..", VINF_SUCCESS, "C:\\from_root" },
+        { RTPATH_STR_F_STYLE_DOS,   "C:\\temp", "D:\\data", VINF_SUCCESS, "D:\\data" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\server\\..\\share", VINF_SUCCESS, "\\\\server\\..\\share" /* kind of strange */ },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\server/", VINF_SUCCESS, "\\\\server\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\", VINF_SUCCESS, "\\\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\\\something", VINF_SUCCESS, "\\\\\\something" /* kind of strange */ },
+        { RTPATH_STR_F_STYLE_DOS,   "\\\\server\\share_as_base", "/from_root", VINF_SUCCESS, "\\\\server\\share_as_base\\from_root" },
+        { RTPATH_STR_F_STYLE_DOS,   "\\\\just_server", "/from_root", VINF_SUCCESS, "\\\\just_server\\from_root" },
+        { RTPATH_STR_F_STYLE_DOS,   "\\\\server\\share_as_base", "relative\\data", VINF_SUCCESS, "\\\\server\\share_as_base\\relative\\data" },
+        { RTPATH_STR_F_STYLE_DOS,   "base", "\\\\?\\UNC\\relative/edwef/..", VINF_SUCCESS, "\\\\?\\UNC\\relative" },
+        { RTPATH_STR_F_STYLE_DOS,   "\\\\?\\UNC\\base", "/from_root", VINF_SUCCESS, "\\\\?\\from_root" },
+        { RTPATH_STR_F_STYLE_DOS,   "\\\\?\\UNC\\base", "./..", VINF_SUCCESS, "\\\\?\\UNC" },
+        { RTPATH_STR_F_STYLE_DOS | RTPATHABS_F_STOP_AT_BASE, "\\\\?\\UNC\\base", "./..", VINF_SUCCESS, "\\\\?\\UNC\\base" },
+        { RTPATH_STR_F_STYLE_DOS | RTPATHABS_F_STOP_AT_BASE, "\\\\?\\UNC\\base", "/..", VINF_SUCCESS, "\\\\?\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\.\\asdf\\..", VINF_SUCCESS, "\\\\.\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\?\\asdf\\..", VINF_SUCCESS, "\\\\?\\" },
+        { RTPATH_STR_F_STYLE_DOS,   NULL, "\\\\x\\asdf\\..", VINF_SUCCESS, "\\\\x\\asdf" },
+#else
+        { RTPATH_STR_F_STYLE_UNIX,  "\\temp", "\\data", VINF_SUCCESS, "%p/\\temp/\\data" },
+#endif
+        { RTPATH_STR_F_STYLE_UNIX,  "/VirtualBox/Machines", "../VirtualBox.xml", VINF_SUCCESS, "/VirtualBox/VirtualBox.xml" },
+        { RTPATH_STR_F_STYLE_UNIX,  "/MustDie", "/from_root/dir/..", VINF_SUCCESS, "/from_root" },
+        { RTPATH_STR_F_STYLE_UNIX,  "/temp", "..", VINF_SUCCESS, "/" },
+    };
+    for (unsigned i = 0; i < RT_ELEMENTS(s_aRTPathAbsExExTests); ++ i)
+    {
+        if (RT_FAILURE(s_aRTPathAbsExExTests[i].rc))
+            RTTestDisableAssertions(hTest);
+
+        size_t cbAbsPath = sizeof(szPath);
+        rc = RTPathAbsExEx(s_aRTPathAbsExExTests[i].pcszInputBase,
+                           s_aRTPathAbsExExTests[i].pcszInputPath,
+                           s_aRTPathAbsExExTests[i].fFlags,
+                           szPath, &cbAbsPath);
+
+        if (RT_FAILURE(s_aRTPathAbsExExTests[i].rc))
+            RTTestRestoreAssertions(hTest);
+
+        if (rc != s_aRTPathAbsExExTests[i].rc)
+        {
+            RTTestIFailed("#%u: unexpected result code!\n"
+                          "        flags: %#x\n"
+                          "   input base: '%s'\n"
+                          "   input path: '%s'\n"
+                          "       output: '%s'\n"
+                          "           rc: %Rrc\n"
+                          "  expected rc: %Rrc",
+                          i,
+                          s_aRTPathAbsExExTests[i].fFlags,
+                          s_aRTPathAbsExExTests[i].pcszInputBase,
+                          s_aRTPathAbsExExTests[i].pcszInputPath,
+                          szPath, rc,
+                          s_aRTPathAbsExExTests[i].rc);
+            continue;
+        }
+
+        char szTmp[RTPATH_MAX];
+        char *pszExpected = NULL;
+        if (s_aRTPathAbsExExTests[i].pcszOutput != NULL)
+        {
+            if (s_aRTPathAbsExExTests[i].pcszOutput[0] == '%')
+            {
+                RTTESTI_CHECK_RC(rc = RTPathGetCurrent(szTmp, sizeof(szTmp)), VINF_SUCCESS);
+                if (RT_FAILURE(rc))
+                    break;
+
+                pszExpected = szTmp;
+
+                if (s_aRTPathAbsExExTests[i].pcszOutput[1] == 'p')
+                {
+                    cch = strlen(szTmp);
+                    if (cch + strlen(s_aRTPathAbsExExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
+                        strcpy(szTmp + cch, s_aRTPathAbsExExTests[i].pcszOutput + 2);
+                }
+#if defined(RT_OS_OS2) || defined(RT_OS_WINDOWS)
+                else if (s_aRTPathAbsExExTests[i].pcszOutput[1] == 'd')
+                {
+                    if (2 + strlen(s_aRTPathAbsExExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
+                        strcpy(szTmp + 2, s_aRTPathAbsExExTests[i].pcszOutput + 2);
+                }
+#endif
+            }
+            else
+            {
+                strcpy(szTmp, s_aRTPathAbsExExTests[i].pcszOutput);
+                pszExpected = szTmp;
+            }
+
+            if (   strcmp(szPath, pszExpected)
+                || strlen(szPath) != cbAbsPath)
+            {
+                RTTestIFailed("#%u: Unexpected result\n"
+                              "        flags: %#x\n"
+                              "   input base: '%s'\n"
+                              "   input path: '%s'\n"
+                              "       output: '%s'\n"
+                              "     expected: '%s' ('%s')\n"
+                              "    cchResult: %#x, actual %#x",
+                              i,
+                              s_aRTPathAbsExExTests[i].fFlags,
+                              s_aRTPathAbsExExTests[i].pcszInputBase,
+                              s_aRTPathAbsExExTests[i].pcszInputPath,
+                              szPath,
+                              pszExpected, s_aRTPathAbsExExTests[i].pcszOutput,
+                              cbAbsPath, strlen(szPath));
+            }
+        }
+    }
+
 
     /*