Changeset 15754 in vbox for trunk/src/VBox

Timestamp:

Dec 25, 2008 10:52:24 AM (16 years ago)

Author:

vboxsync

Message:

Runtime/POSIX: RTPathAbs: Don't access file system when calculating the absolute path.

Location:

trunk/src/VBox/Runtime

Files:

• r3/posix/path-posix.cpp (modified) (2 diffs)
• testcase/tstPath.cpp (modified) (2 diffs)

trunk/src/VBox/Runtime/r3/posix/path-posix.cpp

@@ -169 +169 @@
 RTDECL(int) RTPathAbs(const char *pszPath, char *pszAbsPath, size_t cchAbsPath)
 {
-    /*
-     * Convert input.
-     */
-    char *pszNativePath;
-    int rc = rtPathToNative(&pszNativePath, pszPath);
-    if (RT_FAILURE(rc))
+    if (strlen(pszPath) > PATH_MAX)
     {
         LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath,
-                 pszPath, pszAbsPath, cchAbsPath, rc));
-        return rc;
-    }
-
-    /*
-     * On POSIX platforms the API doesn't take a length parameter, which makes it
-     * a little bit more work.
-     */
+                 pszPath, pszAbsPath, cchAbsPath, VERR_FILENAME_TOO_LONG));
+        return VERR_FILENAME_TOO_LONG;
+    }
+
     char szTmpPath[PATH_MAX + 1];
-    char *psz = realpath(pszNativePath, szTmpPath);
-    if (!psz)
-    {
-        if (errno == ENOENT || errno == ENOTDIR
-#ifdef RT_OS_OS2
-            /// @todo realpath() returns EIO for non-existent UNC paths like
-            //  //server/share/subdir (i.e. when a subdir is specified within
-            //  a share). We should either fix realpath() in libc or remove
-            //  this todo.
-            || errno == EIO
-#endif
-            )
-        {
-            if (strlen(pszNativePath) <= PATH_MAX)
-            {
-                /*
-                 * Iterate the path bit by bit an apply realpath to it.
-                 */
-
-                char szTmpSrc[PATH_MAX + 1];
-                strcpy(szTmpSrc, pszNativePath);
-                fsCleanPath(szTmpSrc);
-
-                size_t cch = 0; // current resolved path length
-                char *pszCur = szTmpSrc;
+    strcpy(szTmpPath, pszPath);
+    fsCleanPath(szTmpPath);
+
+    char *pszCur = szTmpPath;
 
 #ifdef HAVE_DRIVE
-                if (pszCur[0] && RTPATH_IS_VOLSEP(pszCur[1]) && pszCur[2] == '/')
-                {
-                    psz = szTmpPath;
-                    cch = 2;
-                    pszCur += 3;
-                }
+    if (pszCur[0] && RTPATH_IS_VOLSEP(pszCur[1]) && pszCur[2] == '/')
+        pszCur += 3;
 #ifdef HAVE_UNC
-                else
-                if (pszCur[0] == '/' && pszCur[1] == '/')
-                {
-                    pszCur += 2;
-                    char *pszSlash = strchr(pszCur, '/');
-                    size_t cchElement = pszSlash ? pszSlash - pszCur : strlen(pszCur);
-                    if (cchElement && pszCur[cchElement])
-                    {
-                        psz = szTmpPath;
-                        cch = cchElement + 2;
-                        pszCur += cchElement + 1;
-                    }
-                    else
-                        /* we've got just "//server" or "//" */
-                        /// @todo (r=dmik) not 100% sure we should fail, but the
-                        //  above cases are just invalid (incomplete) paths,
-                        //  no matter that Win32 returns these paths as is.
-                        rc = VERR_INVALID_NAME;
-                }
+    else
+    if (pszCur[0] == '/' && pszCur[1] == '/')
+        pszCur += 2;
 #endif
 #else
-                if (*pszCur == '/')
-                {
-                    psz = szTmpPath;
-                    pszCur++;
-                }
+    if (pszCur[0] == '/')
+        pszCur += 1;
 #endif
-                else
-                {
-                    /* get the cwd */
-                    psz = getcwd(szTmpPath,  sizeof(szTmpPath));
-                    AssertMsg(psz, ("Couldn't get cwd!\n"));
-                    if (psz)
-                    {
-#ifdef HAVE_DRIVE
-                        if (*pszCur == '/')
-                        {
-                            cch = 2;
-                            pszCur++;
-                        }
-                        else
-#endif
-                            cch = strlen(psz);
-                    }
-                    else
-                        rc = RTErrConvertFromErrno(errno);
-                }
-
-                if (psz)
-                {
-                    bool fResolveSymlinks = true;
-                    char szTmpPath2[PATH_MAX + 1];
-
-                    /* make sure strrchr() will work correctly */
-                    psz[cch] = '\0';
-
-                    while (*pszCur)
-                    {
-                        char *pszSlash = strchr(pszCur, '/');
-                        size_t cchElement = pszSlash ? pszSlash - pszCur : strlen(pszCur);
-                        if (cch + cchElement + 1 > PATH_MAX)
-                        {
-                            rc = VERR_FILENAME_TOO_LONG;
-                            break;
-                        }
-
-                        if (!strncmp(pszCur, "..", cchElement))
-                        {
-                            char *pszLastSlash = strrchr(psz, '/');
-#ifdef HAVE_UNC
-                            if (pszLastSlash && pszLastSlash > psz &&
-                                pszLastSlash[-1] != '/')
-#else
-                            if (pszLastSlash)
-#endif
-                            {
-                                cch = pszLastSlash - psz;
-                                psz[cch] = '\0';
-                            }
-                            /* else: We've reached the root and the parent of
-                             * the root is the root. */
-                        }
-                        else
-                        {
-                            psz[cch++] = '/';
-                            memcpy(psz + cch, pszCur, cchElement);
-                            cch += cchElement;
-                            psz[cch] = '\0';
-
-                            if (fResolveSymlinks)
-                            {
-                                /* resolve possible symlinks */
-                                char *psz2 = realpath(psz, psz == szTmpPath
-                                                           ? szTmpPath2
-                                                           : szTmpPath);
-                                if (psz2)
-                                {
-                                    psz = psz2;
-                                    cch = strlen(psz);
-                                }
-                                else
-                                {
-                                    if (errno != ENOENT && errno != ENOTDIR
-#ifdef RT_OS_OS2
-                                        /// @todo see above
-                                        && errno != EIO
-#endif
-                                        )
-                                    {
-                                        rc = RTErrConvertFromErrno(errno);
-                                        break;
-                                    }
-
-                                    /* no more need to resolve symlinks */
-                                    fResolveSymlinks = false;
-                                }
-                            }
-                        }
-
-                        pszCur += cchElement;
-                        /* skip the slash */
-                        if (*pszCur)
-                            ++pszCur;
-                    }
-
-#ifdef HAVE_DRIVE
-                    /* check if we're at the root */
-                    if (cch == 2 && RTPATH_IS_VOLSEP(psz[1]))
-#else
-                    /* if the length is zero here, then we're at the root */
-                    if (!cch)
-#endif
-                    {
-                        psz[cch++] = '/';
-                        psz[cch] = '\0';
-                    }
-                }
-            }
-            else
-                rc = VERR_FILENAME_TOO_LONG;
-        }
-        else
-            rc = RTErrConvertFromErrno(errno);
-    }
-
-    RTStrFree(pszNativePath);
-
-    if (psz && RT_SUCCESS(rc))
+    else
     {
         /*
-         * Convert result and copy it to the return buffer.
+         * Prepend the current directory to the relative path.
          */
-        char *pszUtf8AbsPath;
-        rc = rtPathFromNative(&pszUtf8AbsPath, psz);
-        if (RT_FAILURE(rc))
-        {
+
+        char szCurDir[PATH_MAX + 1];
+        if (getcwd(szCurDir, sizeof(szCurDir)) == NULL)
+        {
+            AssertMsgFailed(("Couldn't get cwd!\n"));
+
+            int rc = RTErrConvertFromErrno(errno);
             LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath,
                      pszPath, pszAbsPath, cchAbsPath, rc));
@@ -381 +211 @@
         }
 
-        /* replace '/' back with native RTPATH_SLASH */
-        psz = pszUtf8AbsPath;
-        for (; *psz; psz++)
-            if (*psz == '/')
-                *psz = RTPATH_SLASH;
-
-        unsigned cch = strlen(pszUtf8AbsPath) + 1;
-        if (cch <= cchAbsPath)
-            memcpy(pszAbsPath, pszUtf8AbsPath, cch);
+        fsCleanPath(szCurDir);
+
+        {
+            /*
+             * Convert result and copy it to the return buffer.
+             */
+            char *pszUtf8CurDir;
+            int rc = rtPathFromNative(&pszUtf8CurDir, szCurDir);
+            if (RT_FAILURE(rc))
+            {
+                LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath,
+                         pszPath, pszAbsPath, cchAbsPath, rc));
+                return rc;
+            }
+
+            size_t cchUtf8CurDir = strlen(pszUtf8CurDir);
+            if (cchUtf8CurDir + strlen(szTmpPath) + 1 > PATH_MAX)
+            {
+                RTStrFree(pszUtf8CurDir);
+                LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath,
+                         pszPath, pszAbsPath, cchAbsPath, VERR_FILENAME_TOO_LONG));
+                return VERR_FILENAME_TOO_LONG;
+            }
+
+            strcpy(szTmpPath + cchUtf8CurDir + 1, szTmpPath);
+            strcpy(szTmpPath, pszUtf8CurDir);
+            szTmpPath[cchUtf8CurDir] = '/';
+
+            RTStrFree(pszUtf8CurDir);
+        }
+
+#ifdef HAVE_DRIVE
+        if (pszCur[0] && RTPATH_IS_VOLSEP(pszCur[1]) && pszCur[2] == '/')
+            pszCur += 3;
+#ifdef HAVE_UNC
         else
-            rc = VERR_BUFFER_OVERFLOW;
-        RTStrFree(pszUtf8AbsPath);
-    }
+        if (pszCur[0] == '/' && pszCur[1] == '/')
+            pszCur += 2;
+#endif
+#else
+        if (pszCur[0] == '/')
+            pszCur += 1;
+#endif
+        else
+        {
+            AssertFailed();
+            LogFlow(("RTPathAbs(%p:{%s}, %p, %d): returns %Rrc\n", pszPath,
+                     pszPath, pszAbsPath, cchAbsPath, VERR_GENERAL_FAILURE));
+            return VERR_GENERAL_FAILURE;
+        }
+    }
+
+    char *pszTop = pszCur;
+
+    /*
+     * Get rid of double dot path components by evaluating them.
+     */
+
+    for (;;)
+    {
+        if (pszCur[0] == '.' && pszCur[1] == '.' &&
+            (!pszCur[2] || pszCur[2] == '/'))
+        {
+            /* rewind to the previous component if any */
+            char *pszPrev = pszCur - 1;
+            if (pszPrev > pszTop)
+                while (*--pszPrev != '/')
+                    ;
+
+            AssertMsg(*pszPrev == '/', ("szTmpPath={%s}, pszPrev=+%u\n",
+                                        szTmpPath, pszPrev - szTmpPath));
+            strcpy(pszPrev, pszCur + 2);
+
+            pszCur = pszPrev;
+        }
+        else
+        {
+            while (*pszCur && *pszCur != '/')
+                ++pszCur;
+        }
+
+        if (!*pszCur)
+            break;
+
+        /* skip the slash */
+        ++pszCur;
+    }
+
+    if (pszCur < pszTop)
+    {
+        /*
+         * We overwrote the trailing slash of the root path with zero, restore
+         * it.
+         */
+        *pszCur++ = '/';
+        *pszCur = '\0';
+    }
+    else if (pszCur > pszTop && *(pszCur - 1) == '/')
+    {
+        /*
+         * Extra trailing slash in a non-root path, remove it.
+         */
+        *--pszCur = '\0';
+    }
+
+    int rc = VINF_SUCCESS;
+
+    size_t cch = pszCur - szTmpPath + 1;
+    if (cch <= cchAbsPath)
+        memcpy(pszAbsPath, szTmpPath, cch);
+    else
+        rc = VERR_BUFFER_OVERFLOW;
 
     LogFlow(("RTPathAbs(%p:{%s}, %p:{%s}, %d): returns %Rrc\n", pszPath,

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

@@ -40 +40 @@
 #include <iprt/param.h>
 
+#if defined (RT_OS_WINDOWS)
+# include <direct.h> // for getcwd
+#else
+# include <unistd.h> // for getcwd
+#endif
+#include <errno.h> // for getcwd
 
 #define CHECK_RC(method) \
@@ -85 +91 @@
      */
     RTPrintf("tstPath: TESTING RTPathAbsEx()\n");
-    static const char *aInput[] =
-    {
-        // NULL, NULL, -- assertion in RTStrToUtf16
-        NULL,                           "/absolute/..",
-        NULL,                           "/absolute\\\\../..",
-        NULL,                           "/absolute//../path",
-        NULL,                           "/absolute/../../path",
-        NULL,                           "relative/../dir\\.\\.\\.\\file.txt",
-        NULL,                           "\\",
-        "relative_base/dir\\",          "\\from_root",
-        "relative_base/dir/",           "relative_also",
-#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
-        NULL,                           "C:\\",
-        "C:\\",                         "..",
-        "C:\\temp",                     "..",
-        "C:\\VirtualBox/Machines",      "..\\VirtualBox.xml",
-        "C:\\MustDie",                  "\\from_root/dir/..",
-        "C:\\temp",                     "D:\\data",
-        NULL,                           "\\\\server\\../share", // -- on Win32, GetFullPathName doesn't remove .. here
-        /* the three below use cases should fail with VERR_INVALID_NAME */
-        //NULL,                           "\\\\server",
-        //NULL,                           "\\\\",
-        //NULL,                           "\\\\\\something",
-        "\\\\server\\share_as_base",    "/from_root",
-        "\\\\just_server",              "/from_root",
-        "\\\\server\\share_as_base",    "relative\\data",
-        "base",                         "\\\\?\\UNC\\relative/edwef/..",
-        "base",                         "\\\\?\\UNC\\relative/edwef/..",
-        /* this is not (and I guess should not be) supported, should fail */
-        ///@todo "\\\\?\\UNC\\base",             "/from_root",
+    static const struct
+    {
+        const char *pcszInputBase;
+        const char *pcszInputPath;
+        int rc;
+        const char *pcszOutput;
+    }
+    aRTPathAbsExTests[] =
+    {
+#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
+//  { NULL, "", VINF_SUCCESS, "%p" },
+//  { NULL, ".", VINF_SUCCESS, "%p" },
+    { NULL, "\\", VINF_SUCCESS, "%d\\" },
+    { NULL, "\\..", VINF_SUCCESS, "%d\\" },
+    { NULL, "/absolute/..", VINF_SUCCESS, "%d\\" },
+    { NULL, "/absolute\\\\../..", VINF_SUCCESS, "%d\\" },
+    { NULL, "/absolute//../path\\", VINF_SUCCESS, "%d\\path" },
+    { NULL, "/absolute/../../path", VINF_SUCCESS, "%d\\path" },
+    { NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p\\dir\\file.txt" },
+    { NULL, "\\data\\", VINF_SUCCESS, "%d\\data" },
+    { "relative_base/dir\\", "\\from_root", VINF_SUCCESS, "%d\\from_root" },
+    { "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p\\relative_base\\dir\\relative_also" },
 #else
-        "\\temp",                       "..",
-        "\\VirtualBox/Machines",        "..\\VirtualBox.xml",
-        "\\MustDie",                    "\\from_root/dir/..",
-        "\\temp",                       "\\data",
+//  { NULL, "", VINF_SUCCESS, "/" },
+//  { NULL, ".", VINF_SUCCESS, "%p" },
+    { NULL, "/", VINF_SUCCESS, "/" },
+    { NULL, "/..", VINF_SUCCESS, "/" },
+    { NULL, "/absolute/..", VINF_SUCCESS, "/" },
+    { NULL, "/absolute\\\\../..", VINF_SUCCESS, "/" },
+    { NULL, "/absolute//../path/", VINF_SUCCESS, "/path" },
+    { NULL, "/absolute/../../path", VINF_SUCCESS, "/path" },
+    { NULL, "relative/../dir/./././file.txt", VINF_SUCCESS, "%p/dir/file.txt" },
+    { NULL, "relative/../dir\\.\\.\\.\\file.txt", VINF_SUCCESS, "%p/dir\\.\\.\\.\\file.txt" },  /* linux-specific */
+    { NULL, "/data/", VINF_SUCCESS, "/data" },
+    { "relative_base/dir/", "/from_root", VINF_SUCCESS, "/from_root" },
+    { "relative_base/dir/", "relative_also", VINF_SUCCESS, "%p/relative_base/dir/relative_also" },
+#endif
+#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
+    { NULL, "C:\\", VINF_SUCCESS, "C:\\" },
+    { "C:\\", "..", VINF_SUCCESS, "C:\\" },
+    { "C:\\temp", "..", VINF_SUCCESS, "C:\\" },
+    { "C:\\VirtualBox/Machines", "..\\VirtualBox.xml", VINF_SUCCESS, "C:\\VirtualBox\\VirtualBox.xml" },
+    { "C:\\MustDie", "\\from_root/dir/..", VINF_SUCCESS, "C:\\from_root" },
+    { "C:\\temp", "D:\\data", VINF_SUCCESS, "D:\\data" },
+    { NULL, "\\\\server\\..\\share", VINF_SUCCESS, "\\\\server\\..\\share" /* kind of strange */ },
+    { NULL, "\\\\server/", VINF_SUCCESS, "\\\\server" },
+    { NULL, "\\\\", VINF_SUCCESS, "\\\\" },
+    { NULL, "\\\\\\something", VINF_SUCCESS, "\\\\\\something" /* kind of strange */ },
+    { "\\\\server\\share_as_base", "/from_root", VINF_SUCCESS, "\\\\server\\from_root" },
+    { "\\\\just_server", "/from_root", VINF_SUCCESS, "\\\\just_server\\from_root" },
+    { "\\\\server\\share_as_base", "relative\\data", VINF_SUCCESS, "\\\\server\\share_as_base\\relative\\data" },
+    { "base", "\\\\?\\UNC\\relative/edwef/..", VINF_SUCCESS, "\\\\?\\UNC\\relative" },
+    { "\\\\?\\UNC\\base", "/from_root", VERR_INVALID_NAME, NULL },
+#else
+    { "/temp", "..", VINF_SUCCESS, "/" },
+    { "/VirtualBox/Machines", "../VirtualBox.xml", VINF_SUCCESS, "/VirtualBox/VirtualBox.xml" },
+    { "/MustDie", "/from_root/dir/..", VINF_SUCCESS, "/from_root" },
+    { "\\temp", "\\data", VINF_SUCCESS, "%p/\\temp/\\data" },
 #endif
     };
 
-    for (unsigned i = 0; i < RT_ELEMENTS(aInput); i += 2)
-    {
-        RTPrintf("tstPath: base={%s}, path={%s}, ", aInput[i], aInput[i + 1]);
-        CHECK_RC(RTPathAbsEx(aInput[i], aInput[i + 1], szPath, sizeof(szPath)));
-        if (RT_SUCCESS(rc))
-            RTPrintf("abs={%s}\n", szPath);
+    for (unsigned i = 0; i < RT_ELEMENTS(aRTPathAbsExTests); ++ i)
+    {
+        rc = RTPathAbsEx(aRTPathAbsExTests[i].pcszInputBase,
+                         aRTPathAbsExTests[i].pcszInputPath,
+                         szPath, sizeof(szPath));
+        if (rc != aRTPathAbsExTests[i].rc)
+        {
+            RTPrintf("tstPath: RTPathAbsEx unexpected result code!\n"
+                     "   input base: '%s'\n"
+                     "   input path: '%s'\n"
+                     "       output: '%s'\n"
+                     "           rc: %Rrc\n"
+                     "  expected rc: %Rrc\n",
+                     aRTPathAbsExTests[i].pcszInputBase,
+                     aRTPathAbsExTests[i].pcszInputPath,
+                     szPath, rc,
+                     aRTPathAbsExTests[i].rc);
+            cErrors++;
+            continue;
+        }
+
+        char szTmp[RTPATH_MAX];
+        char *pszExpected = NULL;
+        if (aRTPathAbsExTests[i].pcszOutput != NULL)
+        {
+            if (aRTPathAbsExTests[i].pcszOutput[0] == '%')
+            {
+                if (getcwd(szTmp, sizeof(szTmp)) == NULL)
+                {
+                    RTPrintf("tstPath: getcwd failed with errno=%d!\n", errno);
+                    cErrors++;
+                    break;
+                }
+
+                pszExpected = szTmp;
+
+                if (aRTPathAbsExTests[i].pcszOutput[1] == 'p')
+                {
+                    size_t cch = strlen(szTmp);
+                    if (cch + strlen (aRTPathAbsExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
+                        strcpy (szTmp + cch, aRTPathAbsExTests[i].pcszOutput + 2);
+                }
+#if defined (RT_OS_OS2) || defined (RT_OS_WINDOWS)
+                else if (aRTPathAbsExTests[i].pcszOutput[1] == 'd')
+                {
+                    if (2 + strlen (aRTPathAbsExTests[i].pcszOutput) - 2 <= sizeof(szTmp))
+                        strcpy (szTmp + 2, aRTPathAbsExTests[i].pcszOutput + 2);
+                }
+#endif
+            }
+            else
+            {
+                strcpy(szTmp, aRTPathAbsExTests[i].pcszOutput);
+                pszExpected = szTmp;
+            }
+
+            if (strcmp(szPath, pszExpected))
+            {
+                RTPrintf("tstPath: RTPathAbsEx failed!\n"
+                         "   input base: '%s'\n"
+                         "   input path: '%s'\n"
+                         "       output: '%s'\n"
+                         "     expected: '%s'\n",
+                         aRTPathAbsExTests[i].pcszInputBase,
+                         aRTPathAbsExTests[i].pcszInputPath,
+                         szPath,
+                         aRTPathAbsExTests[i].pcszOutput);
+                cErrors++;
+            }
+        }
     }