// UsbIdentify.cpp: implementation of the CUsbIdentify class.
//
//////////////////////////////////////////////////////////////////////

#include "afx.h"
#include "UsbIdentify.h"

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

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

CUsbIdentify::CUsbIdentify()
{
	m_Usbdev = NULL;
}

CUsbIdentify::~CUsbIdentify()
{
	if (m_Usbdev)
	{
		delete [] m_Usbdev;
		m_Usbdev = NULL;
	}
}

void CUsbIdentify::OutErrorMsg(LPCTSTR lpszMsg)
{
	MessageBox(m_hWnd, lpszMsg, "Results", MB_OK | MB_ICONEXCLAMATION);
//	SendMessage(m_hWnd, WM_REPORT, (WPARAM)lpszMsg, 0);
}


void CUsbIdentify::OnAddNewDevice(WPARAM wParam, LPARAM lParam)
{
	CString temp,temp1,szDesc;
	CONNECTED_DEVICE *pDev = (CONNECTED_DEVICE*)wParam;	
	
	//temp.Format("Device : %s\r\n", pDev->szDesc);
	//temp1 += temp;

	//temp.Format("Controller ID : %d(Self define)\r\n", pDev->dwControllerID);
 //temp1 += temp;

	temp.Format("Port ID : %d(Self define)\r\n", pDev->dwPortID);
	//temp1 += temp;
	temp.Format("VID=%04X ", pDev->idVendor);

	szDesc += temp;
//	temp1 += temp;
	temp.Format("PID=%04X ", pDev->idProduct);
	szDesc += temp;
//		temp.Format("name=%s ", pDev->szDesc);
//	temp1 += temp;
//	szDesc += temp;

	temp.Format("Manufacturer ID: 0x%02X\r\n", pDev->idManufacturer);

//	temp1 += temp;
	temp.Format("Speed=%04X", pDev->bcdUSB);
	szDesc += temp;
//	temp1 += temp;
	
//	temp.Format("USB speed : %02d\r\n(0->Full or Low Speed, =0 High-Speed)\r\n", pDev->speed);
//	szDesc += temp;
//	temp1 += temp;

//	temp.Format("Device Type : %s\r\n", pDev->bIsStorageDevice ? "USB disk" : "Unknown Device");
	szDesc += temp1;
	temp1 += temp;
  printf("----------------------------------------------\n\r%s\r\n",szDesc);
 // printf("------------------------device info is------------\n\r\n%s\r\n",temp1);

}



void CUsbIdentify::RefershDevice(HWND hWnd)
{
	if (m_Usbdev)
	{
		delete [] m_Usbdev;
		m_Usbdev = NULL;
	}

	m_Usbdev = new CONNECTED_DEVICE[MAX_USB_DEVICES];
	memset(m_Usbdev, 0, MAX_USB_DEVICES * sizeof(CONNECTED_DEVICE));
	
	m_nDevConn = 0;
	
	m_hWnd = hWnd;

	EnumHostController();
}

void CUsbIdentify::EnumHostController()
{
	TCHAR buff[16] = {0};
	CString	szRtHubName = "";

	for (int i = 0; i < NUM_OF_CONTROLLER; i++)
	{
		memset(buff, 0, sizeof(buff));
		sprintf(buff, _T("\\\\.\\HCD%d"), i);

		HANDLE hHcd = CreateFile(buff,
								 GENERIC_WRITE | GENERIC_READ,
								 FILE_SHARE_WRITE,
								 NULL,
								 OPEN_EXISTING,
								 0,
								 NULL);

		if (hHcd != INVALID_HANDLE_VALUE)
		{
			szRtHubName = GetRtHubName(hHcd);

			if (szRtHubName != "")
			{
				EnumRtHub(szRtHubName, i);
			}

			CloseHandle(hHcd);
		}

	}	
}

CString CUsbIdentify::GetRtHubName(HANDLE hHcd)
{
	USB_ROOT_HUB_NAME	name = {0};
	PUSB_ROOT_HUB_NAME	pName = NULL;
	BOOL				success = FALSE;
	DWORD				dwBytes = 0;
	CString				szRtName = "";
	
	success = ::DeviceIoControl(hHcd,
								IOCTL_USB_GET_ROOT_HUB_NAME,
								NULL,
								0,
								&name,
								sizeof(name),
								&dwBytes,
								NULL);

	if (success)
	{
		dwBytes = name.ActualLength;
		pName = (PUSB_ROOT_HUB_NAME)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwBytes);

		success = ::DeviceIoControl(hHcd,
									IOCTL_USB_GET_ROOT_HUB_NAME,
									NULL,
									0,
									pName,
									dwBytes,
									&dwBytes,
									NULL);

		if (success)
		{
			szRtName = WideToChar(pName->RootHubName);
		}
		
		HeapFree(GetProcessHeap(), HEAP_NO_SERIALIZE, pName);
		pName = NULL;
	}
	
	return szRtName;
}

void   CUsbIdentify::EnumRtHub(CString szRtHubName, DWORD dwControllerID)
{
	szRtHubName = "\\\\.\\" + szRtHubName;
	BOOL	success = FALSE;
	DWORD	dwBytes = 0;

	HANDLE hRtHub = ::CreateFile((LPCTSTR)szRtHubName,
								 GENERIC_WRITE | GENERIC_READ,
								 FILE_SHARE_READ | FILE_SHARE_WRITE,
								 NULL,
								 OPEN_EXISTING,
								 0,
								 NULL);

	if (hRtHub != INVALID_HANDLE_VALUE)
	{
		USB_NODE_INFORMATION	info;
		info.NodeType = UsbHub;

		success = ::DeviceIoControl(hRtHub,
									IOCTL_USB_GET_NODE_INFORMATION,
									&info,
									sizeof(USB_NODE_INFORMATION),
									&info,
									sizeof(USB_NODE_INFORMATION),
									&dwBytes,
									NULL);
		if (success)
		{
			EnumHubPorts(hRtHub, dwControllerID, info.u.HubInformation.HubDescriptor.bNumberOfPorts);
		}

		CloseHandle(hRtHub);
		hRtHub = NULL;
	}
}

void   CUsbIdentify::EnumHubPorts(HANDLE hRtHub, DWORD dwControllerID, DWORD dwNumOfPorts)
{
	PUSB_NODE_CONNECTION_INFORMATION		pinfo		= NULL;	
	BOOL									success		= FALSE;
	DWORD									dwBytes		= 0;
	ULONG									len			= 0;

	len = sizeof(USB_NODE_CONNECTION_INFORMATION);
//	len	= sizeof(USB_NODE_CONNECTION_INFORMATION) + sizeof(USB_PIPE_INFO) * 30;
	pinfo = (PUSB_NODE_CONNECTION_INFORMATION)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);

	for (int i = 1; i <= (int)dwNumOfPorts; i++)
	{
		memset(pinfo, 0, len);
		pinfo->ConnectionIndex = i;

		success = ::DeviceIoControl(hRtHub,
									IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,
									pinfo,
									len,
									pinfo,
									len,
									&dwBytes,
									NULL);
		if (success)
		{
			if (pinfo->ConnectionStatus == DeviceConnected)
			{
				m_nDevConn++;
				CString szDesc = GetDeviceDesc(hRtHub, i);
				
				m_Usbdev[m_nDevConn].idManufacturer = pinfo->DeviceDescriptor.iManufacturer;
				m_Usbdev[m_nDevConn].idProduct = pinfo->DeviceDescriptor.idProduct;
				m_Usbdev[m_nDevConn].idVendor = pinfo->DeviceDescriptor.idVendor;
				m_Usbdev[m_nDevConn].dwControllerID = dwControllerID;
				m_Usbdev[m_nDevConn].dwPortID = i;
//				m_Usbdev[m_nDevConn].szDesc = new char[100];
//				m_Usbdev[m_nDevConn].szDesc = (LPTSTR)(LPCTSTR)szDesc;
				memcpy(m_Usbdev[m_nDevConn].szDesc, (LPCTSTR)szDesc, szDesc.GetLength());
				m_Usbdev[m_nDevConn].speed = 0;
				m_Usbdev[m_nDevConn].bIsStorageDevice = szDesc == "USB Mass Storage Device";
				m_Usbdev[m_nDevConn].bcdUSB = pinfo->DeviceDescriptor.bcdUSB;
				OnAddNewDevice((WPARAM)&m_Usbdev[m_nDevConn], (LPARAM)m_Usbdev[m_nDevConn].szDesc);
			//	SendMessage(m_hWnd, WM_ADD_USB_DEVICE, 
			//	(WPARAM)&m_Usbdev[m_nDevConn], (LPARAM)m_Usbdev[m_nDevConn].szDesc);
					
			}
		}
	}

	HeapFree(GetProcessHeap(), HEAP_NO_SERIALIZE, pinfo);
	pinfo = NULL;
}

CString CUsbIdentify::GetDeviceDesc(HANDLE hRtHub, int nIndex)
{
	USB_NODE_CONNECTION_DRIVERKEY_NAME			drvName		= {0};
	PUSB_NODE_CONNECTION_DRIVERKEY_NAME			p_drvName	= NULL;
	ULONG										len			= sizeof(USB_NODE_CONNECTION_DRIVERKEY_NAME);
	BOOL										success		= FALSE;
	DWORD										dwBytes		= 0;
	CString										szDrvName	= "";
	CString										szDevDesc	= "";

	drvName.ConnectionIndex = nIndex;

	success = ::DeviceIoControl(hRtHub,
								IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME,
								&drvName,
								len,
								&drvName,
								len,
								&dwBytes,
								NULL);
	if (success)
	{
		dwBytes = drvName.ActualLength;
		p_drvName = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwBytes);
		p_drvName->ConnectionIndex = nIndex;

		success = ::DeviceIoControl(hRtHub,
									IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME,
									p_drvName,
									len,
									p_drvName,
									dwBytes,
									&dwBytes,
									NULL);
		
		if (success)
		{
			szDrvName = WideToChar(p_drvName->DriverKeyName);
			printf("DrvName=%s\r\n",szDrvName);
		}
		
		HeapFree(GetProcessHeap(), HEAP_NO_SERIALIZE, p_drvName);
		p_drvName = NULL;

	}
	
	if (szDrvName != "")
	{
		szDevDesc = DriverNameToDeviceDesc(szDrvName);
	}
	
	return szDevDesc;
}

CString CUsbIdentify::DriverNameToDeviceDesc(CString szDrvName)
{
	DEVINST				devInst		= 0;
	DEVINST				devNextInst	= 0;
	CONFIGRET			cr			= 0;
	BOOL				done		= FALSE;

	CString 			szDesc		= "";
	char				buff[512]   = {0};
	DWORD				len			= sizeof(buff);


	cr = CM_Locate_DevNode(&devInst, NULL, 0);
	if (cr != CR_SUCCESS)
		return "";
	
	while (!done)
	{
		memset(buff, 0, len);
		cr = CM_Get_DevNode_Registry_Property(devInst,
											  CM_DRP_DRIVER,
											  NULL,
											  buff,
											  &len,
											  0);

		if (cr == CR_SUCCESS && (CString)buff == szDrvName)
		{
			memset(buff, 0, len);

			cr = CM_Get_DevNode_Registry_Property(devInst,
												  CM_DRP_DRIVER,
												  NULL,
												  buff,
												  &len,
												  0);
			if (cr == CR_SUCCESS)
			{
				printf("CM_DRP_LOCATION_INFORMATION is %s\r\n",buff);
				return (CString)buff;
			}
			else
			{
				return "";
			}
		}

		cr = CM_Get_Child(&devNextInst, devInst, 0);
		if (cr == CR_SUCCESS)
		{
			devInst = devNextInst;
			continue;
		}

		while (1)
		{
			cr = CM_Get_Sibling(&devNextInst, devInst, 0);
			if (cr == CR_SUCCESS)
			{
				devInst = devNextInst;
				break;
			}

			cr = CM_Get_Parent(&devNextInst, devInst, 0);
			if (cr == CR_SUCCESS)
			{
				devInst = devNextInst;
			}
			else
			{
				done = TRUE;
				break;
			}
		}
	}
	return "";
}

CString CUsbIdentify::WideToChar(WCHAR *wBuff)
{
	char buff[512] = {0};
	::WideCharToMultiByte(CP_ACP, 0, wBuff, -1, buff, 512, NULL, NULL);
	return (CString)buff;
}

int CUsbIdentify::GetNumOfDeviceConnected()
{
	return m_nDevConn;
}