public static bool IsEMSEnabled()
{
bool isEMSEnabled = false;
try
{
// {9dea862c-5cdd-4e70-acc1-f32b344d4795} is the GUID of the System BcdStore
ManagementObject scopeObj = new ManagementObject(new ManagementScope(@"root\WMI"), new ManagementPath("root\\WMI:BcdObject.Id=\"{9dea862c-5cdd-4e70-acc1-f32b344d4795}\",StoreFilePath=\"\""), null);
ManagementBaseObject elementObj = null;
elementObj = scopeObj.GetMethodParameters("GetElement");
// Get the list of IDs from 0x24000001, which is a BCD constant: BcdBootMgrObjectList_DisplayOrder
elementObj["Type"] = ((UInt32)0x24000001);
ManagementBaseObject BCDObj = scopeObj.InvokeMethod("GetElement", elementObj, null);
ManagementBaseObject value = ((ManagementBaseObject)(BCDObj.Properties["Element"].Value));
// Get list of Ids
string[] idList = (string[])value.GetPropertyValue("Ids");
// Define the Management object used to access the WMI info from BCD store
scopeObj = new ManagementObject(new ManagementScope(@"root\WMI"), new ManagementPath("root\\WMI:BcdObject.Id=\"" + idList[0] + "\",StoreFilePath=\"\""), null);
elementObj = scopeObj.GetMethodParameters("GetElement");
// BcdOSLoaderBoolean_EmsEnabled (0x260000b0)
// The EMS enabled setting. The element data format is BcdBooleanElement.
elementObj["Type"] = ((UInt32)0x260000b0);
BCDObj = scopeObj.InvokeMethod("GetElement", elementObj, null);
value = ((ManagementBaseObject)(BCDObj.Properties["Element"].Value));
// try get EMS enabled setting
Boolean.TryParse(value.GetPropertyValue("boolean").ToString(), out isEMSEnabled);
// Dispose unmanaged objects
if (scopeObj != null)
{
scopeObj.Dispose();
}
if (elementObj != null)
{
elementObj.Dispose();
}
if (BCDObj != null)
{
BCDObj.Dispose();
}
if (value != null)
{
value.Dispose();
}
}
catch (Exception e)
{
Tracer.WriteError(String.Format("Exception {0} Trace {1}", e.Message, e.StackTrace));
}
return(isEMSEnabled);
}
/// <summary>
/// Get a DWORD Registry Value as string
/// </summary>
/// <param name="hDefKey">HKLM = 2147483650</param>
/// <param name="sSubKeyName"></param>
/// <param name="sValueName"></param>
/// <param name="DefaultValue">return string if key or value does not exist</param>
/// <returns></returns>
public string GetDWord(UInt32 hDefKey, string sSubKeyName, string sValueName, string DefaultValue)
{
{
String result = "";
try
{
WMIProvider oProv = new WMIProvider(oWMIProvider.mScope.Clone());
oProv.mScope.Path.NamespacePath = @"ROOT\default";
ManagementBaseObject inParams = oProv.GetClass("StdRegProv").GetMethodParameters("GetDWORDValue");
inParams["hDefKey"] = hDefKey;
inParams["sSubKeyName"] = sSubKeyName;
inParams["sValueName"] = sValueName;
ManagementBaseObject outParams = oProv.ExecuteMethod("StdRegProv", "GetDWORDValue", inParams);
if (outParams.GetPropertyValue("ReturnValue").ToString() == "0")
{
if (outParams.GetPropertyValue("uValue") != null)
{
result = outParams.GetPropertyValue("uValue").ToString();
}
}
return(result);
}
catch
{
return(DefaultValue);
}
}
}
/// <summary>
/// Create a new process on a remote system. For security reasons this method cannot be used to start an interactive process remotely.
/// </summary>
/// <param name="CommandLine"></param>
/// <param name="CurrentDirectory"></param>
/// <param name="ProcessStartupInformation">A Win32_ProcessStartup Object <see href="http://msdn2.microsoft.com/en-us/library/aa394375.aspx"/></param>
/// <returns>ProcessID</returns>
public int StartProcess(string CommandLine, string CurrentDirectory, ManagementBaseObject ProcessStartupInformation)
{
if (CurrentDirectory == "")
{
CurrentDirectory = null;
}
WMIProvider oProv = new WMIProvider(oWMIProvider.mScope.Clone());
oProv.mScope.Path.NamespacePath = @"root\cimv2";
ManagementClass MC = oProv.GetClass("Win32_Process");
ManagementBaseObject inParams = MC.GetMethodParameters("Create");
inParams["CommandLine"] = CommandLine;
inParams["CurrentDirectory"] = CurrentDirectory;
inParams["ProcessStartupInformation"] = ProcessStartupInformation;
ManagementBaseObject Result = MC.InvokeMethod("Create", inParams, null);
switch (int.Parse(Result.GetPropertyValue("ReturnValue").ToString()))
{
case 0: return(int.Parse(Result.GetPropertyValue("ProcessID").ToString()));
case 2: throw new System.Security.SecurityException("Access denied");
case 3: throw new System.Security.SecurityException("Insufficient privilege");
case 9: throw new Exception("Path not found: " + CommandLine);
case 21: throw new Exception("Invalid parameter");
default: throw new Exception("Unknown failure");
}
}
/// <summary>
/// Get an ArrayList of all Regisry Values
/// </summary>
/// <param name="hDefKey">2147483650 = HKLM</param>
/// <param name="sSubKeyName"></param>
/// <returns>RegistryValues</returns>
public List <string> RegValuesList(UInt32 hDefKey, string sSubKeyName)
{
try
{
WMIProvider oProv = new WMIProvider(oWMIProvider.mScope.Clone());
oProv.mScope.Path.NamespacePath = @"ROOT\default";
ManagementBaseObject inParams = oProv.GetClass("StdRegProv").GetMethodParameters("EnumValues");
inParams["hDefKey"] = hDefKey;
inParams["sSubKeyName"] = sSubKeyName;
ManagementBaseObject outParams = oProv.ExecuteMethod("StdRegProv", "EnumValues", inParams);
List <string> result = new List <string>();
if (outParams.GetPropertyValue("ReturnValue").ToString() == "0")
{
if (outParams.GetPropertyValue("sNames") != null)
{
result.AddRange(outParams.GetPropertyValue("sNames") as String[]);
}
}
return(result);
}
catch
{
throw;
}
}
/// <summary>
/// Converts a Win32 WMI object to a .NET class instance or struct.
/// </summary>
/// <param name="managementBaseObject"></param>
/// <typeparam name="T"></typeparam>
/// <returns>Instance of the .NET class <typeparamref name="T"/> populated with the data from <paramref name="managementBaseObject"/>.</returns>
/// <exception cref="NotSupportedException">Thrown if the .NET class <typeparamref name="T"/> does not have a zero-argument constructor.</exception>
public static T FromManagementObject <T>(ManagementBaseObject managementBaseObject)
{
var type = typeof(T);
var publicInstanceFields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
var zeroArgCtor = type.GetConstructor(new Type[0]);
if (zeroArgCtor != null)
{
var instance = (T)zeroArgCtor.Invoke(new object[0]);
foreach (var fieldInfo in publicInstanceFields)
{
var value = managementBaseObject.GetPropertyValue(fieldInfo.Name);
fieldInfo.SetValue(instance, value);
}
return(instance);
}
var publicFieldTypes = publicInstanceFields.Select(info => info.FieldType).ToArray();
var fieldArgCtor = type.GetConstructor(publicFieldTypes);
if (fieldArgCtor != null)
{
var args = publicInstanceFields.Select(info => managementBaseObject.GetPropertyValue(info.Name)).ToArray();
var instance = (T)fieldArgCtor.Invoke(args);
return(instance);
}
throw new NotSupportedException(string.Format("No usable constructors found for type {0}. Type must have a zero-argument constructor or a constructor with arguments for all public fields.", type.FullName));
}
private USBDeviceInfo ExtractDevice(ManagementBaseObject device)
{
string deviceID = (string)device.GetPropertyValue("DeviceID");
string pnpDeviceID = (string)device.GetPropertyValue("PNPDeviceID");
string description = (string)device.GetPropertyValue("Description");
string serialNumber = GetSerialNumber(pnpDeviceID);
return(new USBDeviceInfo(deviceID, pnpDeviceID, description, serialNumber));
}
public virtual uint GetCurrentNvmVersion()
{
ManagementBaseObject managementBaseObject = Mo.InvokeMethod("GetCurrentNvmVersion", null, null);
TbtStatus tbtStatus = (TbtStatus)managementBaseObject.GetPropertyValue("ReturnValue");
if (tbtStatus != 0)
{
throw new TbtException(tbtStatus, Resources.GetFirmwareVersionFailed);
}
return((uint)managementBaseObject.GetPropertyValue("nvmVersion"));
}
private void PrintWmiFunctions()
{
try
{
classInstance = new ManagementObject(wmiScope,
$"{wmiAMDACPI}.InstanceName='{instanceName}'",
null);
// Get function names with their IDs
string[] functionObjects = { "GetObjectID", "GetObjectID2" };
var index = 1;
foreach (var functionObject in functionObjects)
{
AddHeading($"WMI: Bios Functions {index}");
try
{
pack = WMI.InvokeMethod(classInstance, functionObject, "pack", null, 0);
if (pack != null)
{
var ID = (uint[])pack.GetPropertyValue("ID");
var IDString = (string[])pack.GetPropertyValue("IDString");
var Length = (byte)pack.GetPropertyValue("Length");
for (var i = 0; i < Length; ++i)
{
if (IDString[i] == "")
{
return;
}
AddLine($"{IDString[i] + ":",-30}{ID[i]:X8}");
}
}
else
{
AddLine("<FAILED>");
}
}
catch
{
// ignored
}
index++;
AddLine();
}
}
catch
{
// ignored
}
}
public void TestCanGetActivityIdStringWithWMI()
{
WmiTraceListener listener = new WmiTraceListener();
LogEntry logEntry = new LogEntry("message", "cat1", 0, 0, TraceEventType.Error, "title", null);
Guid logEntryGuid = Guid.NewGuid();
logEntry.ActivityId = logEntryGuid;
SendLogEntry(listener, logEntry);
Assert.IsTrue(wmiLogged);
Assert.AreEqual(wmiLogEntry.GetPropertyValue("ActivityIdString"), logEntryGuid.ToString());
}
private bool DetectBootloader(ManagementBaseObject instance, bool connected = true)
{
string connected_string = connected ? "connected" : "disconnected";
// Detects Atmel Vendor ID
var dfu = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_03EB.*");
// Detects Arduino Vendor ID
var caterina = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_2341.*");
// Detects PJRC Vendor ID
var halfkay_vid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_16C0.*");
var halfkay_pid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*PID_0478.*");
var halfkay_nohid = Regex.Match(instance.GetPropertyValue("Name").ToString(), @".*USB.*");
var dfuUtil_pid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*VID_0483.*");
var dfuUtil_vid = Regex.Match(instance.GetPropertyValue("DeviceID").ToString(), @".*PID_DF11.*");
Regex deviceid_regex = new Regex("VID_([0-9A-F]+).*PID_([0-9A-F]+)");
var vp = deviceid_regex.Match(instance.GetPropertyValue("DeviceID").ToString());
string VID = vp.Groups[1].ToString();
string PID = vp.Groups[2].ToString();
string device_name;
if (dfu.Success)
{
device_name = "DFU";
devicesAvailable[(int)Chipset.DFU] += connected ? 1 : -1;
}
else if (caterina.Success)
{
device_name = "Caterina";
Regex regex = new Regex("(COM[0-9]+)");
var v = regex.Match(instance.GetPropertyValue("Name").ToString());
flasher.caterinaPort = v.Groups[1].ToString();
devicesAvailable[(int)Chipset.Caterina] += connected ? 1 : -1;
}
else if (halfkay_vid.Success && halfkay_pid.Success && halfkay_nohid.Success)
{
device_name = "Halfkay";
devicesAvailable[(int)Chipset.Halfkay] += connected ? 1 : -1;
}
else if (dfuUtil_pid.Success && dfuUtil_vid.Success)
{
device_name = "STM32";
devicesAvailable[(int)Chipset.STM32] += connected ? 1 : -1;
}
else
{
return(false);
}
printer.print(device_name + " device " + connected_string + ": " + instance.GetPropertyValue("Name") + " -- 0x" + VID + ":0x" + PID, MessageType.Bootloader);
return(true);
}
private static ServiceInfo ConvertToServiceInfo(ManagementBaseObject service)
{
//var text = service.GetText(TextFormat.CimDtd20);
return(new ServiceInfo(
Convert.ToString(service.GetPropertyValue("Name")),
Convert.ToString(service.GetPropertyValue("DisplayName")),
Convert.ToString(service.GetPropertyValue("Description")),
Convert.ToString(service.GetPropertyValue("StartMode")),
Convert.ToString(service.GetPropertyValue("State"))
));
}
private void Frm_Main_Load(object sender, EventArgs e)
{
SelectQuery Query = new SelectQuery("SELECT * FROM Win32_BaseBoard"); //查询主板
ManagementObjectSearcher driveID = new ManagementObjectSearcher(Query); //创建WMI查询对象
//获取查询结果
ManagementObjectCollection.ManagementObjectEnumerator data = driveID.Get().GetEnumerator();
data.MoveNext(); //循环读取
ManagementBaseObject board = data.Current; //获取当前主板
textBox1.Text = board.GetPropertyValue("SerialNumber").ToString(); //获取主板编号
textBox2.Text = board.GetPropertyValue("Manufacturer").ToString(); //获取主板制造商
textBox3.Text = board.GetPropertyValue("Product").ToString(); //获取主板型号
}
public WMIGraphicsInformation(ManagementBaseObject from)
{
deviceId = from.GetPropertyValue("DeivceID") as string;
AdapterCompat = from.GetPropertyValue("AdapterCompatibility") as string;
AdapterDACType = from.GetPropertyValue("AdapterDACType") as string;
AdapterRAM = from.GetPropertyValue("AdapterRAM") as string;
Caption = from.GetPropertyValue("Caption") as string;
DriverVersion = from.GetPropertyValue("DriverVersion") as string;
DriverDate = ManagementDateTimeConverter.ToDateTime(from.GetPropertyValue("DriverDate") as string);
VideoProcessor = from.GetPropertyValue("VideoProcessor") as string;
name = from.GetPropertyValue("Name") as string;
}
public int GetDeviceCurrentBrightness()
{
var value = brightnessClass.GetPropertyValue("CurrentBrightness");
var valueString = value.ToString();
return(int.Parse(valueString));
}
/// <summary>
/// Get the path to the inf used by a printer
/// </summary>
/// <param name="printer"></param>
/// <returns></returns>
private string GetPrinterDriver(ManagementBaseObject printer)
{
// Get the name of the driver used by the printer and match it to a Win32_PrinterDriver
var name = printer.GetPropertyValue("DriverName");
using (var query = new ManagementObjectSearcher("SELECT * from Win32_PrinterDriver"))
{
// Select only the drivers which match the naming scheme (driver is in CSV format name,version,32/64bit)
foreach (var driver in from ManagementBaseObject driver
in query.Get()
let info = driver.GetPropertyValue("Name").ToString().Split(',')
where info[0].Equals(name)
select driver)
{
// TODO: Rewrite using ternary or null coalescing
try
{
return(Path.Combine(driver.GetPropertyValue("FilePath").ToString(),
driver.GetPropertyValue("InfName").ToString()));
}
catch (Exception)
{
return(@"C:\Windows\inf\ntprint.inf");
}
}
}
return(null);
}
public static object GetPropertyValue(ManagementBaseObject wmiClass, string propertyName)
{
const string method = "GetPropertyValue";
if (wmiClass == null)
{
throw new NullParameterException(typeof(WmiUtil), method, "wmiClass");
}
if (propertyName == null)
{
throw new NullParameterException(typeof(WmiUtil), method, "propertyName");
}
try
{
return(wmiClass.GetPropertyValue(propertyName));
}
catch (ManagementException ex)
{
string classText = null;
try
{
classText = wmiClass.GetText(TextFormat.Mof);
}
catch (System.Exception)
{
}
throw new WmiPropertyGetException(typeof(WmiUtil), method, propertyName,
wmiClass.ClassPath.ToString(), classText, ex);
}
}
public static string GetMachineID()
{
string str;
try
{
SelectQuery selectQuery = new SelectQuery("SELECT * FROM Win32_BaseBoard");
ManagementObjectCollection.ManagementObjectEnumerator enumerator = (new ManagementObjectSearcher(selectQuery)).Get().GetEnumerator();
enumerator.MoveNext();
ManagementBaseObject current = enumerator.Current;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(current.GetPropertyValue("SerialNumber").ToString());
if (stringBuilder.ToString().Trim().Length < 5)
{
foreach (ManagementObject instance in (new ManagementClass("Win32_NetworkAdapterConfiguration")).GetInstances())
{
if ((bool)instance["IPEnabled"])
{
stringBuilder.Append(instance["MacAddress"].ToString());
}
instance.Dispose();
}
}
str = string.Concat("S7", stringBuilder.ToString().Trim());
}
catch
{
str = "";
}
return(str);
}
private ProviderArchitectures GetProviderArchitecture(string computerName)
{
try
{
ManagementScope managementScope = GetManagementScope(computerName: computerName, nameSpace: Namespaces.cimv2, specifyArchitecture: false);
string commandText = string.Format("SELECT {0} FROM {1}", nameof(Win32_Processor.AddressWidth), nameof(Win32_Processor));
ManagementBaseObject result = GetCommandResults(commandText, managementScope).Cast <ManagementBaseObject>().ToArray()[0];
string addressWidth = result.GetPropertyValue(nameof(Win32_Processor.AddressWidth)).ToString();
if (!string.IsNullOrWhiteSpace(addressWidth))
{
if (addressWidth == ProviderArchitectures.x64.ToString("D"))
{
return(ProviderArchitectures.x64);
}
if (addressWidth == ProviderArchitectures.x86.ToString("D"))
{
return(ProviderArchitectures.x86);
}
}
}
catch (Exception ex)
{
Global.LogEvent(string.Format("EXCEPTION in {0}: {1}", MethodBase.GetCurrentMethod(), ex.Message));
}
return(default(ProviderArchitectures));
}
public static string GetMachineID()
{
string result;
try
{
SelectQuery query = new SelectQuery("SELECT * FROM Win32_BaseBoard");
ManagementObjectSearcher managementObjectSearcher = new ManagementObjectSearcher(query);
ManagementObjectCollection.ManagementObjectEnumerator enumerator = managementObjectSearcher.Get().GetEnumerator();
enumerator.MoveNext();
ManagementBaseObject managementBaseObject = enumerator.Current;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(managementBaseObject.GetPropertyValue("SerialNumber").ToString());
if (stringBuilder.ToString().Trim().Length < 5)
{
ManagementClass managementClass = new ManagementClass("Win32_NetworkAdapterConfiguration");
ManagementObjectCollection instances = managementClass.GetInstances();
foreach (ManagementBaseObject managementBaseObject2 in instances)
{
ManagementObject managementObject = (ManagementObject)managementBaseObject2;
if ((bool)managementObject["IPEnabled"])
{
stringBuilder.Append(managementObject["MacAddress"].ToString());
}
managementObject.Dispose();
}
}
result = "S7" + stringBuilder.ToString().Trim();
}
catch
{
result = "";
}
return(result);
}
private static void Win32_SharesSearcher()
{
SelectQuery query = new SelectQuery("select * from Win32_Share where Name=\"" + sharename + "\"");
using (ManagementObjectSearcher searcher = new ManagementObjectSearcher(query))
{
foreach (ManagementObject mo in searcher.Get())
{
foreach (PropertyData prop in mo.Properties)
{
form.textBox1.AppendText(prop.Name + " = " + mo[prop.Name] + Environment.NewLine);
}
//form.textBox1.AppendText(string.Format("Win32ShareName: {0} Description {1} Path {2} ", mo.Properties["Name"].Value, mo.Properties["Description"].Value, mo.Properties["Path"].Value) + Environment.NewLine);
}
}
ManagementObject winShareP = new ManagementObject("root\\CIMV2", "Win32_Share.Name=\"" + sharename + "\"", null);
ManagementBaseObject outParams = winShareP.InvokeMethod("GetAccessMask", null, null);
form.textBox1.AppendText(String.Format("access Mask = {0:x}", outParams["ReturnValue"]) + Environment.NewLine);
ManagementBaseObject inParams = winShareP.GetMethodParameters("SetShareInfo");
form.textBox1.AppendText("SetShareInfor in parameters" + Environment.NewLine);
foreach (PropertyData prop in inParams.Properties)
{
form.textBox1.AppendText(String.Format("PROP = {0}, TYPE = {1} ", prop.Name, prop.Type.ToString()) + Environment.NewLine);
}
Object access = inParams.GetPropertyValue("Access");
//Stopped development here because ShareAFolder project exists. The rest of the development is there
//Maybe should copy Sahare a Folder content to here at some point
}
static List <string> GetBootEntries(ManagementObject BcdStore, ManagementScope managementScope)
{
var bootEntries = new List <string>();
var inParams = BcdStore.GetMethodParameters("GetElement");
// 0x24000001 is a BCD constant: BcdBootMgrObjectList_DisplayOrder
inParams["Type"] = ((UInt32)0x24000001);
ManagementBaseObject outParams = BcdStore.InvokeMethod("GetElement", inParams, null);
ManagementBaseObject mboOut = ((ManagementBaseObject)(outParams.Properties["Element"].Value));
string[] osIdList = (string[])mboOut.GetPropertyValue("Ids");
// Each osGuid is the GUID of one Boot Manager in the BcdStore
foreach (string osGuid in osIdList)
{
ManagementObject currentManObj = new ManagementObject(managementScope,
new ManagementPath("root\\WMI:BcdObject.Id=\"" + osGuid + "\",StoreFilePath=\"\""), null);
var id = currentManObj.GetPropertyValue("Id");
bootEntries.Add((string)currentManObj.GetPropertyValue("Id"));
}
return(bootEntries);
}
/// <summary>
/// Retrieve String value from registry path.
/// </summary>
/// <param name="wmiRegistry">Management Object</param>
/// <param name="keyPath">Registry Path</param>
/// <param name="keyName">Key Name</param>
/// <param name="stringValue">Key Value</param>
/// <returns></returns>
private ResultCodes getRegistryStringValue(
ManagementClass wmiRegistry,
string keyPath,
string keyName,
out string stringValue)
{
ManagementBaseObject inputParameters = wmiRegistry.GetMethodParameters(RegistryMethodNames.GET_MULTI_STRING_VALUE);
inputParameters.SetPropertyValue(RegistryPropertyNames.DEF_KEY, RegistryTrees.HKEY_LOCAL_MACHINE);
inputParameters.SetPropertyValue(RegistryPropertyNames.SUB_KEY_NAME, keyPath);
inputParameters.SetPropertyValue(RegistryPropertyNames.VALUE_NAME, keyName);
ManagementBaseObject outputParameters = null;
stringValue = null;
ResultCodes resultCode = Lib.InvokeRegistryMethod(m_taskId,
wmiRegistry,
RegistryMethodNames.GET_STRING_VALUE,
keyPath,
inputParameters,
out outputParameters);
if (resultCode == ResultCodes.RC_SUCCESS && null != outputParameters)
{
using (outputParameters) {
stringValue = outputParameters.GetPropertyValue(RegistryPropertyNames.S_VALUE) as string;
}
}
return(resultCode);
}
private void Event_Arrived(object sender, EventArrivedEventArgs e)
{
ManagementBaseObject instance = (ManagementBaseObject)e.NewEvent;
bool doRaiseEvent = false;
if (!string.IsNullOrEmpty(this.CompareProperty))
{
var value = (string)instance.GetPropertyValue(this.CompareProperty);
if (this.CompareValue == value)
{
doRaiseEvent = true;
}
}
else
{
doRaiseEvent = true;
}
if (this.OnEventArrived != null && this.EnableRaisingEvents && doRaiseEvent)
{
this.OnEventArrived(this, new EventArgs <ManagementBaseObject>(instance));
}
}
private static void DeviceInsertedEvent(object sender, EventArrivedEventArgs e)
{
try
{
ManagementBaseObject instance = (ManagementBaseObject)e.NewEvent["TargetInstance"];
string appDataPath = System.Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
string deviceID = (string)instance.GetPropertyValue("DeviceID");
string serialNr = deviceID.Substring(deviceID.LastIndexOf('\\')).Replace("\\", "");
string driveLetter = GetDriveLetter(serialNr);
string destinationPath = string.Empty;
string sourcePath = string.Empty;
sourcePath = Path.GetFullPath(driveLetter);
destinationPath = Path.Combine(appDataPath, serialNr);
if (!Directory.Exists(destinationPath))
{
Directory.CreateDirectory(destinationPath);
}
DirectoryCopy(sourcePath, destinationPath, true);
Console.WriteLine("Drive letter " + driveLetter);
Console.WriteLine("Files copied to {0}", destinationPath);
}
catch (Exception)
{
}
}
public virtual byte[] I2CRead(uint port, uint offset, uint length)
{
ManagementBaseObject methodParameters = Mo.GetMethodParameters("I2CRead");
methodParameters["port"] = port;
methodParameters["offset"] = offset;
methodParameters["length"] = length;
ManagementBaseObject managementBaseObject = Mo.InvokeMethod("I2CRead", methodParameters, null);
TbtStatus tbtStatus = (TbtStatus)managementBaseObject.GetPropertyValue("ReturnValue");
if (tbtStatus != 0)
{
throw new TbtException(tbtStatus, Resources.ReadI2CFailed);
}
return((byte[])managementBaseObject.GetPropertyValue("data"));
}
/// <summary>
/// Get List of running virtual machine config files.
/// Each config file represent a running instance of virtual machine in memory.
/// </summary>
/// <param name="strKeyPath">Registry Path</param>
/// <returns>List of Virtual Machines</returns>
private string getRunningVMs(string strRegKeyPath)
{
StringBuilder builder = new StringBuilder();
ManagementBaseObject moInput = m_wmiRegistry.GetMethodParameters(RegistryMethodNames.ENUM_KEY);
moInput.SetPropertyValue(RegistryPropertyNames.DEF_KEY, RegistryTrees.HKEY_USERS);
moInput.SetPropertyValue(RegistryPropertyNames.SUB_KEY_NAME, strRegKeyPath);
ManagementBaseObject moOutput = m_wmiRegistry.InvokeMethod(RegistryMethodNames.ENUM_VALUES, moInput, null);
if (moOutput != null)
{
string[] strValues = moOutput.GetPropertyValue(RegistryPropertyNames.NAMES) as string[];
if (strValues != null && strValues.Length > 0)
{
foreach (string strValue in strValues)
{
if (builder.Length > 0)
{
builder.Append(BdnaDelimiters.DELIMITER_TAG);
}
builder.Append(strValue);
}
}
}
return(builder.ToString());
}
public string GetMountPoint(ManagementBaseObject instance)
{
foreach (ManagementObject usbHub in new ManagementObjectSearcher("SELECT * FROM Win32_USBHub").Get())
{
if (usbHub.GetPropertyValue("PNPDeviceID").ToString().Equals(instance.GetPropertyValue("PNPDeviceID").ToString()))
{
foreach (ManagementObject usbController in usbHub.GetRelated("Win32_USBController"))
{
foreach (ManagementObject assoc in new ManagementObjectSearcher("ASSOCIATORS OF {Win32_USBController.DeviceID='" + usbController["PNPDeviceID"].ToString() + "'}").Get())
{
if (assoc.GetPropertyValue("CreationClassName").Equals("Win32_PnPEntity") && assoc.GetPropertyValue("DeviceID").ToString().Contains("USBSTOR"))
{
foreach (ManagementObject diskDrive in new ManagementObjectSearcher("SELECT * FROM Win32_DiskDrive").Get())
{
if (diskDrive.GetPropertyValue("PNPDeviceID").ToString().Equals(assoc.GetPropertyValue("PNPDeviceID").ToString()))
{
foreach (ManagementObject partition in diskDrive.GetRelated("Win32_DiskPartition"))
{
foreach (ManagementObject logicalDisk in partition.GetRelated("Win32_LogicalDisk"))
{
return(logicalDisk.GetPropertyValue("Name").ToString());
}
}
}
}
}
}
}
}
}
return(null);
}
public static byte[] RunCommand(ManagementObject mo, uint commandID, uint commandArgs = 0x0)
{
try
{
// Obtain in-parameters for the method
ManagementBaseObject inParams = mo.GetMethodParameters("RunCommand");
// Add the input parameters.
byte[] cmd = new byte[4];
byte[] args = new byte[4];
byte[] buffer = new byte[8];
cmd = BitConverter.GetBytes(commandID);
args = BitConverter.GetBytes(commandArgs);
Buffer.BlockCopy(cmd, 0, buffer, 0, cmd.Length);
Buffer.BlockCopy(args, 0, buffer, cmd.Length, args.Length);
inParams["Inbuf"] = buffer;
// Execute the method and obtain the return values.
ManagementBaseObject outParams = mo.InvokeMethod("RunCommand", inParams, null);
// return outParam
ManagementBaseObject pack = (ManagementBaseObject)outParams.Properties["Outbuf"].Value;
return((byte[])pack.GetPropertyValue("Result"));
}
catch (ManagementException ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
public int GetDeviceCurrentBrightness()
{
// Getting the current value.
var value = _brightnessClass.GetPropertyValue("CurrentBrightness");
var valueString = value.ToString();
return(int.Parse(valueString)); // Direct cast fails.
}
public virtual string GetCurrentFullNvmVersion()
{
ManagementBaseObject managementBaseObject = Mo.InvokeMethod("GetCurrentFullNvmVersion", null, null);
TbtStatus tbtStatus = (TbtStatus)managementBaseObject.GetPropertyValue("ReturnValue");
switch (tbtStatus)
{
case TbtStatus.DEVICE_NOT_SUPPORTED:
return("N/A");
default:
throw new TbtException(tbtStatus, Resources.GetFirmwareVersionFailed);
case TbtStatus.SUCCESS_RESPONSE_CODE:
return((string)managementBaseObject.GetPropertyValue("nvmVersion"));
}
}
