mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
1014 lines
45 KiB
C#
1014 lines
45 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : Usb.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Windows direct device access.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Contains code to access USB device information under Windows.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General internal License as
|
|
// published by the Free Software Foundation; either version 2.1 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful, but
|
|
// WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General internal License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2018 Natalia Portillo
|
|
// Copyright © 2007 Fort Hood TX, herethen, Public Domain
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
namespace DiscImageChef.Devices.Windows
|
|
{
|
|
// TODO: Even after cleaning, refactoring and xml-documenting, this code needs some love
|
|
/// <summary>
|
|
/// Implements functions for getting and accesing information from the USB bus
|
|
/// </summary>
|
|
static partial class Usb
|
|
{
|
|
/// <summary>
|
|
/// Return a list of USB Host Controllers
|
|
/// </summary>
|
|
/// <returns>List of USB Host Controllers</returns>
|
|
static IEnumerable<UsbController> GetHostControllers()
|
|
{
|
|
List<UsbController> hostList = new List<UsbController>();
|
|
Guid hostGuid = new Guid(GUID_DEVINTERFACE_HUBCONTROLLER);
|
|
|
|
// We start at the "root" of the device tree and look for all
|
|
// devices that match the interface GUID of a Hub Controller
|
|
IntPtr h = SetupDiGetClassDevs(ref hostGuid, 0, IntPtr.Zero, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return new ReadOnlyCollection<UsbController>(hostList);
|
|
|
|
IntPtr ptrBuf = Marshal.AllocHGlobal(BUFFER_SIZE);
|
|
bool success;
|
|
int i = 0;
|
|
do
|
|
{
|
|
UsbController host = new UsbController {ControllerIndex = i};
|
|
|
|
// create a Device Interface Data structure
|
|
SpDeviceInterfaceData dia = new SpDeviceInterfaceData();
|
|
dia.cbSize = Marshal.SizeOf(dia);
|
|
|
|
// start the enumeration
|
|
success = SetupDiEnumDeviceInterfaces(h, IntPtr.Zero, ref hostGuid, i, ref dia);
|
|
if(success)
|
|
{
|
|
// build a DevInfo Data structure
|
|
SpDevinfoData da = new SpDevinfoData();
|
|
da.cbSize = Marshal.SizeOf(da);
|
|
|
|
// build a Device Interface Detail Data structure
|
|
SpDeviceInterfaceDetailData didd =
|
|
new SpDeviceInterfaceDetailData {cbSize = 4 + Marshal.SystemDefaultCharSize};
|
|
// trust me :)
|
|
|
|
// now we can get some more detailed information
|
|
int nRequiredSize = 0;
|
|
const int N_BYTES = BUFFER_SIZE;
|
|
if(SetupDiGetDeviceInterfaceDetail(h, ref dia, ref didd, N_BYTES, ref nRequiredSize, ref da))
|
|
{
|
|
host.ControllerDevicePath = didd.DevicePath;
|
|
|
|
// get the Device Description and DriverKeyName
|
|
int requiredSize = 0;
|
|
int regType = REG_SZ;
|
|
|
|
if(SetupDiGetDeviceRegistryProperty(h, ref da, SPDRP_DEVICEDESC, ref regType, ptrBuf,
|
|
BUFFER_SIZE, ref requiredSize))
|
|
host.ControllerDeviceDesc = Marshal.PtrToStringAuto(ptrBuf);
|
|
if(SetupDiGetDeviceRegistryProperty(h, ref da, SPDRP_DRIVER, ref regType, ptrBuf, BUFFER_SIZE,
|
|
ref requiredSize))
|
|
host.ControllerDriverKeyName = Marshal.PtrToStringAuto(ptrBuf);
|
|
}
|
|
hostList.Add(host);
|
|
}
|
|
i++;
|
|
}
|
|
while(success);
|
|
|
|
Marshal.FreeHGlobal(ptrBuf);
|
|
SetupDiDestroyDeviceInfoList(h);
|
|
|
|
// convert it into a Collection
|
|
return new ReadOnlyCollection<UsbController>(hostList);
|
|
}
|
|
|
|
/// <summary>
|
|
/// private function for finding a USB device's Description
|
|
/// </summary>
|
|
/// <param name="driverKeyName">Device driver key name</param>
|
|
/// <returns>USB device description</returns>
|
|
static string GetDescriptionByKeyName(string driverKeyName)
|
|
{
|
|
string ans = "";
|
|
const string DEV_ENUM = REGSTR_KEY_USB;
|
|
|
|
// Use the "enumerator form" of the SetupDiGetClassDevs API
|
|
// to generate a list of all USB devices
|
|
IntPtr h = SetupDiGetClassDevs(0, DEV_ENUM, IntPtr.Zero, DIGCF_PRESENT | DIGCF_ALLCLASSES);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return ans;
|
|
|
|
IntPtr ptrBuf = Marshal.AllocHGlobal(BUFFER_SIZE);
|
|
|
|
bool success;
|
|
int i = 0;
|
|
do
|
|
{
|
|
// create a Device Interface Data structure
|
|
SpDevinfoData da = new SpDevinfoData();
|
|
da.cbSize = Marshal.SizeOf(da);
|
|
|
|
// start the enumeration
|
|
success = SetupDiEnumDeviceInfo(h, i, ref da);
|
|
if(success)
|
|
{
|
|
int requiredSize = 0;
|
|
int regType = REG_SZ;
|
|
string keyName = "";
|
|
|
|
if(SetupDiGetDeviceRegistryProperty(h, ref da, SPDRP_DRIVER, ref regType, ptrBuf, BUFFER_SIZE,
|
|
ref requiredSize)) keyName = Marshal.PtrToStringAuto(ptrBuf);
|
|
|
|
// is it a match?
|
|
if(keyName == driverKeyName)
|
|
{
|
|
if(SetupDiGetDeviceRegistryProperty(h, ref da, SPDRP_DEVICEDESC, ref regType, ptrBuf,
|
|
BUFFER_SIZE, ref requiredSize))
|
|
ans = Marshal.PtrToStringAuto(ptrBuf);
|
|
break;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
while(success);
|
|
|
|
Marshal.FreeHGlobal(ptrBuf);
|
|
SetupDiDestroyDeviceInfoList(h);
|
|
|
|
return ans;
|
|
}
|
|
|
|
/// <summary>
|
|
/// private function for finding a USB device's Instance ID
|
|
/// </summary>
|
|
/// <param name="driverKeyName">Device driver key name</param>
|
|
/// <returns>Device instance ID</returns>
|
|
static string GetInstanceIdByKeyName(string driverKeyName)
|
|
{
|
|
string ans = "";
|
|
const string DEV_ENUM = REGSTR_KEY_USB;
|
|
|
|
// Use the "enumerator form" of the SetupDiGetClassDevs API
|
|
// to generate a list of all USB devices
|
|
IntPtr h = SetupDiGetClassDevs(0, DEV_ENUM, IntPtr.Zero, DIGCF_PRESENT | DIGCF_ALLCLASSES);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return ans;
|
|
|
|
IntPtr ptrBuf = Marshal.AllocHGlobal(BUFFER_SIZE);
|
|
|
|
bool success;
|
|
int i = 0;
|
|
do
|
|
{
|
|
// create a Device Interface Data structure
|
|
SpDevinfoData da = new SpDevinfoData();
|
|
da.cbSize = Marshal.SizeOf(da);
|
|
|
|
// start the enumeration
|
|
success = SetupDiEnumDeviceInfo(h, i, ref da);
|
|
if(success)
|
|
{
|
|
int requiredSize = 0;
|
|
int regType = REG_SZ;
|
|
|
|
string keyName = "";
|
|
if(SetupDiGetDeviceRegistryProperty(h, ref da, SPDRP_DRIVER, ref regType, ptrBuf, BUFFER_SIZE,
|
|
ref requiredSize)) keyName = Marshal.PtrToStringAuto(ptrBuf);
|
|
|
|
// is it a match?
|
|
if(keyName == driverKeyName)
|
|
{
|
|
const int N_BYTES = BUFFER_SIZE;
|
|
StringBuilder sb = new StringBuilder(N_BYTES);
|
|
SetupDiGetDeviceInstanceId(h, ref da, sb, N_BYTES, out requiredSize);
|
|
ans = sb.ToString();
|
|
break;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
}
|
|
while(success);
|
|
|
|
Marshal.FreeHGlobal(ptrBuf);
|
|
SetupDiDestroyDeviceInfoList(h);
|
|
|
|
return ans;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents a USB Host Controller
|
|
/// </summary>
|
|
class UsbController
|
|
{
|
|
internal string ControllerDriverKeyName, ControllerDevicePath, ControllerDeviceDesc;
|
|
internal int ControllerIndex;
|
|
|
|
/// <summary>
|
|
/// A simple default constructor
|
|
/// </summary>
|
|
internal UsbController()
|
|
{
|
|
ControllerIndex = 0;
|
|
ControllerDevicePath = "";
|
|
ControllerDeviceDesc = "";
|
|
ControllerDriverKeyName = "";
|
|
}
|
|
|
|
/// <summary>Return the index of the instance</summary>
|
|
internal int Index => ControllerIndex;
|
|
|
|
/// <summary>
|
|
/// Return the Device Path, such as "\\?\pci#ven_10de&dev_005a&subsys_815a1043&rev_a2#3&267a616a&0&
|
|
/// 58#{3abf6f2d-71c4-462a-8a92-1e6861e6af27}"
|
|
/// </summary>
|
|
internal string DevicePath => ControllerDevicePath;
|
|
|
|
/// <summary>The DriverKeyName may be useful as a search key</summary>
|
|
internal string DriverKeyName => ControllerDriverKeyName;
|
|
|
|
/// <summary>Return the Friendly Name, such as "VIA USB Enhanced Host Controller"</summary>
|
|
internal string Name => ControllerDeviceDesc;
|
|
|
|
/// <summary>Return Root Hub for this Controller</summary>
|
|
internal UsbHub GetRootHub()
|
|
{
|
|
IntPtr h, h2;
|
|
UsbHub root = new UsbHub {HubIsRootHub = true, HubDeviceDesc = "Root Hub"};
|
|
|
|
// Open a handle to the Host Controller
|
|
h = CreateFile(ControllerDevicePath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0,
|
|
IntPtr.Zero);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return root;
|
|
|
|
UsbRootHubName hubName = new UsbRootHubName();
|
|
int nBytes = Marshal.SizeOf(hubName);
|
|
IntPtr ptrHubName = Marshal.AllocHGlobal(nBytes);
|
|
|
|
// get the Hub Name
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_ROOT_HUB_NAME, ptrHubName, nBytes, ptrHubName, nBytes, out _,
|
|
IntPtr.Zero))
|
|
{
|
|
hubName = (UsbRootHubName)Marshal.PtrToStructure(ptrHubName, typeof(UsbRootHubName));
|
|
root.HubDevicePath = @"\\.\" + hubName.RootHubName;
|
|
}
|
|
|
|
// TODO: Get DriverKeyName for Root Hub
|
|
|
|
// Now let's open the Hub (based upon the HubName we got above)
|
|
h2 = CreateFile(root.HubDevicePath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0,
|
|
IntPtr.Zero);
|
|
if(h2.ToInt32() != INVALID_HANDLE_VALUE)
|
|
{
|
|
UsbNodeInformation nodeInfo = new UsbNodeInformation {NodeType = (int)UsbHubNode.UsbHub};
|
|
nBytes = Marshal.SizeOf(nodeInfo);
|
|
IntPtr ptrNodeInfo = Marshal.AllocHGlobal(nBytes);
|
|
Marshal.StructureToPtr(nodeInfo, ptrNodeInfo, true);
|
|
|
|
// get the Hub Information
|
|
if(DeviceIoControl(h2, IOCTL_USB_GET_NODE_INFORMATION, ptrNodeInfo, nBytes, ptrNodeInfo, nBytes,
|
|
out _, IntPtr.Zero))
|
|
{
|
|
nodeInfo = (UsbNodeInformation)Marshal.PtrToStructure(ptrNodeInfo, typeof(UsbNodeInformation));
|
|
root.HubIsBusPowered = Convert.ToBoolean(nodeInfo.HubInformation.HubIsBusPowered);
|
|
root.HubPortCount = nodeInfo.HubInformation.HubDescriptor.bNumberOfPorts;
|
|
}
|
|
Marshal.FreeHGlobal(ptrNodeInfo);
|
|
CloseHandle(h2);
|
|
}
|
|
|
|
Marshal.FreeHGlobal(ptrHubName);
|
|
CloseHandle(h);
|
|
return root;
|
|
}
|
|
}
|
|
|
|
/// <summary>The Hub class</summary>
|
|
internal class UsbHub
|
|
{
|
|
internal string HubDriverKey, HubDevicePath, HubDeviceDesc;
|
|
internal bool HubIsBusPowered, HubIsRootHub;
|
|
internal string HubManufacturer, HubProduct, HubSerialNumber, HubInstanceId;
|
|
internal int HubPortCount;
|
|
|
|
/// <summary>a simple default constructor</summary>
|
|
internal UsbHub()
|
|
{
|
|
HubPortCount = 0;
|
|
HubDevicePath = "";
|
|
HubDeviceDesc = "";
|
|
HubDriverKey = "";
|
|
HubIsBusPowered = false;
|
|
HubIsRootHub = false;
|
|
HubManufacturer = "";
|
|
HubProduct = "";
|
|
HubSerialNumber = "";
|
|
HubInstanceId = "";
|
|
}
|
|
|
|
/// <summary>return Port Count</summary>
|
|
internal int PortCount => HubPortCount;
|
|
|
|
/// <summary>
|
|
/// return the Device Path, such as "\\?\pci#ven_10de&dev_005a&subsys_815a1043&rev_a2#3&267a616a&0&
|
|
/// 58#{3abf6f2d-71c4-462a-8a92-1e6861e6af27}"
|
|
/// </summary>
|
|
internal string DevicePath => HubDevicePath;
|
|
|
|
/// <summary>The DriverKey may be useful as a search key</summary>
|
|
internal string DriverKey => HubDriverKey;
|
|
|
|
/// <summary>return the Friendly Name, such as "VIA USB Enhanced Host Controller"</summary>
|
|
internal string Name => HubDeviceDesc;
|
|
|
|
/// <summary>the device path of this device</summary>
|
|
internal string InstanceId => HubInstanceId;
|
|
|
|
/// <summary>is is this a self-powered hub?</summary>
|
|
internal bool IsBusPowered => HubIsBusPowered;
|
|
|
|
/// <summary>is this a root hub?</summary>
|
|
internal bool IsRootHub => HubIsRootHub;
|
|
|
|
internal string Manufacturer => HubManufacturer;
|
|
|
|
internal string Product => HubProduct;
|
|
|
|
internal string SerialNumber => HubSerialNumber;
|
|
|
|
/// <summary>
|
|
/// return a list of the down stream ports
|
|
/// </summary>
|
|
/// <returns>List of downstream ports</returns>
|
|
internal IEnumerable<UsbPort> GetPorts()
|
|
{
|
|
List<UsbPort> portList = new List<UsbPort>();
|
|
|
|
// Open a handle to the Hub device
|
|
IntPtr h = CreateFile(HubDevicePath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0,
|
|
IntPtr.Zero);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return new ReadOnlyCollection<UsbPort>(portList);
|
|
|
|
int nBytes = Marshal.SizeOf(typeof(UsbNodeConnectionInformationEx));
|
|
IntPtr ptrNodeConnection = Marshal.AllocHGlobal(nBytes);
|
|
|
|
// loop thru all of the ports on the hub
|
|
// BTW: Ports are numbered starting at 1
|
|
for(int i = 1; i <= HubPortCount; i++)
|
|
{
|
|
UsbNodeConnectionInformationEx nodeConnection =
|
|
new UsbNodeConnectionInformationEx {ConnectionIndex = i};
|
|
Marshal.StructureToPtr(nodeConnection, ptrNodeConnection, true);
|
|
|
|
if(!DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, ptrNodeConnection, nBytes,
|
|
ptrNodeConnection, nBytes, out _, IntPtr.Zero)) continue;
|
|
|
|
nodeConnection =
|
|
(UsbNodeConnectionInformationEx)Marshal.PtrToStructure(ptrNodeConnection,
|
|
typeof(UsbNodeConnectionInformationEx));
|
|
|
|
// load up the USBPort class
|
|
UsbPort port = new UsbPort
|
|
{
|
|
PortPortNumber = i,
|
|
PortHubDevicePath = HubDevicePath,
|
|
PortStatus = ((UsbConnectionStatus)nodeConnection.ConnectionStatus).ToString(),
|
|
PortSpeed = ((UsbDeviceSpeed)nodeConnection.Speed).ToString(),
|
|
PortIsDeviceConnected =
|
|
nodeConnection.ConnectionStatus == (int)UsbConnectionStatus.DeviceConnected,
|
|
PortIsHub = Convert.ToBoolean(nodeConnection.DeviceIsHub),
|
|
PortDeviceDescriptor = nodeConnection.DeviceDescriptor
|
|
};
|
|
|
|
// add it to the list
|
|
portList.Add(port);
|
|
}
|
|
|
|
Marshal.FreeHGlobal(ptrNodeConnection);
|
|
CloseHandle(h);
|
|
// convert it into a Collection
|
|
return new ReadOnlyCollection<UsbPort>(portList);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents an USB port
|
|
/// </summary>
|
|
internal class UsbPort
|
|
{
|
|
internal UsbDeviceDescriptor PortDeviceDescriptor;
|
|
internal bool PortIsHub, PortIsDeviceConnected;
|
|
internal int PortPortNumber;
|
|
internal string PortStatus, PortHubDevicePath, PortSpeed;
|
|
|
|
/// <summary>a simple default constructor</summary>
|
|
internal UsbPort()
|
|
{
|
|
PortPortNumber = 0;
|
|
PortStatus = "";
|
|
PortHubDevicePath = "";
|
|
PortSpeed = "";
|
|
PortIsHub = false;
|
|
PortIsDeviceConnected = false;
|
|
}
|
|
|
|
/// <summary>return Port Index of the Hub</summary>
|
|
internal int PortNumber => PortPortNumber;
|
|
|
|
/// <summary>return the Device Path of the Hub</summary>
|
|
internal string HubDevicePath => PortHubDevicePath;
|
|
|
|
/// <summary>the status (see USB_CONNECTION_STATUS above)</summary>
|
|
internal string Status => PortStatus;
|
|
|
|
/// <summary>the speed of the connection (see USB_DEVICE_SPEED above)</summary>
|
|
internal string Speed => PortSpeed;
|
|
|
|
/// <summary>is this a downstream external hub?</summary>
|
|
internal bool IsHub => PortIsHub;
|
|
|
|
/// <summary>is anybody home?</summary>
|
|
internal bool IsDeviceConnected => PortIsDeviceConnected;
|
|
|
|
/// <summary>
|
|
/// return a down stream external hub
|
|
/// </summary>
|
|
/// <returns>Downstream external hub</returns>
|
|
internal UsbDevice GetDevice()
|
|
{
|
|
if(!PortIsDeviceConnected) return null;
|
|
|
|
// Copy over some values from the Port class
|
|
// Ya know, I've given some thought about making Device a derived class...
|
|
UsbDevice device = new UsbDevice
|
|
{
|
|
DevicePortNumber = PortPortNumber,
|
|
DeviceHubDevicePath = PortHubDevicePath,
|
|
DeviceDescriptor = PortDeviceDescriptor
|
|
};
|
|
|
|
// Open a handle to the Hub device
|
|
IntPtr h = CreateFile(PortHubDevicePath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0,
|
|
IntPtr.Zero);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return device;
|
|
|
|
int nBytesReturned;
|
|
int nBytes = BUFFER_SIZE;
|
|
// We use this to zero fill a buffer
|
|
string nullString = new string((char)0, BUFFER_SIZE / Marshal.SystemDefaultCharSize);
|
|
|
|
// The iManufacturer, iProduct and iSerialNumber entries in the
|
|
// Device Descriptor are really just indexes. So, we have to
|
|
// request a String Descriptor to get the values for those strings.
|
|
|
|
if(PortDeviceDescriptor.iManufacturer > 0)
|
|
{
|
|
// build a request for string descriptor
|
|
UsbDescriptorRequest request = new UsbDescriptorRequest
|
|
{
|
|
ConnectionIndex = PortPortNumber,
|
|
SetupPacket =
|
|
{
|
|
// Language Code
|
|
wIndex = 0x409,
|
|
wValue = (short)((USB_STRING_DESCRIPTOR_TYPE << 8) + PortDeviceDescriptor.iManufacturer)
|
|
}
|
|
};
|
|
request.SetupPacket.wLength = (short)(nBytes - Marshal.SizeOf(request));
|
|
// Geez, I wish C# had a Marshal.MemSet() method
|
|
IntPtr ptrRequest = Marshal.StringToHGlobalAuto(nullString);
|
|
Marshal.StructureToPtr(request, ptrRequest, true);
|
|
|
|
// Use an IOCTL call to request the String Descriptor
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, ptrRequest, nBytes, ptrRequest,
|
|
nBytes, out nBytesReturned, IntPtr.Zero))
|
|
{
|
|
// The location of the string descriptor is immediately after
|
|
// the Request structure. Because this location is not "covered"
|
|
// by the structure allocation, we're forced to zero out this
|
|
// chunk of memory by using the StringToHGlobalAuto() hack above
|
|
IntPtr ptrStringDesc = new IntPtr(ptrRequest.ToInt32() + Marshal.SizeOf(request));
|
|
UsbStringDescriptor stringDesc =
|
|
(UsbStringDescriptor)Marshal.PtrToStructure(ptrStringDesc, typeof(UsbStringDescriptor));
|
|
device.DeviceManufacturer = stringDesc.bString;
|
|
}
|
|
Marshal.FreeHGlobal(ptrRequest);
|
|
}
|
|
if(PortDeviceDescriptor.iProduct > 0)
|
|
{
|
|
// build a request for string descriptor
|
|
UsbDescriptorRequest request = new UsbDescriptorRequest
|
|
{
|
|
ConnectionIndex = PortPortNumber,
|
|
SetupPacket =
|
|
{
|
|
// Language Code
|
|
wIndex = 0x409,
|
|
wValue = (short)((USB_STRING_DESCRIPTOR_TYPE << 8) + PortDeviceDescriptor.iProduct)
|
|
}
|
|
};
|
|
request.SetupPacket.wLength = (short)(nBytes - Marshal.SizeOf(request));
|
|
// Geez, I wish C# had a Marshal.MemSet() method
|
|
IntPtr ptrRequest = Marshal.StringToHGlobalAuto(nullString);
|
|
Marshal.StructureToPtr(request, ptrRequest, true);
|
|
|
|
// Use an IOCTL call to request the String Descriptor
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, ptrRequest, nBytes, ptrRequest,
|
|
nBytes, out nBytesReturned, IntPtr.Zero))
|
|
{
|
|
// the location of the string descriptor is immediately after the Request structure
|
|
IntPtr ptrStringDesc = new IntPtr(ptrRequest.ToInt32() + Marshal.SizeOf(request));
|
|
UsbStringDescriptor stringDesc =
|
|
(UsbStringDescriptor)Marshal.PtrToStructure(ptrStringDesc, typeof(UsbStringDescriptor));
|
|
device.DeviceProduct = stringDesc.bString;
|
|
}
|
|
Marshal.FreeHGlobal(ptrRequest);
|
|
}
|
|
if(PortDeviceDescriptor.iSerialNumber > 0)
|
|
{
|
|
// build a request for string descriptor
|
|
UsbDescriptorRequest request = new UsbDescriptorRequest
|
|
{
|
|
ConnectionIndex = PortPortNumber,
|
|
SetupPacket =
|
|
{
|
|
// Language Code
|
|
wIndex = 0x409,
|
|
wValue = (short)((USB_STRING_DESCRIPTOR_TYPE << 8) + PortDeviceDescriptor.iSerialNumber)
|
|
}
|
|
};
|
|
request.SetupPacket.wLength = (short)(nBytes - Marshal.SizeOf(request));
|
|
// Geez, I wish C# had a Marshal.MemSet() method
|
|
IntPtr ptrRequest = Marshal.StringToHGlobalAuto(nullString);
|
|
Marshal.StructureToPtr(request, ptrRequest, true);
|
|
|
|
// Use an IOCTL call to request the String Descriptor
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, ptrRequest, nBytes, ptrRequest,
|
|
nBytes, out nBytesReturned, IntPtr.Zero))
|
|
{
|
|
// the location of the string descriptor is immediately after the Request structure
|
|
IntPtr ptrStringDesc = new IntPtr(ptrRequest.ToInt32() + Marshal.SizeOf(request));
|
|
UsbStringDescriptor stringDesc =
|
|
(UsbStringDescriptor)Marshal.PtrToStructure(ptrStringDesc, typeof(UsbStringDescriptor));
|
|
device.DeviceSerialNumber = stringDesc.bString;
|
|
}
|
|
Marshal.FreeHGlobal(ptrRequest);
|
|
}
|
|
|
|
// build a request for configuration descriptor
|
|
UsbDescriptorRequest dcrRequest = new UsbDescriptorRequest
|
|
{
|
|
ConnectionIndex = PortPortNumber,
|
|
SetupPacket = {wIndex = 0, wValue = USB_CONFIGURATION_DESCRIPTOR_TYPE << 8}
|
|
};
|
|
dcrRequest.SetupPacket.wLength = (short)(nBytes - Marshal.SizeOf(dcrRequest));
|
|
// Geez, I wish C# had a Marshal.MemSet() method
|
|
IntPtr dcrPtrRequest = Marshal.StringToHGlobalAuto(nullString);
|
|
Marshal.StructureToPtr(dcrRequest, dcrPtrRequest, true);
|
|
|
|
// Use an IOCTL call to request the String Descriptor
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, dcrPtrRequest, nBytes,
|
|
dcrPtrRequest, nBytes, out nBytesReturned, IntPtr.Zero))
|
|
{
|
|
IntPtr ptrStringDesc = new IntPtr(dcrPtrRequest.ToInt32() + Marshal.SizeOf(dcrRequest));
|
|
device.BinaryDeviceDescriptors = new byte[nBytesReturned];
|
|
Marshal.Copy(ptrStringDesc, device.BinaryDeviceDescriptors, 0, nBytesReturned);
|
|
}
|
|
Marshal.FreeHGlobal(dcrPtrRequest);
|
|
|
|
// Get the Driver Key Name (usefull in locating a device)
|
|
UsbNodeConnectionDriverkeyName driverKey =
|
|
new UsbNodeConnectionDriverkeyName {ConnectionIndex = PortPortNumber};
|
|
nBytes = Marshal.SizeOf(driverKey);
|
|
IntPtr ptrDriverKey = Marshal.AllocHGlobal(nBytes);
|
|
Marshal.StructureToPtr(driverKey, ptrDriverKey, true);
|
|
|
|
// Use an IOCTL call to request the Driver Key Name
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, ptrDriverKey, nBytes, ptrDriverKey,
|
|
nBytes, out nBytesReturned, IntPtr.Zero))
|
|
{
|
|
driverKey = (UsbNodeConnectionDriverkeyName)Marshal.PtrToStructure(ptrDriverKey,
|
|
typeof(
|
|
UsbNodeConnectionDriverkeyName
|
|
));
|
|
device.DeviceDriverKey = driverKey.DriverKeyName;
|
|
|
|
// use the DriverKeyName to get the Device Description and Instance ID
|
|
device.DeviceName = GetDescriptionByKeyName(device.DeviceDriverKey);
|
|
device.DeviceInstanceId = GetInstanceIdByKeyName(device.DeviceDriverKey);
|
|
}
|
|
Marshal.FreeHGlobal(ptrDriverKey);
|
|
CloseHandle(h);
|
|
return device;
|
|
}
|
|
|
|
/// <summary>
|
|
/// return a down stream external hub
|
|
/// </summary>
|
|
/// <returns>Downstream external hub</returns>
|
|
internal UsbHub GetHub()
|
|
{
|
|
if(!PortIsHub) return null;
|
|
|
|
UsbHub hub = new UsbHub();
|
|
IntPtr h, h2;
|
|
hub.HubIsRootHub = false;
|
|
hub.HubDeviceDesc = "External Hub";
|
|
|
|
// Open a handle to the Host Controller
|
|
h = CreateFile(PortHubDevicePath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0,
|
|
IntPtr.Zero);
|
|
if(h.ToInt32() == INVALID_HANDLE_VALUE) return hub;
|
|
// Get the DevicePath for downstream hub
|
|
UsbNodeConnectionName nodeName = new UsbNodeConnectionName {ConnectionIndex = PortPortNumber};
|
|
int nBytes = Marshal.SizeOf(nodeName);
|
|
IntPtr ptrNodeName = Marshal.AllocHGlobal(nBytes);
|
|
Marshal.StructureToPtr(nodeName, ptrNodeName, true);
|
|
|
|
// Use an IOCTL call to request the Node Name
|
|
if(DeviceIoControl(h, IOCTL_USB_GET_NODE_CONNECTION_NAME, ptrNodeName, nBytes, ptrNodeName, nBytes,
|
|
out _, IntPtr.Zero))
|
|
{
|
|
nodeName = (UsbNodeConnectionName)Marshal.PtrToStructure(ptrNodeName,
|
|
typeof(UsbNodeConnectionName));
|
|
hub.HubDevicePath = @"\\.\" + nodeName.NodeName;
|
|
}
|
|
|
|
// Now let's open the Hub (based upon the HubName we got above)
|
|
h2 = CreateFile(hub.HubDevicePath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0,
|
|
IntPtr.Zero);
|
|
if(h2.ToInt32() != INVALID_HANDLE_VALUE)
|
|
{
|
|
UsbNodeInformation nodeInfo = new UsbNodeInformation {NodeType = (int)UsbHubNode.UsbHub};
|
|
nBytes = Marshal.SizeOf(nodeInfo);
|
|
IntPtr ptrNodeInfo = Marshal.AllocHGlobal(nBytes);
|
|
Marshal.StructureToPtr(nodeInfo, ptrNodeInfo, true);
|
|
|
|
// get the Hub Information
|
|
if(DeviceIoControl(h2, IOCTL_USB_GET_NODE_INFORMATION, ptrNodeInfo, nBytes, ptrNodeInfo, nBytes,
|
|
out _, IntPtr.Zero))
|
|
{
|
|
nodeInfo = (UsbNodeInformation)Marshal.PtrToStructure(ptrNodeInfo, typeof(UsbNodeInformation));
|
|
hub.HubIsBusPowered = Convert.ToBoolean(nodeInfo.HubInformation.HubIsBusPowered);
|
|
hub.HubPortCount = nodeInfo.HubInformation.HubDescriptor.bNumberOfPorts;
|
|
}
|
|
Marshal.FreeHGlobal(ptrNodeInfo);
|
|
CloseHandle(h2);
|
|
}
|
|
|
|
// Fill in the missing Manufacture, Product, and SerialNumber values
|
|
// values by just creating a Device instance and copying the values
|
|
UsbDevice device = GetDevice();
|
|
hub.HubInstanceId = device.DeviceInstanceId;
|
|
hub.HubManufacturer = device.Manufacturer;
|
|
hub.HubProduct = device.Product;
|
|
hub.HubSerialNumber = device.SerialNumber;
|
|
hub.HubDriverKey = device.DriverKey;
|
|
|
|
Marshal.FreeHGlobal(ptrNodeName);
|
|
CloseHandle(h);
|
|
return hub;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Represents an USB device
|
|
/// </summary>
|
|
internal class UsbDevice
|
|
{
|
|
internal byte[] BinaryDeviceDescriptors;
|
|
internal UsbDeviceDescriptor DeviceDescriptor;
|
|
internal string DeviceDriverKey, DeviceHubDevicePath, DeviceInstanceId, DeviceName;
|
|
internal string DeviceManufacturer, DeviceProduct, DeviceSerialNumber;
|
|
internal int DevicePortNumber;
|
|
|
|
/// <summary>a simple default constructor</summary>
|
|
internal UsbDevice()
|
|
{
|
|
DevicePortNumber = 0;
|
|
DeviceHubDevicePath = "";
|
|
DeviceDriverKey = "";
|
|
DeviceManufacturer = "";
|
|
DeviceProduct = "Unknown USB Device";
|
|
DeviceSerialNumber = "";
|
|
DeviceName = "";
|
|
DeviceInstanceId = "";
|
|
BinaryDeviceDescriptors = null;
|
|
}
|
|
|
|
/// <summary>return Port Index of the Hub</summary>
|
|
internal int PortNumber => DevicePortNumber;
|
|
|
|
/// <summary>return the Device Path of the Hub (the parent device)</summary>
|
|
internal string HubDevicePath => DeviceHubDevicePath;
|
|
|
|
/// <summary>useful as a search key</summary>
|
|
internal string DriverKey => DeviceDriverKey;
|
|
|
|
/// <summary>the device path of this device</summary>
|
|
internal string InstanceId => DeviceInstanceId;
|
|
|
|
/// <summary>the friendly name</summary>
|
|
internal string Name => DeviceName;
|
|
|
|
internal string Manufacturer => DeviceManufacturer;
|
|
|
|
internal string Product => DeviceProduct;
|
|
|
|
internal string SerialNumber => DeviceSerialNumber;
|
|
|
|
internal byte[] BinaryDescriptors => BinaryDeviceDescriptors;
|
|
}
|
|
|
|
#region "API Region"
|
|
// ********************** Constants ************************
|
|
|
|
const int GENERIC_WRITE = 0x40000000;
|
|
const int FILE_SHARE_READ = 0x1;
|
|
const int FILE_SHARE_WRITE = 0x2;
|
|
const int OPEN_EXISTING = 0x3;
|
|
const int INVALID_HANDLE_VALUE = -1;
|
|
|
|
const int IOCTL_GET_HCD_DRIVERKEY_NAME = 0x220424;
|
|
const int IOCTL_USB_GET_ROOT_HUB_NAME = 0x220408;
|
|
const int IOCTL_USB_GET_NODE_INFORMATION = 0x220408; // same as above... strange, eh?
|
|
const int IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX = 0x220448;
|
|
const int IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION = 0x220410;
|
|
const int IOCTL_USB_GET_NODE_CONNECTION_NAME = 0x220414;
|
|
const int IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME = 0x220420;
|
|
|
|
const int USB_DEVICE_DESCRIPTOR_TYPE = 0x1;
|
|
const int USB_CONFIGURATION_DESCRIPTOR_TYPE = 0x2;
|
|
const int USB_STRING_DESCRIPTOR_TYPE = 0x3;
|
|
|
|
const int BUFFER_SIZE = 2048;
|
|
const int MAXIMUM_USB_STRING_LENGTH = 255;
|
|
|
|
const string GUID_DEVINTERFACE_HUBCONTROLLER = "3abf6f2d-71c4-462a-8a92-1e6861e6af27";
|
|
const string REGSTR_KEY_USB = "USB";
|
|
const int DIGCF_PRESENT = 0x2;
|
|
const int DIGCF_ALLCLASSES = 0x4;
|
|
const int DIGCF_DEVICEINTERFACE = 0x10;
|
|
const int SPDRP_DRIVER = 0x9;
|
|
const int SPDRP_DEVICEDESC = 0x0;
|
|
const int REG_SZ = 1;
|
|
|
|
// ********************** Enumerations ************************
|
|
|
|
enum UsbHubNode
|
|
{
|
|
UsbHub,
|
|
UsbMiParent
|
|
}
|
|
|
|
enum UsbConnectionStatus
|
|
{
|
|
NoDeviceConnected,
|
|
DeviceConnected,
|
|
DeviceFailedEnumeration,
|
|
DeviceGeneralFailure,
|
|
DeviceCausedOvercurrent,
|
|
DeviceNotEnoughPower,
|
|
DeviceNotEnoughBandwidth,
|
|
DeviceHubNestedTooDeeply,
|
|
DeviceInLegacyHub
|
|
}
|
|
|
|
enum UsbDeviceSpeed : byte
|
|
{
|
|
UsbLowSpeed,
|
|
UsbFullSpeed,
|
|
UsbHighSpeed
|
|
}
|
|
|
|
// ********************** Stuctures ************************
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct SpDevinfoData
|
|
{
|
|
internal int cbSize;
|
|
internal Guid ClassGuid;
|
|
internal IntPtr DevInst;
|
|
internal IntPtr Reserved;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct SpDeviceInterfaceData
|
|
{
|
|
internal int cbSize;
|
|
internal Guid InterfaceClassGuid;
|
|
internal int Flags;
|
|
internal IntPtr Reserved;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
struct SpDeviceInterfaceDetailData
|
|
{
|
|
internal int cbSize;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = BUFFER_SIZE)] internal string DevicePath;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
struct UsbHcdDriverkeyName
|
|
{
|
|
internal int ActualLength;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = BUFFER_SIZE)] internal string DriverKeyName;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
struct UsbRootHubName
|
|
{
|
|
internal int ActualLength;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = BUFFER_SIZE)] internal string RootHubName;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
struct UsbHubDescriptor
|
|
{
|
|
internal byte bDescriptorLength;
|
|
internal byte bDescriptorType;
|
|
internal byte bNumberOfPorts;
|
|
internal short wHubCharacteristics;
|
|
internal byte bPowerOnToPowerGood;
|
|
internal byte bHubControlCurrent;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] internal byte[] bRemoveAndPowerMask;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct UsbHubInformation
|
|
{
|
|
internal UsbHubDescriptor HubDescriptor;
|
|
internal byte HubIsBusPowered;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct UsbNodeInformation
|
|
{
|
|
internal int NodeType;
|
|
internal UsbHubInformation HubInformation; // Yeah, I'm assuming we'll just use the first form
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
struct UsbNodeConnectionInformationEx
|
|
{
|
|
internal int ConnectionIndex;
|
|
internal UsbDeviceDescriptor DeviceDescriptor;
|
|
internal byte CurrentConfigurationValue;
|
|
internal byte Speed;
|
|
internal byte DeviceIsHub;
|
|
internal short DeviceAddress;
|
|
internal int NumberOfOpenPipes;
|
|
|
|
internal int ConnectionStatus;
|
|
//internal IntPtr PipeList;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack = 1)]
|
|
[SuppressMessage("ReSharper", "MemberCanBePrivate.Global")]
|
|
internal struct UsbDeviceDescriptor
|
|
{
|
|
internal byte bLength;
|
|
internal byte bDescriptorType;
|
|
internal short bcdUSB;
|
|
internal byte bDeviceClass;
|
|
internal byte bDeviceSubClass;
|
|
internal byte bDeviceProtocol;
|
|
internal byte bMaxPacketSize0;
|
|
internal short idVendor;
|
|
internal short idProduct;
|
|
internal short bcdDevice;
|
|
internal byte iManufacturer;
|
|
internal byte iProduct;
|
|
internal byte iSerialNumber;
|
|
internal byte bNumConfigurations;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
struct UsbStringDescriptor
|
|
{
|
|
internal byte bLength;
|
|
internal byte bDescriptorType;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXIMUM_USB_STRING_LENGTH)] internal string bString;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct UsbSetupPacket
|
|
{
|
|
internal byte bmRequest;
|
|
internal byte bRequest;
|
|
internal short wValue;
|
|
internal short wIndex;
|
|
internal short wLength;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct UsbDescriptorRequest
|
|
{
|
|
internal int ConnectionIndex;
|
|
|
|
internal UsbSetupPacket SetupPacket;
|
|
//internal byte[] Data;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
struct UsbNodeConnectionName
|
|
{
|
|
internal int ConnectionIndex;
|
|
internal int ActualLength;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = BUFFER_SIZE)] internal string NodeName;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
struct UsbNodeConnectionDriverkeyName // Yes, this is the same as the structure above...
|
|
{
|
|
internal int ConnectionIndex;
|
|
internal int ActualLength;
|
|
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = BUFFER_SIZE)] internal string DriverKeyName;
|
|
}
|
|
|
|
// ********************** API Definitions ************************
|
|
|
|
[DllImport("setupapi.dll", CharSet = CharSet.Auto)]
|
|
static extern IntPtr SetupDiGetClassDevs( // 1st form using a ClassGUID
|
|
ref Guid classGuid, int enumerator, IntPtr hwndParent, int flags);
|
|
|
|
[DllImport("setupapi.dll", CharSet = CharSet.Auto)] // 2nd form uses an Enumerator
|
|
static extern IntPtr SetupDiGetClassDevs(int classGuid, string enumerator, IntPtr hwndParent, int flags);
|
|
|
|
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool SetupDiEnumDeviceInterfaces(IntPtr deviceInfoSet, IntPtr deviceInfoData,
|
|
ref Guid interfaceClassGuid, int memberIndex,
|
|
ref SpDeviceInterfaceData deviceInterfaceData);
|
|
|
|
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool SetupDiGetDeviceInterfaceDetail(IntPtr deviceInfoSet,
|
|
ref SpDeviceInterfaceData deviceInterfaceData,
|
|
ref SpDeviceInterfaceDetailData deviceInterfaceDetailData,
|
|
int deviceInterfaceDetailDataSize, ref int requiredSize,
|
|
ref SpDevinfoData deviceInfoData);
|
|
|
|
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool SetupDiGetDeviceRegistryProperty(IntPtr deviceInfoSet, ref SpDevinfoData deviceInfoData,
|
|
int iProperty, ref int propertyRegDataType,
|
|
IntPtr propertyBuffer, int propertyBufferSize,
|
|
ref int requiredSize);
|
|
|
|
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool SetupDiEnumDeviceInfo(IntPtr deviceInfoSet, int memberIndex,
|
|
ref SpDevinfoData deviceInfoData);
|
|
|
|
[DllImport("setupapi.dll", SetLastError = true)]
|
|
static extern bool SetupDiDestroyDeviceInfoList(IntPtr deviceInfoSet);
|
|
|
|
[DllImport("setupapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool SetupDiGetDeviceInstanceId(IntPtr deviceInfoSet, ref SpDevinfoData deviceInfoData,
|
|
StringBuilder deviceInstanceId, int deviceInstanceIdSize,
|
|
out int requiredSize);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool DeviceIoControl(IntPtr hDevice, int dwIoControlCode, IntPtr lpInBuffer, int nInBufferSize,
|
|
IntPtr lpOutBuffer, int nOutBufferSize, out int lpBytesReturned,
|
|
IntPtr lpOverlapped);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern IntPtr CreateFile(string lpFileName, int dwDesiredAccess, int dwShareMode,
|
|
IntPtr lpSecurityAttributes, int dwCreationDisposition,
|
|
int dwFlagsAndAttributes, IntPtr hTemplateFile);
|
|
|
|
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
|
|
static extern bool CloseHandle(IntPtr hObject);
|
|
#endregion
|
|
}
|
|
} |