/*++

Copyright (c) 1997-1998  Microsoft Corporation

Module Name:

RWBulk.c

Abstract:

Console test app for BulkUsb.sys driver

Environment:

user mode only

Notes:

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
PURPOSE.

Copyright (c) 1997-1998 Microsoft Corporation.  All Rights Reserved.


Revision History:

11/17/97: created

--*/

#include <windows.h>

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>

#include "devioctl.h"

#include <setupapi.h>
#include <basetyps.h>
#include "BulkUsr.h"

#include "usbdi.h"

#define NOISY(_x_) printf _x_ ;

char inPipe[32] = "PIPE00";     // pipe name for bulk input pipe on our test board
char outPipe[32] = "PIPE01";    // pipe name for bulk output pipe on our test board
char completeDeviceName[256] = "";  //generated from the GUID registered by the driver itself

BOOL fDumpUsbConfig = FALSE;    // flags set in response to console command line switches
BOOL fDumpReadData = FALSE;
BOOL fRead = FALSE;
BOOL fWrite = FALSE;

int gDebugLevel = 1;      // higher == more verbose, default is 1, 0 turns off all

ULONG IterationCount = 1; //count of iterations of the test we are to perform
int WriteLen = 0;         // #bytes to write
int ReadLen = 0;          // #bytes to read

// functions


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 SetupDiEnumDeviceInterfaces()

   Return Value:

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

--*/
{
    PSP_DEVICE_INTERFACE_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.
    //
    if (SetupDiGetDeviceInterfaceDetail(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
    {
        return INVALID_HANDLE_VALUE;
    }

    if (ERROR_INSUFFICIENT_BUFFER != GetLastError())
    {
        return INVALID_HANDLE_VALUE;
    }

    predictedLength = requiredLength;
    // sizeof (SP_FNCLASS_DEVICE_DATA) + 512;

    functionClassDeviceData = malloc(predictedLength);

    if (NULL == functionClassDeviceData)
    {
        return INVALID_HANDLE_VALUE;
    }

    functionClassDeviceData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);

    //
    // Retrieve the information from Plug and Play.
    //
    if (!SetupDiGetDeviceInterfaceDetail(HardwareDeviceInfo,
                                         DeviceInfoData,
                                         functionClassDeviceData,
                                         predictedLength,
                                         &requiredLength,
                                         NULL))
    {
        free(functionClassDeviceData);

        return INVALID_HANDLE_VALUE;
    }

    strcpy(devName,functionClassDeviceData->DevicePath);
    printf("Attempting to open %s\n", devName);

    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)
    {
        printf("FAILED to open %s\n", devName);
    }

    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;
    PUSB_DEVICE_DESCRIPTOR   tempDevDesc;

    *UsbDevices = NULL;
    tempDevDesc = 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_DEVICEINTERFACE)); // Function class devices.

    if (hardwareDeviceInfo == INVALID_HANDLE_VALUE)
    {
        return INVALID_HANDLE_VALUE;
    }

    //
    // 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)
        {
            tempDevDesc = realloc(*UsbDevices,
                                  (NumberDevices * sizeof (USB_DEVICE_DESCRIPTOR)));
            if(tempDevDesc)
            {
                *UsbDevices = tempDevDesc;
                tempDevDesc = NULL;
            }
            else
            {
                free(*UsbDevices);
                *UsbDevices = NULL;
            }
        }
        else
        {
            *UsbDevices = 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);

    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_CLASS_I82930_BULK,
                                completeDeviceName);

    if (hDEV == INVALID_HANDLE_VALUE)
    {
        printf("Failed to open (%s) = %d", completeDeviceName, GetLastError());
    }
    else
    {
        printf("DeviceName = (%s)\n", completeDeviceName);
    }

    return hDEV;
}


HANDLE
open_file (
    PCHAR   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

--*/
{

    int success = 1;
    HANDLE h;

    if (!GetUsbDeviceFileName((LPGUID) &GUID_CLASS_I82930_BULK,
                              completeDeviceName))
    {
        NOISY(("Failed to GetUsbDeviceFileName err - %d\n", GetLastError()));
        return  INVALID_HANDLE_VALUE;
    }

    strcat(completeDeviceName, "\\");

    if ((strlen(completeDeviceName) + strlen(filename)) > 255)
    {
        NOISY(("Failed to open handle - possibly long filename\n"));
        return INVALID_HANDLE_VALUE;
    }

    strcat(completeDeviceName, filename);

    printf("completeDeviceName = (%s)\n", completeDeviceName);

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

    if (h == INVALID_HANDLE_VALUE)
    {
        NOISY(("Failed to open (%s) = %d", completeDeviceName, GetLastError()));
        success = 0;
    }
    else
    {
        NOISY(("Opened successfully.\n"));
    }

    return h;
}

void
usage()
/*++
   Routine Description:

   Called by main() to dump usage info to the console when
   the app is called with no parms or with an invalid parm

   Arguments:

   None

   Return Value:

   None

--*/
{
    static int i=1;

    if (i)
    {
        printf("Usage for Read/Write test:\n");
        printf("-r [n] where n is number of bytes to read\n");
        printf("-w [n] where n is number of bytes to write\n");
        printf("-c [n] where n is number of iterations (default = 1)\n");
        printf("-i [s] where s is the input pipe\n");
        printf("-o [s] where s is the output pipe\n");
        printf("-v verbose -- dumps read data\n");

        printf("\nUsage for USB and Endpoint info:\n");
        printf("-u to dump USB configuration and pipe info \n");
        i = 0;
    }
}


void
parse (
    int     argc,
    char   *argv[]
)
/*++
   Routine Description:

   Called by main() to parse command line parms

   Arguments:

   argc and argv that was passed to main()

   Return Value:

   Sets global flags as per user function request

--*/
{
    int i;

    if (argc < 2) // give usage if invoked with no parms
    {
        usage();
    }

    for (i=0; i<argc; i++)
    {
        if (argv[i][0] == '-' ||
            argv[i][0] == '/') {
            switch (argv[i][1])
            {
                case 'r':
                case 'R':
                    if (argc > i+1)
                    {
                        ReadLen = atoi(&argv[i+1][0]);
                        fRead = TRUE;
                    }
                    i++;
                    break;
                case 'w':
                case 'W':
                    if (argc > i+1)
                    {
                        WriteLen = atoi(&argv[i+1][0]);
                        fWrite = TRUE;
                    }
                    i++;
                    break;
                case 'c':
                case 'C':
                    if (argc > i+1)
                    {
                        IterationCount = atoi(&argv[i+1][0]);
                    }
                    i++;
                    break;
                case 'i':
                case 'I':
                    if (argc > i+1)
                    {
                        strcpy(inPipe, &argv[i+1][0]);
                    }
                    i++;
                    break;
                case 'u':
                case 'U':
                    fDumpUsbConfig = TRUE;
                    break;
                case 'v':
                case 'V':
                    fDumpReadData = TRUE;
                    break;
                case 'o':
                case 'O':
                    strcpy(outPipe, &argv[i+1][0]);
                    i++;
                    break;
                default: