private string GetWmiQueryString()
{
GetWmiObjectCommand getWmiObjectCommand = (GetWmiObjectCommand)this.wmiObject;
StringBuilder stringBuilder = new StringBuilder("select ");
stringBuilder.Append(string.Join(", ", getWmiObjectCommand.Property));
stringBuilder.Append(" from ");
stringBuilder.Append(getWmiObjectCommand.Class);
if (!string.IsNullOrEmpty(getWmiObjectCommand.Filter))
{
stringBuilder.Append(" where ");
stringBuilder.Append(getWmiObjectCommand.Filter);
}
return(stringBuilder.ToString());
}
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);
}
}
}
protected override void ProcessRecord()
{
ConnectionOptions connection = ComputerWMIHelper.GetConnection(this.Authentication, this.Impersonation, this.Credential);
if (!this.asjob)
{
int num = 0;
string[] strArrays = this.source;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
try
{
num++;
string str1 = this.QueryString(this.destination, true, true);
ObjectQuery objectQuery = new ObjectQuery(str1);
ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), connection);
managementScope.Options.EnablePrivileges = true;
managementScope.Connect();
EnumerationOptions enumerationOption = new EnumerationOptions();
enumerationOption.UseAmendedQualifiers = true;
enumerationOption.DirectRead = true;
this.searcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption);
for (int j = 0; j <= this.count - 1; j++)
{
ManagementObjectCollection managementObjectCollections = this.searcher.Get();
int num1 = 0;
foreach (ManagementBaseObject managementBaseObject in managementObjectCollections)
{
num1++;
this.ProcessPingStatus(managementBaseObject);
if (num1 >= managementObjectCollections.Count && j >= this.count - 1 && num >= (int)this.Source.Length)
{
continue;
}
Thread.Sleep(this.delay * 0x3e8);
}
}
}
catch (ManagementException managementException1)
{
ManagementException managementException = managementException1;
ErrorRecord errorRecord = new ErrorRecord(managementException, "TestConnectionException", ErrorCategory.InvalidOperation, null);
base.WriteError(errorRecord);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
ErrorRecord errorRecord1 = new ErrorRecord(cOMException, "TestConnectionException", ErrorCategory.InvalidOperation, null);
base.WriteError(errorRecord1);
}
}
}
else
{
string str2 = this.QueryString(this.destination, true, false);
GetWmiObjectCommand getWmiObjectCommand = new GetWmiObjectCommand();
getWmiObjectCommand.Filter = str2.ToString();
getWmiObjectCommand.Class = "Win32_PingStatus";
getWmiObjectCommand.ComputerName = this.source;
getWmiObjectCommand.Authentication = this.Authentication;
getWmiObjectCommand.Impersonation = this.Impersonation;
getWmiObjectCommand.ThrottleLimit = this.throttlelimit;
PSWmiJob pSWmiJob = new PSWmiJob(getWmiObjectCommand, this.source, this.throttlelimit, base.MyInvocation.MyCommand.Name, this.count);
base.JobRepository.Add(pSWmiJob);
base.WriteObject(pSWmiJob);
}
if (this.quiet)
{
string[] strArrays1 = this.destination;
for (int k = 0; k < (int)strArrays1.Length; k++)
{
string str3 = strArrays1[k];
bool flag = false;
this.quietResults.TryGetValue(str3, out flag);
base.WriteObject(flag);
}
}
}
private void ConnectGetWMI()
{
string wmiQueryString;
GetWmiObjectCommand getWmiObjectCommand = (GetWmiObjectCommand)this.wmiObject;
this.state = WmiState.Running;
this.RaiseWmiOperationState(null, WmiState.Running);
ConnectionOptions connectionOption = getWmiObjectCommand.GetConnectionOption();
SwitchParameter list = getWmiObjectCommand.List;
if (!list.IsPresent)
{
if (string.IsNullOrEmpty(getWmiObjectCommand.Query))
{
wmiQueryString = this.GetWmiQueryString();
}
else
{
wmiQueryString = getWmiObjectCommand.Query;
}
string str = wmiQueryString;
ObjectQuery objectQuery = new ObjectQuery(str.ToString());
try
{
ManagementScope managementScope = new ManagementScope(WMIHelper.GetScopeString(this.computerName, getWmiObjectCommand.Namespace), connectionOption);
EnumerationOptions enumerationOption = new EnumerationOptions();
enumerationOption.UseAmendedQualifiers = getWmiObjectCommand.Amended;
enumerationOption.DirectRead = getWmiObjectCommand.DirectRead;
ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption);
for (int i = 0; i < this.cmdCount; i++)
{
managementObjectSearcher.Get(this.results);
}
}
catch (ManagementException managementException1)
{
ManagementException managementException = managementException1;
this.internalException = managementException;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
this.internalException = cOMException;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
}
catch (UnauthorizedAccessException unauthorizedAccessException1)
{
UnauthorizedAccessException unauthorizedAccessException = unauthorizedAccessException1;
this.internalException = unauthorizedAccessException;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
}
return;
}
else
{
if (getWmiObjectCommand.ValidateClassFormat())
{
try
{
SwitchParameter recurse = getWmiObjectCommand.Recurse;
if (!recurse.IsPresent)
{
ManagementScope managementScope1 = new ManagementScope(WMIHelper.GetScopeString(this.computerName, getWmiObjectCommand.Namespace), connectionOption);
managementScope1.Connect();
ManagementObjectSearcher objectList = getWmiObjectCommand.GetObjectList(managementScope1);
if (objectList != null)
{
objectList.Get(this.results);
}
else
{
throw new ManagementException();
}
}
else
{
ArrayList arrayLists = new ArrayList();
ArrayList arrayLists1 = new ArrayList();
ArrayList arrayLists2 = new ArrayList();
int num = 0;
arrayLists.Add(getWmiObjectCommand.Namespace);
bool flag = true;
while (num < arrayLists.Count)
{
string item = (string)arrayLists[num];
ManagementScope managementScope2 = new ManagementScope(WMIHelper.GetScopeString(this.computerName, item), connectionOption);
managementScope2.Connect();
ManagementClass managementClass = new ManagementClass(managementScope2, new ManagementPath("__Namespace"), new ObjectGetOptions());
foreach (ManagementBaseObject instance in managementClass.GetInstances())
{
if (getWmiObjectCommand.IsLocalizedNamespace((string)instance["Name"]))
{
continue;
}
arrayLists.Add(string.Concat(item, "\\", instance["Name"]));
}
if (!flag)
{
arrayLists1.Add(this.Job.GetNewSink());
}
else
{
flag = false;
arrayLists1.Add(this.results);
}
arrayLists2.Add(managementScope2);
num++;
}
if (arrayLists1.Count != arrayLists.Count || arrayLists2.Count != arrayLists.Count)
{
this.internalException = new InvalidOperationException();
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
return;
}
else
{
num = 0;
while (num < arrayLists.Count)
{
ManagementObjectSearcher objectList1 = getWmiObjectCommand.GetObjectList((ManagementScope)arrayLists2[num]);
if (objectList1 != null)
{
if (!flag)
{
objectList1.Get((ManagementOperationObserver)arrayLists1[num]);
}
else
{
flag = false;
objectList1.Get(this.results);
}
num++;
}
else
{
num++;
}
}
}
}
}
catch (ManagementException managementException3)
{
ManagementException managementException2 = managementException3;
this.internalException = managementException2;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
this.internalException = cOMException2;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
}
catch (UnauthorizedAccessException unauthorizedAccessException3)
{
UnauthorizedAccessException unauthorizedAccessException2 = unauthorizedAccessException3;
this.internalException = unauthorizedAccessException2;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
}
return;
}
else
{
object[] @class = new object[1];
@class[0] = getWmiObjectCommand.Class;
ArgumentException argumentException = new ArgumentException(string.Format(Thread.CurrentThread.CurrentCulture, "Class", @class));
this.internalException = argumentException;
this.state = WmiState.Failed;
this.RaiseOperationCompleteEvent(null, OperationState.StopComplete);
return;
}
}
}
private static void RunDirectExecutionActivity(System.Management.Automation.PowerShell commandToRun, PSDataCollection<PSObject> input, PSDataCollection<PSObject> output, PSActivityContext psActivityContext, ActivityImplementationContext implementationContext)
{
PSDataCollection<PSObject> pSObjects;
Type type;
CimSessionOptions sessionOptions;
Command item = commandToRun.Commands.Commands[0];
string commandText = item.CommandText;
Cmdlet invokeWmiMethod = null;
bool flag = false;
if (!string.Equals(commandText, "Get-WMIObject", StringComparison.OrdinalIgnoreCase))
{
if (string.Equals(commandText, "Invoke-WMIMethod", StringComparison.OrdinalIgnoreCase))
{
invokeWmiMethod = new InvokeWmiMethod();
flag = true;
}
}
else
{
invokeWmiMethod = new GetWmiObjectCommand();
}
if (!PSActivity.CheckForCancel(psActivityContext))
{
if (output != null)
{
pSObjects = output;
}
else
{
pSObjects = new PSDataCollection<PSObject>();
}
ActivityImplementationContext activityImplementationContext = implementationContext;
if (invokeWmiMethod != null)
{
type = invokeWmiMethod.GetType();
}
else
{
type = psActivityContext.TypeImplementingCmdlet;
}
DirectExecutionActivitiesCommandRuntime directExecutionActivitiesCommandRuntime = new DirectExecutionActivitiesCommandRuntime(pSObjects, activityImplementationContext, type);
directExecutionActivitiesCommandRuntime.Error = commandToRun.Streams.Error;
directExecutionActivitiesCommandRuntime.Warning = commandToRun.Streams.Warning;
directExecutionActivitiesCommandRuntime.Progress = commandToRun.Streams.Progress;
directExecutionActivitiesCommandRuntime.Verbose = commandToRun.Streams.Verbose;
directExecutionActivitiesCommandRuntime.Debug = commandToRun.Streams.Debug;
if (invokeWmiMethod == null)
{
CimActivityImplementationContext cimActivityImplementationContext = implementationContext as CimActivityImplementationContext;
if (cimActivityImplementationContext != null)
{
sessionOptions = cimActivityImplementationContext.SessionOptions;
}
else
{
sessionOptions = null;
}
CimSessionOptions cimSessionOption = sessionOptions;
if (psActivityContext.TypeImplementingCmdlet != null)
{
if (input == null || input.Count <= 0 && !input.IsOpen)
{
CimBaseCommand cimBaseCommand = (CimBaseCommand)Activator.CreateInstance(psActivityContext.TypeImplementingCmdlet);
using (cimBaseCommand)
{
cimBaseCommand.CommandRuntime = directExecutionActivitiesCommandRuntime;
PSObject pSObject = PSObject.AsPSObject(cimBaseCommand);
PSActivity.InitializeCmdletInstanceParameters(item, pSObject, true, psActivityContext, cimSessionOption, implementationContext);
cimBaseCommand.Invoke().GetEnumerator().MoveNext();
}
}
else
{
if (psActivityContext.TypeImplementingCmdlet.GetProperty("InputObject") != null)
{
foreach (PSObject pSObject1 in input)
{
try
{
CimBaseCommand cimBaseCommand1 = (CimBaseCommand)Activator.CreateInstance(psActivityContext.TypeImplementingCmdlet);
using (cimBaseCommand1)
{
cimBaseCommand1.CommandRuntime = directExecutionActivitiesCommandRuntime;
CimInstance cimInstance = LanguagePrimitives.ConvertTo<CimInstance>(pSObject1);
PSObject pSObject2 = PSObject.AsPSObject(cimBaseCommand1);
PSActivity.InitializeCmdletInstanceParameters(item, pSObject2, true, psActivityContext, cimSessionOption, implementationContext);
PSPropertyInfo pSPropertyInfo = pSObject2.Properties["InputObject"];
pSPropertyInfo.Value = cimInstance;
cimBaseCommand1.Invoke().GetEnumerator().MoveNext();
}
}
catch (PSInvalidCastException pSInvalidCastException1)
{
PSInvalidCastException pSInvalidCastException = pSInvalidCastException1;
if (pSInvalidCastException.ErrorRecord != null)
{
directExecutionActivitiesCommandRuntime.Error.Add(pSInvalidCastException.ErrorRecord);
}
}
if (!PSActivity.CheckForCancel(psActivityContext))
{
continue;
}
return;
}
}
else
{
object[] objArray = new object[1];
objArray[0] = commandText;
throw new NotImplementedException(string.Format(CultureInfo.CurrentCulture, Resources.CmdletDoesNotImplementInputObjectProperty, objArray));
}
}
}
else
{
throw new InvalidOperationException(commandText);
}
}
else
{
invokeWmiMethod.CommandRuntime = directExecutionActivitiesCommandRuntime;
PSObject pSObject3 = PSObject.AsPSObject(invokeWmiMethod);
PSActivity.InitializeCmdletInstanceParameters(item, pSObject3, false, psActivityContext, null, implementationContext);
if (!flag || input == null || input.Count <= 0 && !input.IsOpen)
{
invokeWmiMethod.Invoke().GetEnumerator().MoveNext();
return;
}
else
{
InvokeWmiMethod invokeWmiMethod1 = invokeWmiMethod as InvokeWmiMethod;
foreach (PSObject pSObject4 in input)
{
try
{
ManagementObject managementObject = LanguagePrimitives.ConvertTo<ManagementObject>(pSObject4);
invokeWmiMethod1.InputObject = managementObject;
invokeWmiMethod1.Invoke().GetEnumerator().MoveNext();
}
catch (PSInvalidCastException pSInvalidCastException3)
{
PSInvalidCastException pSInvalidCastException2 = pSInvalidCastException3;
if (pSInvalidCastException2.ErrorRecord != null)
{
directExecutionActivitiesCommandRuntime.Error.Add(pSInvalidCastException2.ErrorRecord);
}
}
if (!PSActivity.CheckForCancel(psActivityContext))
{
continue;
}
return;
}
}
}
return;
}
else
{
return;
}
}
protected override void ProcessRecord()
{
ConnectionOptions connection = ComputerWMIHelper.GetConnection(this.Authentication, this.Impersonation, this.Credential);
if (!this.asjob)
{
int num = 0;
string[] strArrays = this.source;
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
try
{
num++;
string str1 = this.QueryString(this.destination, true, true);
ObjectQuery objectQuery = new ObjectQuery(str1);
ManagementScope managementScope = new ManagementScope(ComputerWMIHelper.GetScopeString(str, "\\root\\cimv2"), connection);
managementScope.Options.EnablePrivileges = true;
managementScope.Connect();
EnumerationOptions enumerationOption = new EnumerationOptions();
enumerationOption.UseAmendedQualifiers = true;
enumerationOption.DirectRead = true;
this.searcher = new ManagementObjectSearcher(managementScope, objectQuery, enumerationOption);
for (int j = 0; j <= this.count - 1; j++)
{
ManagementObjectCollection managementObjectCollections = this.searcher.Get();
int num1 = 0;
foreach (ManagementBaseObject managementBaseObject in managementObjectCollections)
{
num1++;
this.ProcessPingStatus(managementBaseObject);
if (num1 >= managementObjectCollections.Count && j >= this.count - 1 && num >= (int)this.Source.Length)
{
continue;
}
Thread.Sleep(this.delay * 0x3e8);
}
}
}
catch (ManagementException managementException1)
{
ManagementException managementException = managementException1;
ErrorRecord errorRecord = new ErrorRecord(managementException, "TestConnectionException", ErrorCategory.InvalidOperation, null);
base.WriteError(errorRecord);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
ErrorRecord errorRecord1 = new ErrorRecord(cOMException, "TestConnectionException", ErrorCategory.InvalidOperation, null);
base.WriteError(errorRecord1);
}
}
}
else
{
string str2 = this.QueryString(this.destination, true, false);
GetWmiObjectCommand getWmiObjectCommand = new GetWmiObjectCommand();
getWmiObjectCommand.Filter = str2.ToString();
getWmiObjectCommand.Class = "Win32_PingStatus";
getWmiObjectCommand.ComputerName = this.source;
getWmiObjectCommand.Authentication = this.Authentication;
getWmiObjectCommand.Impersonation = this.Impersonation;
getWmiObjectCommand.ThrottleLimit = this.throttlelimit;
PSWmiJob pSWmiJob = new PSWmiJob(getWmiObjectCommand, this.source, this.throttlelimit, base.MyInvocation.MyCommand.Name, this.count);
base.JobRepository.Add(pSWmiJob);
base.WriteObject(pSWmiJob);
}
if (this.quiet)
{
string[] strArrays1 = this.destination;
for (int k = 0; k < (int)strArrays1.Length; k++)
{
string str3 = strArrays1[k];
bool flag = false;
this.quietResults.TryGetValue(str3, out flag);
base.WriteObject(flag);
}
}
}