#include "stdafx.h"

#include <windows.h>
#include <stdio.h>
#include <winioctl.h>
#include <basetyps.h>
#include <usbdi.h>

// Microsoft released two setupapi.h files: one in Win98 DDK and
// the other one in VC/C++. We shall use the one in Win98 DDK.
// In oder to resolve this conflict, we have copied setupapi.h
// and setupapi.lib from Win98 DDK to current working directory.
#include "setupapi.h"

#include "ioctl.h"
#include "GUIDUDK.h"

// Generated from the GUID registered by the driver itself
char completeDeviceName[256] = "";


HANDLE
OpenOneDevice (
IN HDEVINFO HardwareDeviceInfo,
IN PSP_DEVICE_INTERFACE_DATA DeviceInfoData,
IN char* devName
)
/*++
Routine Description:

Given the HardwareDeviceInfo, representing a handle to the plug and
play information, and deviceInfoData, representing a specific usb device,
open that device and fill in all the relevant information in the given
USB_DEVICE_DESCRIPTOR structure.

Arguments:

HardwareDeviceInfo: handle to info obtained from Pnp mgr via SetupDiGetClassDevs()
DeviceInfoData: ptr to info obtained via SetupDiEnumInterfaceDevice()

Return Value:

return HANDLE if the open and initialization was successfull,
else INVLAID_HANDLE_VALUE.

--*/
{
PSP_INTERFACE_DEVICE_DETAIL_DATA functionClassDeviceData = NULL;
ULONG predictedLength = 0;
ULONG requiredLength = 0;
HANDLE hOut = INVALID_HANDLE_VALUE;

//
// allocate a function class device data structure to receive the
// goods about this particular device.
//
SetupDiGetInterfaceDeviceDetail
(
HardwareDeviceInfo,
DeviceInfoData,
NULL, // Probing so no output buffer yet
0, // Probing so output buffer length of zero
&requiredLength,
NULL // Not interested in the specific dev-node
);

predictedLength = requiredLength;

functionClassDeviceData = (PSP_INTERFACE_DEVICE_DETAIL_DATA)malloc (predictedLength);
functionClassDeviceData->cbSize = sizeof (SP_INTERFACE_DEVICE_DETAIL_DATA);

//
// Retrieve the information from Plug and Play.
//
if (!SetupDiGetInterfaceDeviceDetail (
HardwareDeviceInfo,
DeviceInfoData,
functionClassDeviceData,
predictedLength,
&requiredLength,
NULL))
{
return INVALID_HANDLE_VALUE;
}

strcpy(devName,functionClassDeviceData->DevicePath);

hOut = CreateFile (
functionClassDeviceData->DevicePath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, // No SECURITY_ATTRIBUTES structure
OPEN_EXISTING, // No special create flags
0, // No special attributes
NULL); // No template file

if (INVALID_HANDLE_VALUE == hOut)
{
}

free(functionClassDeviceData);

return hOut;
}

HANDLE
OpenUsbDevice(LPGUID pGuid, char *outNameBuf)
/*++
Routine Description:

Do the required PnP things in order to find 
the next available proper device in the system at this time.

Arguments:

pGuid: ptr to GUID registered by the driver itself
outNameBuf: the generated name for this device

Return Value:

return HANDLE if the open and initialization was successful,
else INVLAID_HANDLE_VALUE.
--*/
{
ULONG NumberDevices;
HANDLE hOut = INVALID_HANDLE_VALUE;
HDEVINFO hardwareDeviceInfo;
SP_DEVICE_INTERFACE_DATA deviceInfoData;
ULONG i;
BOOLEAN done;
PUSB_DEVICE_DESCRIPTOR usbDeviceInst;
PUSB_DEVICE_DESCRIPTOR* UsbDevices = &usbDeviceInst;

*UsbDevices = NULL;
NumberDevices = 0;

//
// Open a handle to the plug and play dev node.
// SetupDiGetClassDevs() returns a device information set that contains info on all 
// installed devices of a specified class.
//
hardwareDeviceInfo = SetupDiGetClassDevs(
pGuid,
NULL, // Define no enumerator (global)
NULL, // Define no
(DIGCF_PRESENT | // Only Devices present
DIGCF_INTERFACEDEVICE)); // Function class devices.

//
// Take a wild guess at the number of devices we have;
// Be prepared to realloc and retry if there are more than we guessed
//
NumberDevices = 4;
done = FALSE;
deviceInfoData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);

i = 0;
while (!done)
{
NumberDevices *= 2;

if (*UsbDevices)
{
*UsbDevices = (PUSB_DEVICE_DESCRIPTOR)realloc(*UsbDevices, (NumberDevices * sizeof(USB_DEVICE_DESCRIPTOR)));
} 
else 
{
*UsbDevices = (PUSB_DEVICE_DESCRIPTOR)calloc(NumberDevices, sizeof(USB_DEVICE_DESCRIPTOR));
}

if (NULL == *UsbDevices)
{
// SetupDiDestroyDeviceInfoList destroys a device information set 
// and frees all associated memory.

SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);
return INVALID_HANDLE_VALUE;
}

usbDeviceInst = *UsbDevices + i;

for (; i < NumberDevices; i++)
{
// SetupDiEnumDeviceInterfaces() returns information about device interfaces 
// exposed by one or more devices. Each call returns information about one interface;
// the routine can be called repeatedly to get information about several interfaces
// exposed by one or more devices.

if (SetupDiEnumDeviceInterfaces(hardwareDeviceInfo,
0, // We don't care about specific PDOs
pGuid,
i,
&deviceInfoData))
{
hOut = OpenOneDevice (hardwareDeviceInfo, &deviceInfoData, outNameBuf);
if (hOut != INVALID_HANDLE_VALUE)
{
done = TRUE;
break;
}
} 
else 
{
if (ERROR_NO_MORE_ITEMS == GetLastError()) 
{
done = TRUE;
break;
}
}
}
}

NumberDevices = i;

// SetupDiDestroyDeviceInfoList() destroys a device information set 
// and frees all associated memory.

SetupDiDestroyDeviceInfoList(hardwareDeviceInfo);

if (*UsbDevices) 
free(*UsbDevices);

return hOut;
}

BOOL
GetUsbDeviceFileName(LPGUID pGuid, char *outNameBuf)
/*++
Routine Description:

Given a ptr to a driver-registered GUID, give us a string with the device name
that can be used in a CreateFile() call.
Actually briefly opens and closes the device and sets outBuf if successfull;
returns FALSE if not 

Arguments:

pGuid: ptr to GUID registered by the driver itself
outNameBuf: the generated zero-terminated name for this device

Return Value:

TRUE on success else FALSE

--*/
{
HANDLE hDev = OpenUsbDevice(pGuid, outNameBuf);
if (hDev != INVALID_HANDLE_VALUE)
{
CloseHandle(hDev);
return TRUE;
}
return FALSE;
}

HANDLE
open_dev()
/*++
Routine Description:

Called by dumpUsbConfig() to open an instance of our device

Arguments:

None

Return Value:

Device handle on success else NULL

--*/
{

HANDLE hDEV = OpenUsbDevice((LPGUID)&GUID_NETAC_UDK2000, completeDeviceName);

return hDEV;
}

HANDLE
open_file(char *filename)
/*++
Routine Description:

Called by main() to open an instance of our device after obtaining its name

Arguments:

None

Return Value:

Device handle on success else NULL

--*/
{
HANDLE h;

if (!GetUsbDeviceFileName( 
(LPGUID) &GUID_NETAC_UDK2000, 
completeDeviceName))
{
return INVALID_HANDLE_VALUE; 
}

strcat(completeDeviceName, "\\"); 

strcat(completeDeviceName, filename); 

h = CreateFile(completeDeviceName,
GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_WRITE | FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);

return h;
}