/// <summary>
/// Converts the <paramref name="sourceValue"/> parameter to the <paramref name="destinationType"/> parameter using formatProvider and ignoreCase.
/// </summary>
/// <param name="sourceValue">The value to convert from.</param>
/// <param name="destinationType">The type to convert to.</param>
/// <param name="formatProvider">The format provider to use like in IFormattable's ToString.</param>
/// <param name="ignoreCase">True if case should be ignored.</param>
/// <returns>The <paramref name="sourceValue"/> parameter converted to the <paramref name="destinationType"/> parameter using formatProvider and ignoreCase.</returns>
/// <exception cref="InvalidCastException">If no conversion was possible.</exception>
public override object ConvertFrom(object sourceValue, Type destinationType, IFormatProvider formatProvider, bool ignoreCase)
{
if (destinationType == null)
{
throw new ArgumentNullException("destinationType");
}
if (sourceValue == null)
{
throw new ArgumentNullException("sourceValue");
}
ScheduledJobTrigger originalTrigger = (ScheduledJobTrigger)sourceValue;
using (CimSession cimSession = CimSession.Create(null))
{
switch (originalTrigger.Frequency)
{
case TriggerFrequency.Weekly:
return(ConvertToWeekly(originalTrigger, cimSession));
case TriggerFrequency.Once:
return(ConvertToOnce(originalTrigger, cimSession));
case TriggerFrequency.Daily:
return(ConvertToDaily(originalTrigger, cimSession));
case TriggerFrequency.AtStartup:
return(ConvertToAtStartup(originalTrigger, cimSession));
case TriggerFrequency.AtLogon:
return(ConvertToAtLogon(originalTrigger, cimSession));
case TriggerFrequency.None:
return(ConvertToDefault(originalTrigger, cimSession));
default:
string errorMsg = StringUtil.Format(ScheduledJobErrorStrings.UnknownTriggerFrequency,
originalTrigger.Frequency.ToString());
throw new PSInvalidOperationException(errorMsg);
}
}
}
private static HvVirtualMachine GetVirtualMachine(string hvHostMachine, Guid vmGuid)
{
var vms = new List <HvVirtualMachine>();
var options = new CimSessionOptions();
using (var session = CimSession.Create(hvHostMachine, options))
{
var vmQuery = string.Format("SELECT * FROM Msvm_ComputerSystem WHERE Name = '{0}'", vmGuid.ToString());
var cimOpsOptions = new CimOperationOptions();
var computerSystems = session.QueryInstances(VirtualizationNamespace, "WQL", vmQuery, cimOpsOptions);
foreach (var cs in computerSystems)
{
vms.Add(new HvVirtualMachine(cs));
cs.Dispose();
}
}
return(vms.FirstOrDefault());
}
public UWFManagement()
{
try
{
if (_cimSession != null)
{
_cimSession.Close();
}
var sessionOptions = new DComSessionOptions();
sessionOptions.Timeout = new TimeSpan(0, 2, 0);
_cimSession = CimSession.Create(@".", sessionOptions);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
UpdateCimInstance();
}
internal static CimSession CreateCimSession(
string computerName,
PSCredential credential,
string authentication,
CancellationToken cancellationToken,
PSCmdlet cmdlet)
{
var sessionOptions = new CimSessionOptions();
CimCredential cimCredentials = GetCimCredentials(authentication, credential);
if (cimCredentials != null)
{
sessionOptions.AddDestinationCredentials(cimCredentials);
}
CimSession cimSession = CimSession.Create(computerName, sessionOptions);
return(cimSession);
}
protected override void BeginProcessing()
{
if (Session is null)
{
Session = new CimSession[]
{
CimSession.Create(null)
};
_isCimSessionOwner = true;
}
_cts = new CancellationTokenSource();
_options = new CimOperationOptions()
{
CancellationToken = _cts.Token,
};
if (!string.IsNullOrEmpty(ComputerName))
{
_options.SetCustomOption("ComputerName", ComputerName, true);
}
}
private static IReadOnlyCollection <HvVirtualMachine> GetVMs(string hvHostMachine)
{
var vms = new List <HvVirtualMachine>();
var options = new CimSessionOptions();
using (var session = CimSession.Create(hvHostMachine, options))
{
const string query = "SELECT * FROM Msvm_ComputerSystem WHERE Caption = 'Virtual Machine'";
var cimOpsOptions = new CimOperationOptions();
var computerSystems = session.QueryInstances(VirtualizationNamespace, "WQL", query, cimOpsOptions);
foreach (var instance in computerSystems)
{
vms.Add(new HvVirtualMachine(instance));
instance.Dispose();
}
}
return(vms.AsReadOnly());
}
private IEnumerable <string> GetGroupsForUser(string sid)
{
try
{
using var session = CimSession.Create(null);
var user = session
.QueryInstances(@"root\cimv2", "WQL", $"select * from Win32_UserAccount where SID='{sid}'")
.FirstOrDefault();
if (user != null)
{
var groups = session.EnumerateAssociatedInstances(@"root\cimv2", user, "Win32_GroupUser", "Win32_Group", null, null);
return(groups.Select(x => x.CimInstanceProperties["SID"].Value as string));
}
return(null);
}
catch
{
return(null);
}
}
/*
* "function Decode {If ($args[0] -is [System.Array]) {[System.Text.Encoding]::ASCII.GetString($args[0])}
* Else {\"Not Found\"}}
*
*
* $Monitors = Get-CimInstance WmiMonitorID -Namespace root\\wmi;
* ForEach ($Monitor in $monitors) {$Serial = Decode $Monitor.SerialNumberID -notmatch 0; if($Serial -ne 0){return $Serial}}");
*/
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
string Namespace = @"root\wmi";
string className = "WmiMonitorID";
CimInstance myDrive = new CimInstance(className, Namespace);
//myDrive.CimInstanceProperties.Add(CimProperty.Create("SerialNumberID", null, CimFlags.Key)); //CimProperty.Create("SerialNumberID", "C:", CimFlags.Key));
CimSession mySession = CimSession.Create(null);
CimInstance searchInstance = mySession.GetInstance(Namespace, myDrive);
IEnumerable <CimInstance> queryInstances =
mySession.QueryInstances(@"root\wmi",
"WQL",
@"select * from WmiMonitorID");
}
/// <summary>
/// Creates a new collection of <see cref="ComponentDescriptor"/> that describes the specified
/// components installed in system associated with a network host-name.
/// </summary>
/// <param name="hostName">
/// The network host-name that should be described.
/// </param>
/// <returns>
/// The resulting collection of <see cref="ComponentDescriptor"/> if successful.
/// </returns>
public static IEnumerable <ComponentDescriptor> Create(string hostName)
{
// Validate parameters.
if (String.IsNullOrWhiteSpace(hostName))
{
throw new ArgumentNullException("hostName");
}
CimSessionOptions sessionOptions = new CimSessionOptions()
{
};
sessionOptions.AddDestinationCredentials(new CimCredential(ImpersonatedAuthenticationMechanism.Negotiate));
CimSession session = CimSession.Create(hostName, sessionOptions);
return
(ComponentDescriptor.GetProcessors(session)
.Concat(ComponentDescriptor.GetMemory(session))
.Concat(ComponentDescriptor.GetHardDrives(session))
.ToList());
}
/// <summary>
/// Retrieves the duration (TickCount) since the system was last started from a remote machine.
/// </summary>
/// <param name="computerName">Name of computer on network to retrieve tickcount for</param>
/// <returns>WMI Win32_OperatingSystem LocalDateTime - LastBootUpTime (ticks)</returns>
public int? GetRemoteMachineTickCount(string computerName)
{
string namespaceName = @"root\cimv2";
string queryDialect = "WQL";
DComSessionOptions SessionOptions = new DComSessionOptions();
SessionOptions.Impersonation = ImpersonationType.Impersonate;
var baseLineTickCount = Environment.TickCount; // Note: to determine discrepancy
CimSession session = CimSession.Create(computerName, SessionOptions);
string query = "SELECT * FROM Win32_OperatingSystem";
var cimInstances = session.QueryInstances(namespaceName, queryDialect, query);
if (cimInstances.Any())
{
var lastBootUpTime = Convert.ToDateTime(cimInstances.First().CimInstanceProperties["LastBootUpTime"].Value);
var localDateTime = Convert.ToDateTime(cimInstances.First().CimInstanceProperties["LocalDateTime"].Value);
var timeSpan = localDateTime - lastBootUpTime;
var tickCount = Convert.ToInt32(timeSpan.TotalMilliseconds);
var discrepancy = tickCount - baseLineTickCount; // Note: discrepancy about +/- 100ms
return tickCount;
}
return null;
}
public TcpSettingsModel GetTcpSettings()
{
var session = CimSession.Create(Server);
var instances = session.QueryInstances(TcpSettings.SettingsClassNamespace, Wmi.QueryDialect, TcpSettings.SettingsQuery);
var instance = instances.FirstOrDefault();
if (instance == null)
{
return(null);
}
var startPort = Convert.ToInt32(instance.CimInstanceProperties[TcpSettings.DynamicPortRangeStartPortKey].Value);
var totalPorts = Convert.ToInt32(instance.CimInstanceProperties[TcpSettings.DynamicPortRangeNumberOfPortsKey].Value);
return(new TcpSettingsModel()
{
DynamicPortRangeStart = startPort,
DynamicPortRangeEnd = startPort + totalPorts,
TotalDynamicPorts = totalPorts
});
}
/// <summary>
/// Retrieves the duration (TimeSpan) since the system was last started.
/// Note: can be used on a local or a remote machine.
/// </summary>
/// <param name="computerName">Name of computer on network to retrieve uptime for</param>
/// <returns>WMI Win32_OperatingSystem LocalDateTime - LastBootUpTime</returns>
private static TimeSpan?GetSystemUptime(string computerName)
{
string namespaceName = @"root\cimv2";
string queryDialect = "WQL";
DComSessionOptions SessionOptions = new DComSessionOptions();
SessionOptions.Impersonation = ImpersonationType.Impersonate;
CimSession session = CimSession.Create(computerName, SessionOptions);
string query = "SELECT * FROM Win32_OperatingSystem";
var cimInstances = session.QueryInstances(namespaceName, queryDialect, query);
if (cimInstances.Any())
{
var cimInstance = cimInstances.First();
var lastBootUpTime = Convert.ToDateTime(cimInstance.CimInstanceProperties["LastBootUpTime"].Value);
var localDateTime = Convert.ToDateTime(cimInstance.CimInstanceProperties["LocalDateTime"].Value);
var uptime = localDateTime - lastBootUpTime;
return(uptime);
}
return(null);
}
public void Execute(object parameter)
{
CimInstance TypedParameter = parameter as CimInstance;
CimSession cimSession = CimSession.Create(TypedParameter.CimInstanceProperties["CSName"].Value.ToString());
uint result = 0;
try
{
result = (uint)cimSession.InvokeMethod(TypedParameter, @"Terminate", null).ReturnValue.Value;
}
catch (CimException e)
{
MessageBox.Show($"{e.Message} ({e.HResult})" + Environment.NewLine + "Das beenden des Prozesses schlug fehl.", "Fehler aufgetreten");
}
if (result != 0)
{
MessageBox.Show($"Das beenden des Prozesses schlug mit Fehlercode {result} fehl.", "Fehler aufgetreten");
}
}
public static CimSession newSession(string computername, string domain, string username, string password, bool impersonate = false)
{
CimSession cimSession;
if (impersonate)
{
DComSessionOptions options = new DComSessionOptions {
Impersonation = ImpersonationType.Impersonate
};
cimSession = CimSession.Create(computername, options);
}
else
{
CimCredential credentials = new CimCredential(PasswordAuthenticationMechanism.Negotiate, domain, username, Misc.CreateSecuredString(password));
WSManSessionOptions sessionOptions = new WSManSessionOptions();
sessionOptions.AddDestinationCredentials(credentials);
sessionOptions.MaxEnvelopeSize = 256000;
cimSession = CimSession.Create(computername, sessionOptions);
}
return(cimSession);
}
private static void PrintMonitorInfos()
{
var mySession = CimSession.Create(null);
var queryInstances =
mySession.QueryInstances(@"root\wmi",
"WQL",
@"select * from WmiMonitorID");
foreach (var queryInstance in queryInstances)
{
foreach (var cimInstanceProperty in queryInstance.CimInstanceProperties)
{
var value = cimInstanceProperty.CimType == CimType.UInt16Array
? ConvertUInt16ArrayToString(cimInstanceProperty)
: Convert.ToString(cimInstanceProperty.Value);
Console.WriteLine(cimInstanceProperty.Name + " " + value);
}
}
}
static public List <PrintJob> GetPrintJobs(List <string> printserver)
{
List <PrintJob> printJobs = new List <PrintJob>();
string Namespace = @"root\cimv2";
string OSQuery = "SELECT * FROM Win32_PrintJob";
foreach (string ps in printserver)
{
CimSession mySession = CimSession.Create(ps);
IEnumerable <CimInstance> queryInstance = mySession.QueryInstances(Namespace, "WQL", OSQuery);
foreach (var props in queryInstance)
{
var Printer = props.CimInstanceProperties["Name"].Value.ToString();
Printer = Printer.Substring(0, Printer.LastIndexOf(','));
var PrintJobID = Int32.Parse(props.CimInstanceProperties["JobID"].Value.ToString());
var PrintJobName = props.CimInstanceProperties["Document"].Value.ToString();
var Server = props.CimInstanceProperties["HostPrintQueue"].Value.ToString();
var Status = props.CimInstanceProperties["Status"].Value.ToString();
var PrintDriver = props.CimInstanceProperties["DriverName"].Value.ToString();
//var TimeSubmitted = ManagementDateTimeConverter.ToDateTime(props.CimInstanceProperties["StartTime"].ToString());
var TimeSubmitted = Convert.ToDateTime(props.CimInstanceProperties["TimeSubmitted"].Value);
var PagesPrinted = Int32.Parse(props.CimInstanceProperties["PagesPrinted"].Value.ToString());
var TotalPages = Int32.Parse(props.CimInstanceProperties["TotalPages"].Value.ToString());
printJobs.Add(new PrintJob {
Printer = Printer,
PrintJobID = PrintJobID,
PrintJobName = PrintJobName,
Server = Server,
Status = Status,
PrintDriver = PrintDriver,
TimeSubmitted = TimeSubmitted,
PagesPrinted = PagesPrinted,
TotalPages = TotalPages
});
}
}
return(printJobs);
}
public string UnInstallSoftware(string programName)
{
CimSession session = CimSession.Create("localHost");
IEnumerable queryInstance = session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Product ");
ManagementObjectSearcher mos = new ManagementObjectSearcher("SELECT * FROM Win32_Product");
foreach (var item in mos.Get())
{
if (item["Name"].ToString() == programName)
{
//object hr = item.InvokeMethod("Uninstall", null);
// return (bool)hr;
}
}
foreach (CimInstance cimObj in queryInstance)
{
//cimObj.Uninstall();
}
return("");
}
static void Main()
{
string Namespace = @"root\cimv2";
string ComputerName = "127.0.0.1";
string ClassName = "Win32_Process";
DComSessionOptions DComOptions = new DComSessionOptions();
DComOptions.Impersonation = ImpersonationType.Impersonate;
CimSession Session = CimSession.Create(ComputerName, DComOptions);
IEnumerable <CimInstance> processes = Session.EnumerateInstances(Namespace, ClassName);
foreach (CimInstance process in processes)
{
Console.WriteLine("{0} {1} {2} {3}",
process.CimInstanceProperties["Name"],
process.CimInstanceProperties["ParentProcessId"],
process.CimInstanceProperties["ProcessId"],
process.CimInstanceProperties["CommandLine"]);
}
Console.ReadLine();
}
private IDscRes DscResReadConfig(IHasDiagnostics result, IDscRes config)
{
using var ses = CimSession.Create(config.ComputerName ?? DscRes.DefaultCimHostname);
using var cls = ses.GetClass(DscRes.DscCimNamespace, config.TypeName);
using var cim = new CimInstance(DscRes.LcmCimClassName, DscRes.DscCimNamespace);
var mofBody = DscRes.BuildMof(config, cls);
_log.LogDebug("Generated MOF:\n{0}", mofBody);
var mofBodyBytes = DscRes.ToUint8(mofBody);
var methodParams = new CimMethodParametersCollection
{
CimMethodParameter.Create("ModuleName", config.ModuleName, CimFlags.None),
CimMethodParameter.Create("ResourceType", config.TypeName, CimFlags.None),
CimMethodParameter.Create("resourceProperty", mofBodyBytes, CimFlags.None),
};
CimMethodResult methodResult;
lock (_dscSync) {
methodResult = ses.InvokeMethod(cim, "ResourceGet", methodParams);
}
var dscResConfigs = (CimInstance)methodResult.OutParameters["configurations"].Value;
var state = config;
state.Results = new Dictionary <string, string>();
foreach (var p in dscResConfigs.CimInstanceProperties)
{
state.Results[p.Name] = p.Value?.ToString() ?? string.Empty;
}
lock (_dscSync) {
methodResult = ses.InvokeMethod(cim, "ResourceTest", methodParams);
}
state.InDesiredState = (bool)methodResult.OutParameters["InDesiredState"].Value;
return(state);
}
/// <summary>
/// Creates a new <see cref="AssetDescriptor"/> that describes the specified
/// network host-name.
/// </summary>
/// <param name="hostName">
/// The network host-name that should be described.
/// </param>
/// <returns>
/// The resulting <see cref="AssetDescriptor"/> if successful.
/// </returns>
public static AssetDescriptor Create(string hostName)
{
CimSessionOptions sessionOptions = new CimSessionOptions()
{
};
sessionOptions.AddDestinationCredentials(new CimCredential(ImpersonatedAuthenticationMechanism.Negotiate));
CimSession session = CimSession.Create(hostName, sessionOptions);
CimInstance computerDetails = session.EnumerateInstances(@"root\cimv2", "Win32_ComputerSystem").FirstOrDefault();
CimInstance productDetails = session.EnumerateInstances(@"root\cimv2", "Win32_ComputerSystemProduct").FirstOrDefault();
return(new AssetDescriptor()
{
Serial = Convert.ToString(productDetails.CimInstanceProperties["IdentifyingNumber"].Value, CultureInfo.InvariantCulture),
Name = Convert.ToString(computerDetails.CimInstanceProperties["Name"].Value, CultureInfo.InvariantCulture),
Manufacturer = Convert.ToString(computerDetails.CimInstanceProperties["Manufacturer"].Value, CultureInfo.InvariantCulture),
Model = String.Join(" ", computerDetails.CimInstanceProperties["Manufacturer"].Value, computerDetails.CimInstanceProperties["Model"].Value),
ModelNumber = Convert.ToString(computerDetails.CimInstanceProperties["Model"].Value, CultureInfo.InvariantCulture),
Category = pcSystemTypeExMap[Convert.ToInt32(computerDetails.CimInstanceProperties["PCSystemTypeEx"].Value, CultureInfo.InvariantCulture)]
});
}
public static List <MachineHardwareInfo> GetHardwareInfo(string computer, string domain, string username, string plaintextpassword)
{
MachineName = computer;
List <MachineHardwareInfo> info = new List <MachineHardwareInfo>();
SecureString securepassword = new SecureString();
foreach (char c in plaintextpassword)
{
securepassword.AppendChar(c);
}
// create Credentials
CimCredential Credentials = new CimCredential(PasswordAuthenticationMechanism.Default,
domain,
username,
securepassword);
// create SessionOptions using Credentials
WSManSessionOptions SessionOptions = new WSManSessionOptions();
SessionOptions.AddDestinationCredentials(Credentials);
// create Session using computer, SessionOptions
using (CimSession Session = CimSession.Create(computer, SessionOptions))
{
var usb = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_USBControllerDevice");
var disks = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_LogicalDisk");
var ram = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_PhysicalMemory");
var processor = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_Processor");
var sound = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_SoundDevice");
info.AddRange(RamInfo(ram));
info.AddRange(ProcessorInfo(processor));
info.AddRange(USBInfo(usb));
info.AddRange(DiskInfo(disks));
}
return(info);
}
public string GetAccounts()
{
//CimSession session = CimSession.Create("ROBINDEVIL");
string computer = "ROBINDEVIL";
DComSessionOptions DComOptions = new DComSessionOptions();
DComOptions.Impersonation = ImpersonationType.Impersonate;
CimSession session = CimSession.Create(computer, DComOptions);
IEnumerable queryInstance = session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_ComputerSystem");
StringBuilder sb = new StringBuilder();
foreach (CimInstance cimObj in queryInstance)
{
sb.Append("computer name :" + cimObj.CimInstanceProperties["Name"].ToString() + Environment.NewLine);
sb.Append("computer Domain :" + cimObj.CimInstanceProperties["Domain"].ToString() + Environment.NewLine);
//Console.WriteLine(cimObj.CimInstanceProperties["Name"].ToString());// to get computer name
//Console.WriteLine(cimObj.CimInstanceProperties["Domain"].ToString());// to get domain name
}
return(sb.ToString());
}
public static string GetCurrentUser()
{
try
{
if (OSUtils.IsWindows)
{
var session = CimSession.Create(null);
var computerSystem = session.EnumerateInstances("root\\cimv2", "CIM_ComputerSystem");
var username = computerSystem.FirstOrDefault().CimInstanceProperties["UserName"].Value ?? "";
return(username as string);
}
else if (OSUtils.IsLinux)
{
var users = OSUtils.StartProcessWithResults("users", "");
var username = users?.Split()?.FirstOrDefault()?.Trim();
return($"{Environment.UserDomainName}\\{username}");
}
throw new Exception("Unsupported operating system.");
}
catch
{
return("Error Retrieving");
}
}
public static void CreateSnapshot()
{
const string hvNamespace = @"root\virtualization\v2";
var sessionOptions = new DComSessionOptions
{
Timeout = TimeSpan.FromSeconds(30)
};
var cimSession = CimSession.Create("localhost", sessionOptions);
// Get an instance of the VM to snapshot
var vm = cimSession.QueryInstances(hvNamespace, "WQL", $"SELECT * FROM CIM_ComputerSystem WHERE ElementName = 'MyTestVM'").First();
// Get the instance of Msvm_VirtualSystemSnapshotService. There is only one.
var vmSnapshotService = cimSession.EnumerateInstances(hvNamespace, "Msvm_VirtualSystemSnapshotService").First();
// Set the snapshot parameters by creating a Msvm_VirtualSystemSnapshotSettingData
var snapshotSettings = new CimInstance("Msvm_VirtualSystemSnapshotSettingData");
snapshotSettings.CimInstanceProperties.Add(CimProperty.Create("ConsistencyLevel", 1, CimType.UInt8, CimFlags.ReadOnly));
snapshotSettings.CimInstanceProperties.Add(CimProperty.Create("IgnoreNonSnapshottableDisks", true, CimFlags.ReadOnly));
// Put all of these things into a CimMethodParametersCollection.
// Note; no need to specify the "Out" parameters. They will be returned by the call to InvokeMethod.
var methodParameters = new CimMethodParametersCollection
{
CimMethodParameter.Create("AffectedSystem", vm, CimType.Reference, CimFlags.In),
CimMethodParameter.Create("SnapshotSettings", snapshotSettings.ToString(), CimType.String, CimFlags.In),
CimMethodParameter.Create("SnapshotType", 2, CimType.UInt16, CimFlags.In),
};
cimSession.InvokeMethod(hvNamespace, vmSnapshotService, "CreateSnapshot", methodParameters);
Console.WriteLine($"Snapshot created!");
}
private bool DscResTestConfig(IHasDiagnostics result, IDscRes config)
{
using var ses = CimSession.Create(config.ComputerName ?? DscRes.DefaultCimHostname);
using var cls = ses.GetClass(DscRes.DscCimNamespace, config.TypeName);
using var cim = new CimInstance(DscRes.LcmCimClassName, DscRes.DscCimNamespace);
var mofBody = DscRes.BuildMof(config, cls);
_log.LogDebug("Generated MOF:\n{0}", mofBody);
var mofBodyBytes = DscRes.ToUint8(mofBody);
var methodParams = new CimMethodParametersCollection
{
CimMethodParameter.Create("ModuleName", config.ModuleName, CimFlags.None),
CimMethodParameter.Create("ResourceType", config.TypeName, CimFlags.None),
CimMethodParameter.Create("resourceProperty", mofBodyBytes, CimFlags.None),
};
CimMethodResult methodResult;
lock (_dscSync) {
methodResult = ses.InvokeMethod(cim, "ResourceTest", methodParams);
}
return((bool)methodResult.OutParameters["InDesiredState"].Value);
}
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();
}
private static CimSession CreateDefaultCimSession()
{
return(CimSession.Create(null));
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//string computer = "ILPT2113";
//string domain = "ICERTIS.COM";
//string username = @"*****@*****.**";
string computer = "myfirstvm";
string domain = "";
string username = "******";
string plaintextpassword;
Console.WriteLine("Enter password:"******"root\cimv2", "WQL", "SELECT * FROM Win32_Directory");
var allPDisks = Session.QueryInstances(@"root\cimv2", "WQL", "SELECT * FROM Win32_DiskDrive");
// Loop through all volumes
foreach (CimInstance oneVolume in allVolumes)
{
// Show volume information
if (oneVolume.CimInstanceProperties["DriveLetter"].ToString()[0] > ' ')
{
Console.WriteLine("Volume ‘{0}’ has {1} bytes total, {2} bytes available",
oneVolume.CimInstanceProperties["DriveLetter"],
oneVolume.CimInstanceProperties["Size"],
oneVolume.CimInstanceProperties["SizeRemaining"]);
}
}
// Loop through all physical disks
foreach (CimInstance onePDisk in allPDisks)
{
// Show physical disk information
Console.WriteLine("Disk {0} is model {1}, serial number {2}",
onePDisk.CimInstanceProperties["DeviceId"],
onePDisk.CimInstanceProperties["Model"].ToString().TrimEnd(),
onePDisk.CimInstanceProperties["SerialNumber"]);
}
Console.ReadKey();
}
private CimInstance[] GetServices(string szMachine, string szUsername, CancellationToken _cancel)
{
bool _exceptionThrown = false;
List <CimInstance> _results = new List <CimInstance>();
if (!_cancel.IsCancellationRequested)
{
try
{
string Namespace = @"root\cimv2";
string OSQuery = "SELECT * FROM Win32_Service";
CimSession mySession = CimSession.Create(szMachine);
IEnumerable <CimInstance> queryInstance = mySession.QueryInstances(Namespace, "WQL", OSQuery);
foreach (CimInstance _svc in queryInstance)
{
if (_cancel.IsCancellationRequested)
{
break;
}
string szServiceName = _svc.CimInstanceProperties["StartName"].Value as string;
if (!string.IsNullOrWhiteSpace(szServiceName))
{
if (szServiceName.ToLower().Contains(szUsername.ToLower()))
{
_results.Add(_svc);
}
}
}
}
catch (CimException _cex)
{
switch (_cex.HResult)
{
case unchecked ((int)0x80338126):
case unchecked ((int)0x80131500):
Status($"Error Gathering Service Accounts ({szMachine}) - most likely offline / firewall");
break;
case unchecked ((int)0x80070005):
Status($"Error Gathering Service Accounts ({szMachine}) - invalid permissions");
break;
default:
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
Status($"Error Gathering Service Accounts ({szMachine}) - PROVIDE TO SUPPORT - CIM UNKNKOWN ({_cex.HResult})");
break;
}
_exceptionThrown = true;
}
catch (Exception _ex)
{
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
Status($"Error Gathering Service Accounts ({szMachine}) - PROVIDE TO SUPPORT - UNKNKOWN ({_ex.GetType().Name}:{_ex.HResult})");
_exceptionThrown = true;
}
if (_exceptionThrown)
{
_results.Clear(); // clear results so we do not error and can continue.
System.Threading.Thread.Sleep(5000); // give them time to see the error
}
}
return(_results.ToArray());
}
public static IEnumerable <CimInstance> Query(string nameSpace, string queryExpression)
{
return(CimSession.Create(null).QueryInstances(nameSpace, "WQL", queryExpression));
}
