Computer.cs

#if !UNIX

/********************************************************************++
Copyright (c) Microsoft Corporation.  All rights reserved.
--********************************************************************/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Management.Automation;
using System.Management.Automation.Internal;
using System.Net;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using Microsoft.Win32;
using Microsoft.PowerShell.Commands.Internal;
using Microsoft.Management.Infrastructure;
using Microsoft.Management.Infrastructure.Options;
using System.Linq;
using Dbg = System.Management.Automation;

#if CORECLR
using Microsoft.PowerShell.CoreClr.Stubs;
#else
//TODO:CORECLR System.DirectoryServices is not available on CORE CLR
using System.DirectoryServices;
//TODO:CORECLR System.Security.Permission is not available on CORE CLR
using System.Security.Permissions;
using System.Management; // We are not porting the library to CoreCLR
using Microsoft.WSMan.Management;
#endif

// FxCop suppressions for resource strings:
[module: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", Scope = "resource", Target = "ComputerResources.resources", MessageId = "unjoined")]
[module: SuppressMessage("Microsoft.Naming", "CA1701:ResourceStringCompoundWordsShouldBeCasedCorrectly", Scope = "resource", Target = "ComputerResources.resources", MessageId = "UpTime")]

namespace Microsoft.PowerShell.Commands
{
#region Test-Connection

    /// <summary>
    /// This cmdlet is used to test whether a particular host is reachable across an
    /// IP network. It works by sending ICMP "echo request" packets to the target
    /// host and listening for ICMP "echo response" replies. This cmdlet prints a
    /// statistical summary when finished.
    /// </summary>
    [Cmdlet(VerbsDiagnostic.Test, "Connection", DefaultParameterSetName = RegularParameterSet,
        HelpUri = "https://go.microsoft.com/fwlink/?LinkID=135266", RemotingCapability = RemotingCapability.OwnedByCommand)]
    [OutputType(typeof(Boolean))]
    [OutputType(@"System.Management.ManagementObject#root\cimv2\Win32_PingStatus")]
    public class TestConnectionCommand : PSCmdlet
    {
#region "Parameters"

        private const string RegularParameterSet = "Default";
        private const string QuietParameterSet = "Quiet";
        private const string SourceParameterSet = "Source";

        /// <summary>
        ///
        /// </summary>
        [Parameter(ParameterSetName = SourceParameterSet)]
        [Parameter(ParameterSetName = RegularParameterSet)]
        public SwitchParameter AsJob { get; set; } = false;

        /// <summary>
        /// The following is the definition of the input parameter "DcomAuthentication".
        /// Specifies the authentication level to be used with WMI connection. Valid
        /// values are:
        ///
        /// Unchanged = -1,
        /// Default = 0,
        /// None = 1,
        /// Connect = 2,
        /// Call = 3,
        /// Packet = 4,
        /// PacketIntegrity = 5,
        /// PacketPrivacy = 6.
        /// </summary>

        [Parameter]
        [Alias("Authentication")]
        public AuthenticationLevel DcomAuthentication { get; set; } = AuthenticationLevel.Packet;

        /// <summary>
        /// The authentication options for CIM_WSMan connection
        /// </summary>
        [Parameter]
        [ValidateSet(
            "Default",
            "Basic",
            "Negotiate", // can be used with and without credential (without -> PSRP mapped to NegotiateWithImplicitCredential)
            "CredSSP",
            "Digest",
            "Kerberos")] // can be used with and without credential (not sure about implications)
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
        public string WsmanAuthentication { get; set; } = "Default";

        /// <summary>
        /// Specify the protocol to use
        /// </summary>
        [Parameter]
        [ValidateSet(ComputerWMIHelper.DcomProtocol, ComputerWMIHelper.WsmanProtocol)]
        public string Protocol { get; set; } =
#if CORECLR
            //CoreClr does not support DCOM protocol
            // This change makes sure that the the command works seamlessly if user did not explicitly entered the protocol
            ComputerWMIHelper.WsmanProtocol;
#else
            ComputerWMIHelper.DcomProtocol;
#endif

        /// <summary>
        /// The following is the definition of the input parameter "BufferSize".
        /// Buffer size sent with the this command. The default value is 32.
        /// </summary>
        [Parameter]
        [Alias("Size", "Bytes", "BS")]
        [ValidateRange((int)0, (int)65500)]
        public Int32 BufferSize { get; set; } = 32;

        /// <summary>
        /// The following is the definition of the input parameter "TimeOut".
        /// Time-out value in milliseconds. If a response is not received in this time, no response is assumed. The default is 1000 milliseconds.
        /// </summary>
        [Parameter]
        [ValidateRange((int)1, Int32.MaxValue)]
        public Int32 TimeOut { get; set; } = 1000;

        /// <summary>
        /// The following is the definition of the input parameter "ComputerName".
        /// Value of the address requested. The form of the value can be either the
        /// computer name ("wxyz1234"), IPv4 address ("192.168.177.124"), or IPv6
        /// address ("2010:836B:4179::836B:4179").
        /// </summary>
        [Parameter(Mandatory = true,
                   Position = 0,
                   ValueFromPipelineByPropertyName = true)]
        [ValidateNotNullOrEmpty]
        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
        [Alias("CN", "IPAddress", "__SERVER", "Server", "Destination")]
        public String[] ComputerName { get; set; }

        /// <summary>
        /// The following is the definition of the input parameter "Count".
        /// Number of echo requests to send.
        /// </summary>
        [Parameter]
        [ValidateRange(1, UInt32.MaxValue)]
        public Int32 Count { get; set; } = 4;

        /// <summary>
        /// The following is the definition of the input parameter "Credential".
        /// Specifies a user account that has permission to perform this action. Type a
        /// user-name, such as "User01" or "Domain01\User01", or enter a PSCredential
        /// object, such as one from the Get-Credential cmdlet
        /// </summary>
        [Parameter(ParameterSetName = SourceParameterSet, Mandatory = false)]
        [ValidateNotNullOrEmpty]
        [Credential]
        public PSCredential Credential { get; set; }

        /// <summary>
        /// The following is the definition of the input parameter "FromComputerName".
        /// Specifies the Computer names where the ping request is originated from.
        /// </summary>
        [Parameter(Position = 1, ParameterSetName = SourceParameterSet, Mandatory = true)]
        [ValidateNotNullOrEmpty]
        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
        [Alias("FCN", "SRC")]
        public String[] Source { get; set; } = new string[] { "." };

        /// <summary>
        /// The following is the definition of the input parameter "Impersonation".
        /// Specifies the impersonation level to use when calling the WMI method. Valid
        /// values are:
        ///
        /// Default = 0,
        /// Anonymous = 1,
        /// Identify = 2,
        /// Impersonate = 3,
        /// Delegate = 4.
        /// </summary>
        [Parameter]
        public ImpersonationLevel Impersonation { get; set; } = ImpersonationLevel.Impersonate;

        /// <summary>
        /// The following is the definition of the input parameter "ThrottleLimit".
        /// The number of concurrent computers on which the command will be allowed to
        /// execute
        /// </summary>
        [Parameter(ParameterSetName = SourceParameterSet)]
        [Parameter(ParameterSetName = RegularParameterSet)]
        [ValidateRange(int.MinValue, (int)1000)]
        public Int32 ThrottleLimit
        {
            get { return throttlelimit; }
            set
            {
                throttlelimit = value;
                if (throttlelimit <= 0)
                    throttlelimit = 32;
            }
        }
        private Int32 throttlelimit = 32;

        /// <summary>
        /// The following is the definition of the input parameter "TimeToLive".
        /// Life span of the packet in seconds. The value is treated as an upper limit.
        /// All routers must decrement this value by 1 (one). When this value becomes 0
        /// (zero), the packet is dropped by the router. The default value is 80
        /// seconds. The hops between routers rarely take this amount of time.
        /// </summary>
        [Parameter]
        [ValidateRange(1, (int)255)]
        [Alias("TTL")]
        public Int32 TimeToLive { get; set; } = 80;

        /// <summary>
        /// delay parameter
        /// </summary>
        [Parameter]
        [ValidateRange(1, 60)]
        public Int32 Delay { get; set; } = 1;

        /// <summary>
        /// quiet parameter
        /// </summary>
        [Parameter(ParameterSetName = QuietParameterSet)]
        public SwitchParameter Quiet
        {
            get { return quiet; }
            set { quiet = value; }
        }
        private bool quiet = false;

#endregion "parameters"
#region "Overrides"

#if !CORECLR
        ///// <summary>
        ///// To Store the output for each ping reply
        ///// </summary>
        private ManagementObjectSearcher searcher;

#endif
        private TransportProtocol _transportProtocol = TransportProtocol.DCOM;
        private readonly CancellationTokenSource cancel = new CancellationTokenSource();
        private Dictionary<string, bool> quietResults = new Dictionary<string, bool>();
        /// <summary>
        /// To begin processing Test-connection
        /// </summary>
        protected override void BeginProcessing()
        {
            base.BeginProcessing();
            // Verify parameter set

            bool haveProtocolParam = this.MyInvocation.BoundParameters.ContainsKey("Protocol");
            bool haveWsmanAuthenticationParam = this.MyInvocation.BoundParameters.ContainsKey("WsmanAuthentication");
            bool haveDcomAuthenticationParam = this.MyInvocation.BoundParameters.ContainsKey("DcomAuthentication");
            bool haveDcomImpersonation = this.MyInvocation.BoundParameters.ContainsKey("Impersonation");
            _transportProtocol = (this.Protocol.Equals(ComputerWMIHelper.WsmanProtocol, StringComparison.OrdinalIgnoreCase) || (haveWsmanAuthenticationParam && !haveProtocolParam)) ?
                                 TransportProtocol.WSMan : TransportProtocol.DCOM;

            if (haveWsmanAuthenticationParam && (haveDcomAuthenticationParam || haveDcomImpersonation))
            {
                string errMsg = StringUtil.Format(ComputerResources.StopCommandParamWSManAuthConflict, ComputerResources.StopCommandParamMessage);
                ThrowTerminatingError(
                    new ErrorRecord(
                        new PSArgumentException(errMsg),
                        "InvalidParameter",
                        ErrorCategory.InvalidArgument,
                        this));
            }

            if ((_transportProtocol == TransportProtocol.DCOM) && haveWsmanAuthenticationParam)
            {
                string errMsg = StringUtil.Format(ComputerResources.StopCommandWSManAuthProtocolConflict, ComputerResources.StopCommandParamMessage);
                ThrowTerminatingError(
                    new ErrorRecord(
                        new PSArgumentException(errMsg),
                        "InvalidParameter",
                        ErrorCategory.InvalidArgument,
                        this));
            }

            if ((_transportProtocol == TransportProtocol.WSMan) && (haveDcomAuthenticationParam || haveDcomImpersonation))
            {
                string errMsg = StringUtil.Format(ComputerResources.StopCommandAuthProtocolConflict, ComputerResources.StopCommandParamMessage);
                ThrowTerminatingError(
                    new ErrorRecord(
                        new PSArgumentException(errMsg),
                        "InvalidParameter",
                        ErrorCategory.InvalidArgument,
                        this));
            }

#if CORECLR
            if (this.MyInvocation.BoundParameters.ContainsKey("DcomAuthentication"))
            {
                string errMsg = StringUtil.Format(ComputerResources.InvalidParameterForCoreClr, "DcomAuthentication");
                PSArgumentException ex = new PSArgumentException(errMsg, ComputerResources.InvalidParameterForCoreClr);
                ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForCoreClr", ErrorCategory.InvalidArgument, null));
            }

            if (this.MyInvocation.BoundParameters.ContainsKey("Impersonation"))
            {
                string errMsg = StringUtil.Format(ComputerResources.InvalidParameterForCoreClr, "Impersonation");
                PSArgumentException ex = new PSArgumentException(errMsg, ComputerResources.InvalidParameterForCoreClr);
                ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterForCoreClr", ErrorCategory.InvalidArgument, null));
            }

            if(this.Protocol.Equals(ComputerWMIHelper.DcomProtocol , StringComparison.OrdinalIgnoreCase))
            {
                InvalidOperationException ex = new InvalidOperationException(ComputerResources.InvalidParameterDCOMNotSupported);
                ThrowTerminatingError(new ErrorRecord(ex, "InvalidParameterDCOMNotSupported", ErrorCategory.InvalidOperation, null));
            }
#endif


            //testing
        }
        /// <summary>
        /// Process Record
        /// </summary>
        protected override void ProcessRecord()
        {
            switch (_transportProtocol)
            {
#if !CORECLR
                case TransportProtocol.DCOM:
                    processDCOMProtocolForTestConnection();
                    break;
#endif

                case TransportProtocol.WSMan:
                    ProcessWSManProtocolForTestConnection();
                    break;
            }
        }
        /// <summary>
        /// to implement ^C
        /// </summary>
        protected override void StopProcessing()
        {
#if !CORECLR
            ManagementObjectSearcher stopSearcher = searcher;
            if (stopSearcher != null)
            {
                try
                {
                    stopSearcher.Dispose();
                }
                catch (ObjectDisposedException) { }
            }
#endif
            try
            {
                cancel.Cancel();
            }
            catch (ObjectDisposedException) { }
            catch (AggregateException) { }
        }
#endregion

#region "Private Methods "
        private string QueryString(string[] machinenames, bool escaperequired, bool selectrequired)
        {
            StringBuilder FilterString = new StringBuilder();
            if (selectrequired)
            {
                FilterString.Append("Select * from ");
                FilterString.Append(ComputerWMIHelper.WMI_Class_PingStatus);
                FilterString.Append(" where ");
            }
            FilterString.Append("((");
            for (int i = 0; i <= machinenames.Length - 1; i++)
            {
                FilterString.Append("Address='");
                string EscapeComp = machinenames[i].ToString();
                if (EscapeComp.Equals(".", StringComparison.CurrentCultureIgnoreCase))
                    EscapeComp = "localhost";
                if (escaperequired)
                {
                    EscapeComp = EscapeComp.Replace("\\", "\\\\'").ToString();
                    EscapeComp = EscapeComp.Replace("'", "\\'").ToString();
                }
                FilterString.Append(EscapeComp.ToString());
                FilterString.Append("'");
                if (i < machinenames.Length - 1)
                {
                    FilterString.Append(" Or ");
                }
            }
            FilterString.Append(")");
            FilterString.Append(" And ");
            FilterString.Append("TimeToLive=");
            FilterString.Append(TimeToLive);
            FilterString.Append(" And ");
            FilterString.Append("BufferSize=");
            FilterString.Append(BufferSize);
            FilterString.Append(" And ");
            FilterString.Append("TimeOut=");
            FilterString.Append(TimeOut);
            FilterString.Append(")");
            return FilterString.ToString();
        }
        private void ProcessPingStatus(Object pingStatusObj)
        {
            Dbg.Diagnostics.Assert(pingStatusObj != null, "Caller should verify that pingStatus != null");
            //Dbg.Diagnostics.Assert(pingStatusObj.ClassPath.ClassName.Equals("Win32_PingStatus"), "Caller should verify that pingStatus is a Win32_PingStatus object");
            string destinationAddress = null;
            UInt32 primaryAddressResolutionStatus;
            UInt32 statusCode;
#if !CORECLR
            if (_transportProtocol == TransportProtocol.DCOM)
            {
                ManagementBaseObject pingStatus = (ManagementBaseObject)pingStatusObj;

                destinationAddress = (string)LanguagePrimitives.ConvertTo(
                    pingStatus.GetPropertyValue("Address"),
                    typeof(string),
                    CultureInfo.InvariantCulture);

                primaryAddressResolutionStatus = (UInt32)LanguagePrimitives.ConvertTo(
                    pingStatus.GetPropertyValue("PrimaryAddressResolutionStatus"),
                    typeof(UInt32),
                    CultureInfo.InvariantCulture);
                statusCode = (UInt32)LanguagePrimitives.ConvertTo(
                        pingStatus.GetPropertyValue("StatusCode"),
                        typeof(UInt32),
                        CultureInfo.InvariantCulture);
            }
            else
            {
#endif
                CimInstance pingStatus = (CimInstance)pingStatusObj;
                destinationAddress = (string)LanguagePrimitives.ConvertTo(
                        pingStatus.CimInstanceProperties["Address"].Value.ToString(),
                        typeof(string),
                        CultureInfo.InvariantCulture);
                primaryAddressResolutionStatus = (UInt32)LanguagePrimitives.ConvertTo(
                        pingStatus.CimInstanceProperties["PrimaryAddressResolutionStatus"].Value,
                        typeof(UInt32),
                        CultureInfo.InvariantCulture);
                statusCode = (UInt32)LanguagePrimitives.ConvertTo(
                        pingStatus.CimInstanceProperties["StatusCode"].Value,
                        typeof(UInt32),
                        CultureInfo.InvariantCulture);

#if !CORECLR
            }
#endif
            if (primaryAddressResolutionStatus != 0)
            {
                if (!quiet)
                {
                    Win32Exception win32Exception = new Win32Exception(unchecked((int)primaryAddressResolutionStatus));
                    string message = StringUtil.Format(ComputerResources.NoPingResult, destinationAddress, win32Exception.Message);
                    Exception pingException = new System.Net.NetworkInformation.PingException(message, win32Exception);
                    ErrorRecord errorRecord = new ErrorRecord(pingException, "TestConnectionException", ErrorCategory.ResourceUnavailable, destinationAddress);
                    WriteError(errorRecord);
                }
            }
            else
            {
                if (statusCode != 0)
                {
                    if (!quiet)
                    {
                        Win32Exception win32Exception = new Win32Exception(unchecked((int)statusCode));
                        string message = StringUtil.Format(ComputerResources.NoPingResult, destinationAddress, win32Exception.Message);
                        Exception pingException = new System.Net.NetworkInformation.PingException(message, win32Exception);
                        ErrorRecord errorRecord = new ErrorRecord(pingException, "TestConnectionException", ErrorCategory.ResourceUnavailable, destinationAddress);
                        WriteError(errorRecord);
                    }
                }
                else
                {
                    this.quietResults[destinationAddress] = true;
                    if (!quiet)
                    {
                        WriteObject(pingStatusObj);
                    }
                }
            }
        }

#if !CORECLR
        private void processDCOMProtocolForTestConnection()
        {
            ConnectionOptions options = ComputerWMIHelper.GetConnectionOptions(DcomAuthentication, this.Impersonation, this.Credential);
            if (AsJob)
            {
                string filter = QueryString(ComputerName, true, false);
                GetWmiObjectCommand WMICmd = new GetWmiObjectCommand();
                WMICmd.Filter = filter.ToString();
                WMICmd.Class = ComputerWMIHelper.WMI_Class_PingStatus;
                WMICmd.ComputerName = Source;
                WMICmd.Authentication = DcomAuthentication;
                WMICmd.Impersonation = Impersonation;
                WMICmd.ThrottleLimit = throttlelimit;
                PSWmiJob wmiJob = new PSWmiJob(WMICmd, Source, throttlelimit, this.MyInvocation.MyCommand.Name, Count);
                this.JobRepository.Add(wmiJob);
                WriteObject(wmiJob);
            }
            else
            {
                int sourceCount = 0;
                foreach (string fromcomp in Source)
                {
                    try
                    {
                        sourceCount++;
                        EnumerationOptions enumOptions = new EnumerationOptions();
                        enumOptions.UseAmendedQualifiers = true;
                        enumOptions.DirectRead = true;

                        int destCount = 0;
                        foreach (var tocomp in ComputerName)
                        {
                            destCount++;
                            string querystring = QueryString(new string[] { tocomp }, true, true);
                            ObjectQuery query = new ObjectQuery(querystring);
                            ManagementScope scope = new ManagementScope(ComputerWMIHelper.GetScopeString(fromcomp, ComputerWMIHelper.WMI_Path_CIM), options);
                            scope.Options.EnablePrivileges = true;
                            scope.Connect();

                            using (searcher = new ManagementObjectSearcher(scope, query, enumOptions))
                            {
                                for (int j = 0; j <= Count - 1; j++)
                                {
                                    using (ManagementObjectCollection mobj = searcher.Get())
                                    {
                                        int mobjCount = 0;
                                        foreach (ManagementBaseObject obj in mobj)
                                        {
                                            using (obj)
                                            {
                                                mobjCount++;

                                                ProcessPingStatus(obj);

                                                // to delay the request, if case to avoid the delay for the last pingrequest
                                                if (mobjCount < mobj.Count || j < Count - 1 || sourceCount < Source.Length || destCount < ComputerName.Length)
                                                    Thread.Sleep(Delay * 1000);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        searcher = null;
                    }
                    catch (ManagementException e)
                    {
                        ErrorRecord errorRecord = new ErrorRecord(e, "TestConnectionException", ErrorCategory.InvalidOperation, null);
                        WriteError(errorRecord);
                        continue;
                    }
                    catch (System.Runtime.InteropServices.COMException e)
                    {
                        ErrorRecord errorRecord = new ErrorRecord(e, "TestConnectionException", ErrorCategory.InvalidOperation, null);
                        WriteError(errorRecord);
                        continue;
                    }
                }
            }

            if (quiet)
            {
                foreach (string destinationAddress in this.ComputerName)
                {
                    bool destinationResult = false;
                    this.quietResults.TryGetValue(destinationAddress, out destinationResult);
                    WriteObject(destinationResult);
                }
            }
        }
#endif
        private void ProcessWSManProtocolForTestConnection()
        {
            if (AsJob)
            {
                // TODO:  Need job for MI.Net WSMan protocol
                // Early return of job object.
                throw new PSNotSupportedException();
            }

            var operationOptions = new CimOperationOptions
            {
                Timeout = TimeSpan.FromMilliseconds(2000),
                CancellationToken = cancel.Token
            };
            int destCount = 0;
            int sourceCount = 0;
            foreach (string sourceComp in Source)
            {
                try
                {
                    sourceCount++;
                    string sourceMachine;
                    if ((sourceComp.Equals("localhost", StringComparison.CurrentCultureIgnoreCase)) || (sourceComp.Equals(".", StringComparison.OrdinalIgnoreCase)))
                    {
                        sourceMachine = Dns.GetHostName();
                    }
                    else
                    {
                        sourceMachine = sourceComp;
                    }
                    foreach (var tocomp in ComputerName)
                    {
                        destCount++;
                        string querystring = QueryString(new string[] { tocomp }, true, true);

                        using (CimSession cimSession = RemoteDiscoveryHelper.CreateCimSession(sourceComp, this.Credential, WsmanAuthentication, cancel.Token, this))
                        {
                            WriteVerbose(String.Format("WMI query {0} sent to {1}", querystring, sourceComp));
                            for (int echoRequestCount = 0; echoRequestCount < Count; echoRequestCount++)
                            {
                                IEnumerable<CimInstance> mCollection = cimSession.QueryInstances(
                                                                     ComputerWMIHelper.CimOperatingSystemNamespace,
                                                                     ComputerWMIHelper.CimQueryDialect,
                                                                     querystring,
                                                                     operationOptions);
                                int total = mCollection.ToList().Count;
                                int cimInsCount = 1;
                                foreach (CimInstance obj in mCollection)
                                {
                                    ProcessPingStatus(obj);
                                    cimInsCount++;
                                    // to delay the request, if case to avoid the delay for the last pingrequest
                                    if (cimInsCount < total || echoRequestCount < Count - 1 || sourceCount < Source.Length || destCount < ComputerName.Length)
                                        Thread.Sleep(Delay * 1000);
                                }
                            }
                        }
                    }
                }
                catch (CimException ex)
                {
                    ErrorRecord errorRecord = new ErrorRecord(ex, "TestConnectionException", ErrorCategory.InvalidOperation, null);
                    WriteError(errorRecord);
                    continue;
                }
                catch (System.Runtime.InteropServices.COMException e)
                {
                    ErrorRecord errorRecord = new ErrorRecord(e, "TestConnectionException", ErrorCategory.InvalidOperation, null);
                    WriteError(errorRecord);
                    continue;
                }
            }

            if (quiet)
            {
                foreach (string destinationAddress in this.ComputerName)
                {
                    bool destinationResult = false;
                    this.quietResults.TryGetValue(destinationAddress, out destinationResult);
                    WriteObject(destinationResult);
                }
            }
        }

#endregion  "Private Methods "
    }
#endregion Test-Connection
#if !CORECLR

#region Enable-ComputerRestore

    /// <summary>
    /// Cmdlet for Enable-ComputerRestore
    /// </summary>
    [Cmdlet(VerbsLifecycle.Enable, "ComputerRestore", SupportsShouldProcess = true, HelpUri = "https://go.microsoft.com/fwlink/?LinkID=135209")]
    public sealed class EnableComputerRestoreCommand : PSCmdlet, IDisposable
    {
#region Parameters
        /// <summary>
        /// Specifies the Drive on which the system restore will be enabled.
        /// The drive string should be of the form "C:\".
        /// </summary>
        [Parameter(Position = 0, Mandatory = true)]
        [ValidateNotNullOrEmpty]
        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
        public string[] Drive { get; set; }

        #endregion Parameters
        private const string ErrorBase = "ComputerResources";
        private ManagementClass WMIClass;
#region "IDisposable Members"

        /// <summary>
        /// Dispose Method
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            // Use SuppressFinalize in case a subclass
            // of this type implements a finalizer.
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Dispose Method.
        /// </summary>
        /// <param name="disposing"></param>
        public void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (WMIClass != null)
                {
                    WMIClass.Dispose();
                }
            }
        }

#endregion "IDisposable Members"

#region Overrides

        /// <summary>
        /// To Enable the Restore Point of the drives
        /// </summary>
        protected override void BeginProcessing()
        {
            // system restore APIs are not supported on ARM platform
            if (ComputerWMIHelper.SkipSystemRestoreOperationForARMPlatform(this))
            {
                return;
            }

            ManagementScope scope = new ManagementScope(ComputerWMIHelper.WMI_Path_Default);
            scope.Connect();
            WMIClass = new ManagementClass(ComputerWMIHelper.WMI_Class_SystemRestore);
            WMIClass.Scope = scope;
            int retValue;
            //get the system drive
            string sysdrive = System.Environment.ExpandEnvironmentVariables("%SystemDrive%");
            sysdrive = String.Concat(new string[] { sysdrive, "\\" });


            if (ComputerWMIHelper.ContainsSystemDrive(Drive, sysdrive))
            {
                object[] input = { sysdrive };
                try
                {
                    retValue = Convert.ToInt32(WMIClass.InvokeMethod("Enable", input), System.Globalization.CultureInfo.CurrentCulture);
                    //if success (return value is 0 or if already enabled (error code is 1056 in XP and 0 in vista)
                    if ((retValue.Equals(0)) || (retValue.Equals(ComputerWMIHelper.ErrorCode_Service)))
                    {
                        string driveNew;
                        foreach (string drive in Drive) //for each input drive
                        {
                            if (!ShouldProcess(drive))
                            {
                                continue;
                            }
                            if (!drive.EndsWith("\\", StringComparison.CurrentCultureIgnoreCase))
                            {
                                driveNew = String.Concat(drive, "\\");
                            }
                            else
                                driveNew = drive;
                            if (!ComputerWMIHelper.IsValidDrive(driveNew))//if not valid drive,throw error
                            {
                                Exception Ex = new ArgumentException(StringUtil.Format(ComputerResources.InvalidDrive, drive));
                                WriteError(new ErrorRecord(Ex, "EnableComputerRestoreInvalidDrive", ErrorCategory.InvalidData, null));
                                continue;
                            }
                            //parameter for Enable method
                            //if the input drive is not system drive
                            if (!driveNew.Equals(sysdrive, StringComparison.OrdinalIgnoreCase))
                            {
                                object[] inputDrive = { driveNew };
                                retValue = Convert.ToInt32(WMIClass.InvokeMethod("Enable", inputDrive), System.Globalization.CultureInfo.CurrentCulture);

                                //if not enabled, retry again
                                if (retValue.Equals(ComputerWMIHelper.ErrorCode_Interface))
                                {
                                    retValue = Convert.ToInt32(WMIClass.InvokeMethod("Enable", inputDrive), System.Globalization.CultureInfo.CurrentCulture);
                                }
                            }
                            //if not success and if it is not already enabled (error code is 1056 in XP)
                            // Error 1717 - The interface is unknown. Even though this comes sometimes . The Drive is getting enabled.
                            if (!(retValue.Equals(0)) && !(retValue.Equals(ComputerWMIHelper.ErrorCode_Service)) && !(retValue.Equals(ComputerWMIHelper.ErrorCode_Interface)))
                            {
                                Exception Ex = new ArgumentException(StringUtil.Format(ComputerResources.NotEnabled, drive));
                                WriteError(new ErrorRecord(Ex, "EnableComputerRestoreNotEnabled", ErrorCategory.InvalidOperation, null));
                                continue;
                            }
                        }
                    }
                    else
                    {
                        ArgumentException Ex = new ArgumentException(StringUtil.Format(ComputerResources.NotEnabled, sysdrive));
                        WriteError(new ErrorRecord(Ex, "EnableComputerRestoreNotEnabled", ErrorCategory.InvalidOperation, null));
                    }
                }
                catch (ManagementException e)
                {
                    if ((e.ErrorCode.Equals(ManagementStatus.NotFound)) || (e.ErrorCode.Equals(ManagementStatus.InvalidClass)))
                    {
                        ErrorRecord er = new ErrorRecord(new ArgumentException(StringUtil.Format(ComputerResources.NotSupported)), null, ErrorCategory.InvalidOperation, null);
                        WriteError(er);
                    }
                    else
                    {
                        ErrorRecord errorRecord = new ErrorRecord(e, "GetWMIManagementException", ErrorCategory.InvalidOperation, null);
                        WriteError(errorRecord);
                    }
                }
                catch (COMException e)
                {
                    if (string.IsNullOrEmpty(e.Message))
                    {
                        Exception Ex = new ArgumentException(StringUtil.Format(ComputerResources.SystemRestoreServiceDisabled));
                        WriteError(new ErrorRecord(Ex, "ServiceDisabled", ErrorCategory.InvalidOperation, null));
                    }
                    else
                    {
                        ErrorRecord errorRecord = new ErrorRecord(e, "COMException", ErrorCategory.InvalidOperation, null);
                        WriteError(errorRecord);
                    }
                }
            }
            else
            {
                ArgumentException Ex = new ArgumentException(StringUtil.Format(ComputerResources.NoSystemDrive));
                WriteError(new ErrorRecord(Ex, "EnableComputerNoSystemDrive", ErrorCategory.InvalidArgument, null));
            }
        }//end of BeginProcessing

        /// <summary>
        /// to implement ^C
        /// </summary>
        protected override void StopProcessing()
        {
            if (WMIClass != null)
            {
                WMIClass.Dispose();
            }
        }

#endregion Overrides
    }//end of class
#endregion

#region Disable-ComputerRestore

    /// <summary>
    /// This cmdlet is to Disable Computer Restore points.
    /// </summary>
    [Cmdlet(VerbsLifecycle.Disable, "ComputerRestore", SupportsShouldProcess = true, HelpUri = "https://go.microsoft.com/fwlink/?LinkID=135207")]
    public sealed class DisableComputerRestoreCommand : PSCmdlet, IDisposable
    {
#region Parameters
        /// <summary>
        /// Specifies the Drive on which the system restore will be enabled.
        /// The drive string should be of the form "C:\".
        /// </summary>
        [Parameter(Position = 0, Mandatory = true)]
        [ValidateNotNullOrEmpty]
        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
        public string[] Drive { get; set; }

        #endregion Parameters

        private ManagementClass WMIClass;
        private const string ErrorBase = "ComputerResources";
#region "IDisposable Members"

        /// <summary>
        /// Dispose Method
        /// </summary>
        public void Dispose()
        {
            this.Dispose(true);
            // Use SuppressFinalize in case a subclass
            // of this type implements a finalizer.
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Dispose Method.
        /// </summary>
        /// <param name="disposing"></param>
        public void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (WMIClass != null)
                {
                    WMIClass.Dispose();
                }
            }
        }

#endregion "IDisposable Members"

#region Overrides

        /// <summary>
        /// To Disable the Restore Point of the drives
        /// </summary>
        protected override void BeginProcessing()
        {
            // system restore APIs are not supported on ARM platform
            if (ComputerWMIHelper.SkipSystemRestoreOperationForARMPlatform(this))
            {
                return;
            }

            ManagementScope scope = new ManagementScope(ComputerWMIHelper.WMI_Path_Default);
            scope.Connect();
            WMIClass = new ManagementClass(ComputerWMIHelper.WMI_Class_SystemRestore);
            WMIClass.Scope = scope;
            string driveNew;
            foreach (string drive in Drive)
            {
                if (!ShouldProcess(drive))
                {
                    continue;
                }

                if (!drive.EndsWith("\\", StringComparison.CurrentCultureIgnoreCase))
                {
                    driveNew = String.Concat(drive, "\\");
                }
                else
                    driveNew = drive;


                if (!ComputerWMIHelper.IsValidDrive(driveNew))
                {
                    ErrorRecord er = new ErrorRecord(new ArgumentException(StringUtil.Format(ComputerResources.NotValidDrive, drive)), null, ErrorCategory.InvalidData, null);
                    WriteError(er);
                    continue;
                }
                else
                {
                    try
                    {
                        object[] input = { driveNew };
                        int retValue = Convert.ToInt32(WMIClass.InvokeMethod("Disable", input), System.Globalization.CultureInfo.CurrentCulture);
                        // Error 1717 - The interface is unknown. Even though this comes sometimes . The Drive is getting disabled.
                        if (!(retValue.Equals(0)) && !(retValue.Equals(ComputerWMIHelper.ErrorCode_Interface)))
                        {
                            ErrorRecord er = new ErrorRecord(new ArgumentException(StringUtil.Format(ComputerResources.NotDisabled, drive)), null, ErrorCategory.InvalidOperation, null);
                            WriteError(er);
                            continue;
                        }
                    }
                    catch (ManagementException e)
                    {
                        if ((e.ErrorCode.Equals(ManagementStatus.NotFound)) || (e.ErrorCode.Equals(ManagementStatus.InvalidClass)))
                        {
                            ErrorRecord er = new ErrorRecord(new ArgumentException(StringUtil.Format(ComputerResources.NotSupported)), null, ErrorCategory.InvalidOperation, null);
                            WriteError(er);
                        }
                        else
                        {
                            ErrorRecord errorRecord = new ErrorRecord(e, "GetWMIManagementException", ErrorCategory.InvalidOperation, null);
                            WriteError(errorRecord);
                        }
                    }
                    catch (COMException e)
                    {
                        if (string.IsNullOrEmpty(e.Message))
                        {
                            Exception Ex = new ArgumentException(StringUtil.Format(ComputerResources.SystemRestoreServiceDisabled));
                            WriteError(new ErrorRecord(Ex, "ServiceDisabled", ErrorCategory.InvalidOperation, null));
                        }
                        else
                        {
                            ErrorRecord errorRecord = new ErrorRecord(e, "COMException", ErrorCategory.InvalidOperation, null);
                            WriteError(errorRecord);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// to implement ^C
        /// </summary>
        protected override void StopProcessing()
        {
            if (WMIClass != null)
            {
                WMIClass.Dispose();