Merge pull request #2410 from JeremyKuhne/AllowExtended

Allow extended syntax for paths

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[] { '?', '*' };