// getserial.cpp: определяет экспортированные функции для приложения DLL.
//
#include <windows.h>

#include <usbioctl.h>
#include <setupapi.h>
#include <cfgmgr32.h>
#include <usbiodef.h>
#include <tchar.h>
#include <string>

typedef std::basic_string<TCHAR> tstring;

int GetDeviceNumber(const tstring& strDevicePath)
{
    int        iDeviceNumber = -1;
    HANDLE    hVolume;

    hVolume = CreateFile(strDevicePath.c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
    if (hVolume != INVALID_HANDLE_VALUE)
    {
        STORAGE_DEVICE_NUMBER    deviceNumber;
        DWORD    dwNumBytes;
        
        if (DeviceIoControl(hVolume, IOCTL_STORAGE_GET_DEVICE_NUMBER, 
            NULL, 0, &deviceNumber, sizeof(deviceNumber), &dwNumBytes, NULL) != 0)
            iDeviceNumber = (deviceNumber.DeviceType << 8) + deviceNumber.DeviceNumber;
      
        CloseHandle(hVolume);
    }

    return iDeviceNumber;
}

bool FindDiskDevice(TCHAR DriveLetter, tstring& strHubDevicePath, 
    tstring& strInstanceID, tstring& strDeviceName, bool& bSerialNumber)
{
    bool    res = false;
    BOOL    bSuccess;
    int        iDeviceNumber;
    HDEVINFO    hSetup;
    int        i;
    DWORD    dwNumBytes;
    SP_DEVICE_INTERFACE_DATA    interfaceData;
    SP_DEVINFO_DATA    devinfoData;
    BYTE    pbBuffer[800];
    PSP_DEVICE_INTERFACE_DETAIL_DATA    pDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) &pbBuffer[0];
    tstring    strDevicePath = _T("\\\\.\\");


    bSerialNumber = false;

    strDevicePath += DriveLetter;
    strDevicePath += _T(':');
    iDeviceNumber = GetDeviceNumber(strDevicePath);
    if (iDeviceNumber == -1)
        return false;

    hSetup = SetupDiGetClassDevs((LPGUID) &GUID_DEVINTERFACE_DISK, 
        NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
    if (hSetup == INVALID_HANDLE_VALUE)
        return false;

    i = 0;
    while (true)
    {
        interfaceData.cbSize = sizeof(interfaceData);

        bSuccess = SetupDiEnumDeviceInterfaces(hSetup, NULL, 
            (LPGUID) &GUID_DEVINTERFACE_DISK, i, &interfaceData);

        if (!bSuccess)
            break;
         
        devinfoData.cbSize = sizeof(devinfoData);
        pDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

        if (SetupDiGetDeviceInterfaceDetail(hSetup, &interfaceData, pDetailData, 
            sizeof(pbBuffer), &dwNumBytes, &devinfoData) != 0)
        {
            if (GetDeviceNumber(pDetailData->DevicePath) == iDeviceNumber)
            {
                DEVINST    devPrev;
                tstring    strTemp, strGUID;
                int    j;
                DWORD    dwCap;

                if (SetupDiGetDeviceRegistryProperty(hSetup, &devinfoData, 
                    SPDRP_FRIENDLYNAME, NULL, (PBYTE) pbBuffer, sizeof(pbBuffer), &dwNumBytes))
                    strDeviceName = (TCHAR*) pbBuffer;

                if (SetupDiGetDeviceRegistryProperty(hSetup, &devinfoData, 
                    SPDRP_CAPABILITIES, NULL, (PBYTE) &dwCap, sizeof(dwCap), &dwNumBytes))
                    bSerialNumber = (dwCap & CM_DEVCAP_UNIQUEID) != 0;
                
                CM_Get_Parent(&devPrev, devinfoData.DevInst, 0);
                CM_Get_Device_ID(devPrev, (TCHAR*) pbBuffer, sizeof(pbBuffer)/sizeof(TCHAR), 0);
                strInstanceID = (TCHAR*) pbBuffer;

                CM_Get_Parent(&devPrev, devPrev, 0);
                CM_Get_Device_ID(devPrev, (TCHAR*) pbBuffer, sizeof(pbBuffer)/sizeof(TCHAR), 0);
                strTemp = (TCHAR*) pbBuffer;

                for (j=0; j < strTemp.length(); ++j)
                    if (strTemp[j] == _T('\\'))
                        strTemp[j] = _T('#');

				GUID devintusbhub={0xf18a0e88, 0xc30c, 0x11d0, 0x88, 0x15, 0x00, 0xa0, 0xc9, 0x06, 0xbe, 0xd8};//GUID_DEVINTERFACE_USB_HUB;
				StringFromGUID2(devintusbhub, (LPOLESTR) pbBuffer, sizeof(pbBuffer) / sizeof(WCHAR));
				char Res[256];
				int rcnt;
				rcnt=WideCharToMultiByte(CP_ACP,WC_COMPOSITECHECK,(WCHAR*)pbBuffer,wcslen((WCHAR*)pbBuffer),Res,256,NULL,NULL);
				Res[rcnt]=0;
                strGUID = (TCHAR*)Res;
					//(LPOLESTR) pbBuffer;

                strHubDevicePath = _T("\\\\.\\") + strTemp + _T("#") + strGUID;
                res = true;

                break;
            }
        }

        ++i;
    }

   SetupDiDestroyDeviceInfoList(hSetup);
   return res;
}

tstring GetDriverKeyName(const tstring& strHubPath, int iPortNumber)
{
    tstring    strDriverKeyName = _T("");
    HANDLE    hHub;
    DWORD    dwNumBytes;
    USB_NODE_CONNECTION_INFORMATION    nodeInfo;
    PBYTE    pbBuffer[500];

    hHub = CreateFile(strHubPath.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, 
        NULL, OPEN_EXISTING, 0, NULL);
    
    if (hHub != INVALID_HANDLE_VALUE)
    {
        nodeInfo.ConnectionIndex = iPortNumber;

        if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,
            &nodeInfo, sizeof(nodeInfo), &nodeInfo, sizeof(nodeInfo), &dwNumBytes, NULL))
        {
            if (nodeInfo.ConnectionStatus == DeviceConnected)
            {
                PUSB_NODE_CONNECTION_DRIVERKEY_NAME    pDriverKeyName = (PUSB_NODE_CONNECTION_DRIVERKEY_NAME) pbBuffer;
                
                pDriverKeyName->ConnectionIndex = iPortNumber;

                if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_DRIVERKEY_NAME, 
                      pDriverKeyName, sizeof(pbBuffer), pDriverKeyName, 
				  	  sizeof(pbBuffer), &dwNumBytes, NULL)) {
  			        char Res[256];
		            int rcnt;
				    rcnt=WideCharToMultiByte(CP_ACP,WC_COMPOSITECHECK,(WCHAR*)(pDriverKeyName->DriverKeyName),wcslen((WCHAR*)pDriverKeyName->DriverKeyName),Res,256,NULL,NULL);
				    Res[rcnt]=0;
                    strDriverKeyName = (TCHAR*)Res;
				}
            }
        }

        CloseHandle(hHub);
    }

    return strDriverKeyName;
}

int GetPortCount(const tstring& strHubDevicePath)
{
    int    nCount = 0;
    HANDLE    hHub;
    DWORD    dwNumBytes;
    USB_NODE_INFORMATION    nodeInfo;

    hHub = CreateFile(strHubDevicePath.c_str(), GENERIC_WRITE,
        FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);

    if (hHub== INVALID_HANDLE_VALUE)
        return nCount;

    nodeInfo.NodeType = UsbHub;

    if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_INFORMATION, &nodeInfo,
        sizeof(nodeInfo), &nodeInfo, sizeof(nodeInfo), &dwNumBytes, NULL))
        nCount = nodeInfo.u.HubInformation.HubDescriptor.bNumberOfPorts;

    CloseHandle(hHub);
    return nCount;
}

tstring FindInstanceIDByKeyName(const tstring& strDriverKeyName, tstring& strHardwareID)
{
    tstring    strInstanceID = _T("");
    HDEVINFO    hDevInfo;
    BOOL    bSuccess;
    int        i = 0;
    tstring    strKeyName;
    SP_DEVINFO_DATA    devinfoData;
    DWORD    dwNumBytes;
    BYTE    pbBuffer[500];


    strHardwareID = _T("");

    hDevInfo = SetupDiGetClassDevs(0, _T("USB"), NULL, DIGCF_PRESENT | DIGCF_ALLCLASSES);
    if (hDevInfo == INVALID_HANDLE_VALUE)
        return strInstanceID;

    while (true)
    {
        devinfoData.cbSize = sizeof(devinfoData);
        bSuccess = SetupDiEnumDeviceInfo(hDevInfo, i, &devinfoData);

        if (!bSuccess)
            break;

        strKeyName = _T("");
        if (SetupDiGetDeviceRegistryProperty(hDevInfo, &devinfoData, SPDRP_DRIVER, NULL, pbBuffer,
            sizeof(pbBuffer), &dwNumBytes))
            strKeyName = (TCHAR*) pbBuffer;

        if (strKeyName == strDriverKeyName)
        {
           SetupDiGetDeviceInstanceId(hDevInfo, &devinfoData, (TCHAR*) pbBuffer, sizeof(pbBuffer), &dwNumBytes);
           strInstanceID = (TCHAR*) pbBuffer;

            if (SetupDiGetDeviceRegistryProperty(hDevInfo, &devinfoData, SPDRP_HARDWAREID, NULL, pbBuffer,
                sizeof(pbBuffer), &dwNumBytes))
                strHardwareID = (TCHAR*) pbBuffer;

           break;
        }

        ++i;
    }

    SetupDiDestroyDeviceInfoList(hDevInfo);
    return strInstanceID;
}

void GetDeviceDescriptor(const tstring& strHubPath, int iPortNumber, 
    PUSB_DEVICE_DESCRIPTOR pDeviceDescriptor)
{
    HANDLE    hHub;
    BYTE    pbBuffer[500];
    PUSB_NODE_CONNECTION_INFORMATION    pConnectionInfo = (PUSB_NODE_CONNECTION_INFORMATION) pbBuffer;
	PUSB_DEVICE_DESCRIPTOR pDescriptor = (PUSB_DEVICE_DESCRIPTOR) pbBuffer;
    DWORD    dwNumBytes;


    memset(pDeviceDescriptor, 0, sizeof(USB_DEVICE_DESCRIPTOR));
    memset(pbBuffer, 0, sizeof(pbBuffer));

    hHub = CreateFile(strHubPath.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
        OPEN_EXISTING, 0, NULL);
    if (hHub == INVALID_HANDLE_VALUE)
        return;

    pConnectionInfo->ConnectionIndex = iPortNumber;

    if (DeviceIoControl(hHub, IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,
        pConnectionInfo, sizeof(pbBuffer), pConnectionInfo, sizeof(pbBuffer), 
        &dwNumBytes, NULL))
//    if (DeviceIoControl(hHub, USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
//        pConnectionInfo, sizeof(pbBuffer), pDescriptor, sizeof(pbBuffer), 
//        &dwNumBytes, NULL))
		
        memcpy(pDeviceDescriptor, &pConnectionInfo->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
//        memcpy(pDeviceDescriptor, &pConnectionInfo, sizeof(USB_DEVICE_DESCRIPTOR));

    CloseHandle(hHub);
}

tstring GetStringDescriptor(const tstring& strHubPath, int iPortNumber, int iIndex)
{
    tstring    strValue;
    HANDLE    hHub;
    BOOL    bSuccess;
    ULONG    nBytes;
    ULONG    nBytesReturned;
    UCHAR    stringDescReqBuf[sizeof(USB_DESCRIPTOR_REQUEST) + MAXIMUM_USB_STRING_LENGTH];
    PUSB_DESCRIPTOR_REQUEST    pStringDescReq;
    PUSB_STRING_DESCRIPTOR    pStringDesc;


    hHub = CreateFile(strHubPath.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
        OPEN_EXISTING, 0, NULL);
    if (hHub == INVALID_HANDLE_VALUE)
        return strValue;

    nBytes = sizeof(stringDescReqBuf);

    pStringDescReq = (PUSB_DESCRIPTOR_REQUEST)stringDescReqBuf;
    pStringDesc = (PUSB_STRING_DESCRIPTOR)(pStringDescReq + 1);

    // Zero fill the entire request structure
    memset(pStringDescReq, 0, nBytes);

    // Indicate the port from which the descriptor will be requested
    pStringDescReq->ConnectionIndex = iPortNumber;

    // USBHUB uses URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE to process this
    // IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION request.
    //
    // USBD will automatically initialize these fields:
    //     bmRequest = 0x80
    //     bRequest  = 0x06
    //
    // We must inititialize these fields:
    //     wValue    = Descriptor Type (high) and Descriptor Index (low byte)
    //     wIndex    = Zero (or Language ID for String Descriptors)
    //     wLength   = Length of descriptor buffer
    pStringDescReq->SetupPacket.wValue = (USB_STRING_DESCRIPTOR_TYPE << 8) | iIndex;
    pStringDescReq->SetupPacket.wIndex = 0x409;
    pStringDescReq->SetupPacket.wLength = (USHORT)(nBytes - sizeof(USB_DESCRIPTOR_REQUEST));

    // Now issue the get descriptor request.
    bSuccess = DeviceIoControl(hHub, IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
        pStringDescReq, nBytes, pStringDescReq, nBytes, &nBytesReturned, NULL);

    CloseHandle(hHub);

    // Do some sanity checks on the return from the get descriptor request.
    if (!bSuccess)
        return strValue;
    if (nBytesReturned < 2)
        return strValue;
    if (pStringDesc->bDescriptorType != USB_STRING_DESCRIPTOR_TYPE)
        return strValue;
    if (pStringDesc->bLength != nBytesReturned - sizeof(USB_DESCRIPTOR_REQUEST))
        return strValue;
    if (pStringDesc->bLength % 2 != 0)
        return strValue;
    
    strValue = (WCHAR)pStringDesc->bString;

    return strValue;
}

EXTERN_C __declspec(dllexport) int GetSerialNumber(TCHAR DriveLetter, char* pcDeviceName, char* pcSerial, int size)
{
    int    iCounter = 15;
    tstring strDeviceName=pcDeviceName;

    while (iCounter)
    {
        tstring    strSerialNumber, strHardwareID;
        tstring    strInstanceID;
        tstring    strHubDevicePath;
        tstring    strDriverKeyName;
        int    i, nPortCount;
        USB_DEVICE_DESCRIPTOR    deviceDesc;
        bool    bSerialNumber;

        if (!FindDiskDevice(DriveLetter, strHubDevicePath, strInstanceID, 
            strDeviceName, bSerialNumber))
        {
            strSerialNumber = _T("");
            strcpy(pcSerial,strSerialNumber.c_str());
            return (0);
        }
        
        if (strInstanceID.find(_T("USB\\")) == 0)
        {
            nPortCount = GetPortCount(strHubDevicePath);
			if (nPortCount == 0){
                strcpy(pcSerial,strSerialNumber.c_str());
                return (0);
			}
            for (i=1; i <= nPortCount; ++i)
            {
                strDriverKeyName = GetDriverKeyName(strHubDevicePath, i);
                if (FindInstanceIDByKeyName(strDriverKeyName, strHardwareID) == strInstanceID)
                {
                    strSerialNumber = _T("HardwareID:");
                    strSerialNumber += strHardwareID;

                    GetDeviceDescriptor(strHubDevicePath, i, &deviceDesc);

                    if (deviceDesc.iSerialNumber > 0)
                    {
                        strSerialNumber = GetStringDescriptor(strHubDevicePath, i, deviceDesc.iSerialNumber);
                        break;
                    }
                }
            }
        }

        if (strSerialNumber.empty())
        {
            --iCounter;
            continue;
        }

        if (!strSerialNumber.empty())
            _tcsupr((TCHAR*) strSerialNumber.c_str());

        strcpy(pcSerial,strSerialNumber.c_str());
        return (1);
    }

    strcpy(pcSerial,"");
    return (0);
}