I am currently trying to scan all USB Ports with their USB Hub (check if it is Root or not) and to which controller they are connectet.
To make it more visible:
USB Port1 (nothing plugged in) -> USB Hub1 | |-> Controller 1
USB Port2 (Keyboard plugged in) -> |-> USB Root Hub |-> Controller 2
USB Port3 (nothing plugged in) -> USB Hub2 | |
USB Port4 (nothing plugged in) -> |-> USB Root Hub |-> Controller3 (Mainboard)
I want to show the User all ports and connected Hubs as a tree. And if the USB Port with its controller are in use or not.
I hope you guys can understand what I am trying to describe. If you could give me some Keywords or even Code snippets i would greatly appreciate it.
PS.: Sorry for my bad english.
Here is the Code so far (I am using the .NetFramework 4.5.x):
USBPortScanner Class:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Management;
using System.IO.Ports;
namespace USBPortScanner
{
class USBPortScanner
{
static void Main(string[] args)
{
var usbDevices = GetUSBDevices();
foreach (var usbDevice in usbDevices)
{
//Prints all defined porperties, they need to be defined in the USBDeviceInfo.cs!
Console.WriteLine("Name: {0}\r\nCaption: {1}\r\nError Code: {2}\r\nDevice ID: {3}\r\nSystem Name: {4}\r\nStatus: {5}",
usbDevice.Name, usbDevice.Caption, usbDevice.ConfigManagerErrorCode, usbDevice.DeviceID, usbDevice.SystemName, usbDevice.Status);
Console.WriteLine();
}
Console.Read();
}
//Sets the Properties for the device variable
static List<USBDeviceInfo> GetUSBDevices()
{
List<USBDeviceInfo> devices = new List<USBDeviceInfo>();
//Scanning all USBHubs with WMI
using (var searcher = new ManagementObjectSearcher(@"Select * From Win32_USBHub"))
{
using (ManagementObjectCollection collection = searcher.Get())
{
foreach (ManagementObject device in collection)
{
//To show all available data
//Console.WriteLine(device.Path);
//foreach (PropertyData prop in device.Properties)
//{
// Console.WriteLine(prop.Name + ": " + prop.Value);
//}
//Console.WriteLine();
//Adds properties to device
devices.Add(new USBDeviceInfo(device));
}
}
}
return devices;
}
}
}
USBDeviceInfo Class:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Management;
namespace USBPortScanner
{
class USBDeviceInfo
{
public USBDeviceInfo(ManagementObject device)
{
this.Name = device.GetPropertyValue("Name").ToString();
this.Caption = device.GetPropertyValue("Caption").ToString();
if (device.GetPropertyValue("ConfigManagerErrorCode") != null)
{
this.ConfigManagerErrorCode = (ErrorCode)device.GetPropertyValue("ConfigManagerErrorCode");
}
else
{
this.ConfigManagerErrorCode = ErrorCode.Device_is_not_present_not_working_properly_or_does_not_have_all_of_its_drivers_installed;
}
this.DeviceID = device.GetPropertyValue("DeviceID").ToString();
this.SystemName = device.GetPropertyValue("SystemName").ToString();
this.Status = device.GetPropertyValue("Status").ToString();
}
//Sets the variables above usable for our purpose in the Program.cs
public string Name { get; private set; }
public string Caption { get; private set; }
public ErrorCode ConfigManagerErrorCode { get; private set; }
public string DeviceID { get; private set; }
public string SystemName { get; private set; }
public string Status { get; private set; }
}
enum ErrorCode : uint
{
Device_is_working_properly = 0,
Device_is_not_configured_correctly = 1,
Windows_cannot_load_the_driver_for_this_device = 2,
Driver_for_this_device_might_be_corrupted_or_the_system_may_be_low_on_memory_or_other_resources = 3,
Device_is_not_working_properly_One_of_its_drivers_or_the_registry_might_be_corrupted = 4,
Driver_for_the_device_requires_a_resource_that_Windows_cannot_manage = 5,
Boot_configuration_for_the_device_conflicts_with_other_devices = 6,
Cannot_filter = 7,
Driver_loader_for_the_device_is_missing = 8,
Device_is_not_working_properly_The_controlling_firmware_is_incorrectly_reporting_the_resources_for_the_device = 9,
Device_cannot_start = 10,
Device_failed = 11,
Device_cannot_find_enough_free_resources_to_use = 12,
Windows_cannot_verify_the_device_resources = 13,
Device_cannot_work_properly_until_the_computer_is_restarted = 14,
Device_is_not_working_properly_due_to_a_possible_reenumeration_problem = 15,
Windows_cannot_identify_all_of_the_resources_that_the_device_uses = 16,
Device_is_requesting_an_unknown_resource_type = 17,
Device_drivers_must_be_reinstalled = 18,
Failure_using_the_VxD_loader = 19,
Registry_might_be_corrupted = 20,
System_failure_If_changing_the_device_driver_is_ineffective_see_the_hardware_documentation_Windows_is_removing_the_device = 21,
Device_is_disabled = 22,
System_failure_If_changing_the_device_driver_is_ineffective_see_the_hardware_documentation = 23,
Device_is_not_present_not_working_properly_or_does_not_have_all_of_its_drivers_installed = 24,
Windows_is_still_setting_up_the_device = 25 | 26,
Device_does_not_have_valid_log_configuration = 27,
Device_drivers_are_not_installed = 28,
Device_is_disabled_The_device_firmware_did_not_provide_the_required_resources = 29,
Device_is_using_an_IRQ_resource_that_another_device_is_using = 30,
Device_is_not_working_properly_Windows_cannot_load_the_required_device_drivers = 31,
}
}
I've found the solution myself. The Code below is a example i used from another site. I hope it will help the community too.
source: http://www.news2news.com/vfp/?example=545&ver=vcs&PHPSESSID=70ba6845606a96b355ab7f772fb14386
Code:
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Linq;
namespace DeviceEnumerator
{
public class Program
{
public static void Main()
{
var deviceTree = new DeviceTree();
foreach (var deviceClass in Win32.DeviceClasses)
{
Console.WriteLine("\n{0}:", deviceClass.Value);
foreach (var device in deviceTree.DeviceNodes
.Where(d => d.ClassGuid == deviceClass.Key))
{
Console.WriteLine(
"\t{1}: {0}",
device.Description,
device.EnumeratorName);
}
}
Console.Write("\n\nAny key...");
Console.ReadKey();
}
}
public class DeviceTree : IDisposable
{
private IntPtr _machineHandle = IntPtr.Zero;
private IntPtr _rootDeviceHandle = IntPtr.Zero;
private DeviceNode _rootNode;
// flat collection of all devices found
private List< DeviceNode > _deviceNodes;
public DeviceNode RootNode
{
get
{
return this._rootNode;
}
}
public List< DeviceNode > DeviceNodes
{
get
{
return this._deviceNodes;
}
}
public DeviceTree()
{
EnumerateDevices();
}
~DeviceTree()
{
this.Dispose(false);
}
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
this._deviceNodes.Clear();
}
this.DisconnectFromMachine();
}
private void EnumerateDevices()
{
this.DisconnectFromMachine();
// local machine assumed
if (Win32.CM_Connect_Machine(
null, ref this._machineHandle) != 0)
{
return;
}
try
{
Win32.CM_Locate_DevNode_Ex(
ref this._rootDeviceHandle,
0,
0,
this._machineHandle);
// recursive enumeration
this._rootNode = new DeviceNode(
this._rootDeviceHandle,
null,
this._machineHandle);
}
finally
{
this.DisconnectFromMachine();
if (this._rootNode != null)
{
this._deviceNodes = this._rootNode
.Flatten(node => node.Children).ToList();
}
}
}
private void DisconnectFromMachine()
{
if (this._machineHandle != IntPtr.Zero)
{
Win32.CM_Disconnect_Machine(this._machineHandle);
this._machineHandle = IntPtr.Zero;
}
}
}
public class DeviceNode : IDisposable
{
private readonly DeviceNode _parentDevice;
private readonly List< DeviceNode > _children;
private readonly IntPtr _deviceHandle;
private readonly IntPtr _machineHandle;
private readonly Dictionary< int, string >
_deviceProperties;
public DeviceNode ParentDevice
{
get
{
return _parentDevice;
}
}
public Dictionary< int, string > DeviceProperties
{
get
{
return _deviceProperties;
}
}
public List< DeviceNode > Children
{
get
{
return this._children;
}
}
public Guid ClassGuid
{
get
{
string buffer =
this.GetProperty(Win32.DevRegProperty.ClassGuid);
var guid = new Guid();
if (buffer.Length >= 32)
{
try
{
guid = new Guid(buffer);
}
catch
{
guid = new Guid();
}
}
return guid;
}
}
public string Description
{
get
{
return
GetProperty(Win32.DevRegProperty.DeviceDescription);
}
}
public string FriendlyName
{
get
{
return
GetProperty(Win32.DevRegProperty.FriendlyName);
}
}
public string EnumeratorName
{
get
{
return
GetProperty(Win32.DevRegProperty.EnumeratorName);
}
}
public string LocationInfo
{
get
{
return
GetProperty(Win32.DevRegProperty.LocationInfo);
}
}
public DeviceNode(IntPtr deviceHandle, DeviceNode parentDevice)
: this(
deviceHandle,
parentDevice,
parentDevice._machineHandle)
{
}
public DeviceNode(
IntPtr deviceHandle,
DeviceNode parentDevice,
IntPtr machineHandle)
{
_deviceProperties = new Dictionary< int, string >();
_children = new List< DeviceNode >();
_deviceHandle = deviceHandle;
_machineHandle = machineHandle;
_parentDevice = parentDevice;
EnumerateDeviceProperties();
EnumerateChildren();
}
private string GetProperty(
Win32.DevRegProperty devRegProperty)
{
return GetProperty((int)devRegProperty);
}
private string GetProperty(int index)
{
string buffer;
var result = this._deviceProperties
.TryGetValue(index, out buffer);
return result ? buffer : string.Empty;
}
private void EnumerateDeviceProperties()
{
for (var index = 0; index < 64; index++)
{
uint bufsize = 2048;
IntPtr buffer =
Marshal.AllocHGlobal((int)bufsize);
var result =
Win32.CM_Get_DevNode_Registry_Property_Ex(
_deviceHandle,
index,
IntPtr.Zero,
buffer,
ref bufsize,
0,
_machineHandle);
var propertyString = result == 0
? Marshal.PtrToStringAnsi(buffer)
: string.Empty;
_deviceProperties.Add(index, propertyString);
Marshal.FreeHGlobal(buffer);
}
}
private void EnumerateChildren()
{
IntPtr ptrFirstChild = IntPtr.Zero;
if (Win32.CM_Get_Child_Ex(
ref ptrFirstChild,
_deviceHandle,
0,
_machineHandle) != 0)
{
return;
}
var ptrChild = ptrFirstChild;
var ptrSibling = IntPtr.Zero;
do
{
var childDevice = new DeviceNode(ptrChild, this);
_children.Add(childDevice);
if (Win32.CM_Get_Sibling_Ex(
ref ptrSibling,
ptrChild,
0,
_machineHandle) != 0) break;
ptrChild = ptrSibling;
}
while (true);
}
public void Dispose()
{
this.Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_deviceProperties.Clear();
}
}
}
internal static class LinqExtensionMethods
{
public static IEnumerable< T > Return< T >(T element)
{
yield return element;
}
public static IEnumerable< T > StartWith< T >(
this IEnumerable< T > list, T element)
{
return Return(element).Concat(list);
}
public static IEnumerable< TEntity > Flatten< TEntity >(
this TEntity element,
Func< TEntity, IEnumerable< TEntity > > childSelector)
{
if (childSelector(element) != null)
return childSelector(element)
.SelectMany(child => child.Flatten(childSelector))
.StartWith(element);
var items = new List< TEntity > { element };
return items;
}
}
public static class Win32
{
// this is a partial list
public static readonly
Dictionary< Guid, string > DeviceClasses =
new Dictionary< Guid, string >
{
{ new Guid("{4d36e967-e325-11ce-bfc1-08002be10318}"),
"Disk Drives" },
{ new Guid("{4d36e968-e325-11ce-bfc1-08002be10318}"),
"Display Adapters" },
{ new Guid("{4d36e96b-e325-11ce-bfc1-08002be10318}"),
"Keyboards" },
{ new Guid("{4d36e96f-e325-11ce-bfc1-08002be10318}"),
"Mice" },
};
public enum DevRegProperty : uint
{
DeviceDescription = 1,
HardwareId = 2,
CompatibleIds = 3,
Unused0 = 4,
Service = 5,
Unused1 = 6,
Unused2 = 7,
Class = 8,
ClassGuid = 9,
Driver = 0x0a,
ConfigFlags = 0x0b,
Mfg = 0x0c,
FriendlyName = 0x0d,
LocationInfo = 0x0e,
PhysicalDeviceObjectName = 0x0f,
Capabilities = 0x10,
UiNumber = 0x11,
UpperFilters = 0x12,
LowerFilters = 0x13,
BusTypeGuid = 0x014,
LegacyBusType = 0x15,
BusNumber = 0x16,
EnumeratorName = 0x17,
}
[DllImport("kernel32.dll")]
public static extern uint GetLogicalDrives();
[DllImport("kernel32.dll")]
public static extern int GetDriveType(
[MarshalAs(UnmanagedType.LPStr)] string rootPathName);
[DllImport("cfgmgr32.dll")]
public static extern int CM_Connect_Machine(
[MarshalAs(UnmanagedType.LPStr)] string uncServerName,
ref IntPtr machineHandle);
[DllImport("cfgmgr32.dll")]
public static extern int CM_Disconnect_Machine(
IntPtr machineHandle);
[DllImport("cfgmgr32.dll")]
public static extern int CM_Locate_DevNode_Ex(
ref IntPtr deviceHandle,
int deviceId,
uint flags,
IntPtr machineHandle);
[DllImport("cfgmgr32.dll")]
public static extern int CM_Get_Child_Ex(
ref IntPtr childDeviceHandle,
IntPtr parentDeviceHandle,
uint flags,
IntPtr machineHandle);
[DllImport("cfgmgr32.dll")]
public static extern int CM_Get_Sibling_Ex(
ref IntPtr siblingDeviceHandle,
IntPtr deviceHandle,
uint flags,
IntPtr machineHandle);
[DllImport("cfgmgr32.dll")]
public static extern int
CM_Get_DevNode_Registry_Property_Ex(
IntPtr deviceHandle,
int property,
IntPtr regDataType,
IntPtr outBuffer,
ref uint size,
int flags,
IntPtr machineHandle);
}
}