 |
Introduction
Most flash-based USB disk devices have a unique serial number assigned by the manufacturer. (However, some earlier v1.1-based USB devices may not support a serial number)
There are generally two different methods for getting the serial number of a USB-based device... an "easy" way using Windows Management Instrumentation (WMI) and a "hard" way using the Win32 APIs. There are advantages and disadvantages for both methods...
one is slow but simple to implement, the other is fast (and potentially provides more information) but is difficult to implement.
Method 1: Using Windows Management Instrumentation (WMI)
This might be a good time to review a companion article on Introduction to Windows Management Instrumentation.
The WMI technique uses a series of "relationships" that exist between several WMI classes. We start with the Win32_LogicalDisk class, track it to the Win32_DiskPartition class (which itself is just a relationship class), and then track that to the WiNote:
Although it is generally accepted as true, there is no documentation to guarantee that the PnPDeviceID will continue to contain the Serial Number.
Public Function GetSerialNumber(ByVal DriveLetter As String) As String
Dim wmi_ld, wmi_dp, wmi_dd As ManagementObject
Dim temp, parts(), ans As String
ans = ""
' get the Logical Disk for that drive letter
wmi_ld = New ManagementObject("Win32_LogicalDisk.DeviceID='" & _
DriveLetter.TrimEnd("\"c) & "'")
' get the associated DiskPartition
For Each wmi_dp In wmi_ld.GetRelated("Win32_DiskPartition")
' get the associated DiskDrive
For Each wmi_dd In wmi_dp.GetRelated("Win32_DiskDrive")
' the serial number is embedded in the PnPDeviceID
temp = wmi_dd("PnPDeviceID").ToString
If Not temp.StartsWith("USBSTOR") Then
Throw New ApplicationException(DriveLetter & " doesn't appear to be USB Device")
End If
parts = temp.Split("\&".ToCharArray)
' The serial number should be the next to the last element
ans = parts(parts.Length - 2)
Next
Next
Return ans
End Functionl number should be the next to the last element
ans = parts(parts.Length - 2)
Next
Next
Return ans
End Function
Note: There is a bug in the Windows Vista "provider" for the Win32_Disk class... and the above technique won't work on Vista. So, use the following as a work around:
Public Function GetSerialNumber(ByVal DriveLetter As String) As String
Dim wmi_ld, wmi_dp, wmi_dd As ManagementObject
Dim temp, parts(), ans As String
ans = ""
' get the Logical Disk for that drive letter
wmi_ld = New ManagementObject("Win32_LogicalDisk.DeviceID='" & _
DriveLetter.TrimEnd("\"c) & "'")
' get the associated DiskPartition
For Each wmi_dp In wmi_ld.GetRelated("Win32_DiskPartition")
' get the associated DiskDrive
For Each wmi_dd In wmi_dp.GetRelated("Win32_DiskDrive")
' There is a bug in WinVista that corrupts some of the fields
' of the Win32_DiskDrive class if you instantiate the class via
' its primary key (as in the example above) and the device is
' a USB disk. Oh well... so we have go thru this extra step
Dim wmi As New ManagementClass("Win32_DiskDrive")
' loop thru all of the instances. This is silly, we shouldn't
' have to loop thru them all, when we know which one we want.
For Each obj As ManagementObject In wmi.GetInstances
' do the DeviceID fields match?
If obj("DeviceID").ToString = wmi_dd("DeviceID").ToString Then
' the serial number is embedded in the PnPDeviceID
temp = obj("PnPDeviceID").ToString
If Not temp.StartsWith("USBSTOR") Then
Throw New ApplicationException(DriveLetter & " doesn't appear to be USB Device")
End If
parts = temp.Split("\&".ToCharArray)
' The serial number should be the next to the last element
ans = parts(parts.Length - 2)
End If
Next
Next
Next
Return ans
End Function
I think you need to look at the Win32 API method to truly appreciate the simplicity of the WMI method.
Method 2: Using the Win32 APIs
OK, now let's do it the "hard" way. The API method uses functions from SetupAPI.DLL for listing devices and getting device parameters. It also uses the normal DeviceIoControlAPI function from Kernel.DLL to talk to the hardware devices. I'll admit,
the technique is a bit convoluted, so let's break it down into steps:
- Step 1: Find the correct disk device in the "device tree" by searching for a unique device number
- Step 2: Get the InstanceID of the device and "walk the device tree" upwards to get the DevicePath of the Hub
- Step 3: Loop thru each of the ports on the Hub to find the matching InstanceID
- Step 4: Get the iSerialNumber "index" from the DeviceDescriptor
- Step 5: Get the string value for StringDescriptor
Note: I have not included the API Consts, Enums, Structures, and Declares in this web article (because they took up too much room). However, they are in the downloadable sample code (see the link at the bottom of the article).
This top-level routine follows the steps outlined above. The FindDiskDevice() function searches the device tree for DeviceNumber that matches that of the drive letter. It returns (via it passed by reference parameters) the full HubDevicePath for
the USB Hub and the unique InstanceID of the drive. The GetPortCount() function merely returns the number of USB ports on the Hub. Next it uses the GetDriverKeyName() andFindInstanceIDByKeyName() functions to find the
correct port number on the Hub. Next, the GetDeviceDescriptor() method returns the DeviceDescriptor so we know the "index" of the Serial Number string. And lastly, the GetStringDescriptor() function returns the actual serial
number string.
Function GetSerialNumber(ByVal DriveLetter As String) As String
Dim SerialNumber As String = ""
Dim InstanceID As String = ""
Dim HubDevicePath As String = ""
Dim HubPortCount As Integer
' HubDevicePath and InstanceID are passed by reference
If Not FindDiskDevice(DriveLetter, HubDevicePath, InstanceID) Then
Throw New ApplicationException("Can't find the device instance")
End If
If Not InstanceID.StartsWith("USB\") Then
Throw New ApplicationException("This drive doesn't appear to be a USB device")
End If
' how many ports are there?
HubPortCount = GetPortCount(HubDevicePath)
If HubPortCount = 0 Then
Throw New ApplicationException("Can't get the number of ports on the hub")
End If
' loop thru all of the ports hunting for a matching InstanceID
' BTW: Port numbers start at 1
For i As Integer = 1 To HubPortCount
' does the device match the InstanceID we're looking for?
If FindInstanceIDByKeyName(GetDriverKeyName(HubDevicePath, i)) = InstanceID Then
' get the "index" for the serial number
Dim DeviceDescriptor As USB_DEVICE_DESCRIPTOR = _
GetDeviceDescriptor(HubDevicePath, i)
' a iSerialNumber of 0 means there is no serial number
If DeviceDescriptor.iSerialNumber > 0 Then
SerialNumber = GetStringDescriptor(HubDevicePath, i, _
DeviceDescriptor.iSerialNumber)
Exit For
End If
End If
Next
Return SerialNumber
End Function
Every "Storage Device" is assigned a unique number based upon its device type. We use this feature to allow us to see if two different device paths (such as "\\.\E:" and "\\\\?\\usbstor#disk&ven_lexar&prod_jd_lightning&rev_3000#33000001928000002345&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}")
are actually pointing to the same device. Since the STORAGE_DEVICE_NUMBER.DeviceNumber field is only unique with itsSTORAGE_DEVICE_NUMBER.DeviceType, we "fold" the two numbers together.
Private Function GetDeviceNumber(ByVal DevicePath As String) As Integer
Dim ans As Integer = -1
Dim h As IntPtr = CreateFile(DevicePath.TrimEnd("\"c), 0, 0, Nothing, _
OPEN_EXISTING, 0, Nothing)
If h.ToInt32 <> INVALID_HANDLE_VALUE Then
Dim reqSize As Integer = 0
Dim Sdn As New STORAGE_DEVICE_NUMBER
Dim nBytes As Integer = Marshal.SizeOf(Sdn)
Dim ptrSdn As IntPtr = Marshal.AllocHGlobal(nBytes)
If DeviceIoControl(h, IOCTL_STORAGE_GET_DEVICE_NUMBER, IntPtr.Zero, 0, _
ptrSdn, Marshal.SizeOf(Sdn), reqSize, Nothing) Then
Sdn = CType(Marshal.PtrToStructure(ptrSdn, GetType( _
STORAGE_DEVICE_NUMBER)), STORAGE_DEVICE_NUMBER)
' just my way of combining the relevant parts of the
' STORAGE_DEVICE_NUMBER into a single number
ans = (Sdn.DeviceType << 8) + Sdn.DeviceNumber
End If
Marshal.FreeHGlobal(ptrSdn)
CloseHandle(h)
End If
Return ans
End Function
Next, we need to find the full "symbolic name" of the USB Hub where are disk is located (an average PC might have 2-3 internal USB hubs), and we also need the "Instance ID" of the device itself (sorta like a device driver name). We start by getting theDeviceNumber of
the drive letter assigned to the USB disk. Next, we search the entire "device tree" for a device that matches that device number. After we found a match, we need to "walk the device tree" upwards to get path to the USB Hub. These two strings are passed
"by reference", so that we can make changes to them inside this function.
Private Function FindDiskDevice(ByVal DriveLetter As String, ByRef HubDevicePath As _
String, ByRef InstanceID As String) As Boolean
Dim ans As Boolean = False
' Get the DeviceNumber using the drive letter (without a trailing
' backslash, ie "C:"). We'll use this later to match the DeviceNumber
' of each of the device's Symbolic Name
Dim DeviceNumber As Integer = GetDeviceNumber("\\.\" & DriveLetter.TrimEnd("\"c))
If DeviceNumber < 0 Then
Return ans
End If
Dim DiskGUID As New Guid(GUID_DEVINTERFACE_DISK)
' We start at the "root" of the device tree and look for all
' devices that match the interface GUID of a disk
Dim hSetup As IntPtr = SetupDiGetClassDevs(DiskGUID, 0, IntPtr.Zero, DIGCF_PRESENT _
Or DIGCF_DEVICEINTERFACE)
If hSetup.ToInt32 <> INVALID_HANDLE_VALUE Then
Dim Success As Boolean
Dim i As Integer = 0
do
' create a Device Interface Data structure
Dim dia As New SP_DEVICE_INTERFACE_DATA
dia.cbSize = Marshal.SizeOf(dia)
' start the enumeration
Success = SetupDiEnumDeviceInterfaces(hSetup, IntPtr.Zero, DiskGUID, i, dia)
If Success Then
' prepare a Devinfo Data structure
Dim da As New SP_DEVINFO_DATA
da.cbSize = Marshal.SizeOf(da)
' prepare a Device Interface Detail Data structure
Dim didd As New SP_DEVICE_INTERFACE_DETAIL_DATA
didd.cbSize = 4 + Marshal.SystemDefaultCharSize ' trust me 
' now we can get some more detailed information
Dim nBytes As Integer = BUFFER_SIZE
Dim nRequiredSize As Integer = 0
If SetupDiGetDeviceInterfaceDetail(hSetup, dia, didd, nBytes, nRequiredSize, da) Then
' OK, let's get the Device Number again... this time using
' the device's "Symbolic Name". If the numbers match, we've
' found the one we're looking for.
If GetDeviceNumber(didd.DevicePath) = DeviceNumber Then
' This should get us to the USBSTOR "level"
Dim ptrPrevious As IntPtr
CM_Get_Parent(ptrPrevious, da.DevInst, 0)
' Get the InstanceID
Dim ptrBuf As IntPtr = Marshal.AllocHGlobal(nBytes)
CM_Get_Device_ID(ptrPrevious, ptrBuf, nBytes, 0)
InstanceID = Marshal.PtrToStringAuto(ptrBuf)
' This should get us to the USB "level" (the USB hub)
CM_Get_Parent(ptrPrevious, ptrPrevious, 0)
' Now get the ID of the hub
CM_Get_Device_ID(ptrPrevious, ptrBuf, nBytes, 0)
Dim temp As String = Marshal.PtrToStringAuto(ptrBuf)
Marshal.FreeHGlobal(ptrBuf)
' Build the final string that represents the full "Symbolic Name"
' of the USB Hub using its ID
HubDevicePath = "\\.\" & temp.Replace("\", "#") & "#{" & _
GUID_DEVINTERFACE_USB_HUB & "}"
ans = True
Exit Do
End If
End If
End If
i += 1
Loop While Success
End If
SetupDiDestroyDeviceInfoList(hSetup)
Return ans
End Function
Next we need to get the "Driver Key Name" of a device, given the full path to the USB Hub and the port number on the Hub. The Driver Key Name isn't used directly by this application, instead it's used as an intermediate value to enable us to get the dvice's
Instance ID.
In USB programming, you rarely talk to the USB device directly... you talk to the Hub and ask the Hub to intercede on your behalf. You must know the port number to where the device is located in order to get any meaningful data from the USB Hub. If you
don't know the port number, you're forced to try them all to find the one you want.
Private Function GetDriverKeyName(ByVal HubPath As String, ByVal PortNumber _
As Integer) As String
Dim ans As String = ""
' open a handle to the USB hub
Dim hHub As IntPtr = CreateFile(HubPath, GENERIC_WRITE, FILE_SHARE_WRITE, _
IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero)
If hHub.ToInt32 <> INVALID_HANDLE_VALUE Then
Dim nBytesReturned As Integer
Dim nBytes As Integer = Marshal.SizeOf(GetType( _
USB_NODE_CONNECTION_INFORMATION_EX))
Dim ptrNodeConnection As IntPtr = Marshal.AllocHGlobal(nBytes)
Dim NodeConnection As New USB_NODE_CONNECTION_INFORMATION_EX
NodeConnection.ConnectionIndex = PortNumber
Marshal.StructureToPtr(NodeConnection, ptrNodeConnection, True)
' let's check to see if there is something plugged in first
If DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, _
ptrNodeConnection, nBytes, ptrNodeConnection, nBytes, nBytesReturned, _
IntPtr.Zero) Then
NodeConnection = CType(Marshal.PtrToStructure(ptrNodeConnection, _
GetType(USB_NODE_CONNECTION_INFORMATION_EX)), _
USB_NODE_CONNECTION_INFORMATION_EX)
If NodeConnection.ConnectionStatus = _
USB_CONNECTION_STATUS.DeviceConnected Then
' now let's get the Driver Key Name
Dim DriverKey As New USB_NODE_CONNECTION_DRIVERKEY_NAME
DriverKey.ConnectionIndex = PortNumber
nBytes = Marshal.SizeOf(DriverKey)
Dim ptrDriverKey As IntPtr = Marshal.AllocHGlobal(nBytes)
Marshal.StructureToPtr(DriverKey, ptrDriverKey, True)
'Use an IOCTL call to request the Driver Key Name
If DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, _
ptrDriverKey, nBytes, ptrDriverKey, nBytes, nBytesReturned, IntPtr.Zero) Then
DriverKey = CType(Marshal.PtrToStructure(ptrDriverKey, GetType( _
USB_NODE_CONNECTION_DRIVERKEY_NAME)), _
USB_NODE_CONNECTION_DRIVERKEY_NAME)
ans = DriverKey.DriverKeyName
End If
Marshal.FreeHGlobal(ptrDriverKey)
End If
End If
' Clean up and go home
Marshal.FreeHGlobal(ptrNodeConnection)
CloseHandle(hHub)
End If
Return ans
End Function
This next section of code returns the number of ports on a given hub.
Private Function GetPortCount(ByVal HubDevicePath As String) As Integer
Dim ans As Integer = 0
' open a connection to the HubDevice (that we just found)
Dim hHub As IntPtr = CreateFile(HubDevicePath, GENERIC_WRITE, _
FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, 0, IntPtr.Zero)
If hHub.ToInt32 <> INVALID_HANDLE_VALUE Then
Dim nBytesReturned As Integer = 0
Dim NodeInfo As New USB_NODE_INFORMATION
NodeInfo.NodeType = USB_HUB_NODE.UsbHub
Dim nBytes As Integer = Marshal.SizeOf(NodeInfo)
Dim ptrNodeInfo As IntPtr = Marshal.AllocHGlobal(nBytes)
Marshal.StructureToPtr(NodeInfo, ptrNodeInfo, True)
' get the number of ports on the hub
If DeviceIoControl(hHub, IOCTL_USB_GET_NODE_INFORMATION, ptrNodeInfo, _
nBytes, ptrNodeInfo, nBytes, nBytesReturned, IntPtr.Zero) Then
NodeInfo = CType(Marshal.PtrToStructure(ptrNodeInfo, GetType( _
USB_NODE_INFORMATION)), USB_NODE_INFORMATION)
ans = NodeInfo.HubInformation.HubDescriptor.bNumberOfPorts
End If
Marshal.FreeHGlobal(ptrNodeInfo)
CloseHandle(hHub)
End If
Return ans
End Function
We need to be able to compare two USB Instance IDs to see if they point to the same device. This is completely analogous to the technique we used to compare storage device numbers. There is no straight-forward technique for a converting a USB "Driver
Key Name" into a "Instance ID". So, we're forced to use the SetupAPI again to examine each device in the device tree for a matching DriverKeyName, and when found, we useSetupDiGetDeviceInstanceId() to return the associated InstanceID.
Private Function FindInstanceIDByKeyName(ByVal DriverKeyName As String) As String
Dim ans As String = ""
Dim DevEnum As String = REGSTR_KEY_USB
' Use the "enumerator form" of the SetupDiGetClassDevs API
' to generate a list of all USB devices
Dim h As IntPtr = SetupDiGetClassDevs(0, DevEnum, IntPtr.Zero, DIGCF_PRESENT _
Or DIGCF_ALLCLASSES)
If h.ToInt32 <> INVALID_HANDLE_VALUE Then
Dim ptrBuf As IntPtr = Marshal.AllocHGlobal(BUFFER_SIZE)
Dim KeyName As String
Dim Success As Boolean
Dim i As Integer = 0
Do
' create a Device Interface Data structure
Dim da As New SP_DEVINFO_DATA
da.cbSize = Marshal.SizeOf(da)
' start the enumeration
Success = SetupDiEnumDeviceInfo(h, i, da)
If Success Then
Dim RequiredSize As Integer = 0
Dim RegType As Integer = REG_SZ
KeyName = ""
' get the driver key name
If SetupDiGetDeviceRegistryProperty(h, da, SPDRP_DRIVER, RegType, ptrBuf, _
BUFFER_SIZE, RequiredSize) Then
KeyName = Marshal.PtrToStringAuto(ptrBuf)
End If
' do we have a match?
If KeyName = DriverKeyName Then
Dim nBytes As Integer = BUFFER_SIZE
Dim sb As New StringBuilder(nBytes)
SetupDiGetDeviceInstanceId(h, da, sb, nBytes, RequiredSize)
ans = sb.ToString()
Exit Do
End If
End If
i += 1
Loop While Success
CloseHandle(ptrBuf)
SetupDiDestroyDeviceInfoList(h)
End If
Return ans
End Function
Each USB Device has a "Device Descriptor" which contains (among other things) an "index" for its string values. The technique to retrieve the DeviceDescriptor requires a "request packet" which carries the USB_DEVICE_DESCRIPTOR structure as a payload.
This requires some spooky pointer magic (and careful memory allocation).
Private Function GetDeviceDescriptor(ByVal HubPath As String, ByVal PortNumber As _
Integer) As USB_DEVICE_DESCRIPTOR
Dim ans As New USB_DEVICE_DESCRIPTOR
Dim hHub, ptrDescReq, ptrDevDesc As IntPtr
Dim DescReq As New USB_DESCRIPTOR_REQUEST
Dim DevDesc As New USB_DEVICE_DESCRIPTOR
Dim nBytesReturned, nBytes As Integer
' open a handle to the USB hub
hHub = CreateFile(HubPath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, _
OPEN_EXISTING, 0, IntPtr.Zero)
If hHub.ToInt32 <> INVALID_HANDLE_VALUE Then
nBytes = BUFFER_SIZE
' build a "request" packet for a Device Descriptor
DescReq = New USB_DESCRIPTOR_REQUEST
DescReq.ConnectionIndex = PortNumber ' the "port number" on the hub
DescReq.SetupPacket.wValue = USB_DEVICE_DESCRIPTOR_TYPE << 8
DescReq.SetupPacket.wLength = CShort(nBytes - Marshal.SizeOf(DescReq))
ptrDescReq = Marshal.AllocHGlobal(BUFFER_SIZE)
Marshal.StructureToPtr(DescReq, ptrDescReq, True)
' Use an IOCTL call to request the Device Descriptor
If DeviceIoControl(hHub, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, _
ptrDescReq, nBytes, ptrDescReq, nBytes, nBytesReturned, IntPtr.Zero) Then
' the pointer to the Device Descriptor is just "off the edge" of
' the descriptor request packet.
ptrDevDesc = New IntPtr(ptrDescReq.ToInt32 + Marshal.SizeOf(DescReq))
ans = CType(Marshal.PtrToStructure(ptrDevDesc, GetType( _
USB_DEVICE_DESCRIPTOR)), USB_DEVICE_DESCRIPTOR)
End If
' Clean up and go home
Marshal.FreeHGlobal(ptrDescReq)
CloseHandle(hHub)
End If
Return ans
End Function
The Device Descriptor only contains the "index" for the string values, so we need to retrieve the String Descriptor to get the the value for the Serial Number string. We use the same technique above to create a "request packet" with a USB_STRING_DESCRIPTOR
payload. However, this time the allocation of memory needs to be zero-filled (otherwise we'd get garbage at the end of the string). VB.Net doesn't have a direct technique for performing a zero-fill operation, so we use a bit of a hack.
Private Function GetStringDescriptor(ByVal HubPath As String, ByVal PortNumber As _
Integer, ByVal Index As Integer) As String
Dim ans As String = ""
Dim hHub, ptrDescReq, ptrStrDesc As IntPtr
Dim DescReq As New USB_DESCRIPTOR_REQUEST
Dim StrDesc As New USB_STRING_DESCRIPTOR
Dim nBytesReturned, nBytes As Integer
' open a handle to the USB hub
hHub = CreateFile(HubPath, GENERIC_WRITE, FILE_SHARE_WRITE, IntPtr.Zero, _
OPEN_EXISTING, 0, IntPtr.Zero)
If hHub.ToInt32 <> INVALID_HANDLE_VALUE Then
nBytes = BUFFER_SIZE
' build a "request" packet for a StringDescriptor
DescReq = New USB_DESCRIPTOR_REQUEST
DescReq.ConnectionIndex = PortNumber
DescReq.SetupPacket.wValue = CShort((USB_STRING_DESCRIPTOR_TYPE << 8) + _
Index)
DescReq.SetupPacket.wLength = CShort(nBytes - Marshal.SizeOf(DescReq))
DescReq.SetupPacket.wIndex = &H409 ' Language Code
' we have to be a bit creative on how we "zero out" the buffer
Dim NullString As New String(Chr(0), BUFFER_SIZE \ Marshal.SystemDefaultCharSize)
ptrDescReq = Marshal.StringToHGlobalAuto(NullString)
Marshal.StructureToPtr(DescReq, ptrDescReq, True)
' Use an IOCTL call to request the String Descriptor
If DeviceIoControl(hHub, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, _
ptrDescReq, nBytes, ptrDescReq, nBytes, nBytesReturned, IntPtr.Zero) Then
' the pointer to the String Descriptor is just "off the edge" of
' the descriptor request packet.
ptrStrDesc = New IntPtr(ptrDescReq.ToInt32 + Marshal.SizeOf(DescReq))
StrDesc = CType(Marshal.PtrToStructure(ptrStrDesc, GetType( _
USB_STRING_DESCRIPTOR)), USB_STRING_DESCRIPTOR)
ans = StrDesc.bString
End If
' Clean up and go home
Marshal.FreeHGlobal(ptrDescReq)
CloseHandle(hHub)
End If
Return ans
End Function
Note: If you prefer a class-based example of using the Win32 API for USB, take a look at the link for a C# source code example at the end of this article
Additional Tools
The following tools from Microsoft are very helpful when dealing with USB device programming
Documentation Links
Downloads/Links
Download the VB.Net Source code examples used in this article: USB_SerialNumber.zip
Download the C# Source code for a class-based USB demonstration project: USBView.zip
Read a related article on Introduction to Windows Management Instrumentation
|
