Fix issues related to server share paths

src/libraries/Common/src/System/IO/FileSystem.Attributes.Windows.cs

@@ -64,19 +64,7 @@ internal static int FillAttributeInfo(string? path, ref Interop.Kernel32.WIN32_F
                 {
                     errorCode = Marshal.GetLastWin32Error();
 
-                    if (errorCode != Interop.Errors.ERROR_FILE_NOT_FOUND
-                        && errorCode != Interop.Errors.ERROR_PATH_NOT_FOUND
-                        && errorCode != Interop.Errors.ERROR_NOT_READY
-                        && errorCode != Interop.Errors.ERROR_INVALID_NAME
-                        && errorCode != Interop.Errors.ERROR_BAD_PATHNAME
-                        && errorCode != Interop.Errors.ERROR_BAD_NETPATH
-                        && errorCode != Interop.Errors.ERROR_BAD_NET_NAME
-                        && errorCode != Interop.Errors.ERROR_INVALID_PARAMETER
-                        && errorCode != Interop.Errors.ERROR_NETWORK_UNREACHABLE
-                        && errorCode != Interop.Errors.ERROR_NETWORK_ACCESS_DENIED
-                        && errorCode != Interop.Errors.ERROR_INVALID_HANDLE         // eg from \\.\CON
-                        && errorCode != Interop.Errors.ERROR_FILENAME_EXCED_RANGE   // Path is too long
-                        )
+                    if (!IsPathUnreachableError(errorCode))
                     {
                         // Assert so we can track down other cases (if any) to add to our test suite
                         Debug.Assert(errorCode == Interop.Errors.ERROR_ACCESS_DENIED || errorCode == Interop.Errors.ERROR_SHARING_VIOLATION || errorCode == Interop.Errors.ERROR_SEM_TIMEOUT,
@@ -127,5 +115,27 @@ internal static int FillAttributeInfo(string? path, ref Interop.Kernel32.WIN32_F
 
             return errorCode;
         }
+
+        internal static bool IsPathUnreachableError(int errorCode)
+        {
+            switch (errorCode)
+            {
+                case Interop.Errors.ERROR_FILE_NOT_FOUND:
+                case Interop.Errors.ERROR_PATH_NOT_FOUND:
+                case Interop.Errors.ERROR_NOT_READY:
+                case Interop.Errors.ERROR_INVALID_NAME:
+                case Interop.Errors.ERROR_BAD_PATHNAME:
+                case Interop.Errors.ERROR_BAD_NETPATH:
+                case Interop.Errors.ERROR_BAD_NET_NAME:
+                case Interop.Errors.ERROR_INVALID_PARAMETER:
+                case Interop.Errors.ERROR_NETWORK_UNREACHABLE:
+                case Interop.Errors.ERROR_NETWORK_ACCESS_DENIED:
+                case Interop.Errors.ERROR_INVALID_HANDLE:           // eg from \\.\CON
+                case Interop.Errors.ERROR_FILENAME_EXCED_RANGE:     // Path is too long
+                    return true;
+                default:
+                    return false;
+            }
+        }
     }
 }

src/libraries/System.IO.FileSystem/tests/Base/SymbolicLinks/BaseSymbolicLinks.FileSystem.cs

@@ -424,14 +424,26 @@ public static IEnumerable<object[]> ResolveLinkTarget_PathToTarget_Data
 
         internal static string[] PathToTargetData => new[]
         {
-            // Non-rooted relative
+            //Non-rooted relative
             "foo", ".\\foo", "..\\foo",
             // Rooted relative
             "\\foo",
             // Rooted absolute
             Path.Combine(Path.GetTempPath(), "foo"),
-            //Path.Combine(@"\\?\", Path.GetTempPath(), "foo"),
-            //@"\\server\share\path", @"\\.\pipe\foo",
+            Path.Combine(@"\\?\", Path.GetTempPath(), "foo"),
+            @"\\SERVER\share\path", @"\\.\pipe\foo",
         };
+
+        [Fact]
+        public void quicktest()
+        {
+            //Debugger.Launch();
+            var info = new DirectoryInfo(@"C:\\linktests\\0628.f");
+            Assert.True(info.Exists);
+            Assert.Equal(@"\\LOCALHOST\\Users\david\share", info.LinkTarget);
+
+            var targetInfo = info.ResolveLinkTarget();
+            Assert.True(targetInfo.Exists);
+        }
     }
 }

src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.Windows.cs

@@ -413,8 +413,9 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
                 Path.Join(Path.GetDirectoryName(path), pathToTarget) : pathToTarget;
 
             Interop.Kernel32.WIN32_FILE_ATTRIBUTE_DATA data = default;
-            FillAttributeInfo(pathToTargetFullPath, ref data, returnErrorOnNotFound: false);
-            if (data.dwFileAttributes != -1 &&
+            int errorCode = FillAttributeInfo(pathToTargetFullPath, ref data, returnErrorOnNotFound: true);
+            if (errorCode == Interop.Errors.ERROR_SUCCESS &&
+                data.dwFileAttributes != -1 &&
                 isDirectory != ((data.dwFileAttributes & Interop.Kernel32.FileAttributes.FILE_ATTRIBUTE_DIRECTORY) != 0))
             {
                 throw new IOException(SR.Format(SR.IO_InconsistentLinkType, path));
@@ -430,20 +431,20 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
         {
             string? targetPath = returnFinalTarget ?
                 GetFinalLinkTarget(linkPath, isDirectory) :
-                GetImmediateLinkTarget(linkPath, isDirectory, throwOnNotFound: true, normalize: true);
+                GetImmediateLinkTarget(linkPath, isDirectory, throwOnUnreachable: true, normalize: true);
 
             return targetPath == null ? null :
                 isDirectory ? new DirectoryInfo(targetPath) : new FileInfo(targetPath);
         }
 
         internal static string? GetLinkTarget(string linkPath, bool isDirectory)
-            => GetImmediateLinkTarget(linkPath, isDirectory, throwOnNotFound: false, normalize: false);
+            => GetImmediateLinkTarget(linkPath, isDirectory, throwOnUnreachable: false, normalize: false);
 
         /// <summary>
         /// Gets reparse point information associated to <paramref name="linkPath"/>.
         /// </summary>
         /// <returns>The immediate link target, absolute or relative or null if the file is not a supported link.</returns>
-        internal static unsafe string? GetImmediateLinkTarget(string linkPath, bool isDirectory, bool throwOnNotFound, bool normalize)
+        internal static unsafe string? GetImmediateLinkTarget(string linkPath, bool isDirectory, bool throwOnUnreachable, bool normalize)
         {
             using SafeFileHandle handle = OpenSafeFileHandle(linkPath,
                     Interop.Kernel32.FileOperations.FILE_FLAG_BACKUP_SEMANTICS |
@@ -452,20 +453,19 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
             if (handle.IsInvalid)
             {
                 int error = Marshal.GetLastWin32Error();
-                switch (error)
+
+                if (!throwOnUnreachable && IsPathUnreachableError(error))
                 {
-                    case Interop.Errors.ERROR_FILE_NOT_FOUND:
-                    case Interop.Errors.ERROR_PATH_NOT_FOUND:
-                        if (throwOnNotFound)
-                        {
-                            throw Win32Marshal.GetExceptionForWin32Error(
-                                // File not found doesn't make much sense coming from a directory.
-                                isDirectory ? Interop.Errors.ERROR_PATH_NOT_FOUND : error, linkPath);
-                        }
-                        return null;
-                    default:
-                        throw Win32Marshal.GetExceptionForWin32Error(error, linkPath);
+                    return null;
                 }
+
+                // File not found doesn't make much sense coming from a directory.
+                if (isDirectory && error == Interop.Errors.ERROR_FILE_NOT_FOUND)
+                {
+                    error = Interop.Errors.ERROR_PATH_NOT_FOUND;
+                }
+
+                throw Win32Marshal.GetExceptionForWin32Error(error, linkPath);
             }
 
             byte[] buffer = ArrayPool<byte>.Shared.Rent(Interop.Kernel32.MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
@@ -503,9 +503,10 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
                     return null;
                 }
 
-                // We use PrintName instead of SubstitutneName given that we don't want to return a NT path.
+                // We use PrintName instead of SubstitutneName given that we don't want to return a NT path when the link wasn't created with such NT path.
                 // Unlike SubstituteName and GetFinalPathNameByHandle(), PrintName doesn't start with a prefix.
                 // Another nuance is that SubstituteName does not contain redundant path segments while PrintName does.
+                // PrintName can ONLY return a NT path if the link was created explicitly targeting a file/folder in such way. e.g: mklink /D linkName \??\C:\path\to\target.
                 int printNameNameOffset = sizeof(Interop.Kernel32.REPARSE_DATA_BUFFER) + rdb.ReparseBufferSymbolicLink.PrintNameOffset;
                 int printNameNameLength = rdb.ReparseBufferSymbolicLink.PrintNameLength;
 
@@ -548,11 +549,10 @@ internal static void CreateSymbolicLink(string path, string pathToTarget, bool i
 
             if (handle.IsInvalid)
             {
-                // If the handle fails with "not found", is becuse the link was broken.
-                // We need to fallback to manually traverse the link targets and return the target of the last resolved link.
+                // If the handle fails because it is unreachable, is becuse the link was broken.
+                // We need to fallback to manually traverse the links and return the target of the last resolved link.
                 int error = Marshal.GetLastWin32Error();
-                if (error == Interop.Errors.ERROR_FILE_NOT_FOUND ||
-                    error == Interop.Errors.ERROR_PATH_NOT_FOUND)
+                if (IsPathUnreachableError(error))
                 {
                     return GetFinalLinkTargetSlow(linkPath);
                 }
@@ -607,13 +607,13 @@ uint GetFinalPathNameByHandle(SafeFileHandle handle, char[] buffer)
             {
                 // Since all these paths will be passed to CreateFile, which takes a string anyway, it is pointless to use span.
                 // I am not sure if it's possible to change CreateFile's param to ROS<char> and avoid all these allocations.
-                string? current = GetImmediateLinkTarget(linkPath, isDirectory, throwOnNotFound: false, normalize: true);
+                string? current = GetImmediateLinkTarget(linkPath, isDirectory, throwOnUnreachable: false, normalize: true);
                 string? prev = null;
 
                 while (current != null)
                 {
                     prev = current;
-                    current = GetImmediateLinkTarget(current, isDirectory, throwOnNotFound: false, normalize: true);
+                    current = GetImmediateLinkTarget(current, isDirectory, throwOnUnreachable: false, normalize: true);
                 }
 
                 return prev;