public void OnNext(T value)
{
CimInstance instance = value as CimInstance;
if (instance != null)
{
SampleCimOperation.PrintCimInstance(instance);
return;
}
CimMethodResult methodResult = value as CimMethodResult;
if (methodResult != null)
{
SampleCimOperation.PrintCimMethodResult(methodResult);
return;
}
CimMethodStreamedResult methodStreamResult = value as CimMethodStreamedResult;
if (methodStreamResult != null)
{
SampleCimOperation.PrintCimMethodStreamResult(methodStreamResult);
}
CimSubscriptionResult subscriptionResult = value as CimSubscriptionResult;
if (subscriptionResult != null)
{
SampleCimOperation.PrintCimInstance(subscriptionResult.Instance);
return;
}
}
private void CheckForRegSoftware(string SubKey, string[] RegSubKeyArray)
{
foreach (var item in RegSubKeyArray)
{
string TmpSubKey = SubKey + @"\" + item;
CimMethodResult SoftwareData = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "EnumValues", SetRegParameters(RegHives.LOCAL_MACHINE, RegistryMethods.EnumValues, TmpSubKey));
string[] SoftWareDataFields = (string[])SoftwareData.OutParameters["sNames"].Value;
if (SoftWareDataFields != null)
{
string DisplayName = "";
string DisplayVersion = "";
foreach (var DataField in SoftWareDataFields)
{
if (DataField == "DisplayName")
{
CimMethodResult NameResults = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "GetStringValue", SetRegParameters(RegHives.LOCAL_MACHINE, RegistryMethods.GetStringValue, TmpSubKey, "DisplayName"));
DisplayName = NameResults.OutParameters["sValue"].Value.ToString();
}
if (DataField == "DisplayVersion")
{
CimMethodResult VersionResults = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "GetStringValue", SetRegParameters(RegHives.LOCAL_MACHINE, RegistryMethods.GetStringValue, TmpSubKey, "DisplayVersion"));
DisplayVersion = VersionResults.OutParameters["sValue"].Value.ToString();
}
}
}
}
}
public static void AddMembershipRule(string hostName, string userName, string passWord, string domain, string cmSite, string collectionId)
{
CimSession session = Connect(hostName, userName, passWord, domain);
// Get All Collection
// Add Exception catching chain
var collectionInstance = session.EnumerateInstances($"root\\sms\\site_{cmSite}", "SMS_Collection")
.Where(i => i.CimInstanceProperties["CollectionId"].Value.ToString().Contains(collectionId)).ToList();
if (!collectionInstance.Any())
{
return;
}
var ruleInstance = new CimInstance(session.GetClass($"root\\sms\\site_{cmSite}", "SMS_CollectionRuleDirect"));
ruleInstance.CimInstanceProperties["RuleName"].Value = "";
ruleInstance.CimInstanceProperties["ResourceClassName"].Value = "SMS_R_System";
ruleInstance.CimInstanceProperties["ResourceID"].Value = 1;
var parameters = new CimMethodParametersCollection
{
CimMethodParameter.Create("collectionRule", ruleInstance, CimType.Instance, 0)
};
CimMethodResult result = session.InvokeMethod(collectionInstance.FirstOrDefault(), "AddMembershipRule", parameters);
}
protected void CheckError(CimMethodResult result)
{
uint code = (uint)result.ReturnValue.Value;
if (code != 0)
{
throw new WmiException((ReturnValue)code);
}
}
public void EnumerateBaseSoftwareKeys()
{
string SubKey = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall";
CimMethodResult CimMR = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "EnumKey", SetRegParameters(RegHive.LOCAL_MACHINE, RegistryMethods.EnumKey, SubKey));
string[] RegSubKeyArray = (string[])CimMR.OutParameters["sNames"].Value;
if (RegSubKeyArray != null)
{
CheckForRegSoftware(SubKey, RegSubKeyArray);
}
}
public static CimMethodResult readRegValue(CimSession cimSession, UInt32 hDefKey, string sSubKeyName, string keyName, string method)
{
CimMethodParametersCollection cimParams = new CimMethodParametersCollection
{
CimMethodParameter.Create("hDefKey", hDefKey, CimFlags.In),
CimMethodParameter.Create("sSubKeyName", sSubKeyName, CimFlags.In),
CimMethodParameter.Create("sValueName", keyName, CimFlags.In)
};
CimMethodResult results = cimSession.InvokeMethod(new CimInstance("StdRegProv", Namespace), method, cimParams);
return(results);
}
public static string setRegValue(CimSession cimSession, UInt32 hDefKey, string sSubKeyName, string keyName, UInt32 keyValue)
{
CimMethodParametersCollection cimParams = new CimMethodParametersCollection
{
CimMethodParameter.Create("hDefKey", hDefKey, CimFlags.In),
CimMethodParameter.Create("sSubKeyName", sSubKeyName, CimFlags.In),
CimMethodParameter.Create("sValueName", keyName, CimFlags.In),
CimMethodParameter.Create("uValue", keyValue, CimFlags.In)
};
CimMethodResult result = cimSession.InvokeMethod(new CimInstance("StdRegProv", Namespace), "SetDWORDValue", cimParams);
return(result.ReturnValue.Value.ToString());
}
public override object?Invoke(object proxy, MethodInfo method, object[] arguments)
{
ParameterInfo[] methodParameters = method.GetParameters();
if (method.Name == nameof(Win32Services.Select))
{
// select method to find instances
StringBuilder query = new StringBuilder("SELECT * FROM ").Append(this.className).Append(" WHERE ");
for (int i = 0; i < arguments.Length; i++)
{
if (i != 0)
{
query.Append(" AND ");
}
query.Append(' ').Append(Capitalize(methodParameters[i].Name !)).Append(" = '").Append(arguments[i]).Append('\'');
}
#if FEATURE_CIM
// TODO: support collections
foreach (CimInstance cimInstance in this.cimSession.QueryInstances(CimNamespace, "WQL", query.ToString()))
{
return(ProxyFactory.GetInstance().Create(new InstanceHandler(this.cimSession, cimInstance), method.ReturnType, true));
}
#else
using ManagementObjectSearcher searcher = new ManagementObjectSearcher(this.wmiClass.Scope, new ObjectQuery(query.ToString()));
using ManagementObjectCollection results = searcher.Get();
// TODO: support collections
foreach (ManagementObject wmiObject in results)
{
return(ProxyFactory.GetInstance().Create(new InstanceHandler(wmiObject), method.ReturnType, true));
}
#endif
return(null);
}
string methodName = method.Name;
#if FEATURE_CIM
using CimMethodParametersCollection? cimParameters = arguments.Length == 0 ? null :
this.GetMethodParameters(this.cimClass, methodName, methodParameters, arguments);
using CimMethodResult result = this.cimSession.InvokeMethod(CimNamespace, this.className, methodName, cimParameters);
this.CheckError(result);
#else
using ManagementBaseObject? wmiParameters = arguments.Length == 0 ? null :
this.GetMethodParameters(this.wmiClass, methodName, methodParameters, arguments);
using ManagementBaseObject result = this.wmiClass.InvokeMethod(methodName, wmiParameters, null);
this.CheckError(result);
#endif
return(null);
}
private void ProcessOutParameter(CimMethodResult methodResult, MethodParameter methodParameter, IDictionary <string, MethodParameter> cmdletOutput)
{
object value;
CimMethodParameter item = methodResult.OutParameters[methodParameter.Name];
if (item == null)
{
value = null;
}
else
{
value = item.Value;
}
object obj = value;
object dotNet = CimValueConverter.ConvertFromCimToDotNet(obj, methodParameter.ParameterType);
if (MethodParameterBindings.Out != (methodParameter.Bindings & MethodParameterBindings.Out))
{
if (MethodParameterBindings.Error == (methodParameter.Bindings & MethodParameterBindings.Error))
{
bool flag = (bool)LanguagePrimitives.ConvertTo(dotNet, typeof(bool), CultureInfo.InvariantCulture);
if (flag)
{
string str = (string)LanguagePrimitives.ConvertTo(dotNet, typeof(string), CultureInfo.InvariantCulture);
CimJobException cimJobException = CimJobException.CreateFromMethodErrorCode(base.GetDescription(), base.JobContext, base.MethodName, str);
throw cimJobException;
}
}
}
else
{
methodParameter.Value = dotNet;
cmdletOutput.Add(methodParameter.Name, methodParameter);
CimInstance[] cimInstanceArray = dotNet as CimInstance[];
if (cimInstanceArray != null)
{
CimInstance[] cimInstanceArray1 = cimInstanceArray;
for (int i = 0; i < (int)cimInstanceArray1.Length; i++)
{
CimInstance cimInstance = cimInstanceArray1[i];
CimCmdletAdapter.AssociateSessionOfOriginWithInstance(cimInstance, this.JobContext.Session);
}
}
CimInstance cimInstance1 = dotNet as CimInstance;
if (cimInstance1 != null)
{
CimCmdletAdapter.AssociateSessionOfOriginWithInstance(cimInstance1, this.JobContext.Session);
return;
}
}
}
private void KickOffCimAsync(Computer computer, Credential credential, string commandline, CimSessionOptions options)
{
var optionsBuilder = new DbContextOptionsBuilder <ACEWebServiceDbContext>();
optionsBuilder.UseSqlServer("Server=(localdb)\\MSSQLLocalDB;Database=ACEWebService;Trusted_Connection=True;MultipleActiveResultSets=true");
using (ACEWebServiceDbContext context = new ACEWebServiceDbContext(optionsBuilder.Options))
{
// Convert stored password to a secure string
SecureString securePwd = new SecureString();
foreach (char c in _cryptoService.Decrypt(credential.Password))
{
securePwd.AppendChar(c);
}
CimCredential cimCreds = null;
if (credential.UserName.Contains('\\'))
{
// Create a CimCredential object
cimCreds = new CimCredential(PasswordAuthenticationMechanism.Kerberos, credential.UserName.Split('\\')[0], credential.UserName.Split('\\')[1], securePwd);
}
else
{
// Create a CimCredential object
cimCreds = new CimCredential(PasswordAuthenticationMechanism.Default, null, credential.UserName, securePwd);
}
// Create a CimSession with the remote system
options.AddDestinationCredentials(cimCreds);
CimSession session = CimSession.Create(computer.ComputerName, options);
// Create a CimMethodParametersCollection to pass to method invocation
CimMethodParametersCollection collection = new CimMethodParametersCollection();
collection.Add(CimMethodParameter.Create("CommandLine", commandline, CimFlags.None));
CimMethodResult result = session.InvokeMethod("root/cimv2", "Win32_Process", "Create", collection);
if (result.ReturnValue.ToString() == "0")
{
}
else
{
}
session.Dispose();
}
}
public static void disable_winrm(CimSession cimSession)
{
CimMethodParametersCollection cimParams = new CimMethodParametersCollection
{
CimMethodParameter.Create("CommandLine", "powershell -nop -w hidden -command 'Disable-PSRemoting -Force'", CimFlags.In)
};
CimMethodResult results = cimSession.InvokeMethod(new CimInstance("Win32_Process", Namespace), "Create", cimParams);
if (results.ReturnValue.Value.ToString() == "0")
{
Console.WriteLine(" [+] WinRm Disabled");
}
else
{
Console.WriteLine(" [-] Failed To Disable WinRm");
}
}
private void OnNext(CimMethodResult methodResult)
{
Dictionary <string, MethodParameter> strs = new Dictionary <string, MethodParameter>(StringComparer.OrdinalIgnoreCase);
foreach (MethodParameter methodOutputParameter in base.GetMethodOutputParameters())
{
this.ProcessOutParameter(methodResult, methodOutputParameter, strs);
}
if (strs.Count != 1)
{
if (strs.Count > 1)
{
PSObject pSObject = new PSObject();
foreach (KeyValuePair <string, MethodParameter> str in strs)
{
PSNoteProperty pSNoteProperty = new PSNoteProperty(str.Key, str.Value.Value);
pSObject.Properties.Add(pSNoteProperty);
}
this.WriteObject(pSObject);
}
}
else
{
MethodParameter methodParameter = strs.Values.Single <MethodParameter>();
if (methodParameter.Value != null)
{
IEnumerable enumerable = LanguagePrimitives.GetEnumerable(methodParameter.Value);
if (enumerable == null)
{
this.WriteObject(methodParameter.Value, methodParameter);
return;
}
else
{
foreach (object obj in enumerable)
{
this.WriteObject(obj, methodParameter);
}
}
}
else
{
return;
}
}
}
public static void PrintCimMethodResult(CimMethodResult methodResult)
{
//Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("Printing method output ...");
//Console.ResetColor();
foreach (CimMethodParameter methodParam in methodResult.OutParameters)
{
Console.WriteLine(
"Name: {0}, Type: {1}, Flags: {2}, Value: {3}",
methodParam.Name,
methodParam.CimType,
methodParam.Flags,
methodParam.Value);
}
Console.WriteLine(methodResult.ReturnValue);
}
private void KickOffCim(Computer computer, Credential credential, string commandline, CimSessionOptions options)
{
// Convert stored password to a secure string
SecureString securePwd = new SecureString();
foreach (char c in _cryptoService.Decrypt(credential.Password))
{
Console.WriteLine("[char]: {0}", c);
securePwd.AppendChar(c);
}
CimCredential cimCreds = null;
if (credential.UserName.Contains('\\'))
{
// Create a CimCredential object
cimCreds = new CimCredential(PasswordAuthenticationMechanism.Kerberos, credential.UserName.Split('\\')[0], credential.UserName.Split('\\')[1], securePwd);
}
else
{
// Create a CimCredential object
cimCreds = new CimCredential(PasswordAuthenticationMechanism.Default, null, credential.UserName, securePwd);
}
// Create a CimSession with the remote system
options.AddDestinationCredentials(cimCreds);
CimSession session = CimSession.Create(computer.ComputerName, options);
// Create a CimMethodParametersCollection to pass to method invocation
CimMethodParametersCollection collection = new CimMethodParametersCollection
{
CimMethodParameter.Create("CommandLine", commandline, CimFlags.None)
};
CimMethodResult result = session.InvokeMethod("root/cimv2", "Win32_Process", "Create", collection);
if (result.ReturnValue.ToString() == "0")
{
}
else
{
}
session.Dispose();
}
private void ProcessOutParameter(CimMethodResult methodResult, MethodParameter methodParameter, IDictionary <string, MethodParameter> cmdletOutput)
{
Dbg.Assert(methodResult != null, "Caller should verify methodResult != null");
Dbg.Assert(methodParameter != null, "Caller should verify methodParameter != null");
Dbg.Assert(0 != (methodParameter.Bindings & (MethodParameterBindings.Out | MethodParameterBindings.Error)), "Caller should verify that this is an out parameter");
Dbg.Assert(cmdletOutput != null, "Caller should verify cmdletOutput != null");
Dbg.Assert(this.MethodSubject != null, "MethodSubject property should be initialized before starting main job processing");
CimMethodParameter outParameter = methodResult.OutParameters[methodParameter.Name];
object valueReturnedFromMethod = (outParameter == null) ? null : outParameter.Value;
object dotNetValue = CimValueConverter.ConvertFromCimToDotNet(valueReturnedFromMethod, methodParameter.ParameterType);
if (MethodParameterBindings.Out == (methodParameter.Bindings & MethodParameterBindings.Out))
{
methodParameter.Value = dotNetValue;
cmdletOutput.Add(methodParameter.Name, methodParameter);
var cimInstances = dotNetValue as CimInstance[];
if (cimInstances != null)
{
foreach (var instance in cimInstances)
{
CimCmdletAdapter.AssociateSessionOfOriginWithInstance(instance, this.JobContext.Session);
}
}
var cimInstance = dotNetValue as CimInstance;
if (cimInstance != null)
{
CimCmdletAdapter.AssociateSessionOfOriginWithInstance(cimInstance, this.JobContext.Session);
}
}
else if (MethodParameterBindings.Error == (methodParameter.Bindings & MethodParameterBindings.Error))
{
var gotError = (bool)LanguagePrimitives.ConvertTo(dotNetValue, typeof(bool), CultureInfo.InvariantCulture);
if (gotError)
{
var errorCodeAsString = (string)LanguagePrimitives.ConvertTo(dotNetValue, typeof(string), CultureInfo.InvariantCulture);
CimJobException cje = CimJobException.CreateFromMethodErrorCode(this.GetDescription(), this.JobContext, this.MethodName, errorCodeAsString);
throw cje;
}
}
}
private void OnNext(CimMethodResult methodResult)
{
Dbg.Assert(this.MethodSubject != null, "MethodSubject property should be initialized before starting main job processing");
var cmdletOutput = new Dictionary <string, MethodParameter>(StringComparer.OrdinalIgnoreCase);
foreach (MethodParameter methodParameter in this.GetMethodOutputParameters())
{
ProcessOutParameter(methodResult, methodParameter, cmdletOutput);
}
if (cmdletOutput.Count == 1)
{
var singleOutputParameter = cmdletOutput.Values.Single();
if (singleOutputParameter.Value == null)
{
return;
}
IEnumerable enumerable = LanguagePrimitives.GetEnumerable(singleOutputParameter.Value);
if (enumerable != null)
{
foreach (object o in enumerable)
{
this.WriteObject(o, singleOutputParameter);
}
}
else
{
this.WriteObject(singleOutputParameter.Value, singleOutputParameter);
}
}
else if (cmdletOutput.Count > 1)
{
var propertyBag = new PSObject();
foreach (var element in cmdletOutput)
{
var tmp = new PSNoteProperty(element.Key, element.Value.Value);
propertyBag.Properties.Add(tmp);
}
this.WriteObject(propertyBag);
}
}
public override object?Invoke(object proxy, MethodInfo method, object[] arguments)
{
if (method.DeclaringType == typeof(IWmiObject))
{
return(method.Invoke(this, arguments));
}
// TODO: proper property support
if (method.Name.StartsWith("set_"))
{
#if FEATURE_CIM
CimProperty cimProperty = this.cimInstance.CimInstanceProperties[method.Name.Substring(4)];
Debug.Assert((cimProperty.Flags & CimFlags.ReadOnly) == CimFlags.None);
cimProperty.Value = arguments[0];
#else
this.wmiObject[method.Name.Substring(4)] = arguments[0];
#endif
return(null);
}
if (method.Name.StartsWith("get_"))
{
#if FEATURE_CIM
return(this.cimInstance.CimInstanceProperties[method.Name.Substring(4)].Value);
#else
return(this.wmiObject[method.Name.Substring(4)]);
#endif
}
string methodName = method.Name;
#if FEATURE_CIM
using CimMethodParametersCollection? cimParameters = arguments.Length == 0 ? null :
this.GetMethodParameters(this.cimInstance.CimClass, methodName, method.GetParameters(), arguments);
using CimMethodResult result = this.cimSession.InvokeMethod(CimNamespace, this.cimInstance, methodName, cimParameters);
this.CheckError(result);
#else
using ManagementBaseObject? wmiParameters = arguments.Length == 0 ? null :
this.GetMethodParameters(this.wmiObject, methodName, method.GetParameters(), arguments);
using ManagementBaseObject result = this.wmiObject.InvokeMethod(methodName, wmiParameters, null);
this.CheckError(result);
#endif
return(null);
}
/// <summary>
/// Override the OnNext method.
/// </summary>
/// <param name="value"></param>
public override void OnNext(CimMethodResultBase value)
{
DebugHelper.WriteLogEx();
const string PSTypeCimMethodResult = @"Microsoft.Management.Infrastructure.CimMethodResult";
const string PSTypeCimMethodStreamedResult = @"Microsoft.Management.Infrastructure.CimMethodStreamedResult";
const string PSTypeCimMethodResultTemplate = @"{0}#{1}#{2}";
string resultObjectPSType = null;
PSObject resultObject = null;
CimMethodResult methodResult = value as CimMethodResult;
if (methodResult != null)
{
resultObjectPSType = PSTypeCimMethodResult;
resultObject = new PSObject();
foreach (CimMethodParameter param in methodResult.OutParameters)
{
resultObject.Properties.Add(new PSNoteProperty(param.Name, param.Value));
}
}
else
{
CimMethodStreamedResult methodStreamedResult = value as CimMethodStreamedResult;
if (methodStreamedResult != null)
{
resultObjectPSType = PSTypeCimMethodStreamedResult;
resultObject = new PSObject();
resultObject.Properties.Add(new PSNoteProperty(@"ParameterName", methodStreamedResult.ParameterName));
resultObject.Properties.Add(new PSNoteProperty(@"ItemType", methodStreamedResult.ItemType));
resultObject.Properties.Add(new PSNoteProperty(@"ItemValue", methodStreamedResult.ItemValue));
}
}
if (resultObject != null)
{
resultObject.Properties.Add(new PSNoteProperty(@"PSComputerName", this.CurrentSession.ComputerName));
resultObject.TypeNames.Insert(0, resultObjectPSType);
resultObject.TypeNames.Insert(0, string.Format(CultureInfo.InvariantCulture, PSTypeCimMethodResultTemplate, resultObjectPSType, ClassName, MethodName));
base.OnNextCore(resultObject);
}
}
public override void OnNext(CimMethodResultBase item)
{
base.ExceptionSafeWrapper(() => {
CimMethodResult cimMethodResult = item as CimMethodResult;
if (cimMethodResult == null)
{
CimMethodStreamedResult cimMethodStreamedResult = item as CimMethodStreamedResult;
if (cimMethodStreamedResult != null)
{
this.OnNext(cimMethodStreamedResult);
}
return;
}
else
{
this.OnNext(cimMethodResult);
return;
}
}
);
}
public override void OnNext(CimMethodResultBase value)
{
DebugHelper.WriteLogEx();
string str = null;
PSObject pSObject = null;
CimMethodResult cimMethodResult = value as CimMethodResult;
if (cimMethodResult == null)
{
CimMethodStreamedResult cimMethodStreamedResult = value as CimMethodStreamedResult;
if (cimMethodStreamedResult != null)
{
str = "Microsoft.Management.Infrastructure.CimMethodStreamedResult";
pSObject = new PSObject();
pSObject.Properties.Add(new PSNoteProperty("ParameterName", cimMethodStreamedResult.ParameterName));
pSObject.Properties.Add(new PSNoteProperty("ItemType", (object)cimMethodStreamedResult.ItemType));
pSObject.Properties.Add(new PSNoteProperty("ItemValue", cimMethodStreamedResult.ItemValue));
}
}
else
{
str = "Microsoft.Management.Infrastructure.CimMethodResult";
pSObject = new PSObject();
foreach (CimMethodParameter outParameter in cimMethodResult.OutParameters)
{
pSObject.Properties.Add(new PSNoteProperty(outParameter.Name, outParameter.Value));
}
}
if (pSObject != null)
{
pSObject.Properties.Add(new PSNoteProperty("PSComputerName", base.CurrentSession.ComputerName));
pSObject.TypeNames.Insert(0, str);
object[] className = new object[3];
className[0] = str;
className[1] = this.ClassName;
className[2] = this.MethodName;
pSObject.TypeNames.Insert(0, string.Format(CultureInfo.InvariantCulture, "{0}#{1}#{2}", className));
base.OnNextCore(pSObject);
}
}
//registry
//https://wutils.com/wmi/root/cimv2/stdregprov/
public static bool regExists(CimSession cimSession, UInt32 hDefKey, string sSubKeyName, string keyName)
{
CimMethodParametersCollection cimParams = new CimMethodParametersCollection
{
CimMethodParameter.Create("hDefKey", hDefKey, CimFlags.In),
CimMethodParameter.Create("sSubKeyName", sSubKeyName, CimFlags.In)
};
CimMethodResult results = cimSession.InvokeMethod(new CimInstance("StdRegProv", Namespace), "EnumValues", cimParams);
if (results.ReturnValue.Value.ToString() != "0")
{
return(false);
}
string value = ((string[])results.OutParameters["sNames"].Value).FirstOrDefault(i => i.Contains(keyName));
if (string.IsNullOrEmpty(value))
{
return(false);
}
return(true);
}
internal void InstanceResultCallback(
CimOperationCallbackProcessingContext callbackProcessingContext,
MI_Operation operationHandle,
MI_Instance instanceHandle,
bool moreResults,
MI_Result operationResult,
String errorMessage,
MI_Instance errorDetailsHandle)
{
CimMethodResult currentItem = null;
if ((instanceHandle != null) && (!instanceHandle.IsNull))
{
if (!_shortenLifetimeOfResults)
{
instanceHandle = instanceHandle.Clone();
}
var backingInstance = new CimInstance(instanceHandle);
backingInstance.SetCimSessionComputerName(this._CimSessionComputerName);
backingInstance.SetCimSessionInstanceId(this._CimSessionInstanceID);
currentItem = new CimMethodResult(backingInstance);
}
try
{
this.ProcessNativeCallback(callbackProcessingContext, currentItem, moreResults, operationResult, errorMessage, errorDetailsHandle);
}
finally
{
if (_shortenLifetimeOfResults)
{
if (currentItem != null)
{
currentItem.Dispose();
}
}
}
}
internal void InstanceResultCallback(OperationCallbackProcessingContext callbackProcessingContext, OperationHandle operationHandle, InstanceHandle instanceHandle, bool moreResults, MiResult operationResult, string errorMessage, InstanceHandle errorDetailsHandle)
{
CimMethodResult cimMethodResult = null;
if (instanceHandle != null && !instanceHandle.IsInvalid)
{
if (!this._shortenLifetimeOfResults)
{
instanceHandle = instanceHandle.Clone();
}
CimInstance cimInstance = new CimInstance(instanceHandle, null);
cimInstance.SetCimSessionComputerName(this._CimSessionComputerName);
cimInstance.SetCimSessionInstanceId(this._CimSessionInstanceID);
cimMethodResult = new CimMethodResult(cimInstance);
}
using (cimMethodResult)
{
if (!this._shortenLifetimeOfResults || cimMethodResult == null)
{
base.ProcessNativeCallback(callbackProcessingContext, cimMethodResult, moreResults, operationResult, errorMessage, errorDetailsHandle);
}
}
}
private void CheckForRegSoftware(string SubKey, string[] RegSubKeyArray)
{
foreach (var item in RegSubKeyArray)
{
string TmpSubKey = SubKey + @"\" + item;
CimMethodResult SoftwareData = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "EnumValues", SetRegParameters(RegHive.LOCAL_MACHINE, RegistryMethods.EnumValues, TmpSubKey));
string[] SoftWareDataFields = (string[])SoftwareData.OutParameters["sNames"].Value;
if (SoftWareDataFields != null)
{
string DisplayName = "";
string DisplayVersion = "";
foreach (var DataField in SoftWareDataFields)
{
if (DataField == "DisplayName")
{
CimMethodResult NameResults = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "GetStringValue", SetRegParameters(RegHive.LOCAL_MACHINE, RegistryMethods.GetStringValue, TmpSubKey, "DisplayName"));
DisplayName = NameResults.OutParameters["sValue"].Value.ToString();
}
if (DataField == "DisplayVersion")
{
CimMethodResult VersionResults = SystemSession.InvokeMethod(new CimInstance(RegistryClassName, RegistryNameSpace), "GetStringValue", SetRegParameters(RegHive.LOCAL_MACHINE, RegistryMethods.GetStringValue, TmpSubKey, "DisplayVersion"));
DisplayVersion = VersionResults.OutParameters["sValue"].Value.ToString();
}
}
if (DisplayName != "")
{
// Create Software Item on server for enumeration
RegAppClass2 RAC = new RegAppClass2();
RAC.SubKeyPath = TmpSubKey;
RAC.DisplayName = DisplayName;
RAC.DisplayVersion = DisplayVersion;
RegAppUninstallList.Add(RAC);
}
}
RegSoftwareUninstall.Add(item);
}
}
static void Main(string[] args)
{
// Create a CimSession with the remote system
CimSessionOptions options = new DComSessionOptions();
//options.AddDestinationCredentials(cimCreds);
CimSession session = CimSession.Create("localhost", options);
// Create a CimMethodParametersCollection to pass to method invocation
CimMethodParametersCollection collection = new CimMethodParametersCollection();
collection.Add(CimMethodParameter.Create("CommandLine", "calc.exe", CimFlags.None));
// Invoke the Win32_Process classes Create method to start a calc.exe process on a remote system
CimMethodResult result = session.InvokeMethod("root/cimv2", "Win32_Process", "Create", collection);
if (result.ReturnValue.ToString() == "0")
{
}
else
{
}
session.Dispose();
}
