callmsgring0app.cpp

在Ring0层中调用Ring3层的功能 需要安装DDK

        // Setup our operation combo box
        hWnd = GetDlgItem(hDlg, IDC_OP_TYPE_COMBO);

        for(ii = 0; _tcscmp(g_TransferTypeArray[ii], _T("")); ii++)
        {
            // Add the transfer type string to the combo box
            SendMessage(hWnd, CB_ADDSTRING, 0, (LPARAM)g_TransferTypeArray[ii]);
        }

        // Initialize the window.
        return 1;

    case WM_COMMAND:

        switch (LOWORD(wParam))
        {

        case IDOK:
            EndDialog(hDlg, 0);
            PostQuitMessage(0);
            break;

        case IDC_OPEN_BUTTON:

            // Open the selected device
            g_hDevice = CallMsgRing0OpenDevice(hDlg);
            if (g_hDevice == INVALID_HANDLE_VALUE)
            {
                CallMsgRing0OutputText(_T("Failed to open device, all options will be unavailable"));
                return 0;
            }

            // If we opened the device, disable the open button, only one
            // open at a time in this simple app
            EnableWindow(GetDlgItem(hDlg, IDC_OPEN_BUTTON), FALSE);

            // Enable the close button
            EnableWindow(GetDlgItem(hDlg, IDC_CLOSE_BUTTON), TRUE);

            // Enable the operation combo box
            EnableWindow(GetDlgItem(hDlg, IDC_OPERATION_TYPE_STATIC), TRUE);
            EnableWindow(GetDlgItem(hDlg, IDC_OP_TYPE_COMBO), TRUE);

            // Clean up window-specific data objects.
            return 0;

        case IDC_CLOSE_BUTTON:

            // Open the selected device
            if (!CloseHandle(g_hDevice))
            {
                CallMsgRing0OutputText(_T("Failed to close device"));
                return 0;
            }

            CallMsgRing0OutputText(_T("Device closed"));

            // Set our handle to an invalid state
            g_hDevice = INVALID_HANDLE_VALUE;

            // If we closed the device, disable the close button
            EnableWindow(GetDlgItem(hDlg, IDC_CLOSE_BUTTON), FALSE);

            // See if we have a current selection
            // Reflect the change in the current selection box
            itemIndex = (DWORD)SendMessage(
                            GetDlgItem(hDlg, IDC_DEVICE_INSTANCE_LIST),
                            LB_GETCURSEL,
                            0,
                            0
                            );

            // If we have a selection, enable the open button
            EnableWindow(GetDlgItem(hDlg, IDC_OPEN_BUTTON), TRUE);

            // Clear the selection in the current selection edit box
            SetDlgItemText(hDlg, IDC_SELECTED_DEVICE_EDIT, NULL);

            // Disable the operation combo box
            EnableWindow(GetDlgItem(hDlg, IDC_OPERATION_TYPE_STATIC), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_OP_TYPE_COMBO), FALSE);

            // Disable the input data pattern edit box
            EnableWindow(GetDlgItem(hDlg, IDC_IN_DATA_STATIC), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_IN_DATA_EDIT), FALSE);

            // Disable the output data pattern edit box
            EnableWindow(GetDlgItem(hDlg, IDC_OUT_DATA_STATIC), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_OUT_DATA_EDIT), FALSE);

            // Disable the input buffer size edit box
            EnableWindow(GetDlgItem(hDlg, IDC_IN_SIZE_STATIC), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_IN_SIZE_EDIT), FALSE);

            // Disable the output buffer size edit box
            EnableWindow(GetDlgItem(hDlg, IDC_OUT_SIZE_STATIC), FALSE);
            EnableWindow(GetDlgItem(hDlg, IDC_OUT_SIZE_EDIT), FALSE);

            // Disable the execute button
            EnableWindow(GetDlgItem(hDlg, IDC_EXECUTE_BUTTON), FALSE);

            // Disable the cancel I/O button
            EnableWindow(GetDlgItem(hDlg, IDC_CANCEL_IO_BUTTON), FALSE);

            // remove current I/O selection
            SendMessage(GetDlgItem(hDlg, IDC_OP_TYPE_COMBO), CB_SETCURSEL, -1, 0);

            // Clean up window-specific data objects.
            return 0;

        case IDC_DEVICE_INSTANCE_LIST:
            switch (HIWORD(wParam))
            {
            case LBN_SELCHANGE:

                hWnd = (HWND)lParam;

                // Reflect the change in the current selection box
                itemIndex = (DWORD)SendMessage(hWnd, LB_GETCURSEL, 0, 0);

                if ((itemIndex != LB_ERR) && (g_hDevice == INVALID_HANDLE_VALUE))
                {
                    // If we have a selection, enable the open button
                    // If we closed the device, disable the close button
                    EnableWindow(GetDlgItem(hDlg, IDC_OPEN_BUTTON), TRUE);
                }

                return 0;
            }
            break;

        case IDC_OP_TYPE_COMBO:
            switch (HIWORD(wParam))
            {
            case CBN_SELCHANGE:

                hWnd = (HWND)lParam;

                // Get the current selection
                itemIndex = (DWORD)SendMessage(hWnd, CB_GETCURSEL, 0, 0);

                // Get the selection text
                SendMessage(hWnd, CB_GETLBTEXT, (WPARAM)itemIndex, (LPARAM)str);

                // Enable the execute button
                EnableWindow(GetDlgItem(hDlg, IDC_EXECUTE_BUTTON), TRUE);

                // Enable/disable the input data pattern edit box
                EnableWindow(GetDlgItem(hDlg, IDC_IN_DATA_STATIC), bInBufferEnable);
                EnableWindow(GetDlgItem(hDlg, IDC_IN_DATA_EDIT), bInBufferEnable);

                // Enable/disable the input buffer size edit box
                EnableWindow(GetDlgItem(hDlg, IDC_IN_SIZE_STATIC), bInBufferEnable);
                EnableWindow(GetDlgItem(hDlg, IDC_IN_SIZE_EDIT), bInBufferEnable);

                // Enable/disable the output data pattern edit box
                EnableWindow(GetDlgItem(hDlg, IDC_OUT_DATA_STATIC), bOutBufferEnable);
                EnableWindow(GetDlgItem(hDlg, IDC_OUT_DATA_EDIT), bOutBufferEnable);

                // Enable/disable the output buffer size edit box
                EnableWindow(GetDlgItem(hDlg, IDC_OUT_SIZE_STATIC), bOutBufferEnable);
                EnableWindow(GetDlgItem(hDlg, IDC_OUT_SIZE_EDIT), bOutBufferEnable);

                return 0;
            }
            break;

        case IDC_EXECUTE_BUTTON:

            CallMsgRing0ExecuteIo(hDlg);

            // Enable the cancel I/O button
            EnableWindow(GetDlgItem(hDlg, IDC_CANCEL_IO_BUTTON), TRUE);
            break;

        case IDC_CANCEL_IO_BUTTON:

            CancelIo(g_hDevice);

            // Disable the cancel I/O button
            EnableWindow(GetDlgItem(hDlg, IDC_CANCEL_IO_BUTTON), FALSE);
            break;

        default:
            break;
        }
        break;

    case WM_CLOSE:

        if (g_hDevice != INVALID_HANDLE_VALUE)
        {
            CloseHandle(g_hDevice);
            g_hDevice = INVALID_HANDLE_VALUE;
        }

        // Terminate our I/O completion thread
        SetEvent(g_hIoCompletionThreadTerminationEvent);
        WaitForSingleObject(g_hIoCompletionThread, INFINITE);

        UnregisterDeviceNotification(g_hInterfaceNotification);
        EndDialog(hDlg, 0);
        PostQuitMessage(0);

        // Clean up window-specific data objects.
        return 0;

    // Process other messages.

    default:
        return 0;
    }

    return 0;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  WinMain
//      Application entry point
//
//  Arguments:
//      IN  hInstance
//              Handle to current instance
//
//      IN  hPrevInstance
//              unused
//
//      IN  lpCmdLine
//              command line
//
//      IN  nCmdShow
//              unused
//
//  Return Value:
//      status.
//
int APIENTRY WinMain(
    HINSTANCE   hInstance,
    HINSTANCE   hPrevInstance,
    LPSTR       lpCmdLine,
    int         nCmdShow
                )
{
    // do init stuff
    InitCommonControls();

    // Initialize the global io list
    g_IoList.Next = &g_IoList;
    g_IoList.Previous = &g_IoList;

    // Initialize the global list lock
    InitializeCriticalSection(&g_IoListLock);

    // Initialize the global I/O completion thread termination event.
    // This is a manual reset event
    g_hIoCompletionThreadTerminationEvent = CreateEvent(NULL, TRUE, FALSE, NULL);

    UINT nIoCompletionThreadID;

    // Start a new thread to handle I/O completion
    g_hIoCompletionThread = (HANDLE)_beginthreadex(
        NULL,
        0,
        CallMsgRing0IoCompletionThread,
        g_hIoCompletionThreadTerminationEvent,
        0,
        &nIoCompletionThreadID
        );

    // start dialog box
    int retVal = (int)DialogBox(hInstance, _T("CALLMSGRING0APP"), NULL, (DLGPROC)CallMsgRing0MainDlgProc);

    // Free allocated resources
    DeleteCriticalSection(&g_IoListLock);
    CloseHandle(g_hIoCompletionThreadTerminationEvent);

    CloseHandle(g_hIoCompletionThread);

    return retVal;
}