Allow extended syntax for paths

Start on unblocking extended syntax. Moves some shared code to PathInternal.
Start adding tests for key scenarios. Temporarily use local libraries when
testing FileSystem (until we get an updated Runtime.Extensions package).

Author: JeremyKuhne

src/Common/src/System/IO/PathInternal.Unix.cs

@@ -1,31 +1,45 @@
 // Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Diagnostics;
 using System.Diagnostics.Contracts;
 
 namespace System.IO
 {
     /// <summary>Contains internal path helpers that are shared between many projects.</summary>
     internal static partial class PathInternal
     {
+        // Therre is only one invalid path character in Unix
+        private const char InvalidPathChar = '\0';
+        internal static readonly char[] InvalidPathChars = { InvalidPathChar };
+
         /// <summary>Returns a value indicating if the given path contains invalid characters.</summary>
         internal static bool HasIllegalCharacters(string path, bool checkAdditional = false)
         {
             Contract.Requires(path != null);
 
             foreach (char c in path)
             {
-                // Same as Path.InvalidPathChars, unrolled here for performance
-                if (c == '\0')
+                // Same as InvalidPathChars, unrolled here for performance
+                if (c == InvalidPathChar)
                     return true;
-
-                // checkAdditional is meant to check for additional characters 
-                // permitted in a search path but disallowed in a normal path.
-                // In Windows this is * and ?,but Unix permits such characters
-                // in the filename so checkAdditional is ignored.
             }
 
             return false;
         }
+
+        internal static int GetRootLength(string path)
+        {
+            PathInternal.CheckInvalidPathChars(path);
+            return path.Length > 0 && IsDirectorySeparator(path[0]) ? 1 : 0;
+        }
+
+        internal static bool IsDirectorySeparator(char c)
+        {
+            // The alternatie directory separator char is the same as the directory separator,
+            // so we only need to check one.
+            Debug.Assert(Path.DirectorySeparatorChar == Path.AltDirectorySeparatorChar);
+            return c == Path.DirectorySeparatorChar;
+        }
     }
 }

src/Common/src/System/IO/PathInternal.Windows.cs

@@ -8,6 +8,29 @@ namespace System.IO
     /// <summary>Contains internal path helpers that are shared between many projects.</summary>
     internal static partial class PathInternal
     {
+        internal const string LongPathPrefix = @"\\?\";
+        internal const string UNCPathPrefix = @"\\";
+        internal const string UNCLongPathPrefixToInsert = @"?\UNC\";
+        internal const string UNCLongPathPrefix = @"\\?\UNC\";
+
+        internal static readonly char[] InvalidPathChars =
+        {
+            '\"', '<', '>', '|', '\0',
+            (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10,
+            (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17, (char)18, (char)19, (char)20,
+            (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30,
+            (char)31
+        };
+
+        internal static readonly char[] InvalidPathCharsWithAdditionalChecks = // This is used by HasIllegalCharacters
+        {
+            '\"', '<', '>', '|', '\0',
+            (char)1, (char)2, (char)3, (char)4, (char)5, (char)6, (char)7, (char)8, (char)9, (char)10,
+            (char)11, (char)12, (char)13, (char)14, (char)15, (char)16, (char)17, (char)18, (char)19, (char)20,
+            (char)21, (char)22, (char)23, (char)24, (char)25, (char)26, (char)27, (char)28, (char)29, (char)30,
+            (char)31, '*', '?'
+        };
+
         /// <summary>
         /// Returns a value indicating if the given path contains invalid characters (", &lt;, &gt;, | 
         /// NUL, or any ASCII char whose integer representation is in the range of 1 through 31), 
@@ -19,19 +42,67 @@ internal static bool HasIllegalCharacters(string path, bool checkAdditional = fa
 
             Contract.Requires(path != null);
 
-            foreach (char c in path)
+            // Question mark is a normal part of extended path syntax (\\?\)
+            int startIndex = path.StartsWith(LongPathPrefix, StringComparison.Ordinal) ? LongPathPrefix.Length : 0;
+            return path.IndexOfAny(checkAdditional ? InvalidPathCharsWithAdditionalChecks : InvalidPathChars, startIndex) >= 0;
+        }
+
+        /// <summary>
+        /// Gets the length of the root of the path (drive, share, etc.).
+        /// </summary>
+        internal static int GetRootLength(string path)
+        {
+            CheckInvalidPathChars(path);
+
+            int i = 0;
+            int length = path.Length;
+            int volumeSeparatorLength = 2;  // Length to the colon "C:"
+            int uncRootLength = 2;          // Length to the start of the server name "\\"
+
+            bool extendedSyntax = path.StartsWith(LongPathPrefix, StringComparison.Ordinal);
+            bool extendedUncSyntax = extendedSyntax && path.StartsWith(UNCLongPathPrefix, StringComparison.Ordinal);
+            if (extendedSyntax)
+            {
+                // Shift the position we look for the root from to account for the extended prefix
+                if (extendedUncSyntax)
+                {
+                    // "C:" -> "\\?\C:"
+                    uncRootLength = UNCLongPathPrefix.Length;
+                }
+                else
+                {
+                    // "\\" -> "\\?\UNC\"
+                    volumeSeparatorLength += LongPathPrefix.Length;
+                }
+            }
+
+            if ((!extendedSyntax || extendedUncSyntax) && length > 0 && IsDirectorySeparator(path[0]))
             {
-                // Note: Same as Path.InvalidPathChars, unrolled here for performance
-                if (c == '\"' || c == '<' || c == '>' || c == '|' || c < 32)
-                    return true;
-
-                // used when path cannot contain search strings.
-                if (checkAdditional &&
-                    (c == '?' || c == '*'))
-                    return true;
+                // UNC or simple rooted path (e.g. "\foo", NOT "\\?\C:\foo")
+
+                i = 1; //  Drive rooted (\foo) is one character
+                if (extendedUncSyntax || (length > 1 && (IsDirectorySeparator(path[1]))))
+                {
+                    // UNC (\\?\UNC\ or \\), scan past the next two directory separators at most
+                    // (e.g. to \\?\UNC\Server\Share or \\Server\Share\)
+                    i = uncRootLength;
+                    int n = 2; // Maximum separators to skip
+                    while (i < length && (!IsDirectorySeparator(path[i]) || --n > 0)) i++;
+                }
+            }
+            else if (length >= volumeSeparatorLength && path[volumeSeparatorLength - 1] == Path.VolumeSeparatorChar)
+            {
+                // Path is at least longer than where we expect a colon, and has a colon (\\?\A:, A:)
+                // If the colon is followed by a directory separator, move past it
+                i = volumeSeparatorLength;
+                if (length >= volumeSeparatorLength + 1 && (IsDirectorySeparator(path[volumeSeparatorLength]))) i++;
             }
+            return i;
+        }
 
-            return false;
+        internal static bool IsDirectorySeparator(char c)
+        {
+            return c == Path.DirectorySeparatorChar || c == Path.AltDirectorySeparatorChar;
         }
     }
 }

src/Common/src/System/IO/PathInternal.cs

@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Diagnostics.Contracts;
+
+namespace System.IO
+{
+    /// <summary>Contains internal path helpers that are shared between many projects.</summary>
+    internal static partial class PathInternal
+    {
+        /// <summary>
+        /// Checks for invalid path characters in the given path.
+        /// </summary>
+        /// <exception cref="System.ArgumentNullException">Thrown if the path is null.</exception>
+        /// <exception cref="System.ArgumentException">Thrown if the path has invalid characters.</exception>
+        /// <param name="path">The path to check for invalid characters.</param>
+        /// <param name="checkAdditional">Set to true to check for characters that are only valid in specific contexts (such as search characters on Windows).</param>
+        internal static void CheckInvalidPathChars(string path, bool checkAdditional = false)
+        {
+            if (path == null)
+                throw new ArgumentNullException("path");
+
+            if (PathInternal.HasIllegalCharacters(path, checkAdditional))
+                throw new ArgumentException(SR.Argument_InvalidPathChars, "path");
+        }
+    }
+}

src/System.IO.FileSystem.DriveInfo/src/Resources/Strings.resx

@@ -126,6 +126,9 @@
   <data name="Arg_InvalidDriveChars" xml:space="preserve">
     <value>Illegal characters in drive name '{0}'.</value>
   </data>
+  <data name="Argument_InvalidPathChars" xml:space="preserve">
+    <value>Illegal characters in path.</value>
+  </data>
   <data name="ArgumentOutOfRange_FileLengthTooBig" xml:space="preserve">
     <value>Specified file length was too large for the file system.</value>
   </data>

src/System.IO.FileSystem.DriveInfo/src/System.IO.FileSystem.DriveInfo.csproj

@@ -32,6 +32,9 @@
     <Compile Include="$(CommonPath)\System\__HResults.cs">
       <Link>Common\System\__HResults.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\System\IO\PathInternal.cs">
+      <Link>Common\System\IO\PathInternal.cs</Link>
+    </Compile>
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetsWindows)' == 'true' ">
     <Compile Include="System\IO\__Error.cs" />

src/System.IO.FileSystem/src/System.IO.FileSystem.csproj

@@ -52,6 +52,9 @@
     <Compile Include="$(CommonPath)\System\IO\StringBuilderCache.cs">
       <Link>Common\System\IO\StringBuilderCache.cs</Link>
     </Compile>
+    <Compile Include="$(CommonPath)\System\IO\PathInternal.cs">
+      <Link>Common\System\IO\PathInternal.cs</Link>
+    </Compile>
   </ItemGroup>
   <!-- Windows -->
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">

src/System.IO.FileSystem/src/System/IO/Directory.cs

@@ -486,15 +486,15 @@ public static String GetDirectoryRoot(String path)
             Contract.EndContractBlock();
 
             String fullPath = PathHelpers.GetFullPathInternal(path);
-            String root = fullPath.Substring(0, PathHelpers.GetRootLength(fullPath));
+            String root = fullPath.Substring(0, PathInternal.GetRootLength(fullPath));
 
             return root;
         }
 
         internal static String InternalGetDirectoryRoot(String path)
         {
             if (path == null) return null;
-            return path.Substring(0, PathHelpers.GetRootLength(path));
+            return path.Substring(0, PathInternal.GetRootLength(path));
         }
 
         /*===============================CurrentDirectory===============================

src/System.IO.FileSystem/src/System/IO/DirectoryInfo.cs

@@ -25,7 +25,7 @@ public DirectoryInfo(String path)
         [System.Security.SecuritySafeCritical]
         internal DirectoryInfo(String fullPath, IFileSystemObject fileSystemObject) : base(fileSystemObject)
         {
-            Debug.Assert(PathHelpers.GetRootLength(fullPath) > 0, "fullPath must be fully qualified!");
+            Debug.Assert(PathInternal.GetRootLength(fullPath) > 0, "fullPath must be fully qualified!");
 
             // Fast path when we know a DirectoryInfo exists.
             OriginalPath = Path.GetFileName(fullPath);

src/System.IO.FileSystem/src/System/IO/File.cs

@@ -195,7 +195,7 @@ public static bool Exists(String path)
                 // Otherwise, FillAttributeInfo removes it and we may return a false positive.
                 // GetFullPath should never return null
                 Debug.Assert(path != null, "File.Exists: GetFullPath returned null");
-                if (path.Length > 0 && PathHelpers.IsDirectorySeparator(path[path.Length - 1]))
+                if (path.Length > 0 && PathInternal.IsDirectorySeparator(path[path.Length - 1]))
                 {
                     return false;
                 }

src/System.IO.FileSystem/src/System/IO/FileStream.Win32.cs

@@ -24,14 +24,6 @@ static partial void ValidatePath(string fullPath, string paramName)
             // Prevent access to your disk drives as raw block devices.
             if (fullPath.StartsWith("\\\\.\\", StringComparison.Ordinal))
                 throw new ArgumentException(SR.Arg_DevicesNotSupported, paramName);
-
-            // Check for additional invalid characters.  Most invalid characters were checked above
-            // in our call to Path.GetFullPath(path);
-            if (fullPath.IndexOfAny(s_additionalInvalidChars) != -1)
-                throw new ArgumentException(SR.Argument_InvalidPathChars, paramName);
-
-            if (fullPath.IndexOf(':', 2) != -1)
-                throw new NotSupportedException(SR.Argument_PathFormatNotSupported);
         }
 
         private static readonly char[] s_additionalInvalidChars = new[] { '?', '*' };