PowerShell · rkeithhill · Jul 11, 2021 · Jul 15, 2021 · Jul 15, 2021 · Jul 15, 2021
diff --git a/src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs b/src/System.Management.Automation/engine/ExperimentalFeature/ExperimentalFeature.cs
@@ -23,6 +23,7 @@ public class ExperimentalFeature
         internal const string EngineSource = "PSEngine";
         internal const string PSAnsiProgressFeatureName = "PSAnsiProgress";
         internal const string PSNativeCommandArgumentPassingFeatureName = "PSNativeCommandArgumentPassing";
+        internal const string PSNativeCommandErrorActionPreferenceFeatureName = "PSNativeCommandErrorActionPreference";
 
         #endregion
 
@@ -140,6 +141,9 @@ static ExperimentalFeature()
                 new ExperimentalFeature(
                     name: "PSLoadAssemblyFromNativeCode",
                     description: "Expose an API to allow assembly loading from native code"),
+                new ExperimentalFeature(
+                    name: PSNativeCommandErrorActionPreferenceFeatureName,
+                    description: "Native commands with non-zero exit codes issue errors according to $ErrorActionPreference when $PSNativeCommandUseErrorActionPreference is $true"),
                 new ExperimentalFeature(
                     name: "PSAnsiRenderingFileInfo",
                     description: "Enable coloring for FileInfo objects"),

diff --git a/src/System.Management.Automation/engine/InitialSessionState.cs b/src/System.Management.Automation/engine/InitialSessionState.cs
diff --git a/src/System.Management.Automation/engine/MshCommandRuntime.cs b/src/System.Management.Automation/engine/MshCommandRuntime.cs
@@ -2819,7 +2819,7 @@ private void DoWriteError(object obj)
         /// but the command failure will ultimately be
         /// <see cref="System.Management.Automation.ActionPreferenceStopException"/>,
         /// </remarks>
-        internal void _WriteErrorSkipAllowCheck(ErrorRecord errorRecord, ActionPreference? actionPreference = null, bool isNativeError = false)
+        internal void _WriteErrorSkipAllowCheck(ErrorRecord errorRecord, ActionPreference? actionPreference = null, bool isNativeStdErrCall = false)
         {
             ThrowIfStopping();
 
@@ -2839,7 +2839,7 @@ internal void _WriteErrorSkipAllowCheck(ErrorRecord errorRecord, ActionPreferenc
                 this.PipelineProcessor.LogExecutionError(_thisCommand.MyInvocation, errorRecord);
             }
 
-            if (!(ExperimentalFeature.IsEnabled("PSNotApplyErrorActionToStderr") && isNativeError))
+            if (!(ExperimentalFeature.IsEnabled("PSNotApplyErrorActionToStderr") && isNativeStdErrCall))
             {
                 this.PipelineProcessor.ExecutionFailed = true;
 
@@ -2905,7 +2905,7 @@ internal void _WriteErrorSkipAllowCheck(ErrorRecord errorRecord, ActionPreferenc
             // when tracing), so don't add the member again.
 
             // We don't add a note property on messages that comes from stderr stream.
-            if (!isNativeError)
+            if (!isNativeStdErrCall)
             {
                 errorWrap.WriteStream = WriteStreamType.Error;
             }

diff --git a/src/System.Management.Automation/engine/NativeCommandProcessor.cs b/src/System.Management.Automation/engine/NativeCommandProcessor.cs
@@ -3,21 +3,22 @@
 
 #pragma warning disable 1634, 1691
 
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
 using System.IO;
-using System.ComponentModel;
+using System.Management.Automation.Internal;
+using System.Management.Automation.Runspaces;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
 using System.Text;
-using System.Collections;
 using System.Threading;
-using System.Management.Automation.Internal;
 using System.Xml;
-using System.Runtime.InteropServices;
 using Dbg = System.Management.Automation.Diagnostics;
-using System.Runtime.Serialization;
-using System.Globalization;
-using System.Diagnostics.CodeAnalysis;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
 
 namespace System.Management.Automation
 {
@@ -130,6 +131,120 @@ internal ProcessOutputObject(object data, MinishellStream stream)
         }
     }
 
+    /// <summary>
+    /// This exception is used by the NativeCommandProcessor to indicate an error
+    /// when a native command retuns a non-zero exit code.
+    /// </summary>
+    [Serializable]
+    public class NativeCommandExitException : RuntimeException
+    {
+        // NOTE:
+        // When implementing the native error action preference integration,
+        // reusing ApplicationFailedException was contemplated.
+        // However, rather than possibly reusing a type already used in another scenario
+        // it was decided instead to use a fresh type to minimize the chance of conflating the two scenarios.
+
+        /// <summary>
+        /// Gets the path of the native command.
+        /// </summary>
+        public string Path { get; private set; }
+
+        /// <summary>
+        /// Gets the exit code returned by the native command.
+        /// </summary>
+        public int ExitCode { get; private set; }
+
+        /// <summary>
+        /// Gets the native command's process Id.
+        /// </summary>
+        public int ProcessId { get; private set; }
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NativeCommandExitException"/> class with information on the native
+        /// command, a specified error message and a specified error ID.
+        /// </summary>
+        /// <param name="path">The full path of the native command.</param>
+        /// <param name="exitCode">The exit code returned by the native command.</param>
+        /// <param name="processId">The process ID of the process before it ended.</param>
+        /// <param name="message">The error message.</param>
+        /// <param name="errorId">The error ID.</param>
+        internal NativeCommandExitException(string path, int exitCode, int processId, string message, string errorId)
+            : base(message)
+        {
+            SetErrorId(errorId);
+            SetErrorCategory(ErrorCategory.NotSpecified);
+            Path = path;
+            ExitCode = exitCode;
+            ProcessId = processId;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NativeCommandExitException"/> class.
+        /// </summary>
+        public NativeCommandExitException() : base() { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NativeCommandExitException"/> class with a specified error message.
+        /// </summary>
+        /// <param name="message">
+        /// A localized error message.
+        /// </param>
+        public NativeCommandExitException(string message) : base(message) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NativeCommandExitException"/> class with a specified error message
+        /// and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">
+        /// Localized error message.
+        /// </param>
+        /// <param name="innerException">
+        /// Inner exception.
+        /// </param>
+        public NativeCommandExitException(string message, Exception innerException) : base(message, innerException) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NativeCommandExitException"/> class with serialized data.
+        /// </summary>
+        /// <param name="info"></param>
+        /// <param name="context"></param>
+        protected NativeCommandExitException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            if (info == null)
+            {
+                throw new PSArgumentNullException(nameof(info));
+            }
+
+            Path = info.GetString(nameof(Path));
+            ExitCode = info.GetInt32(nameof(ExitCode));
+            ProcessId = info.GetInt32(nameof(ProcessId));
+        }
+
+        #endregion Constructors
+
+        /// <summary>
+        /// Serializes the exception data.
+        /// </summary>
+        /// <param name="info">Serialization information.</param>
+        /// <param name="context">Streaming context.</param>
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
+                throw new PSArgumentNullException(nameof(info));
+            }
+
+            base.GetObjectData(info, context);
+
+            info.AddValue(nameof(Path), Path);
+            info.AddValue(nameof(ExitCode), ExitCode);
+            info.AddValue(nameof(ProcessId), ProcessId);
+        }
+    }
+
     /// <summary>
     /// Provides way to create and execute native commands.
     /// </summary>
@@ -762,8 +877,51 @@ internal override void Complete()
                     }
 
                     this.Command.Context.SetVariable(SpecialVariables.LastExitCodeVarPath, _nativeProcess.ExitCode);
-                    if (_nativeProcess.ExitCode != 0)
-                        this.commandRuntime.PipelineProcessor.ExecutionFailed = true;
+                    if (_nativeProcess.ExitCode == 0)
+                    {
+                        return;
+                    }
+
+                    this.commandRuntime.PipelineProcessor.ExecutionFailed = true;
+
+                    bool nativeCommandUseErrorActionPreference = ExperimentalFeature.IsEnabled(ExperimentalFeature.PSNativeCommandErrorActionPreferenceFeatureName)
+                        && this.Command.Context.GetBooleanPreference(
+                            SpecialVariables.PSNativeCommandUseErrorActionPreferenceVarPath,
+                            InitialSessionState.DefaultPSNativeCommandUseErrorActionPreference,
+                            out _);
+
+                    if (!nativeCommandUseErrorActionPreference)
+                    {
+                        return;
+                    }
+
+                    ActionPreference errorActionPref =
+                        this.Command.Context.GetEnumPreference(
+                            SpecialVariables.ErrorActionPreferenceVarPath,
+                            ActionPreference.SilentlyContinue,
+                            out _);
+
+                    if (errorActionPref != ActionPreference.Ignore)
+                    {
+                        const string errorId = "ProgramFailedToComplete";
-                        const string errorId = "ProgramFailedToComplete";
+                        const string ErrorId = "ProgramFailedToComplete";
-                        const string errorId = "ProgramFailedToComplete";
+                        const string ErrorId = "ProgramFailedToComplete";
+
+                        string errorMsg =
+                            StringUtil.Format(
+                                CommandBaseStrings.ProgramFailedToComplete,
+                                this.NativeCommandName,
+                                _nativeProcess.ExitCode);
+
+                        var exception =
+                            new NativeCommandExitException(
+                                this.Path,
+                                _nativeProcess.ExitCode,
+                                _nativeProcess.Id,
+                                errorMsg,
+                                errorId);
+
+                        var errorRecord = new ErrorRecord(exception, errorId, ErrorCategory.NotSpecified, null);
+                        this.commandRuntime._WriteErrorSkipAllowCheck(errorRecord);
+                    }
                 }
             }
             catch (Win32Exception e)
@@ -1087,7 +1245,7 @@ private void ProcessOutputRecord(ProcessOutputObject outputValue)
                 ErrorRecord record = outputValue.Data as ErrorRecord;
                 Dbg.Assert(record != null, "ProcessReader should ensure that data is ErrorRecord");
                 record.SetInvocationInfo(this.Command.MyInvocation);
-                this.commandRuntime._WriteErrorSkipAllowCheck(record, isNativeError: true);
+                this.commandRuntime._WriteErrorSkipAllowCheck(record, isNativeStdErrCall: true);
             }
             else if (outputValue.Stream == MinishellStream.Output)
             {

diff --git a/src/System.Management.Automation/engine/SpecialVariables.cs b/src/System.Management.Automation/engine/SpecialVariables.cs
@@ -255,6 +255,11 @@ internal static class SpecialVariables
 
         internal static readonly VariablePath InformationPreferenceVarPath = new VariablePath(InformationPreference);
 
+        internal const string PSNativeCommandUseErrorActionPreference = nameof(PSNativeCommandUseErrorActionPreference);
-        internal const string PSNativeCommandUseErrorActionPreference = nameof(PSNativeCommandUseErrorActionPreference);
+        internal const string PSNativeCommandUseErrorActionPreferenceName = nameof(PSNativeCommandUseErrorActionPreference);
-        internal const string PSNativeCommandUseErrorActionPreference = nameof(PSNativeCommandUseErrorActionPreference);
+        internal const string PSNativeCommandUseErrorActionPreferenceName = nameof(PSNativeCommandUseErrorActionPreference);
+
+        internal static readonly VariablePath PSNativeCommandUseErrorActionPreferenceVarPath =
+            new VariablePath(PSNativeCommandUseErrorActionPreference);
+
         #endregion Preference Variables
 
         // Native command argument passing style
@@ -321,25 +326,29 @@ internal static class SpecialVariables
                                                                    /* PSCommandPath */     typeof(string),
                                                                  };
 
-        internal static readonly string[] PreferenceVariables = {
-                                                                    SpecialVariables.DebugPreference,
-                                                                    SpecialVariables.VerbosePreference,
-                                                                    SpecialVariables.ErrorActionPreference,
-                                                                    SpecialVariables.WhatIfPreference,
-                                                                    SpecialVariables.WarningPreference,
-                                                                    SpecialVariables.InformationPreference,
-                                                                    SpecialVariables.ConfirmPreference,
-                                                                };
-
-        internal static readonly Type[] PreferenceVariableTypes = {
-                                                                    /* DebugPreference */       typeof(ActionPreference),
-                                                                    /* VerbosePreference */     typeof(ActionPreference),
-                                                                    /* ErrorPreference */       typeof(ActionPreference),
-                                                                    /* WhatIfPreference */      typeof(SwitchParameter),
-                                                                    /* WarningPreference */     typeof(ActionPreference),
-                                                                    /* InformationPreference */ typeof(ActionPreference),
-                                                                    /* ConfirmPreference */     typeof(ConfirmImpact),
-                                                                  };
+        internal static readonly string[] PreferenceVariables =
+        {
+            SpecialVariables.DebugPreference,
+            SpecialVariables.VerbosePreference,
+            SpecialVariables.ErrorActionPreference,
+            SpecialVariables.WhatIfPreference,
+            SpecialVariables.WarningPreference,
+            SpecialVariables.InformationPreference,
+            SpecialVariables.ConfirmPreference,
+            SpecialVariables.PSNativeCommandUseErrorActionPreference,
+        };
+
+        internal static readonly Type[] PreferenceVariableTypes =
+        {
+            /* DebugPreference */                         typeof(ActionPreference),
+            /* VerbosePreference */                       typeof(ActionPreference),
+            /* ErrorPreference */                         typeof(ActionPreference),
+            /* WhatIfPreference */                        typeof(SwitchParameter),
+            /* WarningPreference */                       typeof(ActionPreference),
+            /* InformationPreference */                   typeof(ActionPreference),
+            /* ConfirmPreference */                       typeof(ConfirmImpact),
+            /* PSNativeCommandUseErrorActionPreference */ typeof(bool),
+        };
 
         // The following variables are created in every session w/ AllScope.  We avoid creating local slots when we
         // see an assignment to any of these variables so that they get handled properly (either throwing an exception
@@ -406,5 +415,6 @@ internal enum PreferenceVariable
         Warning = 13,
         Information = 14,
         Confirm = 15,
+        PSNativeCommandUseErrorAction = 16,
     }
 }
diff --git a/src/System.Management.Automation/resources/CommandBaseStrings.resx b/src/System.Management.Automation/resources/CommandBaseStrings.resx
@@ -156,6 +156,15 @@
   <data name="PauseHelpMessage" xml:space="preserve">
     <value>Pause the current pipeline and return to the command prompt. Type "{0}" to resume the pipeline.</value>
   </data>
+  <data name="ProgramFailedToComplete" xml:space="preserve">
+    <!-- NOTE:
+      This string was added for the native command error action preference integration feature.
+      ParserStrings already declares a ProgramFailedToExecute string,
+      however that is used for ApplicationFailedExceptions thrown when the NativeCommandProcessor fails in an unexpected way.
+      In this case, we have a more specific error for the native command scenario, so the two are not conflated.
+    -->
+    <value>Program "{0}" ended with non-zero exit code {1}.</value>
-    <value>Program "{0}" ended with non-zero exit code {1}.</value>
+    <value>Program "{0}" ended with non-zero exit code: {1}.</value>
-    <value>Program "{0}" ended with non-zero exit code {1}.</value>
+    <value>Program "{0}" ended with non-zero exit code: {1}.</value>
+  </data>
   <data name="ShouldProcessMessage" xml:space="preserve">
     <value>Performing the operation "{0}" on target "{1}".</value>
   </data>

diff --git a/src/System.Management.Automation/resources/RunspaceInit.resx b/src/System.Management.Automation/resources/RunspaceInit.resx
@@ -186,6 +186,9 @@
   <data name="NestedPromptLevelDescription" xml:space="preserve">
     <value>Dictates what type of prompt should be displayed for the current nesting level</value>
   </data>
+  <data name="PSNativeCommandUseErrorActionPreferenceDescription" xml:space="preserve">
+    <value>If true, $ErrorActionPreference applies to native executables, so that non-zero exit codes will generate cmdlet-style errors governed by error action settings</value>
-    <value>If true, $ErrorActionPreference applies to native executables, so that non-zero exit codes will generate cmdlet-style errors governed by error action settings</value>
+    <value>If true, $ErrorActionPreference applies to native executables, so that non-zero exit codes will generate cmdlet-style errors governed by error action settings.</value>
-    <value>If true, $ErrorActionPreference applies to native executables, so that non-zero exit codes will generate cmdlet-style errors governed by error action settings</value>
+    <value>If true, $ErrorActionPreference applies to native executables, so that non-zero exit codes will generate cmdlet-style errors governed by error action settings.</value>
+  </data>
   <data name="WhatIfPreferenceDescription" xml:space="preserve">
     <value>If true, WhatIf is considered to be enabled for all commands.</value>
   </data>