descriptors.cpp

這個程式把主機所有設備的描述元列舉出來﹐包括所有標准描述元和非標准描述元。

// Descriptors.cpp: implementation of the CDescriptors class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Desc.h"
#include "Descriptors.h"
#include <winioctl.h>
#include "cfgmgr32.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define _MaxChar 600
#define _MaxNoOfHostController 10

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDescriptors::CDescriptors()
{

}

CDescriptors::~CDescriptors()
{

}

void CDescriptors::Enum(CEdit* pEd)
{
	for(long n=0; n<_MaxNoOfHostController; n++)
	{
		HANDLE hHC = GetHostController(n);
		if(hHC!=INVALID_HANDLE_VALUE)
		{
			CString strRH;
			if(GetRootHubName(strRH, hHC))
			{
				Show(pEd, "RootHub", strRH);
				Show(pEd, "", "");
				HANDLE hRH = GetHub(strRH);
				if(hRH!=INVALID_HANDLE_VALUE)
				{
					EnumHub(hRH, pEd);
					CloseHandle(hRH);
				}
			}
			CloseHandle(hHC);
		}
	}
}

void CDescriptors::EnumHub(HANDLE hHub, CEdit* pEd)
{
	long nPort = GetNoOfPort(hHub);
	for(long n=1; n<nPort+1; n++)
	{
        USB_NODE_CONNECTION_INFORMATION* pInfo = 
			(USB_NODE_CONNECTION_INFORMATION*)malloc(
			sizeof(USB_NODE_CONNECTION_INFORMATION) +
			sizeof(USB_PIPE_INFO) * 30);

		if(!GetPortConnInfo(pInfo, hHub, n))
		{
			free(pInfo);
			continue;
		}
        if(pInfo->ConnectionStatus==DeviceConnected)
		{
			Show(pEd, "ConnectionIndex", pInfo->ConnectionIndex);
			Show(pEd, "CurrentConfigurationValue", pInfo->CurrentConfigurationValue);
			Show(pEd, "LowSpeed", pInfo->LowSpeed);
			Show(pEd, "DeviceIsHub", pInfo->DeviceIsHub);
			Show(pEd, "DeviceAddress", pInfo->DeviceAddress);
			Show(pEd, "NumberOfOpenPipes", pInfo->NumberOfOpenPipes);
			Show(pEd, "ConnectionStatus", pInfo->ConnectionStatus);

			USB_DESCRIPTOR_REQUEST* pRequest = GetDeviceDesc(hHub, n);
			if(!pRequest)
			{
				free(pInfo);
				continue;
			}
			Show(pEd, (USB_DEVICE_DESCRIPTOR*)pRequest->Data);
			free(pRequest);

			pRequest = GetConfigDesc(hHub, n, 0);
			if(!pRequest)
			{
				free(pInfo);
				continue;
			}
			USB_CONFIGURATION_DESCRIPTOR* pCD = (USB_CONFIGURATION_DESCRIPTOR*)(pRequest + 1);
			EnumAllDesc(pEd, pCD);
			if(IsStringDescExist(&pInfo->DeviceDescriptor, pCD))
				EnumAllStringDescriptors(pEd, hHub, n, &pInfo->DeviceDescriptor, pCD);

			Show(pEd, "", "");

			free(pRequest);
			if(pInfo->DeviceIsHub) 
			{
				CString strExtHub;
				if(GetExternalHubName(strExtHub, hHub, n))
				{
					HANDLE hExtHub = GetHub(strExtHub);
					if(hExtHub!=INVALID_HANDLE_VALUE) EnumHub(hExtHub, pEd);

					CloseHandle(hExtHub);
				}
			}
		}
		free(pInfo);
	}
}

void CDescriptors::EnumAllDesc(CEdit *pEd, USB_CONFIGURATION_DESCRIPTOR *pCD)
{
    PUCHAR pEnd = (PUCHAR)pCD + pCD->wTotalLength;
    USB_COMMON_DESCRIPTOR* pCurDesc = (USB_COMMON_DESCRIPTOR*)pCD;

    while((PUCHAR)pCurDesc + sizeof(USB_COMMON_DESCRIPTOR)<pEnd &&
          (PUCHAR)pCurDesc + pCurDesc->bLength <= pEnd)
    {
        switch(pCurDesc->bDescriptorType)
        {
			case USB_CONFIGURATION_DESCRIPTOR_TYPE:
				if(pCurDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR))
					return;
				Show(pEd, (USB_CONFIGURATION_DESCRIPTOR*)pCurDesc);
                break;

            case USB_INTERFACE_DESCRIPTOR_TYPE:
                if(pCurDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR))
					return;
				Show(pEd, (USB_INTERFACE_DESCRIPTOR*)pCurDesc);
                break;

            case USB_ENDPOINT_DESCRIPTOR_TYPE:
                if(pCurDesc->bLength != sizeof(USB_ENDPOINT_DESCRIPTOR))
					return;
				Show(pEd, (USB_ENDPOINT_DESCRIPTOR*)pCurDesc);
                break;

            default:
				Show(pEd, "Non-Standard - bLength", pCurDesc->bLength);
				Show(pEd, "Non-Standard - bDescriptorType", pCurDesc->bDescriptorType);
				break;
        }
		pCurDesc = (USB_COMMON_DESCRIPTOR*)((PUCHAR)(pCurDesc) + pCurDesc->bLength);
    }
}

void CDescriptors::EnumAllStringDescriptors(CEdit* pEd, HANDLE hHub, ULONG nPort, 
											USB_DEVICE_DESCRIPTOR *pDD, 
											USB_CONFIGURATION_DESCRIPTOR *pCD)
{
	//Get String0 of LangIDs
	USB_DESCRIPTOR_REQUEST* pRequest = GetStringDesc(hHub, nPort, 0, 0);
    if(!pRequest) return;
	USHORT nLangID = ((USB_STRING_DESCRIPTOR*)pRequest->Data)->bString[0];
	free(pRequest);

	//Enum the 1st LangID only!
	if(pDD->iManufacturer)
	{
		if(!(pRequest = GetStringDesc(hHub, nPort, pDD->iManufacturer, nLangID)))
			return;
		Show(pEd, "iManufacturer", (USB_STRING_DESCRIPTOR*)pRequest->Data);
		free(pRequest);
	}

	if(pDD->iProduct)
	{
		if(!(pRequest = GetStringDesc(hHub, nPort, pDD->iProduct, nLangID)))
			return;
		Show(pEd, "iProduct", (USB_STRING_DESCRIPTOR*)pRequest->Data);
		free(pRequest);
	}

	if(pDD->iSerialNumber)
	{
		if(!(pRequest = GetStringDesc(hHub, nPort, pDD->iSerialNumber, nLangID)))
			return;
		Show(pEd, "iSerialNumber", (USB_STRING_DESCRIPTOR*)pRequest->Data);
		free(pRequest);
	}

	pRequest = NULL;
    PUCHAR pEnd = (PUCHAR)pCD + pCD->wTotalLength;
    USB_COMMON_DESCRIPTOR* pCurDesc = (USB_COMMON_DESCRIPTOR*)pCD;

    while((PUCHAR)pCurDesc + sizeof(USB_COMMON_DESCRIPTOR)<pEnd &&
          (PUCHAR)pCurDesc + pCurDesc->bLength <= pEnd)
    {
        switch(pCurDesc->bDescriptorType)
        {
			case USB_CONFIGURATION_DESCRIPTOR_TYPE:
                if(pCurDesc->bLength != sizeof(USB_CONFIGURATION_DESCRIPTOR))
					return;
                if(((USB_CONFIGURATION_DESCRIPTOR*)pCurDesc)->iConfiguration)
 					pRequest = GetStringDesc(hHub, nPort, 
								   ((USB_CONFIGURATION_DESCRIPTOR*)pCurDesc)->iConfiguration,
								   nLangID);
				if(!pRequest) return;
				Show(pEd, "iConfiguration", (USB_STRING_DESCRIPTOR*)pRequest->Data);
				free(pRequest);
				pRequest = NULL;
                break;

            case USB_INTERFACE_DESCRIPTOR_TYPE:
                if(pCurDesc->bLength != sizeof(USB_INTERFACE_DESCRIPTOR))
					return;
                if(((USB_INTERFACE_DESCRIPTOR*)pCurDesc)->iInterface)
					pRequest = GetStringDesc(hHub, nPort, 
								   ((USB_INTERFACE_DESCRIPTOR*)pCurDesc)->iInterface,
								   nLangID);
				Show(pEd, "iInterface", (USB_STRING_DESCRIPTOR*)pRequest->Data);
				free(pRequest);
				pRequest = NULL;
                break;

            default: break;
        }
		pCurDesc = (USB_COMMON_DESCRIPTOR*)((PUCHAR)(pCurDesc) + pCurDesc->bLength);
    }
}

CString CDescriptors::ToString(WCHAR *pUnicode)
{
	char c[_MaxChar];
	wcstombs(c, pUnicode, _MaxChar);
	return CString(c);
}

void CDescriptors::Show(CEdit* pEd, CString str, long n)
{
	CString strN;
	strN.Format("%d", n);
	pEd->ReplaceSel(str + ":" + strN + "\r\n");
}

void CDescriptors::Show(CEdit* pEd, CString str, CString s)
{
	pEd->ReplaceSel(str + ":" + s + "\r\n");
}

void CDescriptors::Show(CEdit *pEd, USB_DEVICE_DESCRIPTOR *pDD)
{
	Show(pEd, "", "");
	Show(pEd, "Device Descriptor", "");
	Show(pEd, "bLength", pDD->bLength);
    Show(pEd, "bDescriptorType", pDD->bDescriptorType);
    Show(pEd, "bcdUSB", pDD->bcdUSB);
    Show(pEd, "bDeviceClass", pDD->bDeviceClass);
    Show(pEd, "bDeviceSubClass", pDD->bDeviceSubClass);
    Show(pEd, "bDeviceProtocol", pDD->bDeviceProtocol);
    Show(pEd, "bMaxPacketSize0", pDD->bMaxPacketSize0);
    Show(pEd, "idVendor", pDD->idVendor);
    Show(pEd, "idProduct", pDD->idProduct);
    Show(pEd, "bcdDevice", pDD->bcdDevice);
    Show(pEd, "iManufacturer", pDD->iManufacturer);
    Show(pEd, "iProduct", pDD->iProduct);
    Show(pEd, "iSerialNumber", pDD->iSerialNumber);
    Show(pEd, "bNumConfigurations", pDD->bNumConfigurations);
	Show(pEd, "", "");
}

void CDescriptors::Show(CEdit *pEd, USB_CONFIGURATION_DESCRIPTOR *pCD)
{
	Show(pEd, "", "");
	Show(pEd, "Config Descriptor", "");
	Show(pEd, "bLength", pCD->bLength);
    Show(pEd, "bDescriptorType", pCD->bDescriptorType);