GetImmediateLinkTarget()

static unsafe string System.IO.FileSystem.GetImmediateLinkTarget ( string linkPath, bool isDirectory, bool throwOnError, bool returnFullPath )

inlinestaticpackage

Definition at line 594 of file FileSystem.cs.

    {
        using (SafeFileHandle safeFileHandle = OpenSafeFileHandle(linkPath, 35651584))
        {
            if (safeFileHandle.IsInvalid)
            {
                if (!throwOnError)
                {
                    return null;
                }
                int num = Marshal.GetLastWin32Error();
                if (isDirectory && num == 2)
                {
                    num = 3;
                }
                throw Win32Marshal.GetExceptionForWin32Error(num, linkPath);
            }
            byte[] array = ArrayPool<byte>.Shared.Rent(16384);
            try
            {
                if (!Interop.Kernel32.DeviceIoControl(safeFileHandle, 589992u, IntPtr.Zero, 0u, array, 16384u, out var _, IntPtr.Zero))
                {
                    if (!throwOnError)
                    {
                        return null;
                    }
                    int lastWin32Error = Marshal.GetLastWin32Error();
                    if (lastWin32Error == 4390)
                    {
                        return null;
                    }
                    throw Win32Marshal.GetExceptionForWin32Error(lastWin32Error, linkPath);
                }
                Span<byte> span = new Span<byte>(array);
                bool flag = MemoryMarshal.TryRead<Interop.Kernel32.SymbolicLinkReparseBuffer>(span, out var value);
                if (value.ReparseTag == 2684354572u)
                {
                    int start = sizeof(Interop.Kernel32.SymbolicLinkReparseBuffer) + value.SubstituteNameOffset;
                    int substituteNameLength = value.SubstituteNameLength;
                    Span<char> span2 = MemoryMarshal.Cast<byte, char>(span.Slice(start, substituteNameLength));
                    if ((value.Flags & 1) == 0)
                    {
                        if (span2.StartsWith("\\??\\UNC\\".AsSpan()))
                        {
                            return Path.Join("\\\\".AsSpan(), span2.Slice("\\??\\UNC\\".Length));
                        }
                        return GetTargetPathWithoutNTPrefix(span2);
                    }
                    if (returnFullPath)
                    {
                        return Path.Join(Path.GetDirectoryName(linkPath.AsSpan()), span2);
                    }
                    return span2.ToString();
                }
                if (value.ReparseTag == 2684354563u)
                {
                    flag = MemoryMarshal.TryRead<Interop.Kernel32.MountPointReparseBuffer>(span, out var value2);
                    int start2 = sizeof(Interop.Kernel32.MountPointReparseBuffer) + value2.SubstituteNameOffset;
                    int substituteNameLength2 = value2.SubstituteNameLength;
                    Span<char> span3 = MemoryMarshal.Cast<byte, char>(span.Slice(start2, substituteNameLength2));
                    return GetTargetPathWithoutNTPrefix(span3);
                }
                return null;
            }
            finally
            {
                ArrayPool<byte>.Shared.Return(array);
            }
        }
        static string GetTargetPathWithoutNTPrefix(ReadOnlySpan<char> targetPath)
        {
            return targetPath.Slice("\\??\\".Length).ToString();
        }
    }

References System.array, Interop.Kernel32.DeviceIoControl(), System.IO.Path.GetDirectoryName(), System.IO.Win32Marshal.GetExceptionForWin32Error(), System.Runtime.InteropServices.Marshal.GetLastWin32Error(), System.IO.Path.Join(), System.IO.FileSystem.OpenSafeFileHandle(), System.start, Interop.Kernel32.SymbolicLinkReparseBuffer.SubstituteNameOffset, System.value, and System.IntPtr.Zero.

Referenced by System.IO.FileSystem.GetFinalLinkTarget(), System.IO.FileSystem.GetLinkTarget(), and System.IO.FileSystem.ResolveLinkTarget().