3 files changed, 307 insertions, 69 deletions

diff --git a/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h b/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h
index 602b4a80..fc6bb3bb 100644
--- a/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h
+++ b/src/libs/dutil/WixToolset.DUtil/inc/pathutil.h
@@ -6,7 +6,17 @@
 extern "C" {
 #endif
 
-typedef enum PATH_EXPAND
+typedef enum _PATH_CANONICALIZE
+{
+    // Always prefix fully qualified paths with the long path prefix (\\?\).
+    PATH_CANONICALIZE_APPEND_LONG_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.
+    PATH_CANONICALIZE_KEEP_UNC_ROOT = 0x0004,
+} PATH_CANONICALIZE;
+
+typedef enum _PATH_EXPAND
 {
     PATH_EXPAND_ENVIRONMENT = 0x0001,
     PATH_EXPAND_FULLPATH    = 0x0002,
@@ -29,7 +39,9 @@ DAPI_(LPCWSTR) PathExtension(
     );
 
 /*******************************************************************
- PathGetDirectory - extracts the directory from a path.
+ 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.
+                    Returns S_FALSE if the path only contains a file name.
 ********************************************************************/
 DAPI_(HRESULT) PathGetDirectory(
     __in_z LPCWSTR wzPath,
@@ -38,6 +50,7 @@ DAPI_(HRESULT) PathGetDirectory(
 
 /*******************************************************************
 PathGetParentPath - extracts the parent directory from a full path.
+                    *psczDirectory is NULL if the path only contains a file name.
 ********************************************************************/
 DAPI_(HRESULT) PathGetParentPath(
     __in_z LPCWSTR wzPath,
@@ -63,6 +76,21 @@ DAPI_(HRESULT) PathPrefix(
     );
 
 /*******************************************************************
+ PathFixedNormalizeSlashes - replaces all / with \ and
+    removes redundant consecutive slashes.
+********************************************************************/
+DAPI_(HRESULT) PathFixedNormalizeSlashes(
+    __inout_z LPWSTR wzPath
+    );
+
+/*******************************************************************
+ PathFixedReplaceForwardSlashes - replaces all / with \
+********************************************************************/
+DAPI_(void) PathFixedReplaceForwardSlashes(
+    __inout_z LPWSTR wzPath
+    );
+
+/*******************************************************************
  PathFixedBackslashTerminate - appends a \ if path does not have it
                                  already, but fails if the buffer is
                                  insufficient.
@@ -77,7 +105,7 @@ DAPI_(HRESULT) PathFixedBackslashTerminate(
                                  already.
 ********************************************************************/
 DAPI_(HRESULT) PathBackslashTerminate(
-    __inout LPWSTR* psczPath
+    __inout_z LPWSTR* psczPath
     );
 
 /*******************************************************************
@@ -168,7 +196,7 @@ DAPI_(HRESULT) PathGetKnownFolder(
 /*******************************************************************
  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, \\server\share, \\?\C:\dir.
+    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(
@@ -179,7 +207,7 @@ DAPI_(BOOL) PathIsFullyQualified(
 /*******************************************************************
  PathIsRooted - returns true if the path is rooted; false otherwise.
     Note that some rooted paths like C:dir are not fully qualified.
-    For example, these are all rooted: C:\dir, C:dir, C:, \dir, \\server\share, \\?\C:\dir.
+    For example, these are all rooted: C:\dir, C:/dir, C:dir, C:, \dir, \\server\share, \\?\C:\dir.
     For example, these are not rooted: dir, dir\subdir.
 *******************************************************************/
 DAPI_(BOOL) PathIsRooted(
@@ -240,7 +268,7 @@ DAPI_(HRESULT) PathGetHierarchyArray(
     );
 
 /*******************************************************************
-  PathCanonicalizePath - wrapper around PathCanonicalizeW.
+ PathCanonicalizePath - wrapper around PathCanonicalizeW.
 *******************************************************************/
 DAPI_(HRESULT) PathCanonicalizePath(
     __in_z LPCWSTR wzPath,
@@ -248,8 +276,20 @@ DAPI_(HRESULT) PathCanonicalizePath(
     );
 
 /*******************************************************************
-PathDirectoryContainsPath - checks if wzPath is located inside
-                            wzDirectory.
+ PathCanonicalizeForComparison - canonicalizes the path based on the given flags.
+    . and .. directories are collapsed.
+    All / are replaced with \.
+    All redundant consecutive slashes are replaced with a single \.
+*******************************************************************/
+DAPI_(HRESULT) PathCanonicalizeForComparison(
+    __in_z LPCWSTR wzPath,
+    __in DWORD dwCanonicalizeFlags,
+    __deref_out_z LPWSTR* psczCanonicalized
+    );
+
+/*******************************************************************
+ PathDirectoryContainsPath - checks if wzPath is located inside wzDirectory.
+    wzDirectory must be a fully qualified path.
 *******************************************************************/
 DAPI_(HRESULT) PathDirectoryContainsPath(
     __in_z LPCWSTR wzDirectory,
diff --git a/src/libs/dutil/WixToolset.DUtil/path2utl.cpp b/src/libs/dutil/WixToolset.DUtil/path2utl.cpp
index ff3a946d..45157d0b 100644
--- a/src/libs/dutil/WixToolset.DUtil/path2utl.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/path2utl.cpp
@@ -9,6 +9,7 @@
 #define PathExitWithLastError(x, s, ...) ExitWithLastErrorSource(DUTIL_SOURCE_PATHUTIL, x, s, __VA_ARGS__)
 #define PathExitOnFailure(x, s, ...) ExitOnFailureSource(DUTIL_SOURCE_PATHUTIL, x, s, __VA_ARGS__)
 #define PathExitOnRootFailure(x, s, ...) ExitOnRootFailureSource(DUTIL_SOURCE_PATHUTIL, x, s, __VA_ARGS__)
+#define PathExitWithRootFailure(x, e, s, ...) ExitWithRootFailureSource(DUTIL_SOURCE_PATHUTIL, x, e, s, __VA_ARGS__)
 #define PathExitOnFailureDebugTrace(x, s, ...) ExitOnFailureDebugTraceSource(DUTIL_SOURCE_PATHUTIL, x, s, __VA_ARGS__)
 #define PathExitOnNull(p, x, e, s, ...) ExitOnNullSource(DUTIL_SOURCE_PATHUTIL, p, x, e, s, __VA_ARGS__)
 #define PathExitOnNullWithLastError(p, x, s, ...) ExitOnNullWithLastErrorSource(DUTIL_SOURCE_PATHUTIL, p, x, s, __VA_ARGS__)
@@ -42,63 +43,141 @@ LExit:
     return hr;
 }
 
-DAPI_(HRESULT) PathDirectoryContainsPath(
-    __in_z LPCWSTR wzDirectory,
-    __in_z LPCWSTR wzPath
+DAPI_(HRESULT) PathCanonicalizeForComparison(
+    __in_z LPCWSTR wzPath,
+    __in DWORD dwCanonicalizeFlags,
+    __deref_out_z LPWSTR* psczCanonicalized
     )
 {
     HRESULT hr = S_OK;
-    LPWSTR sczPath = NULL;
-    LPWSTR sczDirectory = NULL;
-    LPWSTR sczOriginalPath = NULL;
-    LPWSTR sczOriginalDirectory = NULL;
+    LPWSTR sczNormalizedPath = NULL;
+    LPCWSTR wzNormalizedPath = NULL;
+    SIZE_T cchUncRootLength = 0;
+    BOOL fHasPrefix = FALSE;
 
-    hr = PathCanonicalizePath(wzPath, &sczOriginalPath);
-    PathExitOnFailure(hr, "Failed to canonicalize the path.");
+    hr = StrAllocString(&sczNormalizedPath, wzPath, 0);
+    PathExitOnFailure(hr, "Failed to allocate string for the normalized path.");
 
-    hr = PathCanonicalizePath(wzDirectory, &sczOriginalDirectory);
-    PathExitOnFailure(hr, "Failed to canonicalize the directory.");
+    PathFixedNormalizeSlashes(sczNormalizedPath);
+
+    wzNormalizedPath = sczNormalizedPath;
 
-    if (!sczOriginalPath || !*sczOriginalPath)
+    if (PATH_CANONICALIZE_KEEP_UNC_ROOT & dwCanonicalizeFlags)
     {
-        ExitFunction1(hr = S_FALSE);
+        if (L'\\' == sczNormalizedPath[0] && (L'\\' == sczNormalizedPath[1] || L'?' == sczNormalizedPath[1]) && L'?' == sczNormalizedPath[2] && L'\\' == sczNormalizedPath[3])
+        {
+            if (L'U' == sczNormalizedPath[4] && L'N' == sczNormalizedPath[5] && L'C' == sczNormalizedPath[6] && L'\\' == sczNormalizedPath[7])
+            {
+                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;
+                }
+            }
+        }
+    }
+
+    if (*wzNormalizedPath)
+    {
+        hr = PathCanonicalizePath(wzNormalizedPath, psczCanonicalized);
+        PathExitOnFailure(hr, "Failed to canonicalize: %ls", wzNormalizedPath);
     }
-    if (!sczOriginalDirectory || !*sczOriginalDirectory)
+    else
     {
-        ExitFunction1(hr = S_FALSE);
+        Assert(cchUncRootLength);
+        ReleaseStr(*psczCanonicalized);
+        *psczCanonicalized = sczNormalizedPath;
+        sczNormalizedPath = NULL;
+        cchUncRootLength = 0;
     }
 
-    sczPath = sczOriginalPath;
-    sczDirectory = sczOriginalDirectory;
+    if (cchUncRootLength)
+    {
+        hr = StrAllocPrefix(psczCanonicalized, sczNormalizedPath, cchUncRootLength);
+        PathExitOnFailure(hr, "Failed to prefix the UNC root to the canonicalized path.");
+    }
 
-    for (; *sczDirectory;)
+    if (PATH_CANONICALIZE_BACKSLASH_TERMINATE & dwCanonicalizeFlags)
     {
-        if (!*sczPath)
-        {
-            ExitFunction1(hr = S_FALSE);
-        }
+        hr = PathBackslashTerminate(psczCanonicalized);
+        PathExitOnFailure(hr, "Failed to backslash terminate the canonicalized path");
+    }
 
-        if (CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, sczDirectory, 1, sczPath, 1))
-        {
-            ExitFunction1(hr = S_FALSE);
-        }
+    if ((PATH_CANONICALIZE_APPEND_LONG_PATH_PREFIX & dwCanonicalizeFlags) &&
+        PathIsFullyQualified(*psczCanonicalized, &fHasPrefix) && !fHasPrefix)
+    {
+        hr = PathPrefix(psczCanonicalized);
+        PathExitOnFailure(hr, "Failed to ensure the long path prefix on the canonicalized path");
+    }
+
+LExit:
+    ReleaseStr(sczNormalizedPath);
 
-        ++sczDirectory;
-        ++sczPath;
+    return hr;
+}
+
+DAPI_(HRESULT) PathDirectoryContainsPath(
+    __in_z LPCWSTR wzDirectory,
+    __in_z LPCWSTR wzPath
+    )
+{
+    HRESULT hr = S_OK;
+    LPWSTR sczCanonicalizedDirectory = NULL;
+    LPWSTR sczCanonicalizedPath = NULL;
+    DWORD dwDefaultFlags = PATH_CANONICALIZE_APPEND_LONG_PATH_PREFIX | PATH_CANONICALIZE_KEEP_UNC_ROOT;
+    size_t cchDirectory = 0;
+
+    if (!wzDirectory || !*wzDirectory)
+    {
+        PathExitWithRootFailure(hr, E_INVALIDARG, "wzDirectory is required.");
     }
+    if (!wzPath || !*wzPath)
+    {
+        PathExitWithRootFailure(hr, E_INVALIDARG, "wzPath is required.");
+    }
+
+    hr = PathCanonicalizeForComparison(wzDirectory, dwDefaultFlags | PATH_CANONICALIZE_BACKSLASH_TERMINATE, &sczCanonicalizedDirectory);
+    PathExitOnFailure(hr, "Failed to canonicalize the directory.");
 
-    --sczDirectory;
-    if (('\\' == *sczDirectory && *sczPath) || '\\' == *sczPath)
+    hr = PathCanonicalizeForComparison(wzPath, dwDefaultFlags, &sczCanonicalizedPath);
+    PathExitOnFailure(hr, "Failed to canonicalize the path.");
+
+    if (!PathIsFullyQualified(sczCanonicalizedDirectory, NULL))
     {
-        hr = S_OK;
+        PathExitWithRootFailure(hr, E_INVALIDARG, "wzDirectory must be a fully qualified path.");
     }
-    else
+    if (!sczCanonicalizedPath || !*sczCanonicalizedPath)
     {
-        hr = S_FALSE;
+        ExitFunction1(hr = S_FALSE);
     }
 
+    hr = ::StringCchLengthW(sczCanonicalizedDirectory, STRSAFE_MAX_CCH, &cchDirectory);
+    PathExitOnFailure(hr, "Failed to get length of canonicalized directory.");
+
+    if (CSTR_EQUAL != ::CompareStringW(LOCALE_NEUTRAL, NORM_IGNORECASE, sczCanonicalizedDirectory, (DWORD)cchDirectory, sczCanonicalizedPath, (DWORD)cchDirectory))
+    {
+        ExitFunction1(hr = S_FALSE);
+    }
+
+    hr = sczCanonicalizedPath[cchDirectory] ? S_OK : S_FALSE;
+
 LExit:
-    ReleaseStr(sczOriginalPath);
-    ReleaseStr(sczOriginalDirectory);
+    ReleaseStr(sczCanonicalizedPath);
+    ReleaseStr(sczCanonicalizedDirectory);
     return hr;
 }
diff --git a/src/libs/dutil/WixToolset.DUtil/pathutil.cpp b/src/libs/dutil/WixToolset.DUtil/pathutil.cpp
index 314eab85..99be003c 100644
--- a/src/libs/dutil/WixToolset.DUtil/pathutil.cpp
+++ b/src/libs/dutil/WixToolset.DUtil/pathutil.cpp
@@ -20,6 +20,9 @@
 
 #define PATH_GOOD_ENOUGH 64
 
+static BOOL IsPathSeparatorChar(
+    __in WCHAR wc
+    );
 static BOOL IsValidDriveChar(
     __in WCHAR wc
     );
@@ -41,7 +44,7 @@ DAPI_(LPWSTR) PathFile(
         //     \ => Windows path
         //     / => unix and URL path
         //     : => relative path from mapped root
-        if (L'\\' == *wz || L'/' == *wz || (L':' == *wz && wz == wzPath + 1))
+        if (IsPathSeparatorChar(*wz) || (L':' == *wz && wz == wzPath + 1))
         {
             wzFile = wz + 1;
         }
@@ -64,7 +67,7 @@ DAPI_(LPCWSTR) PathExtension(
     LPCWSTR wzExtension = NULL;
     for (LPCWSTR wz = wzPath; *wz; ++wz)
     {
-        if (L'\\' == *wz || L'/' == *wz || L':' == *wz)
+        if (IsPathSeparatorChar(*wz) || L':' == *wz)
         {
             wzExtension = NULL;
         }
@@ -84,7 +87,8 @@ DAPI_(HRESULT) PathGetDirectory(
     )
 {
     HRESULT hr = S_OK;
-    size_t cchDirectory = SIZE_T_MAX;
+    LPCWSTR wzRemaining = NULL;
+    SIZE_T cchDirectory = 0;
 
     for (LPCWSTR wz = wzPath; *wz; ++wz)
     {
@@ -92,18 +96,20 @@ DAPI_(HRESULT) PathGetDirectory(
         //     \ => Windows path
         //     / => unix and URL path
         //     : => relative path from mapped root
-        if (L'\\' == *wz || L'/' == *wz || (L':' == *wz && wz == wzPath + 1))
+        if (IsPathSeparatorChar(*wz) || (L':' == *wz && wz == wzPath + 1))
         {
-            cchDirectory = static_cast<size_t>(wz - wzPath) + 1;
+            wzRemaining = wz;
         }
     }
 
-    if (SIZE_T_MAX == cchDirectory)
+    if (!wzRemaining)
     {
         // we were given just a file name, so there's no directory available
-        return S_FALSE;
+        ExitFunction1(hr = S_FALSE);
     }
 
+    cchDirectory = static_cast<SIZE_T>(wzRemaining - wzPath) + 1;
+
     hr = StrAllocString(psczDirectory, wzPath, cchDirectory);
     PathExitOnFailure(hr, "Failed to copy directory.");
 
@@ -122,7 +128,7 @@ DAPI_(HRESULT) PathGetParentPath(
 
     for (LPCWSTR wz = wzPath; *wz; ++wz)
     {
-        if (wz[1] && (L'\\' == *wz || L'/' == *wz))
+        if (IsPathSeparatorChar(*wz) && wz[1])
         {
             wzParent = wz;
         }
@@ -291,12 +297,13 @@ DAPI_(HRESULT) PathPrefix(
         hr = StrAllocPrefix(psczFullPath, L"\\\\?\\", 4);
         PathExitOnFailure(hr, "Failed to add prefix to file path.");
     }
-    else if (fFullyQualified && L'\\' == wzFullPath[1]) // UNC
+    else if (fFullyQualified && IsPathSeparatorChar(wzFullPath[1])) // UNC
     {
         hr = StrSize(*psczFullPath, &cbFullPath);
         PathExitOnFailure(hr, "Failed to get size of full path.");
 
         memmove_s(wzFullPath, cbFullPath, wzFullPath + 1, cbFullPath - sizeof(WCHAR));
+        wzFullPath[0] = L'\\';
 
         hr = StrAllocPrefix(psczFullPath, L"\\\\?\\UNC", 7);
         PathExitOnFailure(hr, "Failed to add prefix to UNC path.");
@@ -312,6 +319,90 @@ LExit:
 }
 
 
+DAPI_(HRESULT) PathFixedNormalizeSlashes(
+    __inout_z LPWSTR wzPath
+    )
+{
+    HRESULT hr = S_OK;
+    size_t cchLength = 0;
+    BOOL fAllowDoubleSlash = FALSE;
+    SIZE_T iSource = 0;
+    SIZE_T jDestination = 0;
+
+    hr = ::StringCchLengthW(wzPath, STRSAFE_MAX_CCH, &cchLength);
+    PathExitOnFailure(hr, "Failed to get length of path.");
+
+    if (1 < cchLength && IsPathSeparatorChar(wzPath[0]))
+    {
+        if (IsPathSeparatorChar(wzPath[1]))
+        {
+            // \\?\\a\ is not equivalent to \\?\a\ and \\server\\a\ is not equivalent to \\server\a\.
+            fAllowDoubleSlash = TRUE;
+            wzPath[0] = '\\';
+            wzPath[1] = '\\';
+            iSource = 2;
+            jDestination = 2;
+        }
+        else if (2 < cchLength && L'?' == wzPath[1] && L'?' == wzPath[2])
+        {
+            // \??\\a\ is not equivalent to \??\a\.
+            fAllowDoubleSlash = TRUE;
+            wzPath[0] = '\\';
+            wzPath[1] = '?';
+            wzPath[2] = '?';
+            iSource = 3;
+            jDestination = 3;
+        }
+    }
+
+    for (; iSource < cchLength; ++iSource)
+    {
+        if (IsPathSeparatorChar(wzPath[iSource]))
+        {
+            if (fAllowDoubleSlash)
+            {
+                fAllowDoubleSlash = FALSE;
+            }
+            else if (IsPathSeparatorChar(wzPath[iSource + 1]))
+            {
+                // Skip consecutive slashes.
+                continue;
+            }
+
+            wzPath[jDestination] = '\\';
+        }
+        else
+        {
+            wzPath[jDestination] = wzPath[iSource];
+        }
+
+        ++jDestination;
+    }
+
+    for (; jDestination < cchLength; ++jDestination)
+    {
+        wzPath[jDestination] = '\0';
+    }
+
+LExit:
+    return hr;
+}
+
+
+DAPI_(void) PathFixedReplaceForwardSlashes(
+    __inout_z LPWSTR wzPath
+    )
+{
+    for (LPWSTR wz = wzPath; *wz; ++wz)
+    {
+        if (L'/' == *wz)
+        {
+            *wz = L'\\';
+        }
+    }
+}
+
+
 DAPI_(HRESULT) PathFixedBackslashTerminate(
     __inout_ecount_z(cchPath) LPWSTR wzPath,
     __in SIZE_T cchPath
@@ -320,17 +411,28 @@ DAPI_(HRESULT) PathFixedBackslashTerminate(
     HRESULT hr = S_OK;
     size_t cchLength = 0;
 
+    if (!cchPath)
+    {
+        ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER));
+    }
+
     hr = ::StringCchLengthW(wzPath, cchPath, &cchLength);
     PathExitOnFailure(hr, "Failed to get length of path.");
 
-    if (cchLength >= cchPath)
+    LPWSTR wzLast = wzPath + (cchLength - 1);
+    if (cchLength && L'/' == wzLast[0])
     {
-        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
+        wzLast[0] = L'\\';
     }
-    else if (L'\\' != wzPath[cchLength - 1])
+    else if (!cchLength || L'\\' != wzLast[0])
     {
-        wzPath[cchLength] = L'\\';
-        wzPath[cchLength + 1] = L'\0';
+        if (cchLength + 2 > cchPath)
+        {
+            ExitFunction1(hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER));
+        }
+
+        wzLast[1] = L'\\';
+        wzLast[2] = L'\0';
     }
 
 LExit:
@@ -339,10 +441,10 @@ LExit:
 
 
 DAPI_(HRESULT) PathBackslashTerminate(
-    __inout LPWSTR* psczPath
+    __inout_z LPWSTR* psczPath
     )
 {
-    Assert(psczPath && *psczPath);
+    Assert(psczPath);
 
     HRESULT hr = S_OK;
     SIZE_T cchPath = 0;
@@ -354,7 +456,12 @@ DAPI_(HRESULT) PathBackslashTerminate(
     hr = ::StringCchLengthW(*psczPath, cchPath, &cchLength);
     PathExitOnFailure(hr, "Failed to get length of path.");
 
-    if (L'\\' != (*psczPath)[cchLength - 1])
+    LPWSTR wzLast = *psczPath + (cchLength - 1);
+    if (cchLength && L'/' == wzLast[0])
+    {
+        wzLast[0] = L'\\';
+    }
+    else if (!cchLength || L'\\' != wzLast[0])
     {
         hr = StrAllocConcat(psczPath, L"\\", 1);
         PathExitOnFailure(hr, "Failed to concat backslash onto string.");
@@ -833,13 +940,13 @@ DAPI_(BOOL) PathIsFullyQualified(
         ExitFunction();
     }
 
-    if (L'\\' != wzPath[0])
+    if (!IsPathSeparatorChar(wzPath[0]))
     {
         // The only way to specify a fully qualified path that doesn't begin with a slash
         // is the drive, colon, slash format (C:\).
         if (IsValidDriveChar(wzPath[0]) &&
             L':' == wzPath[1] &&
-            L'\\' == wzPath[2])
+            IsPathSeparatorChar(wzPath[2]))
         {
             fFullyQualified = TRUE;
         }
@@ -849,14 +956,14 @@ DAPI_(BOOL) PathIsFullyQualified(
 
     // Non-drive fully qualified paths must start with \\ or \?.
     // \??\ is an archaic form of \\?\.
-    if (L'?' != wzPath[1] && L'\\' != wzPath[1])
+    if (L'?' != wzPath[1] && !IsPathSeparatorChar(wzPath[1]))
     {
         ExitFunction();
     }
 
     fFullyQualified = TRUE;
 
-    if (L'?' == wzPath[2] && L'\\' == wzPath[3])
+    if (L'?' == wzPath[2] && IsPathSeparatorChar(wzPath[3]))
     {
         fHasLongPathPrefix = TRUE;
     }
@@ -877,7 +984,7 @@ DAPI_(BOOL) PathIsRooted(
     )
 {
     return wzPath &&
-        (wzPath[0] == L'\\' ||
+        (IsPathSeparatorChar(wzPath[0]) ||
         IsValidDriveChar(wzPath[0]) && wzPath[1] == L':');
 }
 
@@ -1008,20 +1115,25 @@ DAPI_(HRESULT) PathGetHierarchyArray(
 
     for (size_t i = 0; i < cchPath; ++i)
     {
-        if (wzPath[i] == L'\\')
+        if (IsPathSeparatorChar(wzPath[i]))
         {
             ++cArraySpacesNeeded;
         }
     }
 
-    if (wzPath[cchPath - 1] != L'\\')
+    if (!IsPathSeparatorChar(wzPath[cchPath - 1]))
     {
         ++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.
-    if (wzPath[0] == L'\\' && wzPath[1] == L'\\')
+    if (IsPathSeparatorChar(wzPath[0]) && IsPathSeparatorChar(wzPath[1]))
     {
+        if (3 > cArraySpacesNeeded)
+        {
+            ExitFunction1(hr = E_INVALIDARG);
+        }
+
         cArraySpacesNeeded -= 3;
     }
 
@@ -1042,7 +1154,7 @@ DAPI_(HRESULT) PathGetHierarchyArray(
         DWORD cchPathCopy = lstrlenW(sczPathCopy);
 
         // 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 (wzPath[cchPathCopy - 1] == L'\\')
+        if (IsPathSeparatorChar(wzPath[cchPathCopy - 1]))
         {
             sczPathCopy[cchPathCopy - 1] = L'\0';
         }
@@ -1063,6 +1175,13 @@ LExit:
     return hr;
 }
 
+static BOOL IsPathSeparatorChar(
+    __in WCHAR wc
+    )
+{
+    return L'/' == wc || L'\\' == wc;
+}
+
 static BOOL IsValidDriveChar(
     __in WCHAR wc
     )