Windows Driver Development | Windows Driver Samples | Toaster Sample Driver | C++ | exe | notify

Sample Code

Windows Driver Samples/ Toaster Sample Driver/ C++/ exe/ notify/ notify.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: notify.c
 
 
Abstract:
 
 
Author:
 
     Eliyas Yakub   Nov 23, 1999
 
Environment:
 
    User mode only.
 
Revision History:
 
    Modified to use linked list for deviceInfo
    instead of arrays. (5/12/2000)
 
--*/
#define UNICODE
#define _UNICODE
#define INITGUID
 
//
// Annotation to indicate to prefast that this is nondriver user-mode code.
//
#include <DriverSpecs.h>
_Analysis_mode_(_Analysis_code_type_user_code_)  
 
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <setupapi.h>
#include <dbt.h>
#include <winioctl.h>
#include <strsafe.h>
#include "public.h"
#include "notify.h"
#include <dontuse.h>
 
BOOL
HandlePowerBroadcast(
    HWND hWnd,
    WPARAM wParam,
    LPARAM lParam);
 
//
// Global variables
//
HINSTANCE   hInst;
HWND        hWndList;
TCHAR       szTitle[]=TEXT("Toaster Package Test Application");
LIST_ENTRY  ListHead;
HDEVNOTIFY  hInterfaceNotification;
TCHAR       OutText[500];
UINT        ListBoxIndex = 0;
GUID        InterfaceGuid;// = GUID_DEVINTERFACE_TOASTER;
BOOLEAN     Verbose= FALSE;
 
_inline BOOLEAN
IsValid(
    ULONG No
    )
{
    PLIST_ENTRY thisEntry;
    PDEVICE_INFO deviceInfo;
 
    if(0==(No)) return TRUE; //special case
 
    for(thisEntry = ListHead.Flink; thisEntry != &ListHead;
                        thisEntry = thisEntry->Flink)
    {
            deviceInfo = CONTAINING_RECORD(thisEntry, DEVICE_INFO, ListEntry);
            if((No) == deviceInfo->SerialNo) {
                return TRUE;
        }
    }
    return 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++;
 
}
 
VOID
DisplayV(
    _In_ LPWSTR pstrFormat,  // @parm A printf style format string
    ...                 // @parm | ... | Variable paramters based on <p pstrFormat>
    )
{
    va_list va;
 
    if (Verbose)
    {
        va_start(va, pstrFormat);
            Display(pstrFormat, va);
        va_end(va);
    }
}
int PASCAL
WinMain (
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPSTR lpCmdLine,
    _In_ int nShowCmd
    )
{
    static    TCHAR szAppName[]=TEXT("Toaster Notify");
    HWND      hWnd;
    MSG       msg;
    WNDCLASS  wndclass;
 
    UNREFERENCED_PARAMETER( lpCmdLine );
 
    InterfaceGuid = GUID_DEVINTERFACE_TOASTER;
    hInst=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,
                         szTitle,
                         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;
 
    switch (message)
    {
 
        case WM_COMMAND:
            HandleCommands(hWnd, message, wParam, lParam);
            return 0;
 
        case WM_CREATE:
 
            //
            // Load and set the icon of the program
            //
            SetClassLongPtr(hWnd, GCLP_HICON,
                (LONG_PTR)LoadIcon((HINSTANCE)lParam,MAKEINTRESOURCE(IDI_CLASS_ICON)));
 
            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,
                         hInst,
                         NULL);
 
            filter.dbcc_size = sizeof(filter);
            filter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
            filter.dbcc_classguid = InterfaceGuid;
            hInterfaceNotification = 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(hInterfaceNotification);
            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;
 
    UNREFERENCED_PARAMETER( uMsg );
    UNREFERENCED_PARAMETER( lParam );
 
    switch (wParam) {
 
        case IDM_OPEN:
            Cleanup(hWnd); // close all open handles
            EnumExistingDevices(hWnd);
            break;
 
        case IDM_CLOSE:
            Cleanup(hWnd);
            break;
 
        case IDM_HIDE:
            result = (PDIALOG_RESULT)DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, DlgProc);
            if(result && result->SerialNo && IsValid(result->SerialNo)) {
                DWORD bytes;
                PDEVICE_INFO deviceInfo = NULL;
                PLIST_ENTRY thisEntry;
 
                //
                // Find out the deviceInfo that matches this SerialNo.
                // We need the deviceInfo to get the handle to the device.
                //
                for(thisEntry = ListHead.Flink; thisEntry != &ListHead;
                    thisEntry = thisEntry->Flink)
                {
                    deviceInfo = CONTAINING_RECORD(thisEntry, DEVICE_INFO, ListEntry);
                    if(result->SerialNo == deviceInfo->SerialNo) {
                        break;
                    }
                    deviceInfo = NULL;
                }
 
                //
                // If found send I/O control
                //
 
                if (deviceInfo && !DeviceIoControl (deviceInfo->hDevice,
                          IOCTL_TOASTER_DONT_DISPLAY_IN_UI_DEVICE,
                          NULL, 0,
                          NULL, 0,
                          &bytes, NULL)) {
                       MessageBox(hWnd, TEXT("Request Failed or Invalid Serial No"),
                                   TEXT("Error"), MB_OK);
                }
             }
            break;
        case IDM_PLUGIN:
 
            result = (PDIALOG_RESULT)DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG), hWnd, DlgProc);
            if(result) {
                if(!result->SerialNo || !OpenBusInterface(result->SerialNo, result->DeviceId, PLUGIN)){
                    MessageBox(hWnd, TEXT("Invalid Serial Number or OpenBusInterface Failed"), TEXT("Error"), MB_OK);
                }
             }
            break;
        case IDM_UNPLUG:
            result = (PDIALOG_RESULT)DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, DlgProc);
 
            if(result && IsValid(result->SerialNo)) {
                if(!OpenBusInterface(result->SerialNo, NULL, UNPLUG)) {
                       MessageBox(hWnd, TEXT("Invalid Serial Number or OpenBusInterface Failed"), TEXT("Error"), MB_OK);
                }
             }
            break;
        case IDM_EJECT:
            result = (PDIALOG_RESULT)DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, DlgProc);
            if(result && IsValid(result->SerialNo)) {
                if(!OpenBusInterface(result->SerialNo, NULL, EJECT)) {
                       MessageBox(hWnd, TEXT("Invalid Serial Number or OpenBusInterface  Failed"), TEXT("Error"), MB_OK);
                }
             }
            break;
 
        case IDM_CLEAR:
            SendMessage(hWndList, LB_RESETCONTENT, 0, 0);
            ListBoxIndex = 0;
            break;
 
        case IDM_IOCTL:
            SendIoctlToFilterDevice();
            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:
            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;
 
    UNREFERENCED_PARAMETER( lParam );
 
    switch(message)
    {
        case WM_INITDIALOG:
               SetDlgItemText(hDlg, IDC_DEVICEID, BUS_HARDWARE_IDS);
            return TRUE;
 
        case WM_COMMAND:
            switch( wParam)
            {
            case ID_OK:
                dialogResult = HeapAlloc(GetProcessHeap(),
                                        HEAP_ZERO_MEMORY,
                                        (sizeof(DIALOG_RESULT) + MAX_PATH * sizeof(WCHAR)));
                if(dialogResult) {
                    dialogResult->DeviceId = (PWCHAR)((PCHAR)dialogResult + sizeof(DIALOG_RESULT));
                    dialogResult->SerialNo = GetDlgItemInt(hDlg,IDC_SERIALNO, &success, FALSE );
                    GetDlgItemText(hDlg, IDC_DEVICEID, dialogResult->DeviceId, MAX_PATH-1 );
                }
                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
    )
{
    DEV_BROADCAST_HANDLE    filter;
    PDEVICE_INFO            deviceInfo = NULL;
    HRESULT                 hr;
 
    switch (evtype)
    {
        case DBT_DEVICEARRIVAL:
        //
        // New device arrived. Open handle to the device
        // and register notification of type DBT_DEVTYP_HANDLE
        //
 
        deviceInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DEVICE_INFO));
        if(!deviceInfo)
            return FALSE;
 
        InitializeListHead(&deviceInfo->ListEntry);
        InsertTailList(&ListHead, &deviceInfo->ListEntry);
 
 
        if(!GetDeviceDescription(dip->dbcc_name,
                                 (PBYTE)deviceInfo->DeviceName,
                                 sizeof(deviceInfo->DeviceName),
                                 &deviceInfo->SerialNo)) {
            MessageBox(hWnd, TEXT("GetDeviceDescription failed"), TEXT("Error!"), MB_OK);
        }
 
        Display(TEXT("New device Arrived (Interface Change Notification): %ws"),
                    deviceInfo->DeviceName);
 
        hr = StringCchCopy(deviceInfo->DevicePath, MAX_PATH, dip->dbcc_name);
        if(FAILED(hr)){
            // DeviceInfo will be freed later by the cleanup routine.
            break;
        }
 
        deviceInfo->hDevice = CreateFile(dip->dbcc_name,
                                        GENERIC_READ |GENERIC_WRITE, 0, NULL,
                                        OPEN_EXISTING, 0, NULL);
        if(deviceInfo->hDevice == INVALID_HANDLE_VALUE) {
            Display(TEXT("Failed to open the device: %ws"), deviceInfo->DeviceName);
            break;
        }
 
        Display(TEXT("Opened handled to the device: %ws"),  deviceInfo->DeviceName);
        memset (&filter, 0, sizeof(filter)); //zero the structure
        filter.dbch_size = sizeof(filter);
        filter.dbch_devicetype = DBT_DEVTYP_HANDLE;
        filter.dbch_handle = deviceInfo->hDevice;
 
        deviceInfo->hHandleNotification =
                            RegisterDeviceNotification(hWnd, &filter, 0);
        break;
 
        case DBT_DEVICEREMOVECOMPLETE:
        Display(TEXT("Remove Complete (Interface Change Notification)"));
        break;
 
        //
        // Device Removed.
        //
 
        default:
        Display(TEXT("Unknown (Interface Change Notification)"));
        break;
    }
    return TRUE;
}
 
BOOL
HandleDeviceChange(
    HWND hWnd,
    DWORD evtype,
    PDEV_BROADCAST_HANDLE dhp
    )
{
    DEV_BROADCAST_HANDLE    filter;
    PDEVICE_INFO            deviceInfo = NULL;
    PLIST_ENTRY             thisEntry;
 
    //
    // Walk the list to get the deviceInfo for this device
    // by matching the handle given in the notification.
    //
    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)"), deviceInfo->DeviceName);
 
        // User is trying to disable, uninstall, or eject our device.
        // 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.
        //
        if (deviceInfo->hDevice != INVALID_HANDLE_VALUE) {
 
            CloseHandle(deviceInfo->hDevice);
            deviceInfo->hDevice = INVALID_HANDLE_VALUE;
            Display(TEXT("Closed handle to device %ws"), deviceInfo->DeviceName );
        }
        break;
 
    case DBT_DEVICEREMOVECOMPLETE:
 
        Display(TEXT("Remove Complete (Handle Notification):%ws"),
                    deviceInfo->DeviceName);
        //
        // Device is getting surprise removed. So close
        // the handle to device and unregister the PNP notification.
        //
 
        if (deviceInfo->hHandleNotification) {
            UnregisterDeviceNotification(deviceInfo->hHandleNotification);
            deviceInfo->hHandleNotification = NULL;
        }
        if (deviceInfo->hDevice != INVALID_HANDLE_VALUE) {
 
            CloseHandle(deviceInfo->hDevice);
            deviceInfo->hDevice = INVALID_HANDLE_VALUE;
            Display(TEXT("Closed handle to device %ws"), deviceInfo->DeviceName );
        }
        //
        // 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.
        //
        if (deviceInfo->hHandleNotification) {
            UnregisterDeviceNotification(deviceInfo->hHandleNotification);
            deviceInfo->hHandleNotification = NULL;
            deviceInfo->hDevice = INVALID_HANDLE_VALUE;
        }
        //
        // Unlink this deviceInfo from the list and free the memory
        //
         RemoveEntryList(&deviceInfo->ListEntry);
         HeapFree (GetProcessHeap(), 0, 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;
         }
        deviceInfo->hDevice = CreateFile(deviceInfo->DevicePath,
                                GENERIC_READ | GENERIC_WRITE,
                                0, NULL, OPEN_EXISTING, 0, NULL);
        if(deviceInfo->hDevice == INVALID_HANDLE_VALUE) {
            Display(TEXT("Failed to reopen the device: %ws"),
                    deviceInfo->DeviceName);
            HeapFree (GetProcessHeap(), 0, deviceInfo);
            break;
        }
 
        //
        // 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 = deviceInfo->hDevice;
 
        deviceInfo->hHandleNotification =
                            RegisterDeviceNotification(hWnd, &filter, 0);
        Display(TEXT("Reopened device %ws"), deviceInfo->DeviceName);
        break;
 
    default:
        Display(TEXT("Unknown (Handle Notification)"), deviceInfo->DeviceName);
        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;
    DWORD                              error;
    DEV_BROADCAST_HANDLE                filter;
    PDEVICE_INFO                        deviceInfo =NULL;
    UINT                                i=0;
    HRESULT                             hr;
 
    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 toaster 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 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                sizeof(DEVICE_INFO));
        if (deviceInfo == NULL) {
            goto Error;
        }
 
        InitializeListHead(&deviceInfo->ListEntry);
        InsertTailList(&ListHead, &deviceInfo->ListEntry);
 
        //
        // Get the device details such as friendly name and SerialNo
        //
        if(!GetDeviceDescription(deviceInterfaceDetailData->DevicePath,
                                 (PBYTE)deviceInfo->DeviceName,
                                 sizeof(deviceInfo->DeviceName),
                                 &deviceInfo->SerialNo)){
            goto Error;
        }
 
        Display(TEXT("Found device %ws"), deviceInfo->DeviceName );
 
        hr = StringCchCopy(deviceInfo->DevicePath, MAX_PATH, deviceInterfaceDetailData->DevicePath);
        if(FAILED(hr)){
            goto Error;
        }
        //
        // Open an handle to the device.
        //
        deviceInfo->hDevice = CreateFile (
                deviceInterfaceDetailData->DevicePath,
                GENERIC_READ | GENERIC_WRITE,
                0,
                NULL, // no SECURITY_ATTRIBUTES structure
                OPEN_EXISTING, // No special create flags
                0, // No special attributes
                NULL);
 
        if (INVALID_HANDLE_VALUE == deviceInfo->hDevice) {
            Display(TEXT("Failed to open the device: %ws"), deviceInfo->DeviceName);
            continue;
        }
 
        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 = deviceInfo->hDevice;
 
        deviceInfo->hHandleNotification = RegisterDeviceNotification(hWnd, &filter, 0);
 
    }
 
    if(deviceInterfaceDetailData)
        HeapFree (GetProcessHeap(), 0, deviceInterfaceDetailData);
 
    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    return 0;
 
Error:
 
    MessageBox(hWnd, TEXT("EnumExisting Devices failed"), TEXT("Error!"), MB_OK);
    if(deviceInterfaceDetailData)
        HeapFree (GetProcessHeap(), 0, deviceInterfaceDetailData);
 
    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    Cleanup(hWnd);
    return 0;
}
 
BOOLEAN Cleanup(HWND hWnd)
{
    PDEVICE_INFO    deviceInfo =NULL;
    PLIST_ENTRY     thisEntry;
 
    UNREFERENCED_PARAMETER( hWnd );
 
    while (!IsListEmpty(&ListHead)) {
        thisEntry = RemoveHeadList(&ListHead);
        deviceInfo = CONTAINING_RECORD(thisEntry, DEVICE_INFO, ListEntry);
        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 );
        }
        HeapFree (GetProcessHeap(), 0, deviceInfo);
    }
    return TRUE;
}
 
 
BOOL
GetDeviceDescription(
    _In_ LPTSTR DevPath,
    _Out_writes_bytes_(OutBufferLen) PBYTE OutBuffer,
    _In_ ULONG OutBufferLen,
    _In_ PULONG SerialNo
)
{
    HDEVINFO                            hardwareDeviceInfo;
    SP_DEVICE_INTERFACE_DATA            deviceInterfaceData;
    SP_DEVINFO_DATA                     deviceInfoData;
    DWORD                               dwRegType, error;
 
    hardwareDeviceInfo = SetupDiCreateDeviceInfoList(NULL, NULL);
    if(INVALID_HANDLE_VALUE == hardwareDeviceInfo)
    {
        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)
    {
        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,
                                     OutBuffer,
                                     OutBufferLen,
                                     NULL))
    {
        if(!SetupDiGetDeviceRegistryProperty(hardwareDeviceInfo, &deviceInfoData,
                                     SPDRP_DEVICEDESC,
                                     &dwRegType,
                                     OutBuffer,
                                     OutBufferLen,
                                     NULL)){
            goto Error;
 
        }
 
 
    }
 
    //
    // Get the serial number of the device. The bus driver reports
    // the device serial number as UINumber in the devcaps.
    //
    if(!SetupDiGetDeviceRegistryProperty(hardwareDeviceInfo,
                 &deviceInfoData,
                 SPDRP_UI_NUMBER,
                 &dwRegType,
                 (BYTE*) SerialNo,
                 sizeof(ULONG),
                 NULL)) {
        Display(TEXT("SerialNo is not available for device: %ws"), OutBuffer );
    }
 
 
    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    return TRUE;
 
Error:
 
    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    return FALSE;
}
 
 
 
BOOLEAN
OpenBusInterface (
    _In_ ULONG SerialNo,
    _When_ (Action == PLUGIN, _In_) LPWSTR DeviceId,
    _In_ USER_ACTION_TYPE Action
    )
{
    HANDLE                              hDevice=INVALID_HANDLE_VALUE;
    PSP_DEVICE_INTERFACE_DETAIL_DATA    deviceInterfaceDetailData = NULL;
    ULONG                               predictedLength = 0;
    ULONG                               requiredLength = 0;
    ULONG                               bytes;
    BUSENUM_UNPLUG_HARDWARE             unplug;
    BUSENUM_EJECT_HARDWARE              eject;
    PBUSENUM_PLUGIN_HARDWARE            hardware;
    HDEVINFO                            hardwareDeviceInfo;
    SP_DEVICE_INTERFACE_DATA            deviceInterfaceData;
    BOOLEAN                             status = FALSE;
    HRESULT                             hr;
    //
    // Open a handle to the device interface information set of all
    // present toaster bus enumerator interfaces.
    //
 
    hardwareDeviceInfo = SetupDiGetClassDevs (
                       (LPGUID)&GUID_DEVINTERFACE_BUSENUM_TOASTER,
                       NULL, // Define no enumerator (global)
                       NULL, // Define no
                       (DIGCF_PRESENT | // Only Devices present
                       DIGCF_DEVICEINTERFACE)); // Function class devices.
 
    if(INVALID_HANDLE_VALUE == hardwareDeviceInfo)
    {
        return FALSE;
    }
 
    deviceInterfaceData.cbSize = sizeof (SP_DEVICE_INTERFACE_DATA);
 
    if (!SetupDiEnumDeviceInterfaces (hardwareDeviceInfo,
                                 0, // No care about specific PDOs
                                 (LPGUID)&GUID_DEVINTERFACE_BUSENUM_TOASTER,
                                 0, //
                                 &deviceInterfaceData)) {
        goto Clean0;
    }
 
    //
    // Allocate a function class device data structure to receive the
    // information about this particular device.
    //
 
    SetupDiGetDeviceInterfaceDetail (
            hardwareDeviceInfo,
            &deviceInterfaceData,
            NULL, // probing so no output buffer yet
            0, // probing so output buffer length of zero
            &requiredLength,
            NULL);//not interested in the specific dev-node
 
    if(ERROR_INSUFFICIENT_BUFFER != GetLastError()) {
        goto Clean0;
     }
 
 
     predictedLength = requiredLength;
 
    deviceInterfaceDetailData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                    predictedLength);
 
    if(deviceInterfaceDetailData) {
        deviceInterfaceDetailData->cbSize =
                        sizeof (SP_DEVICE_INTERFACE_DETAIL_DATA);
    } else {
        goto Clean0;
    }
 
 
    if (! SetupDiGetDeviceInterfaceDetail (
               hardwareDeviceInfo,
               &deviceInterfaceData,
               deviceInterfaceDetailData,
               predictedLength,
               &requiredLength,
               NULL)) {
        goto Clean1;
    }
 
 
    hDevice = CreateFile ( deviceInterfaceDetailData->DevicePath,
                        GENERIC_READ, // Only read access
                        0, // 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 == hDevice) {
        goto Clean1;
    }
 
    //
    // Enumerate Devices
    //
 
    if(Action == PLUGIN) {
        int length =  (int) (wcslen(DeviceId)+2)*sizeof(WCHAR); //in bytes
 
        bytes = sizeof (BUSENUM_PLUGIN_HARDWARE) + length;
        hardware = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bytes);
 
        if(hardware) {
            memset(hardware, 0, bytes);
            hardware->Size = sizeof (BUSENUM_PLUGIN_HARDWARE);
            hardware->SerialNo = SerialNo;
        } else {
            goto Clean2;
        }
 
        //
        // copy the Device ID
        //
        hr = StringCchCopy(hardware->HardwareIDs, length/sizeof(WCHAR), DeviceId);
        if (SUCCEEDED(hr) && DeviceIoControl (hDevice,
                              IOCTL_BUSENUM_PLUGIN_HARDWARE ,
                              hardware, bytes,
                              NULL, 0,
                              &bytes, NULL)) {
              status = TRUE;
         }
 
         HeapFree (GetProcessHeap(), 0, hardware);
 
    }
 
    //
    // Removes a device if given the specific Id of the device. Otherwise this
    // ioctls removes all the devices that are enumerated so far.
    //
 
    if(Action == UNPLUG) {
 
        unplug.Size = bytes = sizeof (unplug);
        unplug.SerialNo = SerialNo;
        if (DeviceIoControl (hDevice,
                              IOCTL_BUSENUM_UNPLUG_HARDWARE,
                              &unplug, bytes,
                              NULL, 0,
                              &bytes, NULL)) {
            status = TRUE;
        }
    }
 
    //
    // Ejects a device if given the specific Id of the device. Otherwise this
    // ioctls ejects all the devices that are enumerated so far.
    //
 
    if(Action == EJECT)
    {
 
        eject.Size = bytes = sizeof (eject);
        eject.SerialNo = SerialNo;
        if (DeviceIoControl (hDevice,
                              IOCTL_BUSENUM_EJECT_HARDWARE,
                              &eject, bytes,
                              NULL, 0,
                              &bytes, NULL)) {
            status = TRUE;
        }
    }
 
Clean2:
    CloseHandle(hDevice);
Clean1:
    HeapFree (GetProcessHeap(), 0, deviceInterfaceDetailData);
Clean0:
    SetupDiDestroyDeviceInfoList (hardwareDeviceInfo);
    return status;
}
 
BOOL
HandlePowerBroadcast(
    HWND hWnd,
    WPARAM wParam,
    LPARAM lParam)
{
    BOOL fRet = TRUE;
 
    UNREFERENCED_PARAMETER( hWnd );
    UNREFERENCED_PARAMETER( lParam );
 
    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;
}
 
void
SendIoctlToFilterDevice()
{
#define IOCTL_CUSTOM_CODE CTL_CODE(FILE_DEVICE_UNKNOWN, 0, METHOD_BUFFERED, FILE_READ_DATA)
 
    HANDLE hControlDevice;
    ULONG  bytes;
 
    //
    // Open handle to the control device. Please note that even
    // a non-admin user can open handle to the device with
    // FILE_READ_ATTRIBUTES | SYNCHRONIZE DesiredAccess and send IOCTLs if the
    // IOCTL is defined with FILE_ANY_ACCESS. So for better security avoid
    // specifying FILE_ANY_ACCESS in your IOCTL defintions.
    // If the IOCTL is defined to have FILE_READ_DATA access rights, you can
    // open the device with GENERIC_READ and call DeviceIoControl.
    // If the IOCTL is defined to have FILE_WRITE_DATA access rights, you can
    // open the device with GENERIC_WRITE and call DeviceIoControl.
    //
    hControlDevice = CreateFile ( TEXT("\\\\.\\ToasterFilter"),
                        GENERIC_READ, // Only read access
                        0, // 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 == hControlDevice) {
        Display(TEXT("Failed to open ToasterFilter device"));
    } else {
        if (!DeviceIoControl (hControlDevice,
                              IOCTL_CUSTOM_CODE,
                              NULL, 0,
                              NULL, 0,
                              &bytes, NULL)) {
            Display(TEXT("Ioctl to ToasterFilter device failed"));
        } else {
            Display(TEXT("Ioctl to ToasterFilter device succeeded"));
        }
        CloseHandle(hControlDevice);
    }
    return;
}
Our Services

What our customers say about us?

Read our customer testimonials to find out why our clients keep returning for their projects.
View Testimonials
We Love Software

Sample Code

Windows Driver Samples/ Toaster Sample Driver/ C++/ exe/ notify/ notify.c/

Our Services

What our customers say about us?

About Us

Sitemap

Explore
