网站首页
这些小活动你都参加了吗？快来围观一下吧！>>
电子产品世界 » 论坛首页 » 嵌入式开发 » STM32 » 枚举所有USB设备代码

共1条 1/1 1 跳转至页

枚举所有USB设备代码

lin35162
高工
2017-12-22 15:30:47     打赏
枚举所有连接的USB设备代码，编译环境VS2010

  1. // ls_usb.cpp : Defines the entry point for the console application.  

  2. #include "stdafx.h"  

  3. #include   

  4. #include   

  5. #include   

  6. #include   

  7. #include   

  8. #include   

  9. #include   

  10. #include   

  11. #include "usb100.h"  

  12. #include "usbdesc.h"  

  13. #include "usbioctl.h"  

  14. #include "usbiodef.h"  

  15.   

  16. #define MAX_HCD 10  

  17.   

  18. typedef struct _STRING_DESCRIPTOR_NODE  

  19. {  

  20.     struct _STRING_DESCRIPTOR_NODE *Next;  

  21.     UCHAR                           DescriptorIndex;  

  22.     USHORT                          LanguageID;  

  23.     USB_STRING_DESCRIPTOR           StringDescriptor[0];  

  24. } STRING_DESCRIPTOR_NODE, *PSTRING_DESCRIPTOR_NODE;  

  25.   

  26. /******************************************************************/  

  27. PCHAR GetDriverKeyName(HANDLE Hub, ULONG ConnectionIndex);  

  28. PCHAR GetHCDDriverKeyName(HANDLE HCD);  

  29. PCHAR GetRootHubName(HANDLE HostController);  

  30. PCHAR WideStrToMultiStr(PWCHAR WideStr);  

  31. bool GetStringDescriptor (HANDLE hHubDevice, ULONG ConnectionIndex, UCHAR DescriptorIndex, CHAR * outBuff);  

  32. PCHAR GetExternalHubName(HANDLE Hub,ULONG ConnectionIndex);  

  33. bool EnumerateHostControllers();  

  34. void EnumerateHub(PCHAR HubName, PCHAR Msg);  

  35. void EnumerateHubPorts(HANDLE hHubDevice,ULONG NumPorts);  

  36. PUSB_DESCRIPTOR_REQUEST GetConfigDescriptor(HANDLE  hHubDevice, ULONG ConnectionIndex, UCHAR DescriptorIndex);  

  37. BOOL AreThereStringDescriptors(PUSB_DEVICE_DESCRIPTOR DeviceDesc,PUSB_CONFIGURATION_DESCRIPTOR ConfigDesc);  

  38. /******************************************************************/  

  39.   

  40. void EnumerateHubPorts(HANDLE hHubDevice,ULONG NumPorts)  

  41. {  

  42.     ULONG       index;  

  43.     BOOL        success;  

  44.     PUSB_NODE_CONNECTION_INFORMATION    connectionInfo;  

  45.     //PUSB_DESCRIPTOR_REQUEST             configDesc;  

  46.   

  47.     //list ports of root hub  

  48.      unsigned int port;  

  49.      port=NumPorts;  

  50.      for (index=1; index <= port; index++)  

  51.      {  

  52.          ULONG nBytes;  

  53.          nBytes = sizeof(USB_NODE_CONNECTION_INFORMATION) + sizeof(USB_PIPE_INFO) * 30;  

  54.          connectionInfo = (PUSB_NODE_CONNECTION_INFORMATION)malloc(nBytes);  

  55.          if (connectionInfo == NULL)  

  56.              goto end;  

  57.           

  58.          connectionInfo->ConnectionIndex = index;  

  59.          success = DeviceIoControl(hHubDevice, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION, connectionInfo, nBytes, connectionInfo, nBytes, &nBytes, NULL);  

  60.          if (!success)  

  61.          {  

  62.              free(connectionInfo);  

  63.              goto end;  

  64.          }  

  65.       

  66.          if (connectionInfo->ConnectionStatus == DeviceConnected)  

  67.          {  

  68.   

  69.             //configDesc = GetConfigDescriptor(hHubDevice, index, 0);  

  70.   

  71.              if (connectionInfo->DeviceIsHub){  

  72.                 PCHAR extHubName;  

  73.                 extHubName = GetExternalHubName(hHubDevice,index);  

  74.                 if (extHubName != NULL){  

  75.                     EnumerateHub(extHubName," - External Hub");  

  76.                     //continue;  

  77.                 }  

  78.              }  

  79.   

  80.             UCHAR nProduct = connectionInfo->DeviceDescriptor.iProduct;  

  81.             UCHAR nManuf = connectionInfo->DeviceDescriptor.iManufacturer;  

  82.             CHAR OutBuffPro[20] = {0};  

  83.             CHAR OutBuffMan[20] = {0};  

  84.             GetStringDescriptor(hHubDevice, connectionInfo->ConnectionIndex, nProduct, OutBuffPro);  

  85.             GetStringDescriptor(hHubDevice, connectionInfo->ConnectionIndex, nManuf, OutBuffMan);  

  86.             printf("\n\t[PORT%d]: %04X:%04X\t%04X\t%s - %s", index, connectionInfo->DeviceDescriptor.idVendor, connectionInfo->DeviceDescriptor.idProduct,  

  87.                 connectionInfo->DeviceDescriptor.bcdUSB, OutBuffMan, OutBuffPro);  

  88.          }  

  89.   

  90.     }  

  91.   

  92. end:      

  93.     CloseHandle(hHubDevice);  

  94. }  

  95.   

  96. void EnumerateHub(PCHAR rootHubName, PCHAR Msg)  

  97. {  

  98.     ULONG   index;  

  99.     BOOL    success;  

  100.   

  101.     PUSB_NODE_CONNECTION_INFORMATION    connectionInfo;  

  102.     HANDLE hHubDevice;  

  103.   

  104.     PCHAR driverKeyName, deviceDesc;  

  105.       

  106.     ULONG nBytes;  

  107.   

  108.     PUSB_NODE_INFORMATION HubInfo;  

  109.     HubInfo = (PUSB_NODE_INFORMATION)malloc(sizeof(USB_NODE_INFORMATION));  

  110.       

  111.     PCHAR deviceName;  

  112.     deviceName = (PCHAR)malloc(strlen(rootHubName) + sizeof("\\\\.\\"));  

  113.     if (rootHubName != NULL)  

  114.     {  

  115.         strcpy(deviceName, "\\\\.\\");  

  116.         strcpy(deviceName + sizeof("\\\\.\\") - 1, rootHubName);  

  117.           

  118.         printf("\n%s: %s", Msg, deviceName);  

  119.           

  120.         hHubDevice = CreateFileA(deviceName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);  

  121.         if (hHubDevice == INVALID_HANDLE_VALUE){  

  122.             printf("\nCreateFile");  

  123.             exit(1);  

  124.         }  

  125.   

  126.         free(deviceName);  

  127.       

  128.         success = DeviceIoControl(hHubDevice, IOCTL_USB_GET_NODE_INFORMATION, HubInfo, sizeof(USB_NODE_INFORMATION), HubInfo, sizeof(USB_NODE_INFORMATION), &nBytes, NULL);  

  129.         if (!success){  

  130.             printf("\nDeviceIoControl");  

  131.             exit(1);  

  132.         }  

  133.     }  

  134.       

  135.     // noew emuerate all ports   

  136.     EnumerateHubPorts(hHubDevice, HubInfo->u.HubInformation.HubDescriptor.bNumberOfPorts);  

  137.   

  138. }  

  139.   

  140. bool EnumerateHostControllers()  

  141. {  

  142.     WCHAR       HCName[16];  

  143.     HANDLE      hHCDev;  

  144.     int         HCNum;  

  145.     PCHAR       driverKeyName;  

  146.     PCHAR       deviceDesc;  

  147.     PCHAR       rootHubName;  

  148.   

  149.     for (HCNum = 0; HCNum < MAX_HCD; HCNum++){  

  150.         wsprintf(HCName, _T("\\\\.\\HCD%d"), HCNum);  

  151.         hHCDev = CreateFile(HCName, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);  

  152.         if (hHCDev == INVALID_HANDLE_VALUE){  

  153.             return false;  

  154.         }  

  155.   

  156.         driverKeyName = GetHCDDriverKeyName(hHCDev);  

  157.         if (driverKeyName)  

  158.         {  

  159.             rootHubName=GetRootHubName(hHCDev);  

  160.             if(rootHubName!=NULL)  

  161.             {  

  162.                 EnumerateHub(rootHubName, "Root Hub");  

  163.             }else{  

  164.                 CloseHandle(hHCDev);  

  165.                 return false;  

  166.             }  

  167.         }else{  

  168.             CloseHandle(hHCDev);  

  169.             return false;  

  170.         }  

  171.   

  172.         CloseHandle(hHCDev);  

  173.     }  

  174.   

  175.     return true;  

  176. }  

  177.   

  178. PCHAR GetExternalHubName(HANDLE Hub,ULONG ConnectionIndex)  

  179. {  

  180.     BOOL                        success;  

  181.     ULONG                       nBytes;  

  182.     USB_NODE_CONNECTION_NAME    extHubName;  

  183.     PUSB_NODE_CONNECTION_NAME   extHubNameW;  

  184.     PCHAR                       extHubNameA;  

  185.       

  186.     extHubNameW = NULL;  

  187.     extHubNameA = NULL;  

  188.   

  189.     extHubName.ConnectionIndex = ConnectionIndex;  

  190.     success = DeviceIoControl(Hub, IOCTL_USB_GET_NODE_CONNECTION_NAME, &extHubName, sizeof(extHubName), &extHubName, sizeof(extHubName), &nBytes,NULL);  

  191.     if (!success)  

  192.         goto GetExternalHubNameError;  

  193.       

  194.   

  195.     nBytes = extHubName.ActualLength;  

  196.     if (nBytes <= sizeof(extHubName))  

  197.         goto GetExternalHubNameError;  

  198.       

  199.     extHubNameW=(PUSB_NODE_CONNECTION_NAME)GlobalAlloc(GPTR,nBytes);  

  200.     if (extHubNameW == NULL)  

  201.         goto GetExternalHubNameError;  

  202.   

  203.     extHubNameW->ConnectionIndex = ConnectionIndex;  

  204.     success = DeviceIoControl(Hub, IOCTL_USB_GET_NODE_CONNECTION_NAME, extHubNameW, nBytes, extHubNameW, nBytes, &nBytes, NULL);  

  205.     if (!success)  

  206.         goto GetExternalHubNameError;  

  207.       

  208.   

  209.     extHubNameA = WideStrToMultiStr(extHubNameW->NodeName);  

  210.       

  211.     GlobalFree(extHubNameW);  

  212.   

  213.     return extHubNameA;  

  214.       

  215. GetExternalHubNameError:  

  216.     if (extHubNameW != NULL)  

  217.     {  

  218.         GlobalFree(extHubNameW);  

  219.         extHubNameW = NULL;  

  220.     }  

  221.       

  222.     return NULL;  

  223. }  

  224.   

  225. int main(int argc, char* argv[])  

  226. {  

  227.     EnumerateHostControllers();  

  228.     getchar();  

  229.     return 0;  

  230. }  

  231.   

  232. PCHAR GetDriverKeyName(HANDLE Hub, ULONG ConnectionIndex)  

  233. {  

  234.     BOOL                                success;  

  235.     ULONG                               nBytes;  

  236.     USB_NODE_CONNECTION_DRIVERKEY_NAME  driverKeyName;  

  237.     PUSB_NODE_CONNECTION_DRIVERKEY_NAME driverKeyNameW;  

  238.     PCHAR                               driverKeyNameA;  

  239.       

  240.     driverKeyNameW = NULL;  

  241.     driverKeyNameA = NULL;  

  242.       

  243.     driverKeyName.ConnectionIndex = ConnectionIndex;  

  244.       

  245.     success = DeviceIoControl(Hub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, &driverKeyName, sizeof(driverKeyName),  &driverKeyName, sizeof(driverKeyName), &nBytes, NULL);  

  246.     if (!success)  

  247.     {  

  248.         goto GetDriverKeyNameError;  

  249.     }  

  250.       

  251.     nBytes = driverKeyName.ActualLength;  

  252.     if (nBytes <= sizeof(driverKeyName))  

  253.     {  

  254.         goto GetDriverKeyNameError;  

  255.     }  

  256.       

  257.     driverKeyNameW = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)malloc(nBytes);  

  258.     if (driverKeyNameW == NULL)  

  259.     {  

  260.         goto GetDriverKeyNameError;  

  261.     }  

  262.       

  263.     driverKeyNameW->ConnectionIndex = ConnectionIndex;  

  264.       

  265.     success = DeviceIoControl(Hub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, driverKeyNameW, nBytes, driverKeyNameW, nBytes, &nBytes, NULL);  

  266.     if (!success)  

  267.     {  

  268.         goto GetDriverKeyNameError;  

  269.     }  

  270.     driverKeyNameA = WideStrToMultiStr(driverKeyNameW->DriverKeyName);  

  271.     free(driverKeyNameW);  

  272.       

  273.     return driverKeyNameA;  

  274.   

  275. GetDriverKeyNameError:  

  276.     if (driverKeyNameW != NULL)  

  277.     {  

  278.         free(driverKeyNameW);  

  279.         driverKeyNameW = NULL;  

  280.     }  

  281.       

  282.     return NULL;  

  283. }  

  284.   

  285. PCHAR GetRootHubName(HANDLE HostController)  

  286. {  

  287.     BOOL                success;  

  288.     ULONG               nBytes;  

  289.     USB_ROOT_HUB_NAME   rootHubName;  

  290.     PUSB_ROOT_HUB_NAME  rootHubNameW;  

  291.     PCHAR               rootHubNameA;  

  292.       

  293.     rootHubNameW = NULL;  

  294.     rootHubNameA = NULL;  

  295.       

  296.     success = DeviceIoControl(HostController, IOCTL_USB_GET_ROOT_HUB_NAME, 0, 0, &rootHubName, sizeof(rootHubName), &nBytes, NULL);  

  297.     if (!success)  

  298.     {  

  299.         goto GetRootHubNameError;  

  300.     }  

  301.       

  302.     nBytes = rootHubName.ActualLength;  

  303.       

  304.     rootHubNameW =(PUSB_ROOT_HUB_NAME) malloc(nBytes);  

  305.     if (rootHubNameW == NULL)  

  306.     {  

  307.         goto GetRootHubNameError;  

  308.     }  

  309.       

  310.     success = DeviceIoControl(HostController, IOCTL_USB_GET_ROOT_HUB_NAME, NULL, 0, rootHubNameW, nBytes, &nBytes, NULL);  

  311.     if (!success)  

  312.     {  

  313.         goto GetRootHubNameError;  

  314.     }  

  315.       

  316.     rootHubNameA = WideStrToMultiStr(rootHubNameW->RootHubName);  

  317.   

  318.     free(rootHubNameW);  

  319.       

  320.     return rootHubNameA;  

  321.   

  322. GetRootHubNameError:  

  323.     if (rootHubNameW != NULL)  

  324.     {  

  325.         free(rootHubNameW);  

  326.         rootHubNameW = NULL;  

  327.     }  

  328.       

  329.     return NULL;  

  330. }  

  331. PCHAR GetHCDDriverKeyName(HANDLE HCD)  

  332. {  

  333.     BOOL                    success;  

  334.     ULONG                   nBytes;  

  335.     USB_HCD_DRIVERKEY_NAME driverKeyName;  

  336.     PUSB_HCD_DRIVERKEY_NAME driverKeyNameW;  

  337.     PCHAR                   driverKeyNameA;  

  338.       

  339.     driverKeyNameW = NULL;  

  340.     driverKeyNameA = NULL;  

  341.       

  342.     success = DeviceIoControl(HCD, IOCTL_GET_HCD_DRIVERKEY_NAME, &driverKeyName, sizeof(driverKeyName), &driverKeyName, sizeof(driverKeyName), &nBytes, NULL);  

  343.     if (!success)  

  344.     {  

  345.         goto GetHCDDriverKeyNameError;  

  346.     }  

  347.       

  348.     nBytes = driverKeyName.ActualLength;  

  349.     if (nBytes <= sizeof(driverKeyName))  

  350.     {  

  351.         goto GetHCDDriverKeyNameError;  

  352.     }  

  353.       

  354.     driverKeyNameW =(PUSB_HCD_DRIVERKEY_NAME) malloc(nBytes);  

  355.       

  356.     if (driverKeyNameW == NULL)  

  357.     {  

  358.         goto GetHCDDriverKeyNameError;  

  359.     }  

  360.       

  361.     success = DeviceIoControl(HCD, IOCTL_GET_HCD_DRIVERKEY_NAME, driverKeyNameW, nBytes, driverKeyNameW, nBytes, &nBytes, NULL);  

  362.     if (!success)  

  363.     {  

  364.         goto GetHCDDriverKeyNameError;  

  365.     }  

  366.       

  367.     driverKeyNameA = WideStrToMultiStr(driverKeyNameW->DriverKeyName);  

  368.     free(driverKeyNameW);  

  369.       

  370.     return driverKeyNameA;  

  371.   

  372. GetHCDDriverKeyNameError:  

  373.     if (driverKeyNameW != NULL)  

  374.     {  

  375.         free(driverKeyNameW);  

  376.         driverKeyNameW = NULL;  

  377.     }  

  378.       

  379.     return NULL;  

  380. }  

  381.   

  382. PCHAR WideStrToMultiStr(PWCHAR WideStr)  

  383. {  

  384.     ULONG nBytes;  

  385.     PCHAR MultiStr;  

  386.     nBytes = WideCharToMultiByte(CP_ACP, 0, WideStr, -1, NULL, 0, NULL, NULL);  

  387.     if (nBytes == 0)  

  388.     {  

  389.         return NULL;  

  390.     }  

  391.       

  392.     MultiStr =(PCHAR) malloc(nBytes);  

  393.     if (MultiStr == NULL)  

  394.     {  

  395.         return NULL;  

  396.     }  

  397.       

  398.     nBytes = WideCharToMultiByte(CP_ACP, 0, WideStr, -1, MultiStr, nBytes, NULL, NULL);  

  399.     if (nBytes == 0)  

  400.     {  

  401.         free(MultiStr);  

  402.         return NULL;  

  403.     }  

  404.       

  405.     return MultiStr;  

  406. }  

  407.   

  408. BOOL AreThereStringDescriptors(PUSB_DEVICE_DESCRIPTOR DeviceDesc,PUSB_CONFIGURATION_DESCRIPTOR ConfigDesc)  

  409. {  

  410.     PUCHAR                  descEnd;  

  411.     PUSB_COMMON_DESCRIPTOR  commonDesc;  

  412.       

  413.     // Check Device Descriptor strings  

  414.     if(DeviceDesc->iManufacturer||DeviceDesc->iProduct||DeviceDesc->iSerialNumber)  

  415.         return TRUE;  

  416.       

  417.     // Check the Configuration and Interface Descriptor strings  

  418.     descEnd = (PUCHAR)ConfigDesc + ConfigDesc->wTotalLength;  

  419.     commonDesc = (PUSB_COMMON_DESCRIPTOR)ConfigDesc;  

  420.       

  421.     while ((PUCHAR)commonDesc + sizeof(USB_COMMON_DESCRIPTOR) < descEnd &&  

  422.         (PUCHAR)commonDesc + commonDesc->bLength <= descEnd)  

  423.     {  

  424.         switch (commonDesc->bDescriptorType)  

  425.         {  

  426.         case USB_CONFIGURATION_DESCRIPTOR_TYPE:  

  427.             if (commonDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR))  

  428.                 break;  

  429.               

  430.             if (((PUSB_CONFIGURATION_DESCRIPTOR)commonDesc)->iConfiguration)  

  431.                 return TRUE;              

  432.             continue;  

  433.               

  434.         case USB_INTERFACE_DESCRIPTOR_TYPE:  

  435.             if (commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR) &&  

  436.                 commonDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR2))  

  437.                 break;            

  438.             if (((PUSB_INTERFACE_DESCRIPTOR)commonDesc)->iInterface)  

  439.                 return TRUE;  

  440.             continue;  

  441.               

  442.         default:  

  443.             continue;  

  444.         }  

  445.         break;  

  446.     }  

  447.       

  448.     return FALSE;  

  449. }  

  450.   

  451. PUSB_DESCRIPTOR_REQUEST GetConfigDescriptor(HANDLE  hHubDevice, ULONG ConnectionIndex, UCHAR DescriptorIndex)  

  452. {  

  453.     BOOL    success;  

  454.     ULONG   nBytes;  

  455.     ULONG   nBytesReturned;  

  456.     UCHAR   configDescReqBuf[sizeof(USB_DESCRIPTOR_REQUEST)+  

  457.         sizeof(USB_CONFIGURATION_DESCRIPTOR)];  

  458.   

  459.     PUSB_DESCRIPTOR_REQUEST         configDescReq;  

  460.     PUSB_CONFIGURATION_DESCRIPTOR   configDesc;  

  461.   

  462.     // Request the Configuration Descriptor the first time using our  

  463.     // local buffer, which is just big enough for the Cofiguration  

  464.     // Descriptor itself.  

  465.     nBytes = sizeof(configDescReqBuf);  

  466.     configDescReq = (PUSB_DESCRIPTOR_REQUEST)configDescReqBuf;  

  467.     configDesc = (PUSB_CONFIGURATION_DESCRIPTOR)(configDescReq+1);  

  468.     memset(configDescReq, 0, nBytes);  

  469.     //是此hub上的哪个port需要被request  

  470.     configDescReq->ConnectionIndex = ConnectionIndex;  

  471.   

  472.     // USBHUB uses URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE to process this  

  473.     // IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION request.  

  474.     // USBD will automatically initialize these fields:  

  475.     //     bmRequest = 0x80  

  476.     //     bRequest  = 0x06  

  477.     // We must inititialize these fields:  

  478.     //     wValue    = Descriptor Type (high) and Descriptor Index (low byte)  

  479.     //     wIndex    = Zero (or Language ID for String Descriptors)  

  480.     //     wLength   = Length of descriptor buffer  

  481.     configDescReq->SetupPacket.wValue=(USB_CONFIGURATION_DESCRIPTOR_TYPE<<8)  

  482.         |DescriptorIndex;  

  483.     configDescReq->SetupPacket.wLength=(USHORT)(nBytes-sizeof(USB_DESCRIPTOR_REQUEST));  

  484.   

  485.     success=DeviceIoControl(hHubDevice,  

  486.         IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,  

  487.         configDescReq,  

  488.         nBytes,  

  489.         configDescReq,  

  490.         nBytes,  

  491.         &nBytesReturned,  

  492.         NULL);  

  493.   

  494.     if(!success)  

  495.         return NULL;  

  496.   

  497.     if(nBytes!=nBytesReturned)  

  498.         return NULL;  

  499.   

  500.     if(configDesc->wTotalLengthwTotalLength;  

  501.     configDescReq=(PUSB_DESCRIPTOR_REQUEST)GlobalAlloc(GPTR,nBytes);  

  502.     if (configDescReq==NULL)  

  503.         return NULL;  

  504.   

  505.     configDesc = (PUSB_CONFIGURATION_DESCRIPTOR)(configDescReq+1);  

  506.     // Indicate the port from which the descriptor will be requested  

  507.     configDescReq->ConnectionIndex = ConnectionIndex;  

  508.   

  509.     // USBHUB uses URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE to process this  

  510.     // IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION request.  

  511.     // USBD will automatically initialize these fields:  

  512.     //     bmRequest = 0x80  

  513.     //     bRequest  = 0x06  

  514.     // We must inititialize these fields:  

  515.     //     wValue    = Descriptor Type (high) and Descriptor Index (low byte)  

  516.     //     wIndex    = Zero (or Language ID for String Descriptors)  

  517.     //     wLength   = Length of descriptor buffer  

  518.     configDescReq->SetupPacket.wValue=(USB_CONFIGURATION_DESCRIPTOR_TYPE<<8)  

  519.         |DescriptorIndex;  

  520.   

  521.     configDescReq->SetupPacket.wLength=(USHORT)(nBytes-sizeof(USB_DESCRIPTOR_REQUEST));  

  522.   

  523.     // Now issue the get descriptor request.  

  524.     success = DeviceIoControl(hHubDevice,  

  525.         IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,  

  526.         configDescReq,  

  527.         nBytes,  

  528.         configDescReq,  

  529.         nBytes,  

  530.         &nBytesReturned,  

  531.         NULL);  

  532.   

  533.     if(!success)  

  534.     {  

  535.         GlobalFree(configDescReq);  

  536.         return NULL;  

  537.     }  

  538.   

  539.     if(nBytes!=nBytesReturned)  

  540.     {  

  541.         GlobalFree(configDescReq);  

  542.         return NULL;  

  543.     }  

  544.   

  545.     if(configDesc->wTotalLength!=(nBytes-sizeof(USB_DESCRIPTOR_REQUEST)))  

  546.     {  

  547.         GlobalFree(configDescReq);  

  548.         return NULL;  

  549.     }  

  550.   

  551.     return configDescReq;  

  552. }  

  553.   

  554. bool GetStringDescriptor (HANDLE hHubDevice, ULONG ConnectionIndex,UCHAR DescriptorIndex, CHAR *outBuff)  

  555. {  

  556.     BOOL    success;  

  557.     ULONG   nBytes;  

  558.     ULONG   nBytesReturned;  

  559.       

  560.     UCHAR   stringDescReqBuf[sizeof(USB_DESCRIPTOR_REQUEST) + MAXIMUM_USB_STRING_LENGTH];  

  561.       

  562.     PUSB_DESCRIPTOR_REQUEST stringDescReq;  

  563.     PUSB_STRING_DESCRIPTOR stringDesc;  

  564.       

  565.     nBytes = sizeof(stringDescReqBuf);  

  566.       

  567.     stringDescReq = (PUSB_DESCRIPTOR_REQUEST)stringDescReqBuf;  

  568.     stringDesc = (PUSB_STRING_DESCRIPTOR)(stringDescReq+1);  

  569.       

  570.     ZeroMemory(stringDescReq,nBytes);  

  571.     stringDescReq->ConnectionIndex = ConnectionIndex;  

  572.     stringDescReq->SetupPacket.wValue = (USB_STRING_DESCRIPTOR_TYPE << 8) | DescriptorIndex;  

  573.     stringDescReq->SetupPacket.wIndex = GetSystemDefaultLangID();  

  574.     stringDescReq->SetupPacket.wLength = (USHORT)(nBytes - sizeof(USB_DESCRIPTOR_REQUEST));  

  575.       

  576.     success = DeviceIoControl(hHubDevice, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION, stringDescReq,nBytes, stringDescReq,nBytes, &nBytesReturned, NULL);  

  577.     if (!success || nBytesReturned < 2)  

  578.         return false;  

  579.       

  580.     if (stringDesc->bDescriptorType != USB_STRING_DESCRIPTOR_TYPE)  

  581.         return false;  

  582.       

  583.     if (stringDesc->bLength != nBytesReturned - sizeof(USB_DESCRIPTOR_REQUEST))  

  584.         return false;  

  585.       

  586.     if (stringDesc->bLength % 2 != 0)  

  587.         return false;  

  588.       

  589.     WCHAR * wChar = new WCHAR[stringDesc->bLength + 1];  

  590.   

  591.     memcpy(wChar,stringDesc->bString,stringDesc->bLength);  

  592.   

  593.     char *szTemp = WideStrToMultiStr(wChar);  

  594.   

  595.     lstrcpyA(outBuff, szTemp);  

  596.   

  597.     if(szTemp)  

  598.         delete []szTemp;  

  599.       

  600.     if(wChar)  

  601.         delete []wChar;  

  602.   

  603.     return true;  


回复
收藏
0


共1条 1/1 1 跳转至页

回复

匿名不能发帖！请先 [ 登陆 注册 ]