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

Timestamp:

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

Author:

vboxsync

svn:sync-xref-src-repo-rev:

129883

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/common/path

Files:

• RTPathAbsDup.cpp (modified) (2 diffs)
• RTPathAbsEx.cpp (modified) (4 diffs)
• RTPathAbsExEx.cpp (added)
• RTPathParse.cpp.h (modified) (1 diff)
• RTPathParsedReassemble.cpp (modified) (3 diffs)

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';