Find correct x64 host on arm64 machines

src/clickonce/launcher/HostFinder.cs

@@ -10,10 +10,15 @@ namespace Microsoft.Deployment.Launcher
 {
     internal static class HostFinder
     {
+        internal static readonly string ArchMsil = "msil";
+        internal static readonly string ArchX86   = "x86";
+        internal static readonly string ArchX64   = "amd64";
+        internal static readonly string ArchArm64 = "arm64";
+
         /// <summary>
         /// Gets full path to .NET host appropriate for activating the application.
         /// 
-        /// .NET host'slocation can be obtained from multiple locations.
+        /// .NET host's location can be obtained from multiple locations.
         ///
         /// Current code searches in default, global shared runtime, location only:
         /// %ProgramFiles%\dotnet and %ProgramFiles(x86)%\dotnet
@@ -33,23 +38,63 @@ internal static string GetHost(string applicationFilePath)
         {
             string arch = GetProcessorArchitectureFromAssembly(applicationFilePath);
 
-            if (arch == "x86")
+            if (arch == ArchX86)
             {
-                return GetX86Host();
+                return GetGlobalHost(arch);
             }
-            else if (arch == "amd64" || arch == "arm64")
+            else if (arch == ArchX64 || arch == ArchArm64)
             {
-                return Get64bitHost();
+                return Environment.Is64BitOperatingSystem ? GetGlobalHost(arch) : string.Empty;
             }
             else if (arch == "msil")
             {
-                string host = Get64bitHost();
-                return string.IsNullOrEmpty(host) ? GetX86Host() : host;
+                string host = string.Empty;
+
+                // On arm64 systems, first look for arm64 host
+                if (IsArm64System)
+                {
+                    host = GetGlobalHost(ArchArm64);
+                }
+
+                // Fallback for arm64 systems, and native x64 systems
+                if (string.IsNullOrEmpty(host))
+                {
+                    host = GetGlobalHost(ArchX64);
+                }
+
+                return string.IsNullOrEmpty(host) ? GetGlobalHost(ArchX86) : host;
             }
 
             return string.Empty;
         }
 
+        /// <summary>
+        /// Checks if running on Arm64 system
+        /// </summary>
+        private static bool IsArm64System
+        {
+            get
+            {
+                try
+                {
+                    if (NativeMethods.Kernel32.IsWow64Process2(new IntPtr(-1), out _, out ushort nativeMachine))
+                    {
+                        if (nativeMachine == NativeMethods.Kernel32.IMAGE_FILE_MACHINE_ARM64)
+                        {
+                            return true;
+                        }
+                    }
+                }
+                catch (EntryPointNotFoundException)
+                {
+                    // kernel32.dll does not export IsWow64Process2 on systems before Win10
+                    // API is available on all systems that support arm64.
+                }
+
+                return false;
+            }
+        }
+
         /// <summary>
         /// Gets ProgramFiles folder for the specified bitness.
         /// </summary>
@@ -67,31 +112,22 @@ private static string GetProgramFilesFolder(bool is64bit = false)
         /// <summary>
         /// Get global host if it exists, for the specified bitness.
         /// </summary>
-        /// <param name="is64bit">If 64-bit bitness is required</param>
+        /// <param name="arch">Architecture</param>
         /// <returns></returns>
-        private static string GetGlobalHost(bool is64bit = false)
+        private static string GetGlobalHost(string arch)
         {
+            bool is64bit = arch == ArchX86 ? false : true;
             string folder = GetProgramFilesFolder(is64bit);
-            string host = !string.IsNullOrEmpty(folder) ? Path.Combine(folder, "dotnet\\dotnet.exe") : string.Empty;
-            return File.Exists(host) ? host : string.Empty;
-        }
+            string relativeHostPath = "dotnet\\dotnet.exe";
 
-        /// <summary>
-        /// Gets full path to x86 .NET host.
-        /// </summary>
-        /// <returns>X86 host</returns>
-        private static string GetX86Host()
-        {
-            return GetGlobalHost();
-        }
+            // On Arm64 systems, x64 host is in "x64" sub-folder
+            if (is64bit && arch == ArchX64 && IsArm64System)
+            {
+                relativeHostPath = "dotnet\\x64\\dotnet.exe";
+            }
 
-        /// <summary>
-        /// Gets full path to 64-bit .NET host.
-        /// </summary>
-        /// <returns>64-bit host</returns>
-        private static string Get64bitHost()
-        {
-            return Environment.Is64BitOperatingSystem ? GetGlobalHost(true) : string.Empty;
+            string host = !string.IsNullOrEmpty(folder) ? Path.Combine(folder, relativeHostPath) : string.Empty;
+            return File.Exists(host) ? host : string.Empty;
         }
 
         /// <summary>
@@ -120,7 +156,7 @@ private static string GetProcessorArchitectureFromAssembly(string path)
             // Default to "msil", to support failure scenarios, like GetAssemblyIdentityFromFile returning null
             // or encountering an unknown architecture.
             return string.IsNullOrEmpty(processorArchitecture) ?
-                        "msil" :
+                        ArchMsil :
                         processorArchitecture.ToLowerInvariant();
         }
 

src/clickonce/shared/NativeMethods.cs

@@ -16,6 +16,11 @@ internal static class Kernel32
         {
             public const UInt32 LOAD_LIBRARY_AS_DATAFILE = 0x00000002;
             public const int ERROR_SHARING_VIOLATION = -2147024864;
+            public const ushort IMAGE_FILE_MACHINE_ARM64 = 0xAA64;
+
+            [DllImport(nameof(Kernel32), SetLastError = true, CallingConvention = CallingConvention.Winapi)]
+            [return: MarshalAs(UnmanagedType.Bool)]
+            public static extern bool IsWow64Process2([In] IntPtr process, [Out] out ushort processMachine, [Out] out ushort nativeMachine);
 
             [DllImport(nameof(Kernel32), CharSet = CharSet.Unicode, SetLastError = true)]
             public static extern IntPtr BeginUpdateResourceW(String fileName, bool deleteExistingResource);