Allow users that have certain special characters in their username to build successfully when using exec

ref/Microsoft.Build.Tasks.Core/net/Microsoft.Build.Tasks.Core.cs

@@ -313,6 +313,7 @@ public sealed partial class ErrorFromResources : Microsoft.Build.Tasks.TaskExten
     public partial class Exec : Microsoft.Build.Tasks.ToolTaskExtension
     {
         public Exec() { }
+        public string CharactersToEscape { set { } }
         [Microsoft.Build.Framework.RequiredAttribute]
         public string Command { get { throw null; } set { } }
         [Microsoft.Build.Framework.OutputAttribute]

ref/Microsoft.Build.Tasks.Core/netstandard/Microsoft.Build.Tasks.Core.cs

@@ -243,6 +243,7 @@ public sealed partial class ErrorFromResources : Microsoft.Build.Tasks.TaskExten
     public partial class Exec : Microsoft.Build.Tasks.ToolTaskExtension
     {
         public Exec() { }
+        public string CharactersToEscape { set { } }
         [Microsoft.Build.Framework.RequiredAttribute]
         public string Command { get { throw null; } set { } }
         [Microsoft.Build.Framework.OutputAttribute]

src/Shared/TempFileUtilities.cs

@@ -19,9 +19,10 @@ internal static partial class FileUtilities
         /// Caller must delete when finished.
         /// </summary>
         /// <param name="createDirectory"></param>
-        internal static string GetTemporaryDirectory(bool createDirectory = true)
+        /// <param name="subfolder"></param>
+        internal static string GetTemporaryDirectory(bool createDirectory = true, string subfolder = null)
         {
-            string temporaryDirectory = Path.Combine(Path.GetTempPath(), "Temporary" + Guid.NewGuid().ToString("N"));
+            string temporaryDirectory = Path.Combine(Path.GetTempPath(), "Temporary" + Guid.NewGuid().ToString("N"), subfolder ?? string.Empty);
 
             if (createDirectory)
             {

src/Shared/UnitTests/TestEnvironment.cs

@@ -172,6 +172,15 @@ public TransientTempPath CreateNewTempPath()
             return SetTempPath(folder.Path, true);
         }
 
+        /// <summary>
+        /// Creates a new temp path with a custom subfolder
+        /// </summary>
+        public TransientTempPath CreateNewTempPathWithSubfolder(string subfolder)
+        {
+            var folder = CreateFolder(null, true, subfolder);
+            return SetTempPath(folder.Path, true);
+        }
+
         /// <summary>
         /// Creates a new temp path
         /// Sets all OS temp environment variables to the new path
@@ -266,9 +275,9 @@ public TransientTestFile ExpectFile(TransientTestFolder transientTestFolder, str
         ///     Creates a test variant used to add a unique temporary folder during a test. Will be deleted when the test
         ///     completes.
         /// </summary>
-        public TransientTestFolder CreateFolder(string folderPath = null, bool createFolder = true)
+        public TransientTestFolder CreateFolder(string folderPath = null, bool createFolder = true, string subfolder = null)
         {
-            var folder = WithTransientTestState(new TransientTestFolder(folderPath, createFolder));
+            var folder = WithTransientTestState(new TransientTestFolder(folderPath, createFolder, subfolder));
 
             Assert.True(!(createFolder ^ FileSystems.Default.DirectoryExists(folder.Path)));
 
@@ -605,9 +614,9 @@ public void Delete()
 
     public class TransientTestFolder : TransientTestState
     {
-        public TransientTestFolder(string folderPath = null, bool createFolder = true)
+        public TransientTestFolder(string folderPath = null, bool createFolder = true, string subfolder = null)
         {
-            Path = folderPath ?? FileUtilities.GetTemporaryDirectory(createFolder);
+            Path = folderPath ?? FileUtilities.GetTemporaryDirectory(createFolder, subfolder);
 
             if (createFolder)
             {

src/Tasks.UnitTests/Exec_Tests.cs

@@ -48,6 +48,46 @@ private ExecWrapper PrepareExecWrapper(string command)
             return exec;
         }
 
+        [Fact]
+        [Trait("Category", "mono-osx-failing")]
+        [Trait("Category", "netcore-osx-failing")]
+        [Trait("Category", "netcore-linux-failing")]
+        public void EscapeSpecifiedCharactersInPathToGeneratedBatchFile()
+        {
+            using (var testEnvironment = TestEnvironment.Create())
+            {
+                var newTempPath = testEnvironment.CreateNewTempPathWithSubfolder("hello()w]o(rld)").TempPath;
+
+                string tempPath = Path.GetTempPath();
+                Assert.StartsWith(newTempPath, tempPath);
+
+                // Now run the Exec task on a simple command.
+                Exec exec = PrepareExec("echo Hello World!");
+                exec.CharactersToEscape = "()]";
+                exec.Execute().ShouldBeTrue();
+            }
+        }
+
+        [Fact]
+        [Trait("Category", "mono-osx-failing")]
+        [Trait("Category", "netcore-osx-failing")]
+        [Trait("Category", "netcore-linux-failing")]
+        public void EscapeParenthesesInPathToGeneratedBatchFile_DuplicateCharactersToEscapeDontGetEscapedMultipleTimes()
+        {
+            using (var testEnvironment = TestEnvironment.Create())
+            {
+                var newTempPath = testEnvironment.CreateNewTempPathWithSubfolder("hello()wo(rld)").TempPath;
+
+                string tempPath = Path.GetTempPath();
+                Assert.StartsWith(newTempPath, tempPath);
+
+                // Now run the Exec task on a simple command.
+                Exec exec = PrepareExec("echo Hello World!");
+                exec.CharactersToEscape = "()()";
+                exec.Execute().ShouldBeTrue();
+            }
+        }
+
         /// <summary>
         /// Ensures that calling the Exec task does not leave any extra TEMP files
         /// lying around.
@@ -918,6 +958,59 @@ public void EndToEndMultilineExec()
                 }
             }
         }
+
+        [Fact]
+        [Trait("Category", "mono-osx-failing")]
+        [Trait("Category", "netcore-osx-failing")]
+        [Trait("Category", "netcore-linux-failing")]
+        public void EndToEndMultilineExec_WithCharactersToEscapeMetadata()
+        {
+            using (var env = TestEnvironment.Create(_output))
+            {
+                var testProject = env.CreateTestProjectWithFiles(@"<Project>
+<Target Name=""ExecCommand"">
+  <Exec CharactersToEscape=""()"" Command=""echo Hello, World!"" />
+   </Target>
+</Project>");
+
+                // Ensure path has subfolders
+                var newTempPath = env.CreateNewTempPathWithSubfolder("hello()wo(rld)").TempPath;
+                string tempPath = Path.GetTempPath();
+                Assert.StartsWith(newTempPath, tempPath);
+
+                using (var buildManager = new BuildManager())
+                {
+                    MockLogger logger = new MockLogger(_output, profileEvaluation: false, printEventsToStdout: false);
+
+                    var parameters = new BuildParameters()
+                    {
+                        Loggers = new[] { logger },
+                    };
+
+                    var collection = new ProjectCollection(
+                        new Dictionary<string, string>(),
+                        new[] { logger },
+                        remoteLoggers: null,
+                        ToolsetDefinitionLocations.Default,
+                        maxNodeCount: 1,
+                        onlyLogCriticalEvents: false,
+                        loadProjectsReadOnly: true);
+
+                    var project = collection.LoadProject(testProject.ProjectFile).CreateProjectInstance();
+
+                    var request = new BuildRequestData(
+                        project,
+                        targetsToBuild: new[] { "ExecCommand" },
+                        hostServices: null);
+
+                    var result = buildManager.Build(parameters, request);
+
+                    logger.AssertLogContains("Hello, World!");
+
+                    result.OverallResult.ShouldBe(BuildResultCode.Success);
+                }
+            }
+        }
     }
 
     internal class ExecWrapper : Exec

src/Tasks/Exec.cs

@@ -188,6 +188,19 @@ public ITaskItem[] Outputs
         [Output]
         public ITaskItem[] ConsoleOutput => !ConsoleToMSBuild ? Array.Empty<ITaskItem>(): _nonEmptyOutput.ToArray();
 
+        private HashSet<char> _charactersToEscape;
+
+        public string CharactersToEscape
+        {
+            set
+            {
+                if (!string.IsNullOrEmpty(value))
+                {
+                    _charactersToEscape = new HashSet<char>(value);
+                }
+            }
+        }
+
         #endregion
 
         #region Methods
@@ -611,18 +624,38 @@ protected internal override void AddCommandLineCommands(CommandLineBuilderExtens
 
                     // If for some crazy reason the path has a & character and a space in it
                     // then get the short path of the temp path, which should not have spaces in it
-                    // and then escape the &
                     if (batchFileForCommandLine.Contains("&") && !batchFileForCommandLine.Contains("^&"))
                     {
                         batchFileForCommandLine = NativeMethodsShared.GetShortFilePath(batchFileForCommandLine);
-                        batchFileForCommandLine = batchFileForCommandLine.Replace("&", "^&");
                     }
+
+                    StringBuilder fileName = StringBuilderCache.Acquire(batchFileForCommandLine.Length);
+
+                    // Escape any characters specified by the CharactersToEscape metadata, or '&'
+                    for (int i = 0; i < batchFileForCommandLine.Length; i++)
+                    {
+                        char c = batchFileForCommandLine[i];
+
+                        if (ShouldEscapeCharacter(c) && (i == 0 || batchFileForCommandLine[i - 1] != '^'))
+                        {
+                            fileName.Append('^');
+                        }
+                        fileName.Append(c);
+                    }
+
+                    batchFileForCommandLine = StringBuilderCache.GetStringAndRelease(fileName);
                 }
 
                 commandLine.AppendFileNameIfNotNull(batchFileForCommandLine);
             }
         }
 
+        private bool ShouldEscapeCharacter(char c)
+        {
+            // Escape '&' to preserve previous functionality
+            return c == '&' || (_charactersToEscape != null && _charactersToEscape.Contains(c));
+        }
+
         #endregion
 
         #region Overridden properties