Как получить номер USB-порта, на котором "сидит" подключенное устройство

#include <windows.h> 
#include <setupapi.h>
#include <Dbt.h>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
 
#pragma comment(lib,"setupapi.lib")
#pragma comment(lib,"advapi32.lib")
#pragma comment(lib,"user32.lib")

/*void TreeUpdate(): функция идентифицирует (обновляет), подключенные USB и HID устройства и выводит их в TreeView (DevTree)*/
private: System::Void TreeUpdate() {
            GUID GUID_USB_DEVICE = { 0x36FC9E60, 0xC465, 0x11CF, 0x80, 0x56, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00 };
            GUID GUID_HID_DEVICE = { 0x745a17a0, 0x74d3, 0x11d0, 0xb6, 0xfe, 0x00, 0xa0, 0xc9, 0x0f, 0x57, 0xda };
            HDEVINFO PnPHandle_USB = NULL;
            HDEVINFO PnPHandle_HID = NULL;
            SP_DEVINFO_DATA DeviceInfoData;
            SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
            PBYTE  buffer;
            DWORD  buffersize = 0;
 
            DevTree->Nodes[0]->Nodes->Clear();
            DevTree->Nodes[1]->Nodes->Clear();
            cbDevList->Items->Clear();
 
            PnPHandle_USB = SetupDiGetClassDevs
                (&GUID_USB_DEVICE, // GUID
                0,
                0,
                DIGCF_PRESENT // список (USB) устройств, которые в настоящее время присутствуют в системе
                );
            PnPHandle_HID = SetupDiGetClassDevs
                (&GUID_HID_DEVICE, // GUID
                0,
                0,
                DIGCF_PRESENT // список (HID) устройств, которые в настоящее время присутствуют в системе
                );
 
            if ((PnPHandle_USB == INVALID_HANDLE_VALUE) && (PnPHandle_HID == INVALID_HANDLE_VALUE))
            {
                MessageBox::Show("Список устройств НЕ получен!", "Warning!");
                return;
            }
 
            DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
            DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
            int ch = 0;
            int k = 0;
            // берем каждое USB устройство из списка
            for (ch = 0; SetupDiEnumDeviceInfo(PnPHandle_USB, k, &DeviceInfoData); k++)
            {
                buffer = 0;
                buffersize = 0;
                // и читаем его свойства в буфер
                while (!SetupDiGetDeviceRegistryProperty(
                    PnPHandle_USB,
                    &DeviceInfoData,
                    SPDRP_DEVICEDESC,
                    NULL,
                    buffer,
                    buffersize,
                    &buffersize))
                {
                    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
                    {
                        if (buffer) LocalFree(buffer);
                        buffer = (PBYTE)LocalAlloc(LPTR, buffersize * 2);
                    }
                    else break;
                }
                ch++;
                // Вывод USB идентифицированных устройств в DevTree
                // Заполняем дочерние элементы первого узла дерева Node[0]
                DevTree->Nodes[0]->Nodes->Add(gcnew String(reinterpret_cast<wchar_t*>(buffer)));
                cbDevList->Items->Add(gcnew String(reinterpret_cast<wchar_t*>(buffer)));
            }
 
            ch = 0; k = 0;
            // берем каждое HID устройство из списка
            for (ch = 0; SetupDiEnumDeviceInfo(PnPHandle_HID, k, &DeviceInfoData); k++)
            {
                buffer = 0;
                buffersize = 0;
                // и читаем его свойства в буфер
                while (!SetupDiGetDeviceRegistryProperty(
                    PnPHandle_HID,
                    &DeviceInfoData,
                    SPDRP_DEVICEDESC,
                    NULL,
                    buffer,
                    buffersize,
                    &buffersize))
                {
                    if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
                    {
                        if (buffer) LocalFree(buffer);
                        buffer = (PBYTE)LocalAlloc(LPTR, buffersize * 2);
                    }
                    else break;
                }
                ch++;
                // Вывод HID идентифицированных устройств в DevTree
                // Заполняем дочерние элементы первого узла дерева Node[0]
                DevTree->Nodes[1]->Nodes->Add(gcnew String(reinterpret_cast<wchar_t*>(buffer)));
                cbDevList->Items->Add(gcnew String(reinterpret_cast<wchar_t*>(buffer)));
            }
 
            SetupDiDestroyDeviceInfoList(PnPHandle_USB);
            SetupDiDestroyDeviceInfoList(PnPHandle_HID);
}

unsigned long error;
 
bool GetAccessToUSB(HDEVINFO hDevInfo, GUID &interfaceGuid, int index, WCHAR* DevPath){
    SP_DEVICE_INTERFACE_DATA            DeviceInterfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA    DeviceInterfaceDetailData;
    SP_DEVINFO_DATA                     DevInfo;
    ULONG                               requiredSize;
    bool                                bReturn;
 
    //PSP_DEVICE_INTERFACE_DATA DevInfoData = (PSP_DEVICE_INTERFACE_DATA)malloc(sizeof(SP_DEVICE_INTERFACE_DATA));
    DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
    if (SetupDiEnumDeviceInterfaces(hDevInfo, 0, &interfaceGuid, index, &DeviceInterfaceData))
    {
        bReturn = SetupDiGetDeviceInterfaceDetail(hDevInfo,
            &DeviceInterfaceData,
            NULL,
            0,
            &requiredSize,
            NULL
            );
        DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(requiredSize);
        DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
        DevInfo.cbSize = sizeof(SP_DEVINFO_DATA);
        bReturn = SetupDiGetDeviceInterfaceDetail(hDevInfo,
            &DeviceInterfaceData,
            DeviceInterfaceDetailData,
            requiredSize,
            &requiredSize,
            0);
        if (!bReturn)
        {
            error = GetLastError();
            LocalFree(DeviceInterfaceDetailData);
            return false;
        }
        else
        {
            DevPath = DeviceInterfaceDetailData->DevicePath;
            LocalFree(DeviceInterfaceDetailData);
        }
    }
    else
       {
                error = GetLastError();
        if (error == ERROR_NO_MORE_ITEMS)
            MessageBox::Show("No more interfaces.", "WTF???");
        else
             Exception("SetupDiEnumDeviceInterfaces failed with error: " + error);
        return false;
 
    return true;
}

// Библиотека для работы с Hid. Написана с применением шаблонов.
// Она с помощью WINAPI функции LoadLibrary подгружает hid.dll,
// затем GetProcAddress - вычисляет адреса функций внутри hid.dll.
// Предоставляет удобный и простый интерфейс для работы с HID.
// Нашел на [url]http://speleoastronomy.org/elektro/atmega/usingusb.html[/url]
// Дописал функцию IsConnectedDevice()
 
const char idstring[] = "vid_046D&pid_C219";
 
#include <windows.h>
#include <setupapi.h>
#include <string>
#include <vector>
#include <map>
 
typedef void (WINAPI* t_HidD_GetHidGuid)( OUT LPGUID );
typedef BOOLEAN (WINAPI* t_HidD_GetManufacturerString)(IN HANDLE, OUT PVOID, IN ULONG);
typedef BOOLEAN (WINAPI* t_HidD_GetProductString)(IN HANDLE, OUT PVOID, IN ULONG);
typedef BOOLEAN (WINAPI* t_HidD_GetFeature)(IN HANDLE, OUT PVOID, IN ULONG);
typedef BOOLEAN (WINAPI* t_HidD_SetFeature)(IN HANDLE, IN PVOID, IN ULONG);
 
using namespace std;
 
template <typename T> class HIDLibrary
{
protected:
    static const int datasize = sizeof(T);
    T data;
    char pad[16];
    GUID m_hidguid;
    HINSTANCE hDLL; 
    t_HidD_GetHidGuid HidD_GetHidGuid;
    t_HidD_GetManufacturerString HidD_GetManufacturerString;
    t_HidD_GetProductString HidD_GetProductString;
    t_HidD_GetFeature HidD_GetFeature;
    t_HidD_SetFeature HidD_SetFeature;
    vector<string> m_HIDPaths;
    map<string,string> m_HIDDeviceIdents;
    //string GetDevicePath(HDEVINFO hInfoSet, PSP_DEVICE_INTERFACE_DATA oInterface);
    string m_ConnectedDevice;
public:
    HIDLibrary();
    bool IsAvailableLib();
    int EnumerateHIDDevices();
    bool Connect(unsigned int device=0);
    string GetDevicePath(HDEVINFO hInfoSet, PSP_DEVICE_INTERFACE_DATA oInterface);
    string GetConnectedDevicePath(){return m_ConnectedDevice;};
    string GetConnectedDeviceName(){return m_HIDDeviceIdents[m_ConnectedDevice];};
    string GetDeviceCount() { return m_HIDPaths.size(); };
    string GetDeviceName(int i){
                                    if(i<m_HIDPaths.size()) 
                                        return m_HIDDeviceIdents[m_HIDPaths[i]]; 
                                    else 
                                        return string.empty;
                                }
    int SendData(T* data);
    int ReceiveData(T* data);
    int IsConnectedDevice();
};
 
template< typename T > HIDLibrary< T >::HIDLibrary()
{
        hDLL = LoadLibrary(L"HID.DLL");
        if(hDLL != NULL)
        {
           HidD_GetHidGuid = (t_HidD_GetHidGuid)GetProcAddress(hDLL, "HidD_GetHidGuid");
           HidD_GetManufacturerString = (t_HidD_GetManufacturerString)GetProcAddress(hDLL, "HidD_GetManufacturerString");
           HidD_GetProductString = (t_HidD_GetProductString) GetProcAddress(hDLL, "HidD_GetProductString");
           HidD_GetFeature = (t_HidD_GetFeature) GetProcAddress(hDLL, "HidD_GetFeature");
           HidD_SetFeature = (t_HidD_SetFeature) GetProcAddress(hDLL, "HidD_SetFeature");
           if(HidD_GetHidGuid)
           {
              HidD_GetHidGuid(&m_hidguid);
           }
        }
}
 
template< typename T > bool HIDLibrary< T >::IsAvailableLib()
{
    return  !(hDLL == NULL || HidD_GetHidGuid == NULL || HidD_GetManufacturerString == NULL ||
            HidD_GetProductString == NULL || HidD_GetFeature == NULL || HidD_SetFeature == NULL);
}
 
template<typename T> string HIDLibrary<T>::GetDevicePath(HDEVINFO hInfoSet, PSP_DEVICE_INTERFACE_DATA oInterface)
{
        char vpath [1000];
        vpath[0]=0;
        DWORD nRequiredSize = 0;
        // Get the device interface details
        if (!SetupDiGetDeviceInterfaceDetail(hInfoSet, oInterface, 0, 0, &nRequiredSize, 0))
        {
            PSP_DEVICE_INTERFACE_DETAIL_DATA oDetail = (PSP_DEVICE_INTERFACE_DETAIL_DATA)malloc(nRequiredSize);
            oDetail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);  
            if (SetupDiGetDeviceInterfaceDetail(hInfoSet, oInterface, oDetail, nRequiredSize, &nRequiredSize, 0))
            {
                string s((char*)oDetail->DevicePath);
                free(oDetail);
                return s;
            }
        }
        return "";
}
 
template<typename T> int HIDLibrary<T>::EnumerateHIDDevices()
{
        wchar_t buffer[1000];
        char s1[1000];
        m_HIDPaths.clear();
        int nIndex = 0;
        HDEVINFO hInfoSet = SetupDiGetClassDevs(&m_hidguid,0,0,DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
        SP_DEVICE_INTERFACE_DATA spd;
        spd.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
        while (SetupDiEnumDeviceInterfaces(hInfoSet, 0, &m_hidguid, nIndex, &spd))
        {
            string path = GetDevicePath(hInfoSet, &spd);    
            if(path.find(idstring)!= string::npos)
            {
                HANDLE h = CreateFileA(path.c_str(),GENERIC_READ,0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0);
                if(h != INVALID_HANDLE_VALUE)
                {
                    HidD_GetManufacturerString(h,buffer,500);
                    wcstombs(s1,buffer, 1000);
                    if(strlen(s1)>2)
                    {
                        strcat(s1," ");
                        HidD_GetProductString(h,buffer,500);
                        wcstombs(s1+strlen(s1),buffer, 1000);
                    }
                    CloseHandle(h);
                }
                else
                    strcpy(s1,"Unknown device");
                string name(s1);
                m_HIDDeviceIdents[path]=s1;
                m_HIDPaths.push_back(path);
            }
            nIndex++;
        }
        SetupDiDestroyDeviceInfoList(hInfoSet);
        return nIndex;
}
 
template<typename T> bool HIDLibrary<T>::Connect(unsigned int device)
{
    if(m_HIDPaths.size() < device+1)
    {
        EnumerateHIDDevices();
        if(m_HIDPaths.size() < device+1) return false;
    }
    m_ConnectedDevice = m_HIDPaths[device];
    return true;
}
 
template<typename T> int HIDLibrary<T>::SendData(T* data)
{
   char vpath[datasize+16];
   vpath[0]=0;
   int len=datasize+1;
   HANDLE h = CreateFileA(m_ConnectedDevice.c_str(),GENERIC_READ,0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0);
   if(h != INVALID_HANDLE_VALUE)
   {
        memcpy(vpath+1,data,datasize);
        int err = HidD_SetFeature(h, vpath , len);
        CloseHandle(h);
        return err;
   }
   else
        return 0;
}
 
template<typename T> int HIDLibrary<T>::ReceiveData(T* data)
{
    char vpath[datasize+16];
    memset(vpath,0,sizeof(vpath));
    int len=datasize+1;
    HANDLE h = CreateFileA(m_ConnectedDevice.c_str(),GENERIC_READ,0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0);
   if(h != INVALID_HANDLE_VALUE)
   {
        int err = HidD_GetFeature(h, vpath , len);
        memcpy(data,vpath+1,datasize);
        CloseHandle(h);
        return err;
   }
   else
        return 0;
}
 
template<typename T> int HIDLibrary<T>::IsConnectedDevice()
{
   HANDLE h = CreateFileA(m_ConnectedDevice.c_str(),GENERIC_READ,0,0,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,0);
   if(h != INVALID_HANDLE_VALUE)
   {
        CloseHandle(h);
        return 1;
   }
   else
        return 0;
}

typedef unsigned char uchar;
 
struct dataexchange_t           // Описание структуры для передачи данных
{
    uchar  b1;        
    uchar  b2;        
    uchar  b3;    
    uchar  b4;
    uchar  b5;
    uchar  b6;
    uchar  b7;
    uchar  b8;
    uchar  b9;
    uchar  b10;
    uchar  b11;
    uchar  b12;
    uchar  b13;
    uchar  b14;
    uchar  b15;
    uchar  b16;
};
 
struct dataexchange_t pdata = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
HIDLibrary <dataexchange_t> hid; // создаем экземпляр класса с типом нашей структуры
 
System::String^ GetPath()
{
    // Получаем путь выбранного устройства
    HDEVINFO hInfoSet = SetupDiGetClassDevs(&GuidDevInterfaceHID, 0, 0, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
    SP_DEVICE_INTERFACE_DATA spd;
    spd.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
    SetupDiEnumDeviceInterfaces(hInfoSet, 0, &GuidDevInterfaceHID, NodeIndex, &spd);
    String^ path = gcnew System::String(hid.GetDevicePath(hInfoSet, &spd).c_str());       // получаем путь
    MessageBox::Show(path, "Debug string");
    return path;
}

String^ path = marshal_as<String^>(hid.GetDevicePath(hInfoSet, &spd));