path: root/general/pcidrv/test/testapp.c

/*++

Copyright (c) Microsoft Corporation.  All rights reserved.

    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.

Module Name: Testapp.c


Abstract:

    Testapp for PCIDRV

Environment:

    User mode only.

--*/

#include "testapp.h"


//
// Global variables
//
HINSTANCE   HWndInstance;
HWND        HWndList; // handle to the embedded list box
TCHAR       WindowTitle[]=TEXT("MyPing - Test Application for PCIDRV");
LIST_ENTRY  ListHead;
HDEVNOTIFY  InterfaceNotificationHandle;
TCHAR       OutText[500];
UINT        ListBoxIndex = 0;
GUID        InterfaceGuid;// = GUID_DEVINTERFACE_PCIDRV;
ULONG       DeviceIndex;
BOOLEAN     Verbose = FALSE;


VOID
Display(
    _In_ LPWSTR pstrFormat,  // @parm A printf style format string
    ...                 // @parm | ... | Variable paramters based on <p pstrFormat>
    )
{
    HRESULT hr;
    va_list va;

    va_start(va, pstrFormat);
    //
    // Truncation is acceptable.
    //
    hr = StringCbVPrintf(OutText, sizeof(OutText)-sizeof(WCHAR), pstrFormat, va);
    va_end(va);

    if(FAILED(hr)){
        return;
    }

    SendMessage(HWndList, LB_INSERTSTRING, ListBoxIndex, (LPARAM)OutText);
    SendMessage(HWndList, LB_SETCURSEL, ListBoxIndex, 0);
    ListBoxIndex++;

}

_Use_decl_annotations_
int
PASCAL
WinMain (
    HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPSTR lpCmdLine,
    int nShowCmd
    )
{
    static    TCHAR szAppName[]=TEXT("MYPING");
    HWND      hWnd;
    MSG       msg;
    WNDCLASS  wndclass;

    InterfaceGuid = GUID_DEVINTERFACE_PCIDRV;
    HWndInstance=hInstance;

    if (!hPrevInstance)
       {
         wndclass.style        =  CS_HREDRAW | CS_VREDRAW;
         wndclass.lpfnWndProc  =  WndProc;
         wndclass.cbClsExtra   =  0;
         wndclass.cbWndExtra   =  0;
         wndclass.hInstance    =  hInstance;
         wndclass.hIcon        =  LoadIcon (NULL, IDI_APPLICATION);
         wndclass.hCursor      =  LoadCursor(NULL, IDC_ARROW);
         wndclass.hbrBackground=  GetStockObject(WHITE_BRUSH);
         wndclass.lpszMenuName =  TEXT("GenericMenu");
         wndclass.lpszClassName=  szAppName;

         RegisterClass(&wndclass);
       }

        hWnd = CreateWindow (szAppName,
                         WindowTitle,
                         WS_OVERLAPPEDWINDOW,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         NULL,
                         NULL,
                         hInstance,
                         NULL);

    ShowWindow (hWnd, nShowCmd);
    UpdateWindow(hWnd);

    while (GetMessage (&msg, NULL, 0,0))
      {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
      }

    return (0);
}


LRESULT FAR PASCAL
WndProc (HWND hWnd,
         UINT message,
         WPARAM wParam,
         LPARAM lParam
         )
{
    DWORD                           nEventType = (DWORD)wParam;
    PDEV_BROADCAST_HDR              p = (PDEV_BROADCAST_HDR) lParam;
    DEV_BROADCAST_DEVICEINTERFACE   filter;
    WSADATA                         wsd;

    switch (message)
    {

        case WM_COMMAND:
            HandleCommands(hWnd, message, wParam, lParam);
            return 0;

        case WM_CREATE:

            // Load Winsock
            if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
            {
                MessageBox(hWnd, TEXT("WSAStartup failed"), TEXT("Error"), MB_OK);
                exit(0);
            }

            HWndList = CreateWindow (TEXT("listbox"),
                         NULL,
                         WS_CHILD|WS_VISIBLE|LBS_NOTIFY |
                         WS_VSCROLL | WS_BORDER,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         hWnd,
                         (HMENU)ID_EDIT,
                         HWndInstance,
                         NULL);

            filter.dbcc_size = sizeof(filter);
            filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
            filter.dbcc_classguid = InterfaceGuid;
            InterfaceNotificationHandle = RegisterDeviceNotification(hWnd, &filter, 0);

            InitializeListHead(&ListHead);
            EnumExistingDevices(hWnd);

            return 0;

      case WM_SIZE:

            MoveWindow(HWndList, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
            return 0;

      case WM_SETFOCUS:
            SetFocus(HWndList);
            return 0;

      case WM_DEVICECHANGE:

            //
            // The DBT_DEVNODES_CHANGED broadcast message is sent
            // everytime a device is added or removed. This message
            // is typically handled by Device Manager kind of apps,
            // which uses it to refresh window whenever something changes.
            // The lParam is always NULL in this case.
            //
            if(DBT_DEVNODES_CHANGED == wParam) {
                DisplayV(TEXT("Received DBT_DEVNODES_CHANGED broadcast message"));
                return 0;
            }

            //
            // All the events we're interested in come with lParam pointing to
            // a structure headed by a DEV_BROADCAST_HDR.  This is denoted by
            // bit 15 of wParam being set, and bit 14 being clear.
            //
            if((wParam & 0xC000) == 0x8000) {

                if (!p)
                    return 0;

                if (p->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE) {

                    HandleDeviceInterfaceChange(hWnd, nEventType, (PDEV_BROADCAST_DEVICEINTERFACE) p);
                } else if (p->dbch_devicetype == DBT_DEVTYP_HANDLE) {

                    HandleDeviceChange(hWnd, nEventType, (PDEV_BROADCAST_HANDLE) p);
                }
            }
            return 0;

      case WM_POWERBROADCAST:
            HandlePowerBroadcast(hWnd, wParam, lParam);
            return 0;

      case WM_CLOSE:
            Cleanup(hWnd);
            UnregisterDeviceNotification(InterfaceNotificationHandle);
            return  DefWindowProc(hWnd,message, wParam, lParam);

        case WM_DESTROY:
            PostQuitMessage(0);
            return 0;
    }
    return DefWindowProc(hWnd,message, wParam, lParam);
  }


LRESULT
HandleCommands(
    HWND     hWnd,
    UINT     uMsg,
    WPARAM   wParam,
    LPARAM     lParam
    )

{
    PDIALOG_RESULT result = NULL;
    PDEVICE_INFO deviceInfo = NULL;

    switch (wParam) {

        case IDM_CLOSE:
            Cleanup(hWnd);
            Display(TEXT("Handle to the device closed"));
            EnableMenuItem(GetMenu(hWnd), IDM_PING, MF_BYCOMMAND|MF_GRAYED);
            EnableMenuItem(GetMenu(hWnd), IDM_CLOSE, MF_BYCOMMAND|MF_GRAYED);
            break;

        case IDM_ENUMERATE:
            //
            // First cleanup everything, and then reenumerate all the devices.
            Cleanup(hWnd);
            EnumExistingDevices(hWnd);
            EnableMenuItem(GetMenu(hWnd), IDM_PING, MF_BYCOMMAND|MF_ENABLED);
            break;

        case IDM_PING:

            result = (PDIALOG_RESULT)DialogBox(HWndInstance, MAKEINTRESOURCE(IDD_DIALOG), hWnd, DlgProc);
            if(result) {
                deviceInfo = FindDeviceInfo(result);
                if(!deviceInfo){
                    MessageBox(hWnd, TEXT("FindDeviceInfo failed"), TEXT("Error"), MB_OK);
                    break;
                }

                if(!OpenDevice(hWnd, deviceInfo)){
                    MessageBox(hWnd, TEXT("OpenDevice failed"), TEXT("Error"), MB_OK);
                    break;
                }

                if (!CreatePingThread(deviceInfo)) {
                    MessageBox(hWnd, TEXT("CreatePingThread failed"), TEXT("Error"), MB_OK);
                    break;
                }

                EnableMenuItem(GetMenu(hWnd), IDM_PING, MF_BYCOMMAND|MF_GRAYED);
                EnableMenuItem(GetMenu(hWnd), IDM_CLOSE, MF_BYCOMMAND|MF_ENABLED);

            }
            break;

        case IDM_CLEAR:
            SendMessage(HWndList, LB_RESETCONTENT, 0, 0);
            ListBoxIndex = 0;
            break;

        case IDM_VERBOSE: {

                HMENU hMenu = GetMenu(hWnd);
                Verbose = !Verbose;
                if(Verbose) {
                    CheckMenuItem(hMenu, (UINT)wParam, MF_CHECKED);
                } else {
                    CheckMenuItem(hMenu, (UINT)wParam, MF_UNCHECKED);
                }
            }
            break;

        case IDM_EXIT:
            Cleanup(hWnd);
            PostQuitMessage(0);
            break;

        default:
            break;
    }

    if(result) {
        HeapFree (GetProcessHeap(), 0, result);
    }
    return TRUE;
}

INT_PTR CALLBACK
DlgProc(
    HWND hDlg,
    UINT message,
    WPARAM wParam,
    LPARAM lParam
)
{
    BOOL            success;
    PDIALOG_RESULT  dialogResult = NULL;
    ULONG           value;
    WCHAR SourceIP[80];
    WCHAR DestinationIP[80];
    DWORD SourceIPLen = sizeof(SourceIP);

    switch(message)
    {
        case WM_INITDIALOG:
            //
            // Set default values.
            //
            if(GetRegistryInfo(SourceIP, &SourceIPLen, DestinationIP, &SourceIPLen)) {
                SetDlgItemText(hDlg, IDC_SOURCE_IP, SourceIP);
                SetDlgItemText(hDlg, IDC_DESTINATION_IP, DestinationIP);
            } else {
                SetDlgItemText(hDlg, IDC_SOURCE_IP, DEF_SOURCE_IP);
                SetDlgItemText(hDlg, IDC_DESTINATION_IP, DEF_DEST_IP);

            }

            SetDlgItemInt(hDlg, IDC_PACKET_SIZE, MAX_PAYLOAD_SIZE, FALSE);
            return TRUE;

        case WM_COMMAND:
            switch( wParam)
            {
            case ID_OK:
                //
                // Allocate memory to store the input values.
                //
                dialogResult = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                    sizeof(DIALOG_RESULT));
                if(dialogResult) {

                    dialogResult->DeviceIndex = GetDlgItemInt(hDlg,
                                            IDC_DEVICE_INDEX, &success, FALSE );
                    if(!success){
                        break;
                    }
                    value = GetDlgItemText(hDlg, IDC_SOURCE_IP,
                                            dialogResult->SourceIp, MAX_LEN-1 );
                    if(!value){
                        break;
                    }


                    GetDlgItemText(hDlg, IDC_DESTINATION_IP,
                                        dialogResult->DestIp, MAX_LEN-1 );
                    if(!value){
                        break;
                    }

                    value = GetDlgItemInt(hDlg,IDC_PACKET_SIZE, &success, FALSE );
                    if(success){
                        value = min(value, MAX_PAYLOAD_SIZE);
                        value = max(value, MIN_PAYLOAD_SIZE);

                    } else {
                        value = MIN_PAYLOAD_SIZE;
                    }

                    dialogResult->PacketSize = value;

                    SetRegistryInfo(dialogResult->SourceIp,
                                    sizeof(dialogResult->SourceIp),
                                    dialogResult->DestIp,
                                    sizeof(dialogResult->DestIp));

                }
                EndDialog(hDlg, (UINT_PTR)dialogResult);
                return TRUE;
            case ID_CANCEL:
                EndDialog(hDlg, 0);
                return TRUE;

            }
            break;

    }
    return FALSE;
}


BOOL
HandleDeviceInterfaceChange(
    HWND        hWnd,
    DWORD       evtype,
    PDEV_BROADCAST_DEVICEINTERFACE dip
    )
{
    switch (evtype)
    {
        case DBT_DEVICEARRIVAL:
        //
        // New device arrived. Create a devicinfo structure and record
        // information about the device.
        //
        Display(TEXT("New device Arrived (Interface Change Notification)"));

        if(!CreateDeviceInfo(dip->dbcc_name)) {
            return FALSE;
        }

        break;

        case DBT_DEVICEREMOVECOMPLETE:
        //
        // Device Removed.
        //
        Display(TEXT("Remove Complete (Interface Change Notification)"), NULL);
        break;

        default:
        DisplayV(TEXT("Unknown (Interface Change Notification)"), NULL);
        break;
    }
    return TRUE;
}

BOOL
HandleDeviceChange(
    HWND    hWnd,
    DWORD   evtype,
    PDEV_BROADCAST_HANDLE dhp
    )
{
    PDEVICE_INFO            deviceInfo = NULL;
    PLIST_ENTRY             thisEntry;

    //
    // Walk the list to get the deviceInfo for this device
    // by matching the notification handle saved in our deviceInfo
    // and the one provided as part of the message.
    //
    for(thisEntry = ListHead.Flink; thisEntry != &ListHead;
                        thisEntry = thisEntry->Flink)
    {
        deviceInfo = CONTAINING_RECORD(thisEntry, DEVICE_INFO, ListEntry);
        if(dhp->dbch_hdevnotify == deviceInfo->hHandleNotification) {
            break;
        }
        deviceInfo = NULL;
    }

    if(!deviceInfo) {
        Display(TEXT("Error: spurious message Event Type %x, Device Type %x"),
                                evtype, dhp->dbch_devicetype);
        return FALSE;
    }

    switch (evtype)
    {

    case DBT_DEVICEQUERYREMOVE:

        Display(TEXT("Query Remove (Handle Notification): %ws"),
                        deviceInfo->DeviceName);
        // User is trying to disable, uninstall, or eject our device.
        // Terminate the ping thread and close the handle
        // to the device so that the target device can
        // get removed. Do not unregister the notification
        // at this point, because we want to know whether
        // the device is successfully removed or not.
        //
        TerminatePingThread(deviceInfo);
        break;

    case DBT_DEVICEREMOVECOMPLETE:

        Display(TEXT("Remove Complete (Handle Notification):%ws"),
                deviceInfo->DeviceName);
        //
        // Device is getting surprise removed. So terminate the
        // ping thread to close the handle to device and
        // unregister the PNP notification.
        //
        TerminatePingThread(deviceInfo);

        if (deviceInfo->hHandleNotification) {
            UnregisterDeviceNotification(deviceInfo->hHandleNotification);
            deviceInfo->hHandleNotification = NULL;
        }

        //
        // Unlink this deviceInfo from the list and free the memory
        //
        RemoveEntryList(&deviceInfo->ListEntry);
        HeapFree (GetProcessHeap(), 0, deviceInfo);

        break;

    case DBT_DEVICEREMOVEPENDING:

        Display(TEXT("Remove Pending (Handle Notification):%ws"),
                                        deviceInfo->DeviceName);
        //
        // Device is successfully removed so unregister the notification
        // and free the memory.
        //
        FreeDeviceInfo(deviceInfo);

        break;

    case DBT_DEVICEQUERYREMOVEFAILED :
        Display(TEXT("Remove failed (Handle Notification):%ws"),
                                    deviceInfo->DeviceName);
        //
        // Remove failed. So reopen the device and register for
        // notification on the new handle. But first we should unregister
        // the previous notification.
        //
        if (deviceInfo->hHandleNotification) {
            UnregisterDeviceNotification(deviceInfo->hHandleNotification);
            deviceInfo->hHandleNotification = NULL;
        }

        if(!OpenDevice(hWnd, deviceInfo)) {
            Display(TEXT("Failed to reopen the device: %ws"),
                    deviceInfo->DeviceName);
            FreeDeviceInfo(deviceInfo);
            break;
        }

        Display(TEXT("Reopened device %ws"), deviceInfo->DeviceName);
        //
        // Restart the ping operation.
        //
        if(CreatePingThread(deviceInfo)){
            FreeDeviceInfo(deviceInfo);
            break;
        }

        break;

    default:
        Display(TEXT("Unknown (Handle Notification)"));
        break;

    }
    return TRUE;
}


BOOLEAN
EnumExistingDevices(
    HWND   hWnd
)
{
    HDEVINFO                            hardwareDeviceInfo;
    SP_DEVICE_INTERFACE_DATA            deviceInterfaceData;
    PSP_DEVICE_INTERFACE_DETAIL_DATA    deviceInterfaceDetailData = NULL;
    ULONG                               predictedLength = 0;
    ULONG                               requiredLength = 0, i;
    DWORD                               error;
    PDEVICE_INFO                        deviceInfo =NULL;

    DisplayV(TEXT("Entered EnumExistingDevices"));

    //
    // Make sure the list is empty
    //
    if(!IsListEmpty(&ListHead) ){
        MessageBox(hWnd, TEXT("ListHead should be empty"), TEXT("Error!"), MB_OK);
        return FALSE;
    }

    DeviceIndex = 0;

    hardwareDeviceInfo = SetupDiGetClassDevs (
                       (LPGUID)&InterfaceGuid,
                       NULL, // Define no enumerator (global)
                       NULL, // Define no
                       (DIGCF_PRESENT | // Only Devices present
                       DIGCF_DEVICEINTERFACE)); // Function class devices.
    if(INVALID_HANDLE_VALUE == hardwareDeviceInfo)
    {
        goto Error;
    }

    //
    // Enumerate devices of a specific interface class
    //
    deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);

    for(i=0; SetupDiEnumDeviceInterfaces (hardwareDeviceInfo,
                                 0, // No care about specific PDOs
                                 (LPGUID)&InterfaceGuid,
                                 i, //
                                 &deviceInterfaceData); i++ ) {

        //
        // Allocate a function class device data structure to
        // receive the information about this particular device.
        //

        //
        // First find out required length of the buffer
        //
        if (deviceInterfaceDetailData) {
            HeapFree (GetProcessHeap(), 0, deviceInterfaceDetailData);
            deviceInterfaceDetailData = NULL;
        }

        if(!SetupDiGetDeviceInterfaceDetail (
                hardwareDeviceInfo,
                &deviceInterfaceData,
                NULL, // probing so no output buffer yet
                0, // probing so output buffer length of zero
                &requiredLength,
                NULL) && (error = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
        {
            goto Error;
        }
        predictedLength = requiredLength;

        deviceInterfaceDetailData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                        predictedLength);
        if (deviceInterfaceDetailData == NULL) {
            goto Error;
        }

        deviceInterfaceDetailData->cbSize =
                        sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA);


        if (! SetupDiGetDeviceInterfaceDetail (
                   hardwareDeviceInfo,
                   &deviceInterfaceData,
                   deviceInterfaceDetailData,
                   predictedLength,
                   &requiredLength,
                   NULL)) {
            goto Error;
        }

        deviceInfo = CreateDeviceInfo(deviceInterfaceDetailData->DevicePath);

        if(!deviceInfo)
            goto Error;


    }

    if(deviceInterfaceDetailData) {
        HeapFree (GetProcessHeap(), 0, deviceInterfaceDetailData);
    }

    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    return 0;

Error:

    error = GetLastError();
    MessageBox(hWnd, TEXT("EnumExisting Devices failed"), TEXT("Error!"), MB_OK);
    if(deviceInterfaceDetailData)
        HeapFree (GetProcessHeap(), 0, deviceInterfaceDetailData);

    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    Cleanup(hWnd);
    return 0;
}

PDEVICE_INFO
FindDeviceInfo(
    PDIALOG_RESULT InputInfo
    )
{
    PLIST_ENTRY thisEntry, listHead;
    PDEVICE_INFO    deviceInfo = NULL, result = NULL;

    listHead = &ListHead;

    for(thisEntry = listHead->Flink;
       thisEntry != listHead;
       thisEntry = thisEntry->Flink){

        deviceInfo = CONTAINING_RECORD(thisEntry, DEVICE_INFO, ListEntry);

        if(deviceInfo->DeviceIndex == InputInfo->DeviceIndex){

            if(deviceInfo->IsANetworkMiniport){
                Display(TEXT("You can't use this app on a device installed as a network device"));
                break;
            }

            if(deviceInfo->hDevice &&
                deviceInfo->hDevice != INVALID_HANDLE_VALUE){
                Display(TEXT("%ws device is already in use"),
                        deviceInfo->DeviceName);
                break;
            }


            deviceInfo->DeviceIndex = InputInfo->DeviceIndex;
            deviceInfo->PacketSize = InputInfo->PacketSize;
            memcpy(deviceInfo->UnicodeSourceIp, InputInfo->SourceIp, MAX_LEN);
            memcpy(deviceInfo->UnicodeDestIp, InputInfo->DestIp, MAX_LEN);
            //
            // Convert the unicode source and destination IP string
            // to ANSI and store it.
            //
            WideCharToMultiByte(CP_ACP, //ANSI code page
                        0, deviceInfo->UnicodeSourceIp, -1,
                        deviceInfo->SourceIp, MAX_LEN, NULL, NULL);

            //
            // Convert Unicode string to ANSI.
            //
            WideCharToMultiByte(CP_ACP, 0, deviceInfo->UnicodeDestIp, -1,
                        deviceInfo->DestIp, MAX_LEN, NULL, NULL);


            result = deviceInfo;
            break;
        }

    }

    return result;

}

PDEVICE_INFO
CreateDeviceInfo(
    _In_ LPWSTR DevicePath
    )
{
    PDEVICE_INFO deviceInfo = NULL;
    HRESULT      hr;

    DisplayV(TEXT("Entered CreateDeviceInfo"));

    deviceInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DEVICE_INFO));
    if(!deviceInfo) {
        goto Error;
    }


    if(!GetDeviceDescription(DevicePath,
                                deviceInfo->DeviceName,
                                sizeof(deviceInfo->DeviceName),
                                &deviceInfo->IsANetworkMiniport
                                )) {
        Display(TEXT("GetDeviceDescription failed %x"), GetLastError());
        goto Error;
    }


    //
    // Copy the device path so that we can open the device using CreateFile.
    //
    hr = StringCchCopy(deviceInfo->DevicePath, MAX_PATH, DevicePath);
    if(FAILED(hr)){
        goto Error;
    }

    DeviceIndex++;
    deviceInfo->DeviceIndex = DeviceIndex;

    //
    // Link this to the global list of devices.
    //
    InitializeListHead(&deviceInfo->ListEntry);
    InsertTailList(&ListHead, &deviceInfo->ListEntry);

    Display(TEXT("Device %d is %ws"), DeviceIndex, deviceInfo->DeviceName);

    return deviceInfo;

Error:

    if(deviceInfo) {
        HeapFree (GetProcessHeap(), 0, deviceInfo);
    }
    return NULL;

}

VOID
FreeDeviceInfo(
    _In_ PDEVICE_INFO DeviceInfo
    )
{
    DisplayV(TEXT("Entered FreeDeviceInfo"));

    if (DeviceInfo->hHandleNotification) {
        UnregisterDeviceNotification(DeviceInfo->hHandleNotification);
        DeviceInfo->hHandleNotification = NULL;
    }
    if (DeviceInfo->hDevice != INVALID_HANDLE_VALUE &&
            DeviceInfo->hDevice != NULL) {
        CloseHandle(DeviceInfo->hDevice);
        DeviceInfo->hDevice = INVALID_HANDLE_VALUE;
        Display(TEXT("Closed handle to device %ws"), DeviceInfo->DeviceName );
    }

    RemoveEntryList(&DeviceInfo->ListEntry);

    HeapFree (GetProcessHeap(), 0, DeviceInfo);

    return;
}

BOOL
SetRegistryInfo(
    _In_reads_bytes_(SourceIPLen) LPWSTR SourceIP,
    _In_ DWORD SourceIPLen,
    _In_reads_bytes_(DestinationIPLen) LPWSTR  DestinationIP,
    _In_ DWORD DestinationIPLen
    )
{
    HKEY    hKey;
    BOOL    ret = FALSE;
    size_t  srcStrLen, destStrLen;

    if (FAILED(StringCbLengthW(SourceIP, SourceIPLen, &srcStrLen))) {
        return ret;
    }

    if (FAILED(StringCbLengthW(DestinationIP, DestinationIPLen, &destStrLen))) {
        return ret;
    }

    //
    // RegSetValueEx takes a DWORD, in the rare case that size_t is larger than
    // a DWORD return an error.
    //
    if (srcStrLen > (DWORD_MAX - sizeof(WCHAR))|| 
        destStrLen > (DWORD_MAX - sizeof(WCHAR))) {
        return ret;
    }

    if (RegOpenKey(HKEY_LOCAL_MACHINE, REG_PATH,  &hKey)) {

        if (ERROR_SUCCESS != RegCreateKey(HKEY_LOCAL_MACHINE, REG_PATH, &hKey)) {
            Display(TEXT("RegCreateKey failed: %x"), GetLastError());
            return ret;
        }
    }

    if (ERROR_SUCCESS == RegSetValueEx(hKey, L"SourceIP", 0, REG_SZ,
                (LPBYTE)SourceIP, (DWORD) srcStrLen+sizeof(WCHAR))) {

        if (ERROR_SUCCESS == RegSetValueEx(hKey, L"DestinationIP", 0, REG_SZ,
                    (LPBYTE)DestinationIP, (DWORD) destStrLen+sizeof(WCHAR))) {
            ret = TRUE;
        }
    }

    RegCloseKey(hKey);
    return ret;
}

_Success_(return)
BOOL
GetRegistryInfo(
    _Out_writes_bytes_(* SourceIPLen) PWSTR SourceIP,
    _Inout_ LPDWORD SourceIPLen,
    _Out_writes_bytes_(* DestinationIPLen) PWSTR  DestinationIP,
    _Inout_ LPDWORD DestinationIPLen
    )
{
    HKEY                                hKey;
    DWORD   dwType = REG_SZ;
    BOOL ret = FALSE;

    if(ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, REG_PATH,  &hKey)) {

        if(ERROR_SUCCESS == RegQueryValueEx(hKey, L"SourceIP", NULL, &dwType,
                                            (LPBYTE)SourceIP, SourceIPLen)){

            if(ERROR_SUCCESS == RegQueryValueEx(hKey, L"DestinationIP", NULL, &dwType,
                                            (LPBYTE)DestinationIP, DestinationIPLen)){

                ret = TRUE;
            }

       }
        RegCloseKey(hKey);
    }

    return ret;
}



BOOLEAN
OpenDevice(
    _In_ HWND HWnd,
    _In_ PDEVICE_INFO DeviceInfo
    )
{
    DEV_BROADCAST_HANDLE    filter;
    HANDLE                  hDevice;

    DisplayV(TEXT("Entered OpenDevice"));

    //
    // Open an handle to the device.
    //
    hDevice = CreateFile (
            DeviceInfo->DevicePath,
            GENERIC_READ | GENERIC_WRITE,
            0,
            NULL, // no SECURITY_ATTRIBUTES structure
            OPEN_EXISTING, // No special create flags
            FILE_FLAG_OVERLAPPED,
            NULL);

    if (INVALID_HANDLE_VALUE == hDevice) {
        Display(TEXT("Failed to open the device: %ws"),
                DeviceInfo->DeviceName);
        return FALSE;
    }

    Display(TEXT("Opened handled to the device: %ws"),
                DeviceInfo->DeviceName);
    //
    // Register handle based notification to receive pnp
    // device change notification on the handle.
    //

    memset (&filter, 0, sizeof(filter)); //zero the structure
    filter.dbch_size = sizeof(filter);
    filter.dbch_devicetype = DBT_DEVTYP_HANDLE;
    filter.dbch_handle = hDevice;

    DeviceInfo->hHandleNotification = RegisterDeviceNotification(HWnd, &filter, 0);
    if(!DeviceInfo->hHandleNotification){
        Display(TEXT("Failed to register notification: %ws"),
                DeviceInfo->DeviceName);
        CloseHandle(hDevice);
        return FALSE;
    }

    DeviceInfo->hDevice = hDevice;

    return TRUE;

}


BOOL
CreatePingThread(
    PDEVICE_INFO DeviceInfo
    )
{
    ULONG id;

    DisplayV(TEXT("CreatePingThread"));

    DeviceInfo->ExitThread = FALSE;

    //
    // Start the ping operation in a separate thread.
    //
    DeviceInfo->ThreadHandle = CreateThread( NULL,      // security attributes
                        0,         // initial stack size
                        (LPTHREAD_START_ROUTINE) PingThread,    // Main() function
                        DeviceInfo,      // arg to Reader thread
                        0,         // creation flags
                        (LPDWORD)&id); // returned thread id

    if ( NULL == DeviceInfo->ThreadHandle) {
        Display(TEXT("CreateThread failed %x"), GetLastError());
        return FALSE;
    }

    return TRUE;
}

VOID
TerminatePingThread(
    PDEVICE_INFO DeviceInfo
    )
{
    DWORD status;

    DisplayV(TEXT("TerminatePingThread"));

    if(DeviceInfo->ThreadHandle){

        DeviceInfo->ExitThread = TRUE;
        //
        // Wait for the thread to exit
        //
        status = WaitForSingleObjectEx(DeviceInfo->ThreadHandle, 1000, TRUE );
        if(status == WAIT_FAILED){
            Display(TEXT("Wait failed %x"), GetLastError());
        }
        CloseHandle(DeviceInfo->ThreadHandle);
        DeviceInfo->ThreadHandle = NULL;
    }

}

BOOLEAN
Cleanup(
    HWND hWnd
    )
/*++

    This routine walks the global list of currently enumerated devices
    and close all handles and frees the memory.
 --*/
{
    PDEVICE_INFO    deviceInfo =NULL;
    PLIST_ENTRY     thisEntry;

    DisplayV(TEXT("Entered Cleanup"));

    while (!IsListEmpty(&ListHead)) {
        thisEntry = ListHead.Flink;
        deviceInfo = CONTAINING_RECORD(thisEntry, DEVICE_INFO, ListEntry);
        //
        // First let us make sure the PingThread is not running.
        //
        TerminatePingThread(deviceInfo);
        FreeDeviceInfo(deviceInfo);
    }
    return TRUE;
}


_Success_(return != FALSE)
BOOL
GetDeviceDescription(
    _In_ LPTSTR DevPath,
    _Out_writes_bytes_all_(OutBufferLen) LPTSTR OutBuffer,
    _In_ ULONG OutBufferLen,
    BOOL   *NetClassDevice
)
{
    HDEVINFO                            hardwareDeviceInfo = NULL;
    SP_DEVICE_INTERFACE_DATA            deviceInterfaceData;
    SP_DEVINFO_DATA                     deviceInfoData;
    DWORD                               dwRegType, error;
    TCHAR                               classGuidString[MAX_GUID_STRING_LEN];
    HRESULT                             hr;
    GUID                                classGuid;
    BOOL                                ret = FALSE;

    DisplayV(TEXT("GetDeviceDescription"));

    hardwareDeviceInfo = SetupDiCreateDeviceInfoList(NULL, NULL);
    if(INVALID_HANDLE_VALUE == hardwareDeviceInfo)
    {
        Display(TEXT("Couldn't create DeviceInfoList: %x"), GetLastError());
        goto Error;
    }

    //
    // Enumerate devices of toaster class
    //
    deviceInterfaceData.cbSize = sizeof(deviceInterfaceData);

    SetupDiOpenDeviceInterface (hardwareDeviceInfo, DevPath,
                                 0, //
                                 &deviceInterfaceData);

    deviceInfoData.cbSize = sizeof(deviceInfoData);
    if(!SetupDiGetDeviceInterfaceDetail (
            hardwareDeviceInfo,
            &deviceInterfaceData,
            NULL, // probing so no output buffer yet
            0, // probing so output buffer length of zero
            NULL,
            &deviceInfoData) && (error = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
    {
        Display(TEXT("Couldn't get interface detail: %x"), GetLastError());
        goto Error;
    }
    //
    // Get the friendly name for this instance, if that fails
    // try to get the device description.
    //

    if(!SetupDiGetDeviceRegistryProperty(hardwareDeviceInfo, &deviceInfoData,
                                     SPDRP_FRIENDLYNAME,
                                     &dwRegType,
                                     (BYTE*) OutBuffer,
                                     OutBufferLen,
                                     NULL))
    {
        if(!SetupDiGetDeviceRegistryProperty(hardwareDeviceInfo, &deviceInfoData,
                                     SPDRP_DEVICEDESC,
                                     &dwRegType,
                                     (BYTE*) OutBuffer,
                                     OutBufferLen,
                                     NULL)){
            Display(TEXT("Couldn't get friendlyname: %x"), GetLastError());
            goto Error;

        }


    }

    //
    // Get the class guid of the device and find out whether this is a
    // network miniport.
    //
    if(!SetupDiGetDeviceRegistryProperty(hardwareDeviceInfo,
                 &deviceInfoData,
                 SPDRP_CLASSGUID,
                 &dwRegType,
                 (BYTE*) classGuidString,
                 sizeof(classGuidString),
                 NULL)) {
        Display(TEXT("Class guid is not available for device: %ws"), OutBuffer );
    }

    hr = CLSIDFromString(classGuidString, &classGuid);
    if(FAILED(hr)) {
        goto Error;
    }

    if(IsEqualGUID(&classGuid, &GUID_DEVCLASS_NET)){
        *NetClassDevice = TRUE;
    } else {
        *NetClassDevice = FALSE;
    }

    ret = TRUE;

Error:

    if(hardwareDeviceInfo) {
        SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    }
    return ret;
}


BOOL
HandlePowerBroadcast(
    HWND hWnd,
    WPARAM wParam,
    LPARAM lParam)
{
    BOOL fRet = TRUE;

    switch (wParam)
    {
        case PBT_APMQUERYSTANDBY:
            DisplayV(TEXT("PBT_APMQUERYSTANDBY"));
            break;
        case PBT_APMQUERYSUSPEND:
            DisplayV(TEXT("PBT_APMQUERYSUSPEND"));
            break;
        case PBT_APMSTANDBY :
            DisplayV(TEXT("PBT_APMSTANDBY"));
            break;
        case PBT_APMSUSPEND :
            DisplayV(TEXT("PBT_APMSUSPEND"));
            break;
        case PBT_APMQUERYSTANDBYFAILED:
            DisplayV(TEXT("PBT_APMQUERYSTANDBYFAILED"));
            break;
        case PBT_APMRESUMESTANDBY:
            DisplayV(TEXT("PBT_APMRESUMESTANDBY"));
            break;
        case PBT_APMQUERYSUSPENDFAILED:
            DisplayV(TEXT("PBT_APMQUERYSUSPENDFAILED"));
            break;
        case PBT_APMRESUMESUSPEND:
            DisplayV(TEXT("PBT_APMRESUMESUSPEND"));
            break;
        case PBT_APMBATTERYLOW:
            DisplayV(TEXT("PBT_APMBATTERYLOW"));
            break;
        case PBT_APMOEMEVENT:
            DisplayV(TEXT("PBT_APMOEMEVENT"));
            break;
        case PBT_APMRESUMEAUTOMATIC:
            DisplayV(TEXT("PBT_APMRESUMEAUTOMATIC"));
            break;
        case PBT_APMRESUMECRITICAL:
            DisplayV(TEXT("PBT_APMRESUMECRITICAL"));
            break;
        case PBT_APMPOWERSTATUSCHANGE:
            DisplayV(TEXT("PBT_APMPOWERSTATUSCHANGE"));
            break;
        default:
            DisplayV(TEXT("Default"));
            break;
    }
    return fRet;
}