Add PathSkipPastRoot.

author: Sean Hall <r.sean.hall@gmail.com> 2022-06-03 17:48:39 -0500
committer: Sean Hall <r.sean.hall@gmail.com> 2022-06-07 19:44:36 -0500
commit: 6b0f2d978504da82070523eb6adb0b59f9812e93 (patch)
tree: 6f0b258519a0f51bf589e4313206b3ffeaa32a41 /src/libs/dutil/WixToolset.DUtil
parent: b652e93a460b4b822a01382e5992f96f1d805ffe (diff)
download: wix-6b0f2d978504da82070523eb6adb0b59f9812e93.tar.gz
wix-6b0f2d978504da82070523eb6adb0b59f9812e93.tar.bz2
wix-6b0f2d978504da82070523eb6adb0b59f9812e93.zip
5 files changed, 255 insertions, 171 deletions
diff --git a/src/libs/dutil/WixToolset.DUtil/dirutil.cpp b/src/libs/dutil/WixToolset.DUtil/dirutil.cpp
index c106a467..94eab9e7 100644
--- a/src/libs/dutil/WixToolset.DUtil/dirutil.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/dirutil.cpp
@@ -364,17 +364,27 @@ extern "C" DWORD DAPI DirDeleteEmptyDirectoriesToRoot(
    __in DWORD /*dwFlags*/
    )
 {
+    HRESULT hr = S_OK;
    DWORD cDeletedDirs = 0;
    LPWSTR sczPath = NULL;
+    LPCWSTR wzPastRoot = NULL;
+    SIZE_T cchRoot = 0;
+    // Make sure the path is normalized and prefixed.
+    hr = PathExpand(&sczPath, wzPath, PATH_EXPAND_FULLPATH);
+    DirExitOnFailure(hr, "Failed to get full path for: %ls", wzPath);
+    wzPastRoot = PathSkipPastRoot(sczPath, NULL, NULL, NULL);
+    DirExitOnNull(wzPastRoot, hr, E_INVALIDARG, "Full path was not rooted: %ls", sczPath);
-    while (wzPath && *wzPath && ::RemoveDirectoryW(wzPath))
+    cchRoot = wzPastRoot - sczPath;
+    while (sczPath && sczPath[cchRoot] && ::RemoveDirectoryW(sczPath))
    {
        ++cDeletedDirs;
-        HRESULT hr = PathGetParentPath(wzPath, &sczPath);
+        hr = PathGetParentPath(sczPath, &sczPath, &cchRoot);
-        DirExitOnFailure(hr, "Failed to get parent directory for path: %ls", wzPath);
+        DirExitOnFailure(hr, "Failed to get parent directory for path: %ls", sczPath);
-        wzPath = sczPath;
    }
 LExit:
diff --git a/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h b/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h
index e64c8ef3..727318f2 100644
--- a/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h
+++ b/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h
@@ -8,8 +8,8 @@ extern "C" {
 typedef enum _PATH_CANONICALIZE
 {
-    // Always prefix fully qualified paths with the long path prefix (\\?\).
+    // Always prefix fully qualified paths with the extended path prefix (\\?\).
-    PATH_CANONICALIZE_APPEND_LONG_PATH_PREFIX = 0x0001,
+    PATH_CANONICALIZE_APPEND_EXTENDED_PATH_PREFIX = 0x0001,
    // Always terminate the path with \.
    PATH_CANONICALIZE_BACKSLASH_TERMINATE = 0x0002,
    // Don't collapse . or .. in the \\server\share portion of a UNC path.
@@ -22,6 +22,14 @@ typedef enum _PATH_EXPAND
    PATH_EXPAND_FULLPATH    = 0x0002,
 } PATH_EXPAND;
+typedef enum _PATH_PREFIX
+{
+    // Add prefix even if the path is not longer than MAX_PATH.
+    PATH_PREFIX_SHORT_PATHS    = 0x0001,
+    // Error with E_INVALIDARG if the path is not fully qualified.
+    PATH_PREFIX_EXPECT_FULLY_QUALIFIED = 0x0002,
+} PATH_PREFIX;
 /*******************************************************************
 PathFile -  returns a pointer to the file part of the path.
@@ -40,8 +48,9 @@ DAPI_(LPCWSTR) PathExtension(
 /*******************************************************************
 PathGetDirectory - extracts the directory from a path including the directory separator.
-                    This means calling the function again with the previous result returns the same result.
+    Calling the function again with the previous result returns the same result.
-                    Returns S_FALSE if the path only contains a file name.
+    Returns S_FALSE if the path only contains a file name.
+    For example, C:\a\b -> C:\a\ -> C:\a\
 ********************************************************************/
 DAPI_(HRESULT) PathGetDirectory(
    __in_z LPCWSTR wzPath,
@@ -49,12 +58,18 @@ DAPI_(HRESULT) PathGetDirectory(
    );
 /*******************************************************************
-PathGetParentPath - extracts the parent directory from a full path.
+PathGetParentPath - extracts the parent directory from a path
-                    *psczDirectory is NULL if the path only contains a file name.
+    ignoring a trailing slash so that when called repeatedly,
+    it eventually returns the root portion of the path.
+    *psczDirectory is NULL if the path only contains a file name or
+    the path only contains the root.
+    *pcchRoot is the length of the root part of the path.
+    For example, C:\a\b -> C:\a\ -> C:\ -> NULL
 ********************************************************************/
 DAPI_(HRESULT) PathGetParentPath(
    __in_z LPCWSTR wzPath,
-    __out_z LPWSTR *psczDirectory
+    __out_z LPWSTR *psczDirectory,
+    __out_opt SIZE_T* pcchRoot
    );
 /*******************************************************************
@@ -78,11 +93,14 @@ DAPI_(HRESULT) PathGetFullPathName(
    );
 /*******************************************************************
- PathPrefix - prefixes a full path with \\?\ or \\?\UNC as
+ PathPrefix - prefixes a path with \\?\ or \\?\UNC if it doesn't
-              appropriate.
+    already have an extended prefix, is longer than MAX_PATH,
+    and is fully qualified.
 ********************************************************************/
 DAPI_(HRESULT) PathPrefix(
-    __inout LPWSTR *psczFullPath
+    __inout_z LPWSTR *psczFullPath,
+    __in SIZE_T cchFullPath,
+    __in DWORD dwPrefixFlags
    );
 /*******************************************************************
@@ -204,14 +222,27 @@ DAPI_(HRESULT) PathGetKnownFolder(
    );
 /*******************************************************************
+ PathSkipPastRoot - returns a pointer to the first character after
+    the root portion of the path or NULL if the path has no root.
+    For example, the pointer will point to the "a" in "after":
+    C:\after, C:after, \after, \\server\share\after,
+    \\?\C:\afterroot, \\?\UNC\server\share\after
+*******************************************************************/
+DAPI_(LPCWSTR) PathSkipPastRoot(
+    __in_z LPCWSTR wzPath,
+    __out_opt BOOL* pfHasExtendedPrefix,
+    __out_opt BOOL* pfFullyQualified,
+    __out_opt BOOL* pfUNC
+    );
+/*******************************************************************
 PathIsFullyQualified - returns true if the path is fully qualified; false otherwise.
    Note that some rooted paths like C:dir are not fully qualified.
    For example, these are all fully qualified: C:\dir, C:/dir, \\server\share, \\?\C:\dir.
    For example, these are not fully qualified: C:dir, C:, \dir, dir, dir\subdir.
 *******************************************************************/
 DAPI_(BOOL) PathIsFullyQualified(
-    __in_z LPCWSTR wzPath,
+    __in_z LPCWSTR wzPath
-    __out_opt BOOL* pfHasLongPathPrefix
    );
 /*******************************************************************
diff --git a/src/libs/dutil/WixToolset.DUtil/logutil.cpp b/src/libs/dutil/WixToolset.DUtil/logutil.cpp
index 94c21374..88a90d8c 100644
--- a/src/libs/dutil/WixToolset.DUtil/logutil.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/logutil.cpp
@@ -133,7 +133,7 @@ extern "C" HRESULT DAPI LogOpen(
        hr = PathConcat(wzDirectory, wzLog, &sczCombined);
        LoguExitOnFailure(hr, "Failed to combine the log path.");
-        if (!PathIsFullyQualified(sczCombined, NULL))
+        if (!PathIsFullyQualified(sczCombined))
        {
            hr = PathExpand(&LogUtil_sczLogPath, sczCombined, PATH_EXPAND_FULLPATH);
            LoguExitOnFailure(hr, "Failed to expand the log path.");
diff --git a/src/libs/dutil/WixToolset.DUtil/path2utl.cpp b/src/libs/dutil/WixToolset.DUtil/path2utl.cpp
index 1957a8c5..9e48f9d5 100644
--- a/src/libs/dutil/WixToolset.DUtil/path2utl.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/path2utl.cpp
@@ -64,31 +64,12 @@ DAPI_(HRESULT) PathCanonicalizeForComparison(
    if (PATH_CANONICALIZE_KEEP_UNC_ROOT & dwCanonicalizeFlags)
    {
-        if (L'\\' == sczNormalizedPath[0] && (L'\\' == sczNormalizedPath[1] || L'?' == sczNormalizedPath[1]) && L'?' == sczNormalizedPath[2] && L'\\' == sczNormalizedPath[3])
+        BOOL fUNC = FALSE;
+        LPCWSTR wzPastRoot = PathSkipPastRoot(sczNormalizedPath, NULL, NULL, &fUNC);
+        if (fUNC)
        {
-            if (L'U' == sczNormalizedPath[4] && L'N' == sczNormalizedPath[5] && L'C' == sczNormalizedPath[6] && L'\\' == sczNormalizedPath[7])
+            wzNormalizedPath = wzPastRoot;
-            {
+            cchUncRootLength = wzPastRoot - sczNormalizedPath;
-                cchUncRootLength = 8;
-            }
-        }
-        else if (L'\\' == sczNormalizedPath[0] && L'\\' == sczNormalizedPath[1])
-        {
-            cchUncRootLength = 2;
-        }
-        if (cchUncRootLength)
-        {
-            DWORD dwRemainingSlashes = 2;
-            for (wzNormalizedPath += cchUncRootLength; *wzNormalizedPath && dwRemainingSlashes; ++wzNormalizedPath)
-            {
-                ++cchUncRootLength;
-                if (L'\\' == *wzNormalizedPath)
-                {
-                    --dwRemainingSlashes;
-                }
-            }
        }
    }
@@ -115,22 +96,24 @@ DAPI_(HRESULT) PathCanonicalizeForComparison(
    if (PATH_CANONICALIZE_BACKSLASH_TERMINATE & dwCanonicalizeFlags)
    {
        hr = PathBackslashTerminate(psczCanonicalized);
-        PathExitOnFailure(hr, "Failed to backslash terminate the canonicalized path");
+        PathExitOnFailure(hr, "Failed to backslash terminate the canonicalized path.");
    }
-    if (PathIsFullyQualified(*psczCanonicalized, &fHasPrefix) && !fHasPrefix &&
+    if (PATH_CANONICALIZE_APPEND_EXTENDED_PATH_PREFIX & dwCanonicalizeFlags)
-        (PATH_CANONICALIZE_APPEND_LONG_PATH_PREFIX & dwCanonicalizeFlags))
    {
-        hr = PathPrefix(psczCanonicalized);
+        hr = PathPrefix(psczCanonicalized, 0, PATH_PREFIX_SHORT_PATHS);
-        PathExitOnFailure(hr, "Failed to ensure the long path prefix on the canonicalized path");
+        PathExitOnFailure(hr, "Failed to ensure the extended path prefix on the canonicalized path.");
-        fHasPrefix = TRUE;
    }
+    PathSkipPastRoot(*psczCanonicalized, &fHasPrefix, NULL, NULL);
    if (fHasPrefix)
    {
-        // Canonicalize \??\ into \\?\.
+        // Canonicalize prefix into \\?\.
+        (*psczCanonicalized)[0] = L'\\';
        (*psczCanonicalized)[1] = L'\\';
+        (*psczCanonicalized)[2] = L'?';
+        (*psczCanonicalized)[3] = L'\\';
    }
 LExit:
@@ -188,7 +171,7 @@ DAPI_(HRESULT) PathCompareCanonicalized(
    HRESULT hr = S_OK;
    LPWSTR sczCanonicalized1 = NULL;
    LPWSTR sczCanonicalized2 = NULL;
-    DWORD dwDefaultFlags = PATH_CANONICALIZE_APPEND_LONG_PATH_PREFIX | PATH_CANONICALIZE_KEEP_UNC_ROOT;
+    DWORD dwDefaultFlags = PATH_CANONICALIZE_APPEND_EXTENDED_PATH_PREFIX | PATH_CANONICALIZE_KEEP_UNC_ROOT;
    int nResult = 0;
    if (!wzPath1 || !wzPath2)
@@ -221,7 +204,7 @@ DAPI_(HRESULT) PathDirectoryContainsPath(
    HRESULT hr = S_OK;
    LPWSTR sczCanonicalizedDirectory = NULL;
    LPWSTR sczCanonicalizedPath = NULL;
-    DWORD dwDefaultFlags = PATH_CANONICALIZE_APPEND_LONG_PATH_PREFIX | PATH_CANONICALIZE_KEEP_UNC_ROOT;
+    DWORD dwDefaultFlags = PATH_CANONICALIZE_APPEND_EXTENDED_PATH_PREFIX | PATH_CANONICALIZE_KEEP_UNC_ROOT;
    size_t cchDirectory = 0;
    if (!wzDirectory || !*wzDirectory)
@@ -239,7 +222,7 @@ DAPI_(HRESULT) PathDirectoryContainsPath(
    hr = PathCanonicalizeForComparison(wzPath, dwDefaultFlags, &sczCanonicalizedPath);
    PathExitOnFailure(hr, "Failed to canonicalize the path.");
-    if (!PathIsFullyQualified(sczCanonicalizedDirectory, NULL))
+    if (!PathIsFullyQualified(sczCanonicalizedDirectory))
    {
        PathExitWithRootFailure(hr, E_INVALIDARG, "wzDirectory must be a fully qualified path.");
    }
diff --git a/src/libs/dutil/WixToolset.DUtil/pathutil.cpp b/src/libs/dutil/WixToolset.DUtil/pathutil.cpp
index abbf4d4b..1ac76626 100644
--- a/src/libs/dutil/WixToolset.DUtil/pathutil.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/pathutil.cpp
@@ -120,13 +120,34 @@ LExit:
 DAPI_(HRESULT) PathGetParentPath(
    __in_z LPCWSTR wzPath,
-    __out_z LPWSTR *psczParent
+    __out_z LPWSTR* psczParent,
+    __out_opt SIZE_T* pcchRoot
    )
 {
    HRESULT hr = S_OK;
+    LPCWSTR wzPastRoot = NULL;
    LPCWSTR wzParent = NULL;
+    LPCWSTR wz = NULL;
-    for (LPCWSTR wz = wzPath; *wz; ++wz)
+    wzPastRoot = PathSkipPastRoot(wzPath, NULL, NULL, NULL);
+    if (pcchRoot)
+    {
+        *pcchRoot = !wzPastRoot ? 0 : wzPastRoot - wzPath;
+    }
+    if (wzPastRoot && *wzPastRoot)
+    {
+        Assert(wzPastRoot > wzPath);
+        wz = wzPastRoot;
+        wzParent = wzPastRoot - 1;
+    }
+    else
+    {
+        wz = wzPath;
+    }
+    for (; *wz; ++wz)
    {
        if (IsPathSeparatorChar(*wz) && wz[1])
        {
@@ -143,7 +164,7 @@ DAPI_(HRESULT) PathGetParentPath(
    }
    else
    {
-        ReleaseNullStr(psczParent);
+        ReleaseNullStr(*psczParent);
    }
 LExit:
@@ -164,9 +185,8 @@ DAPI_(HRESULT) PathExpand(
    LPWSTR sczExpandedPath = NULL;
    SIZE_T cchWritten = 0;
    DWORD cchExpandedPath = 0;
-    SIZE_T cbSize = 0;
    LPWSTR sczFullPath = NULL;
+    DWORD dwPrefixFlags = 0;
    //
    // First, expand any environment variables.
@@ -201,20 +221,7 @@ DAPI_(HRESULT) PathExpand(
            }
        }
-        if (MAX_PATH < cch)
+        cchWritten = cch;
-        {
-            hr = PathPrefix(&sczExpandedPath); // ignore invald arg from path prefix because this may not be a complete path yet
-            if (E_INVALIDARG == hr)
-            {
-                hr = S_OK;
-            }
-            PathExitOnFailure(hr, "Failed to prefix long path after expanding environment variables.");
-            hr = StrMaxLength(sczExpandedPath, &cbSize);
-            PathExitOnFailure(hr, "Failed to get max length of expanded path.");
-            cchExpandedPath = (DWORD)min(DWORD_MAX, cbSize);
-        }
    }
    //
@@ -227,11 +234,7 @@ DAPI_(HRESULT) PathExpand(
        hr = PathGetFullPathName(wzPath, &sczFullPath, NULL, &cchWritten);
        PathExitOnFailure(hr, "Failed to get full path for string: %ls", wzPath);
-        if (MAX_PATH < cchWritten)
+        dwPrefixFlags |= PATH_PREFIX_EXPECT_FULLY_QUALIFIED;
-        {
-            hr = PathPrefix(&sczFullPath);
-            PathExitOnFailure(hr, "Failed to prefix long path after expanding.");
-        }
    }
    else
    {
@@ -239,6 +242,12 @@ DAPI_(HRESULT) PathExpand(
        sczExpandedPath = NULL;
    }
+    if (dwResolveFlags)
+    {
+        hr = PathPrefix(&sczFullPath, cchWritten, dwPrefixFlags);
+        PathExitOnFailure(hr, "Failed to prefix path after expanding.");
+    }
    hr = StrAllocString(psczFullPath, sczFullPath ? sczFullPath : wzRelativePath, 0);
    PathExitOnFailure(hr, "Failed to copy relative path into full path.");
@@ -319,29 +328,54 @@ LExit:
 DAPI_(HRESULT) PathPrefix(
-    __inout LPWSTR *psczFullPath
+    __inout_z LPWSTR* psczFullPath,
+    __in SIZE_T cchFullPath,
+    __in DWORD dwPrefixFlags
    )
 {
-    Assert(psczFullPath && *psczFullPath);
+    Assert(psczFullPath);
    HRESULT hr = S_OK;
    LPWSTR wzFullPath = *psczFullPath;
    BOOL fFullyQualified = FALSE;
    BOOL fHasPrefix = FALSE;
+    BOOL fUNC = FALSE;
    SIZE_T cbFullPath = 0;
-    fFullyQualified = PathIsFullyQualified(wzFullPath, &fHasPrefix);
+    PathSkipPastRoot(wzFullPath, &fHasPrefix, &fFullyQualified, &fUNC);
    if (fHasPrefix)
    {
        ExitFunction();
    }
-    if (fFullyQualified && L':' == wzFullPath[1]) // normal path
+    // The prefix is only allowed on fully qualified paths.
+    if (!fFullyQualified)
    {
-        hr = StrAllocPrefix(psczFullPath, L"\\\\?\\", 4);
+        if (dwPrefixFlags & PATH_PREFIX_EXPECT_FULLY_QUALIFIED)
-        PathExitOnFailure(hr, "Failed to add prefix to file path.");
+        {
+            PathExitWithRootFailure(hr, E_INVALIDARG, "Expected fully qualified path provided to prefix: %ls.", wzFullPath);
+        }
+        ExitFunction();
+    }
+    if (!(dwPrefixFlags & PATH_PREFIX_SHORT_PATHS))
+    {
+        // The prefix is not necessary unless the path is longer than MAX_PATH.
+        if (!cchFullPath)
+        {
+            hr = ::StringCchLengthW(wzFullPath, STRSAFE_MAX_CCH, reinterpret_cast<size_t*>(&cchFullPath));
+            PathExitOnFailure(hr, "Failed to get length of path to prefix.");
+        }
+        if (MAX_PATH >= cchFullPath)
+        {
+            ExitFunction();
+        }
    }
-    else if (fFullyQualified && IsPathSeparatorChar(wzFullPath[1])) // UNC
+    if (fUNC)
    {
        hr = StrSize(*psczFullPath, &cbFullPath);
        PathExitOnFailure(hr, "Failed to get size of full path.");
@@ -352,10 +386,10 @@ DAPI_(HRESULT) PathPrefix(
        hr = StrAllocPrefix(psczFullPath, L"\\\\?\\UNC", 7);
        PathExitOnFailure(hr, "Failed to add prefix to UNC path.");
    }
-    else
+    else // must be a normal path
    {
-        hr = E_INVALIDARG;
+        hr = StrAllocPrefix(psczFullPath, L"\\\\?\\", 4);
-        PathExitOnFailure(hr, "Invalid path provided to prefix: %ls.", wzFullPath);
+        PathExitOnFailure(hr, "Failed to add prefix to file path.");
    }
 LExit:
@@ -970,55 +1004,114 @@ LExit:
 }
-DAPI_(BOOL) PathIsFullyQualified(
+DAPI_(LPCWSTR) PathSkipPastRoot(
-    __in_z LPCWSTR wzPath,
+    __in_z_opt LPCWSTR wzPath,
-    __out_opt BOOL* pfHasLongPathPrefix
+    __out_opt BOOL* pfHasExtendedPrefix,
+    __out_opt BOOL* pfFullyQualified,
+    __out_opt BOOL* pfUNC
    )
 {
+    LPCWSTR wzPastRoot = NULL;
+    BOOL fHasPrefix = FALSE;
    BOOL fFullyQualified = FALSE;
-    BOOL fHasLongPathPrefix = FALSE;
+    BOOL fUNC = FALSE;
+    DWORD dwRootMissingSlashes = 0;
-    if (!wzPath || !wzPath[0] || !wzPath[1])
+    if (!wzPath || !*wzPath)
    {
-        // There is no way to specify a fully qualified path with one character (or less).
        ExitFunction();
    }
-    if (!IsPathSeparatorChar(wzPath[0]))
+    if (IsPathSeparatorChar(wzPath[0]))
    {
-        // The only way to specify a fully qualified path that doesn't begin with a slash
+        if (IsPathSeparatorChar(wzPath[1]) && (L'?' == wzPath[2] || L'.' == wzPath[2]) && IsPathSeparatorChar(wzPath[3]) ||
-        // is the drive, colon, slash format (C:\).
+            L'?' == wzPath[1] && L'?' == wzPath[2] && IsPathSeparatorChar(wzPath[3]))
-        if (IsValidDriveChar(wzPath[0]) &&
-            L':' == wzPath[1] &&
-            IsPathSeparatorChar(wzPath[2]))
        {
-            fFullyQualified = TRUE;
+            fHasPrefix = TRUE;
-        }
-        ExitFunction();
+            if (L'U' == wzPath[4] && L'N' == wzPath[5] && L'C' == wzPath[6] && IsPathSeparatorChar(wzPath[7]))
+            {
+                fUNC = TRUE;
+                wzPastRoot = wzPath + 8;
+                dwRootMissingSlashes = 2;
+            }
+            else
+            {
+                wzPastRoot = wzPath + 4;
+                dwRootMissingSlashes = 1;
+            }
+        }
+        else if (IsPathSeparatorChar(wzPath[1]))
+        {
+            fUNC = TRUE;
+            wzPastRoot = wzPath + 2;
+            dwRootMissingSlashes = 2;
+        }
    }
-    // Non-drive fully qualified paths must start with \\ or \?.
+    if (dwRootMissingSlashes)
-    // \??\ is an archaic form of \\?\.
-    if (L'?' != wzPath[1] && !IsPathSeparatorChar(wzPath[1]))
    {
-        ExitFunction();
+        Assert(wzPastRoot);
+        fFullyQualified = TRUE;
+        for (; *wzPastRoot && dwRootMissingSlashes; ++wzPastRoot)
+        {
+            if (IsPathSeparatorChar(*wzPastRoot))
+            {
+                --dwRootMissingSlashes;
+            }
+        }
    }
+    else
+    {
+        Assert(!wzPastRoot);
-    fFullyQualified = TRUE;
+        if (IsPathSeparatorChar(wzPath[0]))
+        {
+            wzPastRoot = wzPath + 1;
+        }
+        else if (IsValidDriveChar(wzPath[0]) && wzPath[1] == L':')
+        {
+            if (IsPathSeparatorChar(wzPath[2]))
+            {
+                fFullyQualified = TRUE;
+                wzPastRoot = wzPath + 3;
+            }
+            else
+            {
+                wzPastRoot = wzPath + 2;
+            }
+        }
+    }
-    if (L'?' == wzPath[2] && IsPathSeparatorChar(wzPath[3]))
+LExit:
+    if (pfHasExtendedPrefix)
    {
-        fHasLongPathPrefix = TRUE;
+        *pfHasExtendedPrefix = fHasPrefix;
    }
+    if (pfFullyQualified)
+    {
+        *pfFullyQualified = fFullyQualified;
+    }
-LExit:
+    if (pfUNC)
-    if (pfHasLongPathPrefix)
    {
-        *pfHasLongPathPrefix = fHasLongPathPrefix;
+        *pfUNC = fUNC;
    }
+    return wzPastRoot;
+}
+DAPI_(BOOL) PathIsFullyQualified(
+    __in_z LPCWSTR wzPath
+    )
+{
+    BOOL fFullyQualified = FALSE;
+    PathSkipPastRoot(wzPath, NULL, &fFullyQualified, NULL);
    return fFullyQualified;
 }
@@ -1027,9 +1120,7 @@ DAPI_(BOOL) PathIsRooted(
    __in_z LPCWSTR wzPath
    )
 {
-    return wzPath &&
+    return NULL != PathSkipPastRoot(wzPath, NULL, NULL, NULL);
-        (IsPathSeparatorChar(wzPath[0]) ||
-        IsValidDriveChar(wzPath[0]) && wzPath[1] == L':');
 }
@@ -1118,78 +1209,47 @@ DAPI_(HRESULT) PathGetHierarchyArray(
    )
 {
    HRESULT hr = S_OK;
-    LPWSTR sczPathCopy = NULL;
+    LPCWSTR wz = NULL;
-    LPWSTR sczNewPathCopy = NULL;
+    SIZE_T cch = 0;
-    DWORD cArraySpacesNeeded = 0;
+    *pcPathArray = 0;
-    size_t cchPath = 0;
-    hr = ::StringCchLengthW(wzPath, STRSAFE_MAX_LENGTH, &cchPath);
+    PathExitOnNull(wzPath, hr, E_INVALIDARG, "wzPath is required.");
-    PathExitOnRootFailure(hr, "Failed to get string length of path: %ls", wzPath);
-    if (!cchPath)
+    wz = PathSkipPastRoot(wzPath, NULL, NULL, NULL);
+    if (wz)
    {
-        ExitFunction1(hr = E_INVALIDARG);
+        cch = wz - wzPath;
-    }
-    for (size_t i = 0; i < cchPath; ++i)
+        hr = MemEnsureArraySize(reinterpret_cast<void**>(prgsczPathArray), 1, sizeof(LPWSTR), 5);
-    {
+        PathExitOnFailure(hr, "Failed to allocate array.");
-        if (IsPathSeparatorChar(wzPath[i]))
-        {
-            ++cArraySpacesNeeded;
-        }
-    }
-    if (!IsPathSeparatorChar(wzPath[cchPath - 1]))
+        hr = StrAllocString(*prgsczPathArray, wzPath, cch);
-    {
+        PathExitOnFailure(hr, "Failed to copy root into array.");
-        ++cArraySpacesNeeded;
-    }
-    // If it's a UNC path, cut off the first three paths, 2 because it starts with a double backslash, and another because the first ("\\servername\") isn't a path.
+        *pcPathArray += 1;
-    if (IsPathSeparatorChar(wzPath[0]) && IsPathSeparatorChar(wzPath[1]))
+    }
+    else
    {
-        if (3 > cArraySpacesNeeded)
+        wz = wzPath;
-        {
-            ExitFunction1(hr = E_INVALIDARG);
-        }
-        cArraySpacesNeeded -= 3;
    }
-    Assert(cArraySpacesNeeded >= 1);
+    for (; *wz; ++wz)
-    hr = MemEnsureArraySize(reinterpret_cast<void **>(prgsczPathArray), cArraySpacesNeeded, sizeof(LPWSTR), 0);
-    PathExitOnFailure(hr, "Failed to allocate array of size %u for parent directories", cArraySpacesNeeded);
-    *pcPathArray = cArraySpacesNeeded;
-    hr = StrAllocString(&sczPathCopy, wzPath, 0);
-    PathExitOnFailure(hr, "Failed to allocate copy of original path");
-    for (DWORD i = 0; i < cArraySpacesNeeded; ++i)
    {
-        hr = StrAllocString((*prgsczPathArray) + cArraySpacesNeeded - 1 - i, sczPathCopy, 0);
+        ++cch;
-        PathExitOnFailure(hr, "Failed to copy path");
-        DWORD cchPathCopy = lstrlenW(sczPathCopy);
+        if (IsPathSeparatorChar(*wz) || !wz[1])
-        // If it ends in a backslash, it's a directory path, so cut off everything the last backslash before we get the directory portion of the path
-        if (IsPathSeparatorChar(wzPath[cchPathCopy - 1]))
        {
-            sczPathCopy[cchPathCopy - 1] = L'\0';
+            hr = MemEnsureArraySizeForNewItems(reinterpret_cast<void**>(prgsczPathArray), *pcPathArray, 1, sizeof(LPWSTR), 5);
-        }
+            PathExitOnFailure(hr, "Failed to allocate array.");
-        
-        hr = PathGetDirectory(sczPathCopy, &sczNewPathCopy);
-        PathExitOnFailure(hr, "Failed to get directory portion of path");
-        ReleaseStr(sczPathCopy);
+            hr = StrAllocString(*prgsczPathArray + *pcPathArray, wzPath, cch);
-        sczPathCopy = sczNewPathCopy;
+            PathExitOnFailure(hr, "Failed to copy path into array.");
-        sczNewPathCopy = NULL;
-    }
-    hr = S_OK;
+            *pcPathArray += 1;
+        }
+    }
 LExit:
-    ReleaseStr(sczPathCopy);
    return hr;
 }
author	Sean Hall <r.sean.hall@gmail.com>	2022-06-03 17:48:39 -0500
committer	Sean Hall <r.sean.hall@gmail.com>	2022-06-07 19:44:36 -0500
commit	6b0f2d978504da82070523eb6adb0b59f9812e93 (patch)
tree	6f0b258519a0f51bf589e4313206b3ffeaa32a41 /src/libs/dutil/WixToolset.DUtil
parent	b652e93a460b4b822a01382e5992f96f1d805ffe (diff)
download	wix-6b0f2d978504da82070523eb6adb0b59f9812e93.tar.gz wix-6b0f2d978504da82070523eb6adb0b59f9812e93.tar.bz2 wix-6b0f2d978504da82070523eb6adb0b59f9812e93.zip