Merging internal commits for release/8.0

src/installer/tests/HostActivation.Tests/NativeHosting/Comhost.cs

@@ -116,6 +116,35 @@ public void ActivateClass_IgnoreAppLocalHostFxr()
             }
         }
 
+        [Fact]
+        public void ActivateClass_IgnoreWorkingDirectory()
+        {
+            using (TestArtifact cwd = TestArtifact.Create("cwd"))
+            {
+                // Validate that hosting components in the working directory will not be used
+                File.Copy(Binaries.CoreClr.MockPath, Path.Combine(cwd.Location, Binaries.CoreClr.FileName));
+                File.Copy(Binaries.HostFxr.MockPath_5_0, Path.Combine(cwd.Location, Binaries.HostFxr.FileName));
+                File.Copy(Binaries.HostPolicy.MockPath, Path.Combine(cwd.Location, Binaries.HostPolicy.FileName));
+
+                string[] args = {
+                    "comhost",
+                    "synchronous",
+                    "1",
+                    sharedState.ComHostPath,
+                    sharedState.ClsidString
+                };
+                sharedState.CreateNativeHostCommand(args, sharedState.ComLibraryFixture.BuiltDotnet.BinPath)
+                    .WorkingDirectory(cwd.Location)
+                    .Execute()
+                    .Should().Pass()
+                    .And.HaveStdOutContaining("New instance of Server created")
+                    .And.HaveStdOutContaining($"Activation of {sharedState.ClsidString} succeeded.")
+                    .And.ResolveHostFxr(sharedState.ComLibraryFixture.BuiltDotnet)
+                    .And.ResolveHostPolicy(sharedState.ComLibraryFixture.BuiltDotnet)
+                    .And.ResolveCoreClr(sharedState.ComLibraryFixture.BuiltDotnet);
+            }
+        }
+
         [Fact]
         public void ActivateClass_ValidateIErrorInfoResult()
         {

src/installer/tests/HostActivation.Tests/NativeHosting/Ijwhost.cs

@@ -73,6 +73,34 @@ public void LoadLibrary_ContextConfig(bool load_isolated)
             }
         }
 
+        [Fact]
+        public void LoadLibrary_IgnoreWorkingDirectory()
+        {
+            using (TestArtifact cwd = TestArtifact.Create("cwd"))
+            {
+                // Validate that hosting components in the working directory will not be used
+                File.Copy(Binaries.CoreClr.MockPath, Path.Combine(cwd.Location, Binaries.CoreClr.FileName));
+                File.Copy(Binaries.HostFxr.MockPath_5_0, Path.Combine(cwd.Location, Binaries.HostFxr.FileName));
+                File.Copy(Binaries.HostPolicy.MockPath, Path.Combine(cwd.Location, Binaries.HostPolicy.FileName));
+
+                string [] args = {
+                    "ijwhost",
+                    sharedState.IjwApp.AppDll,
+                    "NativeEntryPoint"
+                };
+                var dotnet = new Microsoft.DotNet.Cli.Build.DotNetCli(sharedState.RepoDirectories.BuiltDotnet);
+                sharedState.CreateNativeHostCommand(args, sharedState.RepoDirectories.BuiltDotnet)
+                    .WorkingDirectory(cwd.Location)
+                    .Execute()
+                    .Should().Pass()
+                    .And.HaveStdOutContaining("[C++/CLI] NativeEntryPoint: calling managed class")
+                    .And.HaveStdOutContaining("[C++/CLI] ManagedClass: AssemblyLoadContext = \"Default\" System.Runtime.Loader.DefaultAssemblyLoadContext")
+                    .And.ResolveHostFxr(dotnet)
+                    .And.ResolveHostPolicy(dotnet)
+                    .And.ResolveCoreClr(dotnet);
+            }
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]

src/installer/tests/HostActivation.Tests/NativeHosting/LoadAssemblyAndGetFunctionPointer.cs

@@ -234,6 +234,38 @@ public void CallDelegateOnComponentContext_UnhandledException()
                 .And.ExecuteFunctionPointerWithException(entryPoint, 1);
         }
 
+        [Fact]
+        public void CallDelegateOnComponentContext_IgnoreWorkingDirectory()
+        {
+            using (TestArtifact cwd = TestArtifact.Create("cwd"))
+            {
+                // Validate that hosting components in the working directory will not be used
+                File.Copy(Binaries.CoreClr.MockPath, Path.Combine(cwd.Location, Binaries.CoreClr.FileName));
+                File.Copy(Binaries.HostPolicy.MockPath, Path.Combine(cwd.Location, Binaries.HostPolicy.FileName));
+
+                var component = sharedState.ComponentWithNoDependenciesFixture.TestProject;
+                string[] args =
+                {
+                    ComponentLoadAssemblyAndGetFunctionPointerArg,
+                    sharedState.HostFxrPath,
+                    component.RuntimeConfigJson,
+                    component.AppDll,
+                    sharedState.ComponentTypeName,
+                    sharedState.ComponentEntryPoint1,
+                };
+
+                var dotnet = new Microsoft.DotNet.Cli.Build.DotNetCli(sharedState.DotNetRoot);
+                sharedState.CreateNativeHostCommand(args, sharedState.DotNetRoot)
+                    .WorkingDirectory(cwd.Location)
+                    .Execute()
+                    .Should().Pass()
+                    .And.InitializeContextForConfig(component.RuntimeConfigJson)
+                    .And.ExecuteFunctionPointer(sharedState.ComponentEntryPoint1, 1, 1)
+                    .And.ResolveHostPolicy(dotnet)
+                    .And.ResolveCoreClr(dotnet);
+            }
+        }
+
         public class SharedTestState : SharedTestStateBase
         {
             public string HostFxrPath { get; }

src/installer/tests/HostActivation.Tests/NativeHosting/FunctionPointerResultExtensions.cs → src/installer/tests/HostActivation.Tests/NativeHosting/NativeHostingResultExtensions.cs

@@ -2,10 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.IO;
 
 namespace Microsoft.DotNet.CoreSetup.Test.HostActivation.NativeHosting
 {
-    internal static class FunctionPointerResultExtensions
+    internal static class NativeHostingResultExtensions
     {
         public static FluentAssertions.AndConstraint<CommandResultAssertions> ExecuteFunctionPointer(this CommandResultAssertions assertion, string methodName, int callCount, int returnValue)
         {
@@ -47,5 +48,21 @@ public static FluentAssertions.AndConstraint<CommandResultAssertions> ExecuteWit
         {
             return assertion.HaveStdOutContaining($"{assemblyName}: Location = '{location}'");
         }
+
+        public static FluentAssertions.AndConstraint<CommandResultAssertions> ResolveHostFxr(this CommandResultAssertions assertion, Microsoft.DotNet.Cli.Build.DotNetCli dotnet)
+        {
+            return assertion.HaveStdErrContaining($"Resolved fxr [{dotnet.GreatestVersionHostFxrFilePath}]");
+        }
+
+        public static FluentAssertions.AndConstraint<CommandResultAssertions> ResolveHostPolicy(this CommandResultAssertions assertion, Microsoft.DotNet.Cli.Build.DotNetCli dotnet)
+        {
+            return assertion.HaveStdErrContaining($"{Binaries.HostPolicy.FileName} directory is [{dotnet.GreatestVersionSharedFxPath}]");
+        }
+
+        public static FluentAssertions.AndConstraint<CommandResultAssertions> ResolveCoreClr(this CommandResultAssertions assertion, Microsoft.DotNet.Cli.Build.DotNetCli dotnet)
+        {
+            return assertion.HaveStdErrContaining($"CoreCLR path = '{Path.Combine(dotnet.GreatestVersionSharedFxPath, Binaries.CoreClr.FileName)}'")
+                .And.HaveStdErrContaining($"CoreCLR dir = '{dotnet.GreatestVersionSharedFxPath}{Path.DirectorySeparatorChar}'");
+        }
     }
 }

src/installer/tests/TestUtils/TestArtifact.cs

@@ -52,6 +52,20 @@ protected TestArtifact(TestArtifact source)
             source._copies.Add(this);
         }
 
+        /// <summary>
+        /// Create a new test artifact.
+        /// </summary>
+        /// <param name="name">Name of the test artifact</param>
+        /// <returns>Test artifact containing no files</returns>
+        public static TestArtifact Create(string name)
+        {
+            var (location, parentPath) = GetNewTestArtifactPath(name);
+            return new TestArtifact(location)
+            {
+                DirectoryToDelete = parentPath
+            };
+        }
+
         protected void RegisterCopy(TestArtifact artifact)
         {
             _copies.Add(artifact);

src/native/corehost/apphost/standalone/hostfxr_resolver.cpp

@@ -38,6 +38,11 @@ hostfxr_resolver_t::hostfxr_resolver_t(const pal::string_t& app_root)
     {
         m_status_code = StatusCode::CoreHostLibMissingFailure;
     }
+    else if (!pal::is_path_rooted(m_fxr_path))
+    {
+        // We should always be loading hostfxr from an absolute path
+        m_status_code = StatusCode::CoreHostLibMissingFailure;
+    }
     else if (pal::load_library(&m_fxr_path, &m_hostfxr_dll))
     {
         m_status_code = StatusCode::Success;

src/native/corehost/fxr/standalone/hostpolicy_resolver.cpp

@@ -180,6 +180,10 @@ int hostpolicy_resolver::load(
             return StatusCode::CoreHostLibMissingFailure;
         }
 
+        // We should always be loading hostpolicy from an absolute path
+        if (!pal::is_path_rooted(host_path))
+            return StatusCode::CoreHostLibMissingFailure;
+
         // Load library
         // We expect to leak hostpolicy - just as we do not unload coreclr, we do not unload hostpolicy
         if (!pal::load_library(&host_path, &g_hostpolicy))

src/native/corehost/fxr_resolver.h

@@ -44,6 +44,10 @@ int load_fxr_and_get_delegate(hostfxr_delegate_type type, THostPathToConfigCallb
             return StatusCode::CoreHostLibMissingFailure;
         }
 
+        // We should always be loading hostfxr from an absolute path
+        if (!pal::is_path_rooted(fxr_path))
+            return StatusCode::CoreHostLibMissingFailure;
+
         // Load library
         if (!pal::load_library(&fxr_path, &fxr))
         {

src/native/corehost/hostpolicy/deps_resolver.cpp

@@ -830,13 +830,21 @@ bool deps_resolver_t::resolve_probe_dirs(
         }
     }
 
-    // If the deps file is missing add known locations.
-    if (!get_app_deps().exists())
+    // If the deps file is missing for the app, add known locations.
+    // For libhost scenarios, there is no app or app path
+    if (m_host_mode != host_mode_t::libhost && !get_app_deps().exists())
     {
+        assert(!m_app_dir.empty());
+
         // App local path
         add_unique_path(asset_type, m_app_dir, &items, output, &non_serviced, core_servicing);
 
-        (void) library_exists_in_dir(m_app_dir, LIBCORECLR_NAME, &m_coreclr_path);
+        if (m_coreclr_path.empty())
+        {
+            // deps_resolver treats being able to get the coreclr path as optional, so we ignore the return value here.
+            // The caller is responsible for checking whether coreclr path is set and handling as appropriate.
+            (void) library_exists_in_dir(m_app_dir, LIBCORECLR_NAME, &m_coreclr_path);
+        }
     }
 
     // Handle any additional deps.json that were specified.

src/native/corehost/hostpolicy/standalone/coreclr_resolver.cpp

@@ -13,6 +13,10 @@ bool coreclr_resolver_t::resolve_coreclr(const pal::string_t& libcoreclr_path, c
     pal::string_t coreclr_dll_path(libcoreclr_path);
     append_path(&coreclr_dll_path, LIBCORECLR_NAME);
 
+    // We should always be loading coreclr from an absolute path
+    if (!pal::is_path_rooted(coreclr_dll_path))
+        return false;
+
     if (!pal::load_library(&coreclr_dll_path, &coreclr_resolver_contract.coreclr))
     {
         return false;