internal RuntimeException(ErrorCategory errorCategory, InvocationInfo invocationInfo, IScriptExtent errorPosition, string errorIdAndResourceId, string message, Exception innerException) : base(message, innerException) { SetErrorCategory(errorCategory); SetErrorId(errorIdAndResourceId); if ((errorPosition == null) && (invocationInfo != null)) { errorPosition = invocationInfo.ScriptPosition; } if (invocationInfo == null) { return; } _errorRecord = new ErrorRecord( new ParentContainsErrorRecordException(this), _errorId, _errorCategory, _targetObject); _errorRecord.SetInvocationInfo(new InvocationInfo(invocationInfo.MyCommand, errorPosition)); }
/// <summary> /// Ensures that the provided script block is compatible with the current language mode - to /// be used when a script block is being dotted. /// </summary> /// <param name="scriptBlock">The script block being dotted</param> /// <param name="languageMode">The current language mode</param> /// <param name="invocationInfo">The invocation info about the command</param> protected static void ValidateCompatibleLanguageMode(ScriptBlock scriptBlock, PSLanguageMode languageMode, InvocationInfo invocationInfo) { // If we are in a constrained language mode (Core or Restricted), block it. // This goes both ways: // - Can't dot something from a more permissive mode, since that would probably expose // functions that were never designed to handle untrusted data. // - Can't dot something from a less permissive mode, since that might introduce tainted // data into the current scope. if ((scriptBlock.LanguageMode.HasValue) && (scriptBlock.LanguageMode != languageMode) && ((languageMode == PSLanguageMode.RestrictedLanguage) || (languageMode == PSLanguageMode.ConstrainedLanguage))) { ErrorRecord errorRecord = new ErrorRecord( new NotSupportedException( DiscoveryExceptions.DotSourceNotSupported), "DotSourceNotSupported", ErrorCategory.InvalidOperation, null); errorRecord.SetInvocationInfo(invocationInfo); throw new CmdletInvocationException(errorRecord); } }
/// <summary> /// Writes an ErrorRecord to the commands error pipe because the specified /// input object was not bound to the command. /// </summary> /// <param name="inputObject"> /// The pipeline input object that was not bound. /// </param> /// <param name="resourceString"> /// The error message. /// </param> /// <param name="errorId"> /// The resource ID of the error message is also used as error ID /// of the ErrorRecord. /// </param> /// <param name="args"> /// Additional arguments to be formatted into the error message that represented in <paramref name="resourceString"/>. /// </param> private void WriteInputObjectError( object inputObject, string resourceString, string errorId, params object[] args) { Type inputObjectType = inputObject?.GetType(); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, null, null, inputObjectType, resourceString, errorId, args); ErrorRecord errorRecord = new ErrorRecord( bindingException, errorId, ErrorCategory.InvalidArgument, inputObject); errorRecord.SetInvocationInfo(this.Command.MyInvocation); this.commandRuntime._WriteErrorSkipAllowCheck(errorRecord); }
private void WriteInputObjectError(object inputObject, string resourceAndErrorId, params object[] args) { Type typeSpecified = (inputObject == null) ? null : inputObject.GetType(); ParameterBindingException exception = new ParameterBindingException(ErrorCategory.InvalidArgument, base.Command.MyInvocation, null, null, null, typeSpecified, "ParameterBinderStrings", resourceAndErrorId, args); ErrorRecord errorRecord = new ErrorRecord(exception, resourceAndErrorId, ErrorCategory.InvalidArgument, inputObject); errorRecord.SetInvocationInfo(base.Command.MyInvocation); base.commandRuntime._WriteErrorSkipAllowCheck(errorRecord, null); }
private void WriteInputObjectError( object inputObject, string resourceAndErrorId, params object[] args) { ErrorRecord errorRecord = new ErrorRecord((Exception) new ParameterBindingException(ErrorCategory.InvalidArgument, this.Command.MyInvocation, this.Command.MyInvocation.ScriptToken, (string)null, (Type)null, inputObject == null ? (Type)null : inputObject.GetType(), "ParameterBinderStrings", resourceAndErrorId, args), resourceAndErrorId, ErrorCategory.InvalidArgument, inputObject); errorRecord.SetInvocationInfo(this.Command.MyInvocation); this.commandRuntime._WriteErrorSkipAllowCheck(errorRecord); }
private void ProcessOutputHelper() { for (object obj = this.outputReader.Read(); obj != AutomationNull.Value; obj = this.outputReader.Read()) { ProcessOutputObject processOutputObject = obj as ProcessOutputObject; if (processOutputObject.Stream == MinishellStream.Error) { ErrorRecord data = processOutputObject.Data as ErrorRecord; data.SetInvocationInfo(this.Command.MyInvocation); this.commandRuntime._WriteErrorSkipAllowCheck(data); } else if (processOutputObject.Stream == MinishellStream.Output) { this.commandRuntime._WriteObjectSkipAllowCheck(processOutputObject.Data); } else if (processOutputObject.Stream == MinishellStream.Debug) { this.Command.PSHostInternal.UI.WriteDebugLine(processOutputObject.Data as string); } else if (processOutputObject.Stream == MinishellStream.Verbose) { this.Command.PSHostInternal.UI.WriteVerboseLine(processOutputObject.Data as string); } else if (processOutputObject.Stream == MinishellStream.Warning) { this.Command.PSHostInternal.UI.WriteWarningLine(processOutputObject.Data as string); } else if (processOutputObject.Stream == MinishellStream.Progress && processOutputObject.Data is PSObject data) { long sourceId = 0; PSMemberInfo property1 = (PSMemberInfo)data.Properties["SourceId"]; if (property1 != null) { sourceId = (long)property1.Value; } PSMemberInfo property2 = (PSMemberInfo)data.Properties["Record"]; ProgressRecord record = (ProgressRecord)null; if (property2 != null) { record = property2.Value as ProgressRecord; } if (record != null) { this.Command.PSHostInternal.UI.WriteProgress(sourceId, record); } } if (this.Command.Context.CurrentPipelineStopping) { this.StopProcessing(); break; } } }
internal PipelineStoppedException ManageInvocationException(Exception e) { PipelineStoppedException exception4; try { if (this.Command != null) { ProviderInvocationException innerException = e as ProviderInvocationException; if (innerException != null) { e = new CmdletProviderInvocationException(innerException, this.Command.MyInvocation); } else if (((!(e is PipelineStoppedException) && !(e is CmdletInvocationException)) && (!(e is ActionPreferenceStopException) && !(e is HaltCommandException))) && (!(e is FlowControlException) && !(e is ScriptCallDepthException))) { RuntimeException exception2 = e as RuntimeException; if ((exception2 == null) || !exception2.WasThrownFromThrowStatement) { e = new CmdletInvocationException(e, this.Command.MyInvocation); } } if (this.commandRuntime.UseTransaction != 0) { bool flag = false; for (Exception exception3 = e; exception3 != null; exception3 = exception3.InnerException) { if (exception3 is TimeoutException) { flag = true; break; } } if (flag) { ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(TransactionStrings.TransactionTimedOut), "TRANSACTION_TIMEOUT", ErrorCategory.InvalidOperation, e); errorRecord.SetInvocationInfo(this.Command.MyInvocation); e = new CmdletInvocationException(errorRecord); } if (this._context.TransactionManager.HasTransaction && (this._context.TransactionManager.RollbackPreference != RollbackSeverity.Never)) { this.Context.TransactionManager.Rollback(true); } } return((PipelineStoppedException)this.commandRuntime.ManageException(e)); } exception4 = new PipelineStoppedException(); } catch (Exception) { throw; } return(exception4); }
protected static void ValidateCompatibleLanguageMode(ScriptBlock scriptBlock, PSLanguageMode languageMode, InvocationInfo invocationInfo) { if (scriptBlock.LanguageMode.HasValue) { PSLanguageMode?nullable2 = scriptBlock.LanguageMode; PSLanguageMode mode = languageMode; if (((((PSLanguageMode)nullable2.GetValueOrDefault()) != mode) || !nullable2.HasValue) && ((languageMode == PSLanguageMode.RestrictedLanguage) || (languageMode == PSLanguageMode.ConstrainedLanguage))) { ErrorRecord errorRecord = new ErrorRecord(new NotSupportedException(DiscoveryExceptions.DotSourceNotSupported), "DotSourceNotSupported", ErrorCategory.InvalidOperation, null); errorRecord.SetInvocationInfo(invocationInfo); throw new CmdletInvocationException(errorRecord); } } }
private RuntimeException ConvertToException( object result, ExecutionContext context) { result = PSObject.Base(result); if (LanguagePrimitives.IsNull(result) && context.CurrentExceptionBeingHandled != null && this._inCatch) { result = (object)context.CurrentExceptionBeingHandled; } switch (result) { case RuntimeException runtimeException3: runtimeException3.WasThrownFromThrowStatement = true; return(runtimeException3); case ErrorRecord errorRecord3: RuntimeException runtimeException1 = new RuntimeException(errorRecord3.ToString(), errorRecord3.Exception, errorRecord3); if (errorRecord3.InvocationInfo == null) { errorRecord3.SetInvocationInfo(new InvocationInfo((CommandInfo)null, this.NodeToken, context)); } runtimeException1.WasThrownFromThrowStatement = true; return(runtimeException1); case Exception exception2: ErrorRecord errorRecord1 = new ErrorRecord(exception2, exception2.Message, ErrorCategory.OperationStopped, (object)null); errorRecord1.SetInvocationInfo(new InvocationInfo((CommandInfo)null, this.NodeToken, context)); return(new RuntimeException(exception2.Message, exception2, errorRecord1) { WasThrownFromThrowStatement = true }); default: string str = LanguagePrimitives.IsNull(result) ? "ScriptHalted" : Parser.ConvertTo <string>(result, this.NodeToken); Exception exception1 = (Exception) new RuntimeException(str, (Exception)null); ErrorRecord errorRecord2 = new ErrorRecord(exception1, str, ErrorCategory.OperationStopped, (object)null); errorRecord2.SetInvocationInfo(new InvocationInfo((CommandInfo)null, this.NodeToken, context)); RuntimeException runtimeException2 = new RuntimeException(str, exception1, errorRecord2); runtimeException2.WasThrownFromThrowStatement = true; runtimeException2.SetTargetObject(result); return(runtimeException2); } }
/// <summary> /// Ensures that the provided script block is compatible with the current language mode - to /// be used when a script block is being dotted. /// </summary> /// <param name="scriptBlock">The script block being dotted.</param> /// <param name="languageMode">The current language mode.</param> /// <param name="invocationInfo">The invocation info about the command.</param> protected static void ValidateCompatibleLanguageMode( ScriptBlock scriptBlock, PSLanguageMode languageMode, InvocationInfo invocationInfo) { // If we are in a constrained language mode (Core or Restricted), block it. // We are currently restricting in one direction: // - Can't dot something from a more permissive mode, since that would probably expose // functions that were never designed to handle untrusted data. // This function won't be called for NoLanguage mode so the only direction checked is trusted // (FullLanguage mode) script running in a constrained/restricted session. if ((scriptBlock.LanguageMode.HasValue) && (scriptBlock.LanguageMode != languageMode) && ((languageMode == PSLanguageMode.RestrictedLanguage) || (languageMode == PSLanguageMode.ConstrainedLanguage))) { // Finally check if script block is really just PowerShell commands plus parameters. // If so then it is safe to dot source across language mode boundaries. bool isSafeToDotSource = false; try { scriptBlock.GetPowerShell(); isSafeToDotSource = true; } catch (Exception) { } if (!isSafeToDotSource) { ErrorRecord errorRecord = new ErrorRecord( new NotSupportedException( DiscoveryExceptions.DotSourceNotSupported), "DotSourceNotSupported", ErrorCategory.InvalidOperation, null); errorRecord.SetInvocationInfo(invocationInfo); throw new CmdletInvocationException(errorRecord); } } }
internal static void UpdateExceptionErrorRecordPosition(Exception exception, IScriptExtent extent) { if ((extent != null) && (extent != PositionUtilities.EmptyExtent)) { IContainsErrorRecord record = exception as IContainsErrorRecord; if (record != null) { ErrorRecord errorRecord = record.ErrorRecord; InvocationInfo invocationInfo = errorRecord.InvocationInfo; if (invocationInfo == null) { errorRecord.SetInvocationInfo(new InvocationInfo(null, extent)); } else if ((invocationInfo.ScriptPosition == null) || (invocationInfo.ScriptPosition == PositionUtilities.EmptyExtent)) { invocationInfo.ScriptPosition = extent; errorRecord.LockScriptStackTrace(); } } } }
/// <summary> /// Implementation of ThrowTerminatingError. /// </summary> /// <param name="errorRecord"> /// The error which caused the command to be terminated /// </param> /// <exception cref="PipelineStoppedException"> /// always /// </exception> /// <remarks> /// <see cref="System.Management.Automation.Cmdlet.ThrowTerminatingError"/> /// terminates the command, where /// <see cref="System.Management.Automation.ICommandRuntime.WriteError"/> /// allows the command to continue. /// /// The cmdlet can also terminate the command by simply throwing /// any exception. When the cmdlet's implementation of /// <see cref="System.Management.Automation.Cmdlet.ProcessRecord"/>, /// <see cref="System.Management.Automation.Cmdlet.BeginProcessing"/> or /// <see cref="System.Management.Automation.Cmdlet.EndProcessing"/> /// throws an exception, the Engine will always catch the exception /// and report it as a terminating error. /// However, it is preferred for the cmdlet to call /// <see cref="System.Management.Automation.Cmdlet.ThrowTerminatingError"/>, /// so that the additional information in /// <see cref="System.Management.Automation.ErrorRecord"/> /// is available. /// /// <see cref="System.Management.Automation.Cmdlet.ThrowTerminatingError"/> /// always throws /// <see cref="System.Management.Automation.PipelineStoppedException"/>, /// regardless of what error was specified in <paramref name="errorRecord"/>. /// The Cmdlet should generally just allow /// <see cref="System.Management.Automation.PipelineStoppedException"/>. /// to percolate up to the caller of /// <see cref="System.Management.Automation.Cmdlet.ProcessRecord"/>. /// etc. /// </remarks> public void ThrowTerminatingError(ErrorRecord errorRecord) { ThrowIfStopping(); if (null == errorRecord) { throw PSTraceSource.NewArgumentNullException("errorRecord"); } errorRecord.SetInvocationInfo(MyInvocation); if (null != errorRecord.ErrorDetails && null != errorRecord.ErrorDetails.TextLookupError) { Exception textLookupError = errorRecord.ErrorDetails.TextLookupError; errorRecord.ErrorDetails.TextLookupError = null; MshLog.LogCommandHealthEvent( Context, textLookupError, Severity.Warning); } // This code forces the stack trace and source fields to be populated if (null != errorRecord.Exception && String.IsNullOrEmpty(errorRecord.Exception.StackTrace)) { try { throw errorRecord.Exception; } catch (Exception) { // no need to worry about severe exceptions since // it wasn't really thrown originally } } CmdletInvocationException e = new CmdletInvocationException(errorRecord); // Code sees only that execution stopped throw ManageException(e); }
/// <summary> /// Wraps the exception which occurred during cmdlet invocation, /// stores that as the exception to be returned from /// PipelineProcessor.SynchronousExecute, and writes it to /// the error variable. /// </summary> /// <param name="e"> /// The exception to wrap in a CmdletInvocationException or /// CmdletProviderInvocationException. /// </param> /// <returns> /// Always returns PipelineStoppedException. The caller should /// throw this exception. /// </returns> /// <remarks> /// Almost all exceptions which occur during pipeline invocation /// are wrapped in CmdletInvocationException before they are stored /// in the pipeline. However, there are several exceptions: /// /// AccessViolationException, StackOverflowException: /// These are considered to be such severe errors that we /// FailFast the process immediately. /// /// ProviderInvocationException: In this case, we assume that the /// cmdlet is get-item or the like, a thin wrapper around the /// provider API. We discard the original ProviderInvocationException /// and re-wrap its InnerException (the real error) in /// CmdletProviderInvocationException. This makes it easier to reach /// the real error. /// /// CmdletInvocationException, ActionPreferenceStopException: /// This indicates that the cmdlet itself ran a command which failed. /// We could go ahead and wrap the original exception in multiple /// layers of CmdletInvocationException, but this makes it difficult /// for the caller to access the root problem, plus the serialization /// layer might not communicate properties beyond some fixed depth. /// Instead, we choose to not re-wrap the exception. /// /// PipelineStoppedException: This could mean one of two things. /// It usually means that this pipeline has already stopped, /// in which case the pipeline already stores the original error. /// It could also mean that the cmdlet ran a command which was /// stopped by CTRL-C etc, in which case we choose not to /// re-wrap the exception as with CmdletInvocationException. /// </remarks> internal PipelineStoppedException ManageInvocationException(Exception e) { try { if (Command != null) { do // false loop { ProviderInvocationException pie = e as ProviderInvocationException; if (pie != null) { // If a ProviderInvocationException occurred, // discard the ProviderInvocationException and // re-wrap in CmdletProviderInvocationException e = new CmdletProviderInvocationException( pie, Command.MyInvocation); break; } // 1021203-2005/05/09-JonN // HaltCommandException will cause the command // to stop, but not be reported as an error. // 906445-2005/05/16-JonN // FlowControlException should not be wrapped if (e is PipelineStoppedException || e is CmdletInvocationException || e is ActionPreferenceStopException || e is HaltCommandException || e is FlowControlException || e is ScriptCallDepthException) { // do nothing; do not rewrap these exceptions break; } RuntimeException rte = e as RuntimeException; if (rte != null && rte.WasThrownFromThrowStatement) { // do not rewrap a script based throw break; } // wrap all other exceptions e = new CmdletInvocationException( e, Command.MyInvocation); } while (false); // commandRuntime.ManageException will always throw PipelineStoppedException // Otherwise, just return this exception... // If this exception happened in a transacted cmdlet, // rollback the transaction if (commandRuntime.UseTransaction) { // The "transaction timed out" exception is // exceedingly obtuse. We clarify things here. bool isTimeoutException = false; Exception tempException = e; while (tempException != null) { if (tempException is System.TimeoutException) { isTimeoutException = true; break; } tempException = tempException.InnerException; } if (isTimeoutException) { ErrorRecord errorRecord = new ErrorRecord( new InvalidOperationException( TransactionStrings.TransactionTimedOut), "TRANSACTION_TIMEOUT", ErrorCategory.InvalidOperation, e); errorRecord.SetInvocationInfo(Command.MyInvocation); e = new CmdletInvocationException(errorRecord); } // Rollback the transaction in the case of errors. if ( _context.TransactionManager.HasTransaction && _context.TransactionManager.RollbackPreference != RollbackSeverity.Never ) { Context.TransactionManager.Rollback(true); } } return((PipelineStoppedException)this.commandRuntime.ManageException(e)); } // Upstream cmdlets see only that execution stopped // This should only happen if Command is null return(new PipelineStoppedException()); } catch (Exception) { // this method should not throw exceptions; warn about any violations on checked builds and re-throw Diagnostics.Assert(false, "This method should not throw exceptions!"); throw; } }
internal RuntimeException(ErrorCategory errorCategory, InvocationInfo invocationInfo, IScriptExtent errorPosition, string errorIdAndResourceId, string message, Exception innerException) : base(message, innerException) { SetErrorCategory(errorCategory); SetErrorId(errorIdAndResourceId); if ((errorPosition == null) && (invocationInfo != null)) { errorPosition = invocationInfo.ScriptPosition; } if (invocationInfo == null) return; _errorRecord = new ErrorRecord( new ParentContainsErrorRecordException(this), _errorId, _errorCategory, _targetObject); _errorRecord.SetInvocationInfo(new InvocationInfo(invocationInfo.MyCommand, errorPosition)); }
/// <summary> /// Wraps the exception which occurred during cmdlet invocation, /// stores that as the exception to be returned from /// PipelineProcessor.SynchronousExecute, and writes it to /// the error variable. /// </summary> /// /// <param name="e"> /// The exception to wrap in a CmdletInvocationException or /// CmdletProviderInvocationException. /// </param> /// /// <returns> /// Always returns PipelineStoppedException. The caller should /// throw this exception. /// </returns> /// /// <remarks> /// Almost all exceptions which occur during pipeline invocation /// are wrapped in CmdletInvocationException before they are stored /// in the pipeline. However, there are several exceptions: /// /// AccessViolationException, StackOverflowException: /// These are considered to be such severe errors that we /// FailFast the process immediately. /// /// ProviderInvocationException: In this case, we assume that the /// cmdlet is get-item or the like, a thin wrapper around the /// provider API. We discard the original ProviderInvocationException /// and re-wrap its InnerException (the real error) in /// CmdletProviderInvocationException. This makes it easier to reach /// the real error. /// /// CmdletInvocationException, ActionPreferenceStopException: /// This indicates that the cmdlet itself ran a command which failed. /// We could go ahead and wrap the original exception in multiple /// layers of CmdletInvocationException, but this makes it difficult /// for the caller to access the root problem, plus the serialization /// layer might not communicate properties beyond some fixed depth. /// Instead, we choose to not re-wrap the exception. /// /// PipelineStoppedException: This could mean one of two things. /// It usually means that this pipeline has already stopped, /// in which case the pipeline already stores the original error. /// It could also mean that the cmdlet ran a command which was /// stopped by CTRL-C etc, in which case we choose not to /// re-wrap the exception as with CmdletInvocationException. /// </remarks> internal PipelineStoppedException ManageInvocationException(Exception e) { try { if (null != Command) { do // false loop { ProviderInvocationException pie = e as ProviderInvocationException; if (pie != null) { // If a ProviderInvocationException occurred, // discard the ProviderInvocationException and // re-wrap in CmdletProviderInvocationException e = new CmdletProviderInvocationException( pie, Command.MyInvocation); break; } // 1021203-2005/05/09-JonN // HaltCommandException will cause the command // to stop, but not be reported as an error. // 906445-2005/05/16-JonN // FlowControlException should not be wrapped if (e is PipelineStoppedException || e is CmdletInvocationException || e is ActionPreferenceStopException || e is HaltCommandException || e is FlowControlException || e is ScriptCallDepthException) { // do nothing; do not rewrap these exceptions break; } RuntimeException rte = e as RuntimeException; if (rte != null && rte.WasThrownFromThrowStatement) { // do not rewrap a script based throw break; } // wrap all other exceptions e = new CmdletInvocationException( e, Command.MyInvocation); } while (false); // commandRuntime.ManageException will always throw PipelineStoppedException // Otherwise, just return this exception... // If this exception happened in a transacted cmdlet, // rollback the transaction if (commandRuntime.UseTransaction) { // The "transaction timed out" exception is // exceedingly obtuse. We clarify things here. bool isTimeoutException = false; Exception tempException = e; while (tempException != null) { if (tempException is System.TimeoutException) { isTimeoutException = true; break; } tempException = tempException.InnerException; } if (isTimeoutException) { ErrorRecord errorRecord = new ErrorRecord( new InvalidOperationException( TransactionStrings.TransactionTimedOut), "TRANSACTION_TIMEOUT", ErrorCategory.InvalidOperation, e); errorRecord.SetInvocationInfo(Command.MyInvocation); e = new CmdletInvocationException(errorRecord); } // Rollback the transaction in the case of errors. if ( _context.TransactionManager.HasTransaction && _context.TransactionManager.RollbackPreference != RollbackSeverity.Never ) { Context.TransactionManager.Rollback(true); } } return (PipelineStoppedException)this.commandRuntime.ManageException(e); } // Upstream cmdlets see only that execution stopped // This should only happen if Command is null return new PipelineStoppedException(); } catch (Exception) { // this method should not throw exceptions; warn about any violations on checked builds and re-throw Diagnostics.Assert(false, "This method should not throw exceptions!"); throw; } }
protected static void ValidateCompatibleLanguageMode(ScriptBlock scriptBlock, PSLanguageMode languageMode, InvocationInfo invocationInfo) { if (scriptBlock.LanguageMode.HasValue) { PSLanguageMode? nullable2 = scriptBlock.LanguageMode; PSLanguageMode mode = languageMode; if (((((PSLanguageMode) nullable2.GetValueOrDefault()) != mode) || !nullable2.HasValue) && ((languageMode == PSLanguageMode.RestrictedLanguage) || (languageMode == PSLanguageMode.ConstrainedLanguage))) { ErrorRecord errorRecord = new ErrorRecord(new NotSupportedException(DiscoveryExceptions.DotSourceNotSupported), "DotSourceNotSupported", ErrorCategory.InvalidOperation, null); errorRecord.SetInvocationInfo(invocationInfo); throw new CmdletInvocationException(errorRecord); } } }
internal PipelineStoppedException ManageInvocationException(Exception e) { PipelineStoppedException exception4; try { if (this.Command != null) { ProviderInvocationException innerException = e as ProviderInvocationException; if (innerException != null) { e = new CmdletProviderInvocationException(innerException, this.Command.MyInvocation); } else if (((!(e is PipelineStoppedException) && !(e is CmdletInvocationException)) && (!(e is ActionPreferenceStopException) && !(e is HaltCommandException))) && (!(e is FlowControlException) && !(e is ScriptCallDepthException))) { RuntimeException exception2 = e as RuntimeException; if ((exception2 == null) || !exception2.WasThrownFromThrowStatement) { e = new CmdletInvocationException(e, this.Command.MyInvocation); } } if (this.commandRuntime.UseTransaction != 0) { bool flag = false; for (Exception exception3 = e; exception3 != null; exception3 = exception3.InnerException) { if (exception3 is TimeoutException) { flag = true; break; } } if (flag) { ErrorRecord errorRecord = new ErrorRecord(new InvalidOperationException(TransactionStrings.TransactionTimedOut), "TRANSACTION_TIMEOUT", ErrorCategory.InvalidOperation, e); errorRecord.SetInvocationInfo(this.Command.MyInvocation); e = new CmdletInvocationException(errorRecord); } if (this._context.TransactionManager.HasTransaction && (this._context.TransactionManager.RollbackPreference != RollbackSeverity.Never)) { this.Context.TransactionManager.Rollback(true); } } return (PipelineStoppedException) this.commandRuntime.ManageException(e); } exception4 = new PipelineStoppedException(); } catch (Exception) { throw; } return exception4; }
public void ThrowTerminatingError(ErrorRecord errorRecord) { this.ThrowIfStopping(); if (errorRecord == null) { throw PSTraceSource.NewArgumentNullException("errorRecord"); } errorRecord.SetInvocationInfo(this.MyInvocation); if ((errorRecord.ErrorDetails != null) && (errorRecord.ErrorDetails.TextLookupError != null)) { Exception textLookupError = errorRecord.ErrorDetails.TextLookupError; errorRecord.ErrorDetails.TextLookupError = null; MshLog.LogCommandHealthEvent(this.context, textLookupError, Severity.Warning); } if ((errorRecord.Exception != null) && string.IsNullOrEmpty(errorRecord.Exception.StackTrace)) { try { throw errorRecord.Exception; } catch (Exception) { } } CmdletInvocationException e = new CmdletInvocationException(errorRecord); throw this.ManageException(e); }
private void ProcessOutputHelper() { for (object obj2 = this.outputReader.Read(); obj2 != AutomationNull.Value; obj2 = this.outputReader.Read()) { ProcessOutputObject obj3 = obj2 as ProcessOutputObject; if (obj3.Stream == MinishellStream.Error) { ErrorRecord data = obj3.Data as ErrorRecord; data.SetInvocationInfo(base.Command.MyInvocation); ActionPreference?actionPreference = null; base.commandRuntime._WriteErrorSkipAllowCheck(data, actionPreference); } else if (obj3.Stream == MinishellStream.Output) { base.commandRuntime._WriteObjectSkipAllowCheck(obj3.Data); } else if (obj3.Stream == MinishellStream.Debug) { string message = obj3.Data as string; base.Command.PSHostInternal.UI.WriteDebugLine(message); } else if (obj3.Stream == MinishellStream.Verbose) { string str2 = obj3.Data as string; base.Command.PSHostInternal.UI.WriteVerboseLine(str2); } else if (obj3.Stream == MinishellStream.Warning) { string str3 = obj3.Data as string; base.Command.PSHostInternal.UI.WriteWarningLine(str3); } else if (obj3.Stream == MinishellStream.Progress) { PSObject obj4 = obj3.Data as PSObject; if (obj4 != null) { long sourceId = 0L; PSMemberInfo info = obj4.Properties["SourceId"]; if (info != null) { sourceId = (long)info.Value; } info = obj4.Properties["Record"]; ProgressRecord record = null; if (info != null) { record = info.Value as ProgressRecord; } if (record != null) { base.Command.PSHostInternal.UI.WriteProgress(sourceId, record); } } } if (base.Command.Context.CurrentPipelineStopping) { this.StopProcessing(); return; } } }
/// <summary> /// Writes an ErrorRecord to the commands error pipe because the specified /// input object was not bound to the command. /// </summary> /// /// <param name="inputObject"> /// The pipeline input object that was not bound. /// </param> /// /// <param name="resourceString"> /// The error message. /// </param> /// /// <param name="errorId"> /// The resource ID of the error message is also used as error ID /// of the ErrorRecord. /// </param> /// /// <param name="args"> /// Additional arguments to be formatted into the error message that represented in <paramref name="resourceString"/>. /// </param> /// private void WriteInputObjectError( object inputObject, string resourceString, string errorId, params object[] args) { Type inputObjectType = (inputObject == null) ? null : inputObject.GetType(); ParameterBindingException bindingException = new ParameterBindingException( ErrorCategory.InvalidArgument, this.Command.MyInvocation, null, null, null, inputObjectType, resourceString, errorId, args); ErrorRecord errorRecord = new ErrorRecord( bindingException, errorId, ErrorCategory.InvalidArgument, inputObject); errorRecord.SetInvocationInfo(this.Command.MyInvocation); this.commandRuntime._WriteErrorSkipAllowCheck(errorRecord); } // WriteIgnoredInputObjectError
/// <summary> /// Ensures that the provided script block is compatible with the current language mode - to /// be used when a script block is being dotted. /// </summary> /// <param name="scriptBlock">The script block being dotted</param> /// <param name="languageMode">The current language mode</param> /// <param name="invocationInfo">The invocation info about the command</param> protected static void ValidateCompatibleLanguageMode(ScriptBlock scriptBlock, PSLanguageMode languageMode, InvocationInfo invocationInfo) { // If we are in a constrained language mode (Core or Restricted), block it. // We are currently restricting in one direction: // - Can't dot something from a more permissive mode, since that would probably expose // functions that were never designed to handle untrusted data. // This function won't be called for NoLanguage mode so the only direction checked is trusted // (FullLanguage mode) script running in a constrained/restricted session. if ((scriptBlock.LanguageMode.HasValue) && (scriptBlock.LanguageMode != languageMode) && ((languageMode == PSLanguageMode.RestrictedLanguage) || (languageMode == PSLanguageMode.ConstrainedLanguage))) { // Finally check if script block is really just PowerShell commands plus parameters. // If so then it is safe to dot source across language mode boundaries. bool isSafeToDotSource = false; try { scriptBlock.GetPowerShell(); isSafeToDotSource = true; } catch (Exception e) { CheckForSevereException(e); } if (!isSafeToDotSource) { ErrorRecord errorRecord = new ErrorRecord( new NotSupportedException( DiscoveryExceptions.DotSourceNotSupported), "DotSourceNotSupported", ErrorCategory.InvalidOperation, null); errorRecord.SetInvocationInfo(invocationInfo); throw new CmdletInvocationException(errorRecord); } } }