// UsbInfo.cpp: implementation of the UsbInfo class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "UsbInfo.h"
typedef struct _tagDeviceProperties
{
    int ID;
    TCHAR Property[100];
    TCHAR PropertyValue[500];
}
DeviceProperties;

#define ID_SERVICE				0
#define ID_MFG					1
#define ID_HARDWAREID			2
#define ID_LOCATION				3
#define ID_ENUMERATOR_NAME		4
#define ID_DEVICEDESC			5
#define ID_FRIENDLYNAME			6

#define REGSTR_VAL_MAX_HCID_LEN		1024
#define  USB_FIXX  _T(" USB Device")
#define  USB_VID	_T("Vid_")
#define  USB_PID	_T("Pid_")
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
#pragma comment(lib,"DDK\\cfgmgr32.lib");
#pragma comment(lib,"DDK\\Rpcrt4.lib");
CUsbInfo::CUsbInfo()
:m_strToCmp(_T(""))
{
    m_bIsFound = FALSE;
	m_pTreeCtrl=NULL;
}

CUsbInfo::~CUsbInfo()
{}

void CUsbInfo::SetDevName(CString strDevName)
{
    m_strToCmp = strDevName;
    m_strToCmp.Remove(_T(' '));

//    m_strDevName.Empty();
//    m_strDevDesc.Empty();
//    m_strVidPid.Empty();
//    m_strManufacturing.Empty();
//    m_strLocInfo.Empty();
//    m_strFriendlyName.Empty();
    m_bIsFound = FALSE;
}

void CUsbInfo::EnumDevices()
{
    TCHAR LocalComputer[MAX_PATH];
    DWORD Size = MAX_PATH - 2;
    DEVNODE dnRoot = 0;
    DEVNODE dnFirst = 0;
    CONFIGRET cr;
   	m_pTreeCtrl->DeleteAllItems();
    GetComputerName(LocalComputer + 2, &Size);
    LocalComputer[0] = _T('\\');
    LocalComputer[1] = _T('\\');


    cr = CM_Connect_Machine(LocalComputer, &m_hMachine);
    
    if (cr != CR_SUCCESS)
    {
#ifdef _DEBUG
        TCHAR Text[MAX_PATH];
        
        wsprintf(Text, _T("Machine Connection failed, cr= %lx(hex)\n"), cr);
        ::MessageBox(NULL, Text, _T("Error"), MB_ICONSTOP | MB_OK);
#endif // _DEBUG
        return;
    }
    
    CM_Locate_DevNode_Ex(&dnRoot, NULL, 0, m_hMachine);

    HTREEITEM hTreeItem = m_pTreeCtrl->InsertItem(LocalComputer,0,0);

    CM_Get_Child_Ex(&dnFirst, dnRoot, 0, m_hMachine);
    RetrieveSubNodes(dnRoot, NULL, dnFirst,hTreeItem);
	m_pTreeCtrl->Expand(hTreeItem,TVE_EXPAND);
    CM_Disconnect_Machine(m_hMachine);
}

void CUsbInfo::RetrieveSubNodes(DEVINST parent, DEVINST sibling, DEVNODE dn,HTREEITEM hTreeItem)
{
    DEVNODE dnSibling, dnChild;
    
    do
    {
        CONFIGRET cr = CM_Get_Sibling_Ex(&dnSibling, dn, 0, m_hMachine);
        
        if (cr != CR_SUCCESS)
            dnSibling = NULL;
            
        UCHAR GuidString[MAX_GUID_STRING_LEN];
        
        ULONG Size = sizeof(GuidString);
        
        cr = CM_Get_DevNode_Registry_Property_Ex(dn, CM_DRP_CLASSGUID, NULL, GuidString, &Size, 0, m_hMachine);
        HTREEITEM hTreeItem1;
		
        if (cr == CR_SUCCESS)
        {
            GUID Guid;
            
            GuidString[MAX_GUID_STRING_LEN - 2] = _T('\0');
            UuidFromString(&GuidString[1], &Guid);
            CString DeviceName = GetDeviceName(dn);

			hTreeItem1 = m_pTreeCtrl->InsertItem(DeviceName,0,0,hTreeItem);
			m_pTreeCtrl->EnsureVisible(hTreeItem1);

            if (DeviceName == CString("USB Mass Storage Device"))
            {	
//				hTreeItem1 = m_pTreeCtrl->InsertItem(DeviceName,0,0,m_pTreeCtrl->GetRootItem());
//				m_pTreeCtrl->EnsureVisible(hTreeItem1);
                cr = CM_Get_Child_Ex(&dnChild, dn, 0, m_hMachine);
                if (cr == CR_SUCCESS)
                {
                    EnumMassStorage(dnChild);
                }
                
//                m_strDevName.Replace(USB_FIXX, _T(""));
//				m_strDevName.Remove(_T(' '));

 //               if (!m_strToCmp.IsEmpty() || m_strDevName.Find(m_strToCmp) != -1)
                {
                    EnumDeviceProperties(dn, TRUE);
              //      m_bIsFound = TRUE;
                    //break;
                }
            }
        }else
		{
			hTreeItem1 = m_pTreeCtrl->InsertItem(_T("未知設備"),0,0,hTreeItem);
		}
        
        cr = CM_Get_Child_Ex(&dnChild, dn, 0, m_hMachine);
        if (cr == CR_SUCCESS)
        {
            RetrieveSubNodes(dn, NULL, dnChild,hTreeItem1);
        }
        
        dn = dnSibling;
        
    }
    while ((m_bIsFound == FALSE) && (dn != NULL));
}

CString CUsbInfo::GetDeviceName(DEVNODE DevNode)
{
    CString strType;
    CString strValue;
    CString DisplayName(_T(""));
    LPTSTR Buffer;
    
    int BufferSize = MAX_PATH + MAX_DEVICE_ID_LEN;
    ULONG BufferLen = BufferSize * sizeof(TCHAR);
    
    Buffer = strValue.GetBuffer(BufferSize);
    if (CR_SUCCESS ==
            CM_Get_DevNode_Registry_Property_Ex(DevNode, CM_DRP_FRIENDLYNAME, NULL, Buffer, &BufferLen, 0, m_hMachine))
    {
        DisplayName = Buffer;
    }
    else
    {
        BufferLen = BufferSize * sizeof(TCHAR);
        
        if (CR_SUCCESS ==
                CM_Get_DevNode_Registry_Property_Ex(DevNode, CM_DRP_DEVICEDESC, NULL, Buffer, &BufferLen, 0, m_hMachine))
        {
            DisplayName = Buffer;
        }
        else
        {
            DisplayName = _T("Unknown Device");
        }
    }
    strValue.ReleaseBuffer();
    return DisplayName;
}

CString CUsbInfo::GetProperty(DEVNODE dn, ULONG Property)
{
    CString Temp;
    
    TCHAR Buffer[REGSTR_VAL_MAX_HCID_LEN] = _T("");
    ULONG Type;
    ULONG Size = sizeof(Buffer);
    
    if (CM_Get_DevNode_Registry_Property_Ex(dn, Property, &Type, Buffer, &Size, 0, m_hMachine) == CR_SUCCESS)
    {
        if (Type == REG_DWORD || Type == REG_MULTI_SZ || Type == REG_SZ)
        {
            if (Type == REG_DWORD)
            {
                DWORD Data = *((DWORD *) Buffer);
                
                wsprintf(Buffer, _T("0x%08x"), *((DWORD *) Buffer));
            }
            else if (Type == REG_MULTI_SZ)
            {
                LPTSTR p = Buffer;
                
                while (_T('\0') != *p)
                {
                    p += lstrlen(p);
                    if (_T('\0') != *p)
                        *p++ = _T(',');
                }
            }
        }
    }
    
    Temp = Buffer;
    return Temp;
}

BOOL CUsbInfo::EnumDeviceProperties(DEVNODE dn, BOOL hub)
{
    BOOL value = FALSE;
    int BufferSize = MAX_PATH + MAX_DEVICE_ID_LEN;
    //TCHAR Buffer[MAX_PATH + MAX_DEVICE_ID_LEN];
    CString strTemp;
    
    if (hub)
    {
        m_strManufacturing = GetProperty(dn, CM_DRP_MFG);
        m_strLocInfo = GetProperty(dn, CM_DRP_LOCATION_INFORMATION);
        //設成VIDPID
        strTemp = GetProperty(dn, CM_DRP_HARDWAREID);
        int nIndex = strTemp.Find(USB_VID);
        CString strVid = strTemp.Mid(nIndex + 4, 4);
        
        nIndex = strTemp.Find(_T(USB_PID));
        CString strPid = strTemp.Mid(nIndex + 4, 4);
        
        m_strVidPid = strVid + strPid;
    }
    else
    {
        m_strFriendlyName = GetProperty(dn, CM_DRP_FRIENDLYNAME);
    }
    
    return value;
}

void CUsbInfo::EnumMassStorage(DEVNODE dn)
{

    DEVNODE dnSibling;//, dnChild;
    
    do
    {
        CONFIGRET cr = CM_Get_Sibling_Ex(&dnSibling, dn, 0, m_hMachine);
        
        if (cr != CR_SUCCESS)
            dnSibling = NULL;
            
        UCHAR GuidString[MAX_GUID_STRING_LEN];
        
        ULONG Size = sizeof(GuidString);
        
        cr = CM_Get_DevNode_Registry_Property_Ex(dn, CM_DRP_CLASSGUID, NULL, GuidString, &Size, 0, m_hMachine);
        
        if (cr == CR_SUCCESS)
        {
            GUID Guid;
             
            GuidString[MAX_GUID_STRING_LEN - 2] = _T('\0');
            UuidFromString(&GuidString[1], &Guid);
            m_strDevName = GetDeviceName(dn);
        }
        
        dn = dnSibling;
        
    }
    while (dn != NULL);
}