fxdriverapium.cpp

Go to the documentation of this file.

/*++

Copyright (c) Microsoft Corporation

Module Name:

    FxDriverApiKm.cpp

Abstract:

    This module contains the "C" interface for the FxDriver object.

Author:



Environment:

    User mode only

Revision History:

--*/

#include "coreprivshared.hpp"

// Tracing support
extern "C" {
#include <ntverp.h>
#include "FxDriverApiUm.tmh"
}

//
// extern the whole file
//
extern "C" {

_Must_inspect_result_
__drv_maxIRQL(PASSIVE_LEVEL)
NTSTATUS
WDFEXPORT(WdfDriverOpenParametersRegistryKey)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFDRIVER Driver,
    __in
    ACCESS_MASK DesiredAccess,
    __in_opt
    PWDF_OBJECT_ATTRIBUTES KeyAttributes,
    __out
    WDFKEY* Key
    )
{
    NTSTATUS status;
    LONG result;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    FxDriver* pDriver;
    FxRegKey* pKey;
    HKEY hKey = NULL;
    WDFKEY keyHandle;

    pFxDriverGlobals = GetFxDriverGlobals(DriverGlobals);

    FxPointerNotNull(pFxDriverGlobals, Key);

    *Key = NULL;

    status = FxVerifierCheckIrqlLevel(pFxDriverGlobals, PASSIVE_LEVEL);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    status = FxValidateObjectAttributes(pFxDriverGlobals, KeyAttributes);
    if (!NT_SUCCESS(status)) {
        return status;
    }

    FxObjectHandleGetPtr(pFxDriverGlobals,
                         Driver,
                         FX_TYPE_DRIVER,
                         (PVOID*) &pDriver);

    pKey = new(pFxDriverGlobals, KeyAttributes) FxRegKey(pFxDriverGlobals);
    if (pKey == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    status = pKey->Commit(KeyAttributes, (WDFOBJECT*)&keyHandle);
    if (NT_SUCCESS(status)) {
        if (DesiredAccess & (GENERIC_WRITE | KEY_CREATE_SUB_KEY | WRITE_DAC)) {
            //
            // These access rights are not allowed. This restriction is
            // imposed by the host process and the reflector driver.
            //
            // Even though the maximum-permissions handle is already opened,
            // we fail so that the caller knows not to assume it has the
            // GENERIC_WRITE, KEY_CREATE_SUB_KEY, or WRITE_DAC permissions.
            //
            status = STATUS_ACCESS_DENIED;
            DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
                    "Could not open '%s' service parameters key "
                    "with access rights 0x%x, %!STATUS!",
                    pFxDriverGlobals->Public.DriverName,
                    DesiredAccess, status);
        } else if ((DesiredAccess & ~(KEY_READ | GENERIC_READ)) == 0) {
            //
            // If caller requested read-only access, open a new handle
            // to the parameters key, no reason to give more privileges
            // than needed.
            //
            result = RegOpenKeyEx(pDriver->GetDriverParametersKey(),
                                  L"",
                                  0,
                                  DesiredAccess,
                                  &hKey);
            status = WinErrorToNtStatus(result);
            if (!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
                    "Could not open '%s' service parameters key "
                    "with access rights 0x%x, %!STATUS!",
                    pFxDriverGlobals->Public.DriverName,
                    DesiredAccess, status);
            }
        } else {
            //
            // If caller requested write access, give it the pre-opened
            // handle, since we do not have permission to open this key
            // with write access rights from user mode.
            //
            hKey = pDriver->GetDriverParametersKey();

            //
            // Mark the registry key handle such that it won't be closed
            // when this FxRegKey is deleted. We might need the handle again
            // for future calls to WdfDriverOpenParametersRegistryKey.
            //
            pKey->SetCanCloseHandle(FALSE);
        }

        if (NT_SUCCESS(status)) {
            pKey->SetHandle((HANDLE)hKey);
            *Key = keyHandle;
        }
    }

    if (!NT_SUCCESS(status)) {
        pKey->DeleteFromFailedCreate();
    }

    return status;
}

__drv_maxIRQL(DISPATCH_LEVEL)
PDRIVER_OBJECT
WDFEXPORT(WdfDriverWdmGetDriverObject)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFDRIVER Driver
    )
{
    DDI_ENTRY();

    UNREFERENCED_PARAMETER(DriverGlobals);
    UNREFERENCED_PARAMETER(Driver);

    ASSERTMSG("Not implemented for UMDF\n", FALSE);

    return NULL;
}

__drv_maxIRQL(DISPATCH_LEVEL)
WDFDRIVER
WDFEXPORT(WdfWdmDriverGetWdfDriverHandle)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    PDRIVER_OBJECT DriverObject
    )
{
    DDI_ENTRY();

    UNREFERENCED_PARAMETER(DriverGlobals);
    UNREFERENCED_PARAMETER(DriverObject);

    ASSERTMSG("Not implemented for UMDF\n", FALSE);

    return NULL;
}

VOID
WDFEXPORT(WdfDriverMiniportUnload)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFDRIVER Driver
    )
{
    DDI_ENTRY();

    UNREFERENCED_PARAMETER(DriverGlobals);
    UNREFERENCED_PARAMETER(Driver);

    ASSERTMSG("Not implemented for UMDF\n", FALSE);
}

_Must_inspect_result_
__drv_maxIRQL(PASSIVE_LEVEL)
NTSTATUS
WDFEXPORT(WdfDeviceMiniportCreate)(
    __in
    PWDF_DRIVER_GLOBALS DriverGlobals,
    __in
    WDFDRIVER Driver,
    __in_opt
    PWDF_OBJECT_ATTRIBUTES Attributes,
    __in
    PDEVICE_OBJECT DeviceObject,
    __in_opt
    PDEVICE_OBJECT AttachedDeviceObject,
    __in_opt
    PDEVICE_OBJECT Pdo,
    __out
    WDFDEVICE* Device
    )
{
    DDI_ENTRY();

    UNREFERENCED_PARAMETER(DriverGlobals);
    UNREFERENCED_PARAMETER(Driver);
    UNREFERENCED_PARAMETER(Attributes);
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(AttachedDeviceObject);
    UNREFERENCED_PARAMETER(Pdo);
    UNREFERENCED_PARAMETER(Device);

    ASSERTMSG("Not implemented for UMDF\n", FALSE);

    return STATUS_NOT_IMPLEMENTED;
}

} // extern "C"