How to get drive letter from USB VID and PID

Question

Hello

I have written a C++ application which is able to detect multiple USB VID and PID devices upon insertion and removal by matching "USB\VID_%04X&PID_%04X". From this how am I able to find which drive letter the USB storage has mounted on?

The drive, letter D:// is a UF2, fat filesystem which I am using to flash upgrade an embedded device. On my Windows system this shows up under "Portable Devices" in "Device Manager".

Device SWD\WPDBUSENUM_??_USBSTOR#Disk&Ven_Logger&Prod_&Rev_1.00#9&319384a2&0&24842CB953324D5946202020FF170720&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}

If I view the properties of the D:// drive I can get the following information under properties, events:

Device USBSTOR\Disk&Ven_Logger&Prod_&Rev_1.00\9&319384a2&0&24842CB953324D5946202020FF170720&0 was configured.

Driver Name: disk.inf
Class Guid: {4d36e967-e325-11ce-bfc1-08002be10318}
Driver Date: 06/21/2006
Driver Version: 10.0.19041.789
Driver Provider: Microsoft
Driver Section: disk_install.NT
Driver Rank: 0xFF0006
Matching Device Id: GenDisk
Outranked Drivers: disk.inf:GenDisk:00FF2002
Device Updated: false
Parent Device: USB\VID_17DE&PID_00FF&MI_02\8&1d8b0748&0&0002

Any direction how I can achieve the above in C++ would grateful.

Thanks
J

Answer 1

I did this test on my PC (in C++ as you tagged C++...) by enumerating disk drives; I get :

DeviceID : SCSI\DISK&VEN_ATA&PROD_ST1000DM003-1SB1\4&38FBD192&0&000000                                                                                                                                                                 
    Parent DeviceID : PCI\VEN_8086&DEV_8C02&SUBSYS_B0051458&REV_05\3&11583659&0&FA
    Drive Letters : D:, E:, C:                                                                                                                                      
DeviceID : USBSTOR\DISK&VEN__USB&PROD__SANDISK_3.2GEN1&REV_1.00\010130EBADCCCEFA5A8FF9F68DAD45551D020722931C25CB45700559C9CEEC9                                   
    Parent DeviceID : USB\VID_0781&PID_5591\010130EBADCCCEFA5A8FF9F68DAD45551D020722931C25CB45700559C9CEEC9080A500000000000000000000CE43F2EEFF0A250091558107B8A8A55D
    Drive Letters : H:   

Test code :

HANDLE hDevice = NULL;
HDEVINFO DeviceInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_DISK, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);                
SP_DEVINFO_DATA DeviceInfoData;
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
for (DWORD dwDeviceIndex = 0; SetupDiEnumDeviceInfo(DeviceInfoSet, dwDeviceIndex, &DeviceInfoData); dwDeviceIndex++)
{
    SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
    for (DWORD dwMemberIndex = 0; SetupDiEnumDeviceInterfaces(DeviceInfoSet, &DeviceInfoData, &GUID_DEVINTERFACE_DISK, dwMemberIndex, &DeviceInterfaceData); dwMemberIndex++)
    {
        DWORD dwDeviceInterfaceDetailDataSize = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA, DevicePath) + MAX_PATH * sizeof(TCHAR);
        PSP_DEVICE_INTERFACE_DETAIL_DATA pDeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)new BYTE[dwDeviceInterfaceDetailDataSize];
        pDeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
        if (SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, &DeviceInterfaceData, pDeviceInterfaceDetailData, dwDeviceInterfaceDetailDataSize, NULL, NULL))
        {
            CONFIGRET cRet;
            DEVINST hDevInst = DeviceInfoData.DevInst;
            DEVINST hParentDevInst;
            cRet = CM_Get_Parent(&hParentDevInst, hDevInst, 0);
            TCHAR wsParentDeviceID[MAX_DEVICE_ID_LEN];
            cRet = CM_Get_Device_ID(hParentDevInst, wsParentDeviceID, sizeof(wsParentDeviceID) / sizeof(TCHAR), 0);
            TCHAR wsDeviceID[MAX_DEVICE_ID_LEN];
            cRet = CM_Get_Device_ID(hDevInst, wsDeviceID, sizeof(wsDeviceID) / sizeof(TCHAR), 0);

            WCHAR wsText[MAX_PATH] = L"";
            wsprintf(wsText, L"DeviceID : %s\r\n", wsDeviceID); // 1 PowerDeviceD0
            OutputDebugString(wsText);
            wsprintf(wsText, L"\tParent DeviceID : %s\r\n", wsParentDeviceID); // 1 PowerDeviceD0
            OutputDebugString(wsText);
           /* hDevice = CreateFile(pDeviceInterfaceDetailData->DevicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
            if (hDevice != INVALID_HANDLE_VALUE)
            {
            }*/
            WCHAR wsDriveLetters[MAX_PATH] = L"";
            GetDriveLettersFromDevInstID(wsDeviceID, wsDriveLetters);
            wsprintf(wsText, L"\tDrive Letters : %s\r\n", wsDriveLetters); // 1 PowerDeviceD0
            OutputDebugString(wsText);
        }
    }
}   

Utility functions :

void GetDriveLettersFromDevInstID(LPCTSTR pwsDeviceInstanceID, __out LPTSTR pwsDriveLetters)                                                                               
{                                                                                                                                                                          
    pwsDriveLetters[0] = 0;                                                                                                                                                
    HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED);                                                                                                                  
    if (SUCCEEDED(hr))                                                                                                                                                     
    {                                                                                                                                                                      
        // hr = 0x80010119                                                                                                                                                 
        hr = CoInitializeSecurity(NULL,                                                                                                                                    
            -1,                          // COM authentication                                                                                                             
            NULL,                        // Authentication services                                                                                                        
            NULL,                        // Reserved                                                                                                                       
            RPC_C_AUTHN_LEVEL_NONE,      // RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication                                                                         
            RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation                                                                                                          
            NULL,                        // Authentication info                                                                                                            
            EOAC_NONE,                   // Additional capabilities                                                                                                        
            NULL                         // Reserved                                                                                                                       
        );                                                                                                                                                                 
        if (SUCCEEDED(hr))                                                                                                                                                 
        {                                                                                                                                                                  
            IWbemLocator* pLoc = NULL;                                                                                                                                     
            hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&pLoc);                                                           
            if (SUCCEEDED(hr))                                                                                                                                             
            {                                                                                                                                                              
                IWbemServices* pSvc = NULL;                                                                                                                                
                hr = pLoc->ConnectServer(bstr_t(L"ROOT\\CIMV2"), NULL, NULL, NULL, 0, NULL, NULL, &pSvc);                                                                  
                if (SUCCEEDED(hr))                                                                                                                                         
                {                                                                                                                                                          
                    hr = CoSetProxyBlanket(                                                                                                                                
                        pSvc,                        // Indicates the proxy to set                                                                                         
                        RPC_C_AUTHN_DEFAULT,         // RPC_C_AUTHN_WINNT,  // RPC_C_AUTHN_xxx                                                                             
                        RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx                                                                                                    
                        NULL,                        // Server principal name                                                                                              
                        RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx                                                                                              
                        RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx                                                                                                
                        NULL,                        // client identity                                                                                                    
                        EOAC_NONE                    // proxy capabilities                                                                                                 
                    );                                                                                                                                                     
                    if (SUCCEEDED(hr))                                                                                                                                     
                    {                                                                                                                                                      
                        WCHAR wsQuery[MAX_PATH] = L"";                                                                                                                     
                        lstrcpy(wsQuery, L"SELECT * FROM Win32_DiskDrive where PNPDeviceID='");                                                                            
                        lstrcat(wsQuery, pwsDeviceInstanceID);                                                                                                             
                        lstrcat(wsQuery, L"'");                                                                                                                            
                        StrReplace(wsQuery, L"\\", L"\\\\", ARRAYSIZE(wsQuery));                                                                                           
                        IEnumWbemClassObject* pWbemEnum = NULL;                                                                                                            
                        hr = pSvc->ExecQuery(bstr_t("WQL"),                                                                                                                
                            bstr_t(wsQuery),                                                                                                                               
                            WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pWbemEnum);                                                                      
                        if (SUCCEEDED(hr))                                                                                                                                 
                        {                                                                                                                                                  
                            IWbemClassObject* pclsObj;                                                                                                                     
                            ULONG uReturn = 0;                                                                                                                             
                            int nCount = 0;                                                                                                                                
                            while (pWbemEnum)                                                                                                                              
                            {                                                                                                                                              
                                hr = pWbemEnum->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);                                                                                
                                // 0x80041010  Invalid class WBEM_E_INVALID_CLASS                                                                                          
                                // 2147749911 (0x80041017) WBEM_E_INVALID_QUERY                                                                                            
                                if (0 == uReturn)                                                                                                                          
                                {                                                                                                                                          
                                    break;                                                                                                                                 
                                }                                                                                                                                          

                                VARIANT vtProp;                                                                                                                            
                                VariantInit(&vtProp);                                                                                                                      
                                hr = pclsObj->Get(L"DeviceID", 0, &vtProp, 0, 0);                                                                                          
                                WCHAR wsDeviceID[255] = L"";                                                                                                               
                                wsprintf(wsDeviceID, L"%s", vtProp.bstrVal);                                                                                               
                                VariantClear(&vtProp);                                                                                                                     
                                lstrcpy(wsQuery, L"ASSOCIATORS OF {Win32_DiskDrive.DeviceID='");                                                                           
                                lstrcat(wsQuery, wsDeviceID);                                                                                                              
                                lstrcat(wsQuery, L"'");                                                                                                                    
                                lstrcat(wsQuery, L"} WHERE AssocClass = Win32_DiskDriveToDiskPartition");                                                                  
                                //lstrcpy(wsQuery, L"ASSOCIATORS OF {Win32_DiskDrive.DeviceID='\\\\.\\PHYSICALDRIVE0'} WHERE AssocClass = Win32_DiskDriveToDiskPartition");

                                IEnumWbemClassObject* pWbemEnum2 = NULL;                                                                                                   
                                hr = pSvc->ExecQuery(bstr_t("WQL"),                                                                                                        
                                    bstr_t(wsQuery),                                                                                                                       
                                    WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pWbemEnum2);                                                             
                                StrReplace(wsQuery, L"\\", L"\\\\", ARRAYSIZE(wsQuery));                                                                                   
                                // ASSOCIATORS OF {Win32_DiskDrive.DeviceID= "\\\\.\\PHYSICALDRIVE1"} WHERE AssocClass = Win32_DiskDriveToDiskPartition                    
                                // hr = 0x8004103a WBEM_E_INVALID_OBJECT_PATH 2147749946 (0x8004103A)                                                                      
                                if (SUCCEEDED(hr))                                                                                                                         
                                {                                                                                                                                          
                                    IWbemClassObject* pclsObj2;                                                                                                            
                                    ULONG uReturn2 = 0;                                                                                                                    
                                    while (pWbemEnum2)                                                                                                                     
                                    {                                                                                                                                      
                                        hr = pWbemEnum2->Next(WBEM_INFINITE, 1, &pclsObj2, &uReturn2);                                                                     
                                        if (0 == uReturn2)                                                                                                                 
                                        {                                                                                                                                  
                                            break;                                                                                                                         
                                        }                                                                                                                                  
                                        VARIANT vtProp;                                                                                                                    
                                        VariantInit(&vtProp);                                                                                                              
                                        hr = pclsObj2->Get(L"DeviceID", 0, &vtProp, 0, 0);                                                                                 
                                        WCHAR wsPartitionDeviceID[255] = L"";                                                                                              
                                        wsprintf(wsPartitionDeviceID, L"%s", vtProp.bstrVal);                                                                              
                                        VariantClear(&vtProp);                                                                                                             

                                        lstrcpy(wsQuery, L"ASSOCIATORS Of {Win32_DiskPartition.DeviceID='");                                                               
                                        lstrcat(wsQuery, wsPartitionDeviceID);                                                                                             
                                        lstrcat(wsQuery, L"'");                                                                                                            
                                        lstrcat(wsQuery, L"} WHERE AssocClass = Win32_LogicalDiskToPartition");                                                            
                                        IEnumWbemClassObject* pWbemEnum3 = NULL;                                                                                           
                                        hr = pSvc->ExecQuery(bstr_t("WQL"),                                                                                                
                                            bstr_t(wsQuery),                                                                                                               
                                            WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pWbemEnum3);                                                     
                                        StrReplace(wsQuery, L"\\", L"\\\\", ARRAYSIZE(wsQuery));                                                                           
                                        if (SUCCEEDED(hr))                                                                                                                 
                                        {                                                                                                                                  
                                            IWbemClassObject* pclsObj3;                                                                                                    
                                            ULONG uReturn3 = 0;                                                                                                            
                                            while (pWbemEnum3)                                                                                                             
                                            {                                                                                                                              
                                                hr = pWbemEnum3->Next(WBEM_INFINITE, 1, &pclsObj3, &uReturn3);                                                             
                                                if (0 == uReturn3)                                                                                                         
                                                {                                                                                                                          
                                                    break;                                                                                                                 
                                                }                                                                                                                          
                                                VARIANT vtProp;                                                                                                            
                                                VariantInit(&vtProp);                                                                                                      
                                                hr = pclsObj3->Get(L"DeviceID", 0, &vtProp, 0, 0);                                                                         
                                                WCHAR sLogicalDeviceID[255] = L"";                                                                                         
                                                wsprintf(sLogicalDeviceID, L"%s", vtProp.bstrVal);                                                                         
                                                VariantClear(&vtProp);                                                                                                     

                                                if (lstrcmp(pwsDriveLetters, L"") == 0)                                                                                    
                                                {                                                                                                                          
                                                    lstrcat(pwsDriveLetters, sLogicalDeviceID);                                                                            
                                                }                                                                                                                          
                                                else                                                                                                                       
                                                {                                                                                                                          
                                                    lstrcat(pwsDriveLetters, L", ");                                                                                       
                                                    lstrcat(pwsDriveLetters, sLogicalDeviceID);                                                                            
                                                }                                                                                                                          
                                                pclsObj3->Release();                                                                                                       
                                            }                                                                                                                              
                                            pWbemEnum3->Release();                                                                                                         
                                        }                                                                                                                                  
                                        pclsObj2->Release();                                                                                                               
                                    }                                                                                                                                      
                                    pWbemEnum2->Release();                                                                                                                 
                                }                                                                                                                                          

                                nCount++;                                                                                                                                  
                                pclsObj->Release();                                                                                                                        
                            }                                                                                                                                              
                            pWbemEnum->Release();                                                                                                                          
                        }                                                                                                                                                  
                    }                                                                                                                                                      
                    pSvc->Release();                                                                                                                                       
                }                                                                                                                                                          
                pLoc->Release();                                                                                                                                           
            }                                                                                                                                                              
        }                                                                                                                                                                  
        CoUninitialize();                                                                                                                                                  
    }                                                                                                                                                                      
}                                                                                                                                                                          


int StrReplace(LPCTSTR sStringReplace, LPCTSTR sOldStr, LPCTSTR sNewStr, int nStringLengthMax)                                                                             
{                                                                                                                                                                          
    int nNewLength = lstrlen(sNewStr);                                                                                                                                     
    int nOldLength = lstrlen(sOldStr);                                                                                                                                     
    int nStringLength = lstrlen(sStringReplace);                                                                                                                           
    LPCTSTR pCharRep;                                                                                                                                                      
    if ((pCharRep = wcsstr(sStringReplace, sOldStr)) == NULL)                                                                                                              
        return -1;                                                                                                                                                         
    int nAdd = 0;                                                                                                                                                          
    while (pCharRep != NULL)                                                                                                                                               
    {                          

Answer 2

This third party software may be useful:

https://www.nirsoft.net/utils/usb_devices_view.html
https://www.nirsoft.net/utils/usbdeview-x64.zip

.
.
.
.
.

Please remember to vote and to mark the replies as answers if they help.

On the bottom of each post there is:

Propose as answer = answered the question

On the left side of each post there is /\ with a number: click = a helpful post
.
.
.
.
.

Answer 3

I have 2 removable devices attached one of which I can match to a drive and the other not.

0, VID = USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002, Drive = Unknown
1, VID = USB\VID_30DE&PID_6544\0022CFF653ECC411A350A2F9, Drive = F:

PS C:\Users\jonathan.woodward> Get-WmiObject -ClassName Win32_USBHub | Select-Object DeviceID, PNPDeviceID, Description

DeviceID PNPDeviceID Description

---

USB\VID_17DE&PID_00FF\24842CB953324D5946202020FF170720 USB\VID_17DE&PID_00FF\24842CB953324D5946202020FF170720 USB Composite Device
USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002 USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002 USB Mass Storage Device

USB\VID_03EB&PID_2141\J42700037974 USB\VID_03EB&PID_2141\J42700037974 USB Composite Device
USB\VID_30DE&PID_6544\0022CFF653ECC411A350A2F9 USB\VID_30DE&PID_6544\0022CFF653ECC411A350A2F9 USB Mass Storage Device

PS C:\Users\jonathan.woodward> Get-WmiObject -ClassName Win32_DiskDrive | Select-Object DeviceID, PNPDeviceID, Description

DeviceID PNPDeviceID Description

---

\.\PHYSICALDRIVE1 USBSTOR\DISK&VEN_LOGGER&PROD_&REV_1.00\9&319384A2&0&24842CB953324D5946202020FF170720&0 Disk drive
\.\PHYSICALDRIVE2 USBSTOR\DISK&VEN_KIOXIA&PROD_TRANSMEMORY&REV_1.00\0022CFF653ECC411A350A2F9&0 Disk drive

For whatever reason VID_17DE does not show me the link the other one does however it is somehow mapped to D: drive.

This is how I get the link for the other drive:

    public static USBDevice Get(string pnpDeviceId)
    {
        if (pnpDeviceId == null)
            throw new ArgumentNullException("pnpDeviceId");

        IntPtr hDevInfo = SetupDiGetClassDevs(IntPtr.Zero, pnpDeviceId, IntPtr.Zero, DIGCF.DIGCF_ALLCLASSES | DIGCF.DIGCF_DEVICEINTERFACE);
        if (hDevInfo == (IntPtr)INVALID_HANDLE_VALUE)
            throw new Win32Exception(Marshal.GetLastWin32Error());

        SP_DEVINFO_DATA data = new SP_DEVINFO_DATA();
        data.cbSize = Marshal.SizeOf(data);
        if (!SetupDiEnumDeviceInfo(hDevInfo, 0, ref data))
        {
            int err = Marshal.GetLastWin32Error();
            if (err == ERROR_NO_MORE_ITEMS)
                return null;

            throw new Win32Exception(err);
        }

        return new USBDevice(hDevInfo, data) { PnpDeviceId = pnpDeviceId };
    }

But it returns null...

        using (USBDevice device = USBDevice.Get(PnpDeviceID))
        {
            if (device != null)
            {
                // Get children devices
                foreach (string childDeviceId in device.ChildrenPnpDeviceIds)
                {
                    // Get the drive object that correspond to this id (escape the id)
                    foreach (ManagementObject drive in new ManagementObjectSearcher("SELECT DeviceID FROM Win32_DiskDrive WHERE PNPDeviceID='" + childDeviceId.Replace(@"\", @"\\") + "'").Get())
                    {
                        // Associate physical disks with partitions
                        foreach (ManagementObject partition in new ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskDrive.DeviceID='" + drive["DeviceID"] + "'} WHERE AssocClass=Win32_DiskDriveToDiskPartition").Get())
                        {
                            // Associate partitions with logical disks (drive letter volumes)
                            foreach (ManagementObject disk in new ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskPartition.DeviceID='" + partition["DeviceID"] + "'} WHERE AssocClass=Win32_LogicalDiskToPartition").Get())
                            {
                                yield return (string)disk["DeviceID"];
                            }
                        }
                    }
                }
            }
        }

Answer 4

The PnPEntity is USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003 and not USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002 how can this happen?

PS C:\Users\jonathan.woodward> Get-WmiObject Win32_PnPEntity -Filter 'DeviceID = "USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003"'

__GENUS : 2
__CLASS : Win32_PnPEntity
__SUPERCLASS : CIM_LogicalDevice
__DYNASTY : CIM_ManagedSystemElement
__RELPATH : Win32_PnPEntity.DeviceID="USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003"
__PROPERTY_COUNT : 26
__DERIVATION : {CIM_LogicalDevice, CIM_LogicalElement, CIM_ManagedSystemElement}
__SERVER : GCN0185
__NAMESPACE : root\cimv2
__PATH : \GCN0185\root\cimv2:Win32_PnPEntity.DeviceID="USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003"
Availability :
Caption : USB Input Device
ClassGuid : {745a17a0-74d3-11d0-b6fe-00a0c90f57da}
CompatibleID : {USB\Class_03&SubClass_00&Prot_00, USB\Class_03&SubClass_00, USB\Class_03}
ConfigManagerErrorCode : 0
ConfigManagerUserConfig : False
CreationClassName : Win32_PnPEntity
Description : USB Input Device
DeviceID : USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003
ErrorCleared :
ErrorDescription :
HardwareID : {USB\VID_17DE&PID_00FF&REV_4201&MI_03, USB\VID_17DE&PID_00FF&MI_03}
InstallDate :
LastErrorCode :
Manufacturer : (Standard system devices)
Name : USB Input Device
PNPClass : HIDClass
PNPDeviceID : USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003