version.cpp File Reference

#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <ntverp.h>
#include <ntddk.h>
#include <ntstrsafe.h>
#include "fx.hpp"
#include <fxldr.h>
#include "fxbugcheck.h"
#include "reactos_special.h"
#include "fxifr.h"
#include "fxdynamics.h"
#include "fxlibrarycommon.h"

Include dependency graph for version.cpp:

Go to the source code of this file.

Classes
struct	_DRV_EXTENSION

Macros
#define	FX_DYNAMICS_GENERATE_TABLE   1
#define	DRIVER_OBJECT_EXTENSION_IDENTIFIER   DriverEntry
#define	DRIVER_PARAMETERS   L"Parameters"
#define	REGISTRY_KMDF_MAJOR_VERSION   L"MajorVersion"
#define	REGISTRY_KMDF_MINOR_VERSION   L"MinorVersion"
#define	REGISTRY_KMDF_BUILD_NUMBER   L"BuildNumber"
#define	KMDF_DEFAULT_NAME
#define	KMDF_DEVICE_NAME   L"\\Device\\KMDF"
#define	EVTLOG_MESSAGE_SIZE   70
#define	RAW_DATA_SIZE   4

Typedefs
typedef struct _DRV_EXTENSION	DRV_EXTENSION
typedef struct _DRV_EXTENSION *	PDRV_EXTENSION

Functions
	__drv_dispatchType (IRP_MJ_CREATE) __drv_dispatchType(IRP_MJ_CLEANUP) __drv_dispatchType(IRP_MJ_CLOSE) DRIVER_DISPATCH FxLibraryDispatch
_Must_inspect_result_ NTSTATUS NTAPI	WDF_LIBRARY_COMMISSION (VOID)
_Must_inspect_result_ NTSTATUS NTAPI	WDF_LIBRARY_DECOMMISSION (VOID)
_Must_inspect_result_ NTSTATUS NTAPI	WDF_LIBRARY_REGISTER_CLIENT (__inout PWDF_BIND_INFO Info, __deref_out PWDF_DRIVER_GLOBALS *WdfDriverGlobals, __deref_inout PVOID *Context)
_Must_inspect_result_ NTSTATUS NTAPI	WDF_LIBRARY_UNREGISTER_CLIENT (__in PWDF_BIND_INFO Info, __in PWDF_DRIVER_GLOBALS WdfDriverGlobals)
VOID	FxLibraryDeleteDevice (VOID)
VOID	FxLibraryCleanup (VOID)
VOID	WdfWriteKmdfVersionToRegistry (__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath)
VOID	WdfDeleteKmdfVersionFromRegistry (__in PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	FxLibraryDispatch (__in struct _DEVICE_OBJECT *DeviceObject, __in PIRP Irp)
_Must_inspect_result_ NTSTATUS	FxLibraryCreateDevice (__in PUNICODE_STRING DeviceName)
NTSTATUS NTAPI	DriverEntry (__in PDRIVER_OBJECT DriverObject, __in PUNICODE_STRING RegistryPath)
VOID NTAPI	DriverUnload (__in PDRIVER_OBJECT DriverObject)
_Must_inspect_result_ NTSTATUS NTAPI	WDF_LIBRARY_REGISTER_CLIENT (__in PWDF_BIND_INFO Info, __deref_out PWDF_DRIVER_GLOBALS *WdfDriverGlobals, __deref_inout PVOID *Context)

Variables
union {
WDF_IFR_HEADER *   typeWDF_IFR_HEADER
WDF_IFR_RECORD *   typeWDF_IFR_RECORD
WDF_IFR_OFFSET *   typeWDF_IFR_OFFSET
WDF_BIND_INFO *   typeWDF_BIND_INFO
WDF_OBJECT_CONTEXT_TYPE_INFO *   typeWDF_OBJECT_CONTEXT_TYPE_INFO
WDF_POWER_ROUTINE_TIMED_OUT_DATA *   typeWDF_POWER_ROUTINE_TIMED_OUT_DATA
WDF_BUGCHECK_CODES *   typeWDF_BUGCHECK_CODES
WDF_REQUEST_FATAL_ERROR_CODES *   typeWDF_REQUEST_FATAL_ERROR_CODES
FX_OBJECT_INFO *   typeFX_OBJECT_INFO
FX_POOL_HEADER *   typeFX_POOL_HEADER
FX_POOL *   typeFX_POOL
FxObject *   typeFxObject
FxContextHeader *   typeFxContextHeader
FX_DUMP_DRIVER_INFO_ENTRY *   typeFX_DUMP_DRIVER_INFO_ENTRY
FxTargetSubmitSyncParams *   typeFxTargetSubmitSyncParams
}	uAllPublicTypes
DRIVER_UNLOAD	DriverUnload
DRIVER_INITIALIZE	DriverEntry
RTL_OSVERSIONINFOW	gOsVersion = { sizeof(RTL_OSVERSIONINFOW) }
ULONG	WdfLdrDbgPrintOn = 0
PCHAR	WdfLdrType = KMDF_DEFAULT_NAME
WDF_LIBRARY_INFO	WdfLibraryInfo

Macro Definition Documentation

DRIVER_OBJECT_EXTENSION_IDENTIFIER

#define DRIVER_OBJECT_EXTENSION_IDENTIFIER   DriverEntry

Definition at line 37 of file version.cpp.

DRIVER_PARAMETERS

#define DRIVER_PARAMETERS   L"Parameters"

Definition at line 38 of file version.cpp.

EVTLOG_MESSAGE_SIZE

#define EVTLOG_MESSAGE_SIZE   70

Definition at line 455 of file version.cpp.

FX_DYNAMICS_GENERATE_TABLE

#define FX_DYNAMICS_GENERATE_TABLE   1

Definition at line 28 of file version.cpp.

KMDF_DEFAULT_NAME

#define KMDF_DEFAULT_NAME

Value:

                             "Wdf" ## \
                             LITERAL(__WDF_MAJOR_VERSION_STRING)   ## \
                             "000"

Definition at line 91 of file version.cpp.

KMDF_DEVICE_NAME

#define KMDF_DEVICE_NAME   L"\\Device\\KMDF"

Definition at line 246 of file version.cpp.

RAW_DATA_SIZE

#define RAW_DATA_SIZE   4

Definition at line 456 of file version.cpp.

REGISTRY_KMDF_BUILD_NUMBER

#define REGISTRY_KMDF_BUILD_NUMBER   L"BuildNumber"

Definition at line 41 of file version.cpp.

REGISTRY_KMDF_MAJOR_VERSION

#define REGISTRY_KMDF_MAJOR_VERSION   L"MajorVersion"

Definition at line 39 of file version.cpp.

REGISTRY_KMDF_MINOR_VERSION

#define REGISTRY_KMDF_MINOR_VERSION   L"MinorVersion"

Definition at line 40 of file version.cpp.

Typedef Documentation

DRV_EXTENSION

typedef struct _DRV_EXTENSION DRV_EXTENSION

PDRV_EXTENSION

typedef struct _DRV_EXTENSION * PDRV_EXTENSION

Function Documentation

__drv_dispatchType()

__drv_dispatchType

(

IRP_MJ_CREATE

)

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	__in PDRIVER_OBJECT	DriverObject,
		__in PUNICODE_STRING	RegistryPath
	)

Definition at line 318 of file version.cpp.

{
    UNICODE_STRING name;
    UNICODE_STRING string;
    NTSTATUS status;
 
    //
    // This creates a local buffer which is big enough to hold a copy of the
    // constant string assigned to it.  It does not point to the constant
    // string.  As such, it is a writeable buffer.
    //
    // NOTE:  KMDF_DEVICE_NAME L"XXXX" creates a concatenated string of
    //        KMDF_DEVICE_NAME + L"XXXX".  This is done to give us room for
    //        appending a number up to 4 digits long after KMDF_DEVICE_NAME if
    //        you want a null terminated string, 5 digits long if the string is
    //        not null terminated (as is the case for a UNICODE_STRING)
    //
    WCHAR buffer[] = KMDF_DEVICE_NAME L"XXXX";
 
    //
    // Initialize global to make NonPagedPool be treated as NxPool on Win8
    // and NonPagedPool on down-level
    //
#ifndef __REACTOS__
    ExInitializeDriverRuntime(DrvRtPoolNxOptIn);
#endif
    RtlInitUnicodeString(&string, WDF_REGISTRY_DBGPRINT_ON);
 
    //
    // Determine if debug prints are on.
    //
    (void) WdfLdrDiagnosticsValueByNameAsULONG(&string, &WdfLdrDbgPrintOn);
 
    __Print(("DriverEntry\n"));
 
    DriverObject->DriverUnload = DriverUnload;
 
    FxLibraryGlobals.DriverObject = DriverObject;
 
    DriverObject->MajorFunction[IRP_MJ_CREATE] = FxLibraryDispatch;
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] = FxLibraryDispatch;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = FxLibraryDispatch;
 
    RtlZeroMemory(&name, sizeof(name));
    name.Buffer = buffer;
    name.Length = 0x0;
    name.MaximumLength = sizeof(buffer);
 
    //
    // We use the string when we declare the buffer to get the right sized
    // buffer.  Now we want to make sure there are no contents before we
    // use it to create a device object.
    //
    RtlZeroMemory(buffer, sizeof(buffer));
 
    status = FxLibraryCreateDevice(&name);
    if (!NT_SUCCESS(status)) {
        __Print(("ERROR: FxLibraryCreateDevice failed with Status 0x%x\n", status));
        return status;
    }
 
    //
    // Register this library with WdfLdr
    //
    // NOTE:  Once WdfRegisterLibrary returns NT_SUCCESS() we must return
    //        NT_SUCCESS from DriverEntry!
    //
    status = WdfRegisterLibrary( &WdfLibraryInfo, RegistryPath, &name );
    if (!NT_SUCCESS(status)) {
        __Print(("ERROR: WdfRegisterLibrary failed with Status 0x%x\n", status));
        FxLibraryCleanup();
        return status;
    }
 
    //
    // Write KMDF version to registry
    //
    WdfWriteKmdfVersionToRegistry(DriverObject, RegistryPath);
 
    return STATUS_SUCCESS;
}

DriverUnload()

VOID NTAPI DriverUnload

(

__in PDRIVER_OBJECT

DriverObject

)

Definition at line 409 of file version.cpp.

{
    __Print(("DriverUnload\n"));
 
    //
    // Delete KMDF version from registry before destroying the Driver Object
    //
    WdfDeleteKmdfVersionFromRegistry(DriverObject);
 
    //
    // Make sure everything is deleted.  Since the driver is considered a legacy
    // driver, it can be unloaded while there are still outstanding device objects.
    //
    FxLibraryCleanup();
}

FxLibraryCleanup()

VOID FxLibraryCleanup

(

VOID

)

Definition at line 305 of file version.cpp.

{
    if (FxLibraryGlobals.LibraryDeviceObject != NULL) {
        IoDeleteDevice(FxLibraryGlobals.LibraryDeviceObject);
        FxLibraryGlobals.LibraryDeviceObject = NULL;
    }
}

Referenced by DriverEntry(), DriverUnload(), and FxLibraryDeleteDevice().

FxLibraryCreateDevice()

_Must_inspect_result_ NTSTATUS FxLibraryCreateDevice

(

__in PUNICODE_STRING

DeviceName

)

Definition at line 250 of file version.cpp.

{
    NTSTATUS status;
    ULONG i;
 
    i = 0;
 
    //
    // Repeatedly try to create a named device object until we run out of buffer
    // space or we succeed.
    //
    do {
        status = RtlUnicodeStringPrintf(DeviceName, L"%s%d", KMDF_DEVICE_NAME, i++);
        if (!NT_SUCCESS(status)) {
            return status;
        }
 
        //
        // Create a device with no device extension
        //
        status = IoCreateDevice(
            FxLibraryGlobals.DriverObject,
            0,
            DeviceName,
            FILE_DEVICE_UNKNOWN,
            0,
            FALSE,
            &FxLibraryGlobals.LibraryDeviceObject
            );
    } while (STATUS_OBJECT_NAME_COLLISION == status);
 
    if (NT_SUCCESS(status)) {
        //
        // Clear the initializing bit now because the loader will attempt to
        // open the device before we return from DriverEntry
        //
        ASSERT(FxLibraryGlobals.LibraryDeviceObject != NULL);
        FxLibraryGlobals.LibraryDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
    }
 
    return status;
}

Referenced by DriverEntry().

FxLibraryDeleteDevice()

VOID FxLibraryDeleteDevice

(

VOID

)

Definition at line 297 of file version.cpp.

{
    FxLibraryCleanup();
}

FxLibraryDispatch()

NTSTATUS NTAPI FxLibraryDispatch	(	__in struct _DEVICE_OBJECT *	DeviceObject,
		__in PIRP	Irp
	)

Definition at line 203 of file version.cpp.

{
    NTSTATUS status;
 
    UNREFERENCED_PARAMETER(DeviceObject);
    ASSERT(FxLibraryGlobals.LibraryDeviceObject == DeviceObject);
 
    status = STATUS_INVALID_DEVICE_REQUEST;
 
    switch (IoGetCurrentIrpStackLocation(Irp)->MajorFunction) {
    case IRP_MJ_CREATE:
        //
        // To limit our exposure for this device object, only allow kernel mode
        // creates.
        //
        if (Irp->RequestorMode == KernelMode) {
            status = STATUS_SUCCESS;
        }
        break;
 
    case IRP_MJ_CLEANUP:
    case IRP_MJ_CLOSE:
        //
        // Since we allowed a create to succeed, succeed the cleanup and close
        //
        status = STATUS_SUCCESS;
        break;
    }
 
    Irp->IoStatus.Status = status;
    Irp->IoStatus.Information = 0x0;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by DriverEntry().

WDF_LIBRARY_COMMISSION()

NTSTATUS WDF_LIBRARY_COMMISSION

(

VOID

)

Definition at line 434 of file version.cpp.

{
    return FxLibraryCommonCommission();
}

WDF_LIBRARY_DECOMMISSION()

NTSTATUS WDF_LIBRARY_DECOMMISSION

(

VOID

)

Definition at line 448 of file version.cpp.

{
    return FxLibraryCommonDecommission();
}

WDF_LIBRARY_REGISTER_CLIENT() [1/2]

_Must_inspect_result_ NTSTATUS NTAPI WDF_LIBRARY_REGISTER_CLIENT	(	__in PWDF_BIND_INFO	Info,
		__deref_out PWDF_DRIVER_GLOBALS *	WdfDriverGlobals,
		__deref_inout PVOID *	Context
	)

Definition at line 462 of file version.cpp.

{
    NTSTATUS           status = STATUS_INVALID_PARAMETER;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    WCHAR              insertString[EVTLOG_MESSAGE_SIZE];
    ULONG              rawData[RAW_DATA_SIZE];
    PCLIENT_INFO       clientInfo = NULL;
 
    __Print((LITERAL(WDF_LIBRARY_REGISTER_CLIENT) ": enter\n"));
 
    clientInfo = (PCLIENT_INFO)*Context;
    *Context = NULL;
 
    ASSERT(Info->Version.Major == WdfLibraryInfo.Version.Major);
 
    //
    // NOTE: If the currently loaded  library < drivers minor version fail the load
    // instead of binding to a lower minor version. The reason for that if there
    // is a newer API or new contract change made the driver shouldn't be using older
    // API than it was compiled with.
    //
 
    if (Info->Version.Minor > WdfLibraryInfo.Version.Minor) {
        status = RtlStringCchPrintfW(insertString,
                                     RTL_NUMBER_OF(insertString),
                                     L"Driver Version: %d.%d Kmdf Lib. Version: %d.%d",
                                     Info->Version.Major,
                                     Info->Version.Minor,
                                     WdfLibraryInfo.Version.Major,
                                     WdfLibraryInfo.Version.Minor);
        if (!NT_SUCCESS(status)) {
            __Print(("ERROR: RtlStringCchPrintfW failed with Status 0x%x\n", status));
            return status;
        }
        rawData[0] = Info->Version.Major;
        rawData[1] = Info->Version.Minor;
        rawData[2] = WdfLibraryInfo.Version.Major;
        rawData[3] = WdfLibraryInfo.Version.Minor;
 
        LibraryLogEvent(FxLibraryGlobals.DriverObject,
                       WDFVER_MINOR_VERSION_NOT_SUPPORTED,
                       STATUS_OBJECT_TYPE_MISMATCH,
                       insertString,
                       rawData,
                       sizeof(rawData) );
        //
        // this looks like the best status to return
        //
        return STATUS_OBJECT_TYPE_MISMATCH;
 
    }
 
    status = FxLibraryCommonRegisterClient(Info,
                                           WdfDriverGlobals,
                                           clientInfo);
 
    if (NT_SUCCESS(status)) {
        //
        // The context will be a pointer to FX_DRIVER_GLOBALS
        //
        *Context = GetFxDriverGlobals(*WdfDriverGlobals);
 
        //
        // Set the WDF_BIND_INFO structure pointer in FxDriverGlobals
        //
        pFxDriverGlobals = GetFxDriverGlobals(*WdfDriverGlobals);
        pFxDriverGlobals->WdfBindInfo = Info;
    }
 
    return status;
}

WDF_LIBRARY_REGISTER_CLIENT() [2/2]

_Must_inspect_result_ NTSTATUS NTAPI WDF_LIBRARY_REGISTER_CLIENT	(	__inout PWDF_BIND_INFO	Info,
		__deref_out PWDF_DRIVER_GLOBALS *	WdfDriverGlobals,
		__deref_inout PVOID *	Context
	)

WDF_LIBRARY_UNREGISTER_CLIENT()

_Must_inspect_result_ NTSTATUS NTAPI WDF_LIBRARY_UNREGISTER_CLIENT	(	__in PWDF_BIND_INFO	Info,
		__in PWDF_DRIVER_GLOBALS	WdfDriverGlobals
	)

Definition at line 546 of file version.cpp.

{
    return FxLibraryCommonUnregisterClient(Info, WdfDriverGlobals);
}

WdfDeleteKmdfVersionFromRegistry()

VOID WdfDeleteKmdfVersionFromRegistry

(

__in PDRIVER_OBJECT

DriverObject

)

Definition at line 699 of file version.cpp.

{
    PUNICODE_STRING registryPath;
    OBJECT_ATTRIBUTES objectAttributes;
    HANDLE driverKey;
    HANDLE parametersKey;
    UNICODE_STRING valueName;
    NTSTATUS status;
    UNICODE_STRING parametersPath;
    PDRV_EXTENSION driverExtension;
 
    RtlInitUnicodeString(&parametersPath, DRIVER_PARAMETERS);
 
    driverKey = NULL;
    parametersKey = NULL;
 
    driverExtension = (PDRV_EXTENSION)IoGetDriverObjectExtension(DriverObject,
                                                                 (PVOID)DRIVER_OBJECT_EXTENSION_IDENTIFIER);
 
    if (driverExtension == NULL || driverExtension->ParametersRegistryPath.Buffer == NULL) {
        return;
    }
 
    registryPath = &driverExtension->ParametersRegistryPath;
 
    InitializeObjectAttributes(&objectAttributes,
                               registryPath,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    status = ZwOpenKey(&driverKey, KEY_SET_VALUE, &objectAttributes);
    if (!NT_SUCCESS(status)) {
        goto out;
    }
 
    InitializeObjectAttributes(&objectAttributes,
                               &parametersPath,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               driverKey,
                               NULL);
    //
    // Open the key for deletion
    //
    status = ZwOpenKey(&parametersKey,
                       DELETE,
                       &objectAttributes);
 
    if (!NT_SUCCESS(status)) {
        goto out;
    }
 
    RtlInitUnicodeString(&valueName, REGISTRY_KMDF_MAJOR_VERSION);
    ZwDeleteValueKey(parametersKey, &valueName);
 
    RtlInitUnicodeString(&valueName, REGISTRY_KMDF_MINOR_VERSION);
    ZwDeleteValueKey(parametersKey, &valueName);
 
    RtlInitUnicodeString(&valueName, REGISTRY_KMDF_BUILD_NUMBER);
    ZwDeleteValueKey(parametersKey, &valueName);
 
    ZwDeleteKey(parametersKey);
 
out:
    if (driverExtension->ParametersRegistryPath.Buffer != NULL) {
        ExFreePool(driverExtension->ParametersRegistryPath.Buffer);
    }
 
    if (driverKey != NULL) {
        ZwClose(driverKey);
    }
 
    if (parametersKey != NULL) {
        ZwClose(parametersKey);
    }
 
    return;
}

Referenced by DriverUnload().

WdfWriteKmdfVersionToRegistry()

VOID WdfWriteKmdfVersionToRegistry	(	__in PDRIVER_OBJECT	DriverObject,
		__in PUNICODE_STRING	RegistryPath
	)

Definition at line 555 of file version.cpp.

{
    NTSTATUS status;
    OBJECT_ATTRIBUTES objectAttributes;
    HANDLE driverKey;
    HANDLE parametersKey;
    UNICODE_STRING valueName;
    UNICODE_STRING parametersPath;
    PDRV_EXTENSION driverExtension;
 
    driverKey = NULL;
    parametersKey = NULL;
    driverExtension = NULL;
 
    RtlInitUnicodeString(&parametersPath, DRIVER_PARAMETERS);
 
    InitializeObjectAttributes(&objectAttributes,
                               RegistryPath,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    status = ZwOpenKey(&driverKey, KEY_CREATE_SUB_KEY, &objectAttributes);
    if (!NT_SUCCESS(status)) {
        __Print(("WdfWriteKmdfVersionToRegistry: Failed to open HKLM\\%S\n",
                 RegistryPath->Buffer));
        goto out;
    }
 
    InitializeObjectAttributes(&objectAttributes,
                               &parametersPath,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               driverKey,
                               NULL);
 
    //
    // Open or create key and get a handle
    //
    status = ZwCreateKey(&parametersKey,
                         KEY_SET_VALUE,
                         &objectAttributes,
                         0,
                         (PUNICODE_STRING) NULL,
                         REG_OPTION_VOLATILE,
                         NULL);
 
    if (!NT_SUCCESS(status)) {
        __Print(("WdfWriteKmdfVersionToRegistry: Failed to open HKLM\\%S\\%S\n",
                 RegistryPath->Buffer, parametersPath.Buffer));
        goto out;
    }
 
    //
    // Set Major Version
    //
    RtlInitUnicodeString(&valueName, REGISTRY_KMDF_MAJOR_VERSION);
 
    status = ZwSetValueKey(parametersKey,
                           &valueName,
                           0,
                           REG_DWORD,
                           &WdfLibraryInfo.Version.Major,
                           sizeof(WdfLibraryInfo.Version.Major));
 
    if (!NT_SUCCESS(status)) {
        __Print(("WdfWriteKmdfVersionToRegistry: Failed to set Major Version\n"));
        goto out;
    }
 
    //
    // Set Minor Version
    //
    RtlInitUnicodeString(&valueName, REGISTRY_KMDF_MINOR_VERSION);
 
    status = ZwSetValueKey(parametersKey,
                           &valueName,
                           0,
                           REG_DWORD,
                           &WdfLibraryInfo.Version.Minor,
                           sizeof(WdfLibraryInfo.Version.Minor));
 
    if (!NT_SUCCESS(status)) {
        __Print(("WdfWriteKmdfVersionToRegistry: Failed to set Minor Version\n"));
        goto out;
    }
 
 
    //
    // Set Build Number
    //
    RtlInitUnicodeString(&valueName, REGISTRY_KMDF_BUILD_NUMBER);
 
    status = ZwSetValueKey(parametersKey,
                           &valueName,
                           0,
                           REG_DWORD,
                           &WdfLibraryInfo.Version.Build,
                           sizeof(WdfLibraryInfo.Version.Build));
 
    if (!NT_SUCCESS(status)) {
        __Print(("WdfWriteKmdfVersionToRegistry: Failed to set Build Number\n"));
        goto out;
    }
 
    //
    // Create a Driver Extension to store the registry path, where we write the
    // version of the wdf01000.sys that's loaded in memory
    //
    status = IoAllocateDriverObjectExtension(DriverObject,
                                             (PVOID) DRIVER_OBJECT_EXTENSION_IDENTIFIER,
                                             sizeof(DRV_EXTENSION),
                                             (PVOID *)&driverExtension);
 
    if (!NT_SUCCESS(status) || driverExtension == NULL) {
        goto out;
    }
 
    driverExtension->ParametersRegistryPath.Buffer = (PWCHAR) ExAllocatePoolWithTag(
                                                                PagedPool,
                                                                RegistryPath->MaximumLength,
                                                                FX_TAG);
    if (driverExtension->ParametersRegistryPath.Buffer == NULL) {
        goto out;
    }
 
    driverExtension->ParametersRegistryPath.MaximumLength = RegistryPath->MaximumLength;
    RtlCopyUnicodeString(&(driverExtension->ParametersRegistryPath), RegistryPath);
 
out:
    if (driverKey != NULL) {
        ZwClose(driverKey);
    }
 
    if (parametersKey != NULL) {
        ZwClose(parametersKey);
    }
 
    return;
}

Referenced by DriverEntry().

Variable Documentation

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 103 of file version.cpp.

Referenced by TestDriverObject().

DriverUnload

DRIVER_UNLOAD DriverUnload

Definition at line 100 of file version.cpp.

Referenced by DriverEntry().

gOsVersion

RTL_OSVERSIONINFOW gOsVersion = { sizeof(RTL_OSVERSIONINFOW) }

Definition at line 111 of file version.cpp.

Referenced by FxLibraryCommonCommission().

typeFX_DUMP_DRIVER_INFO_ENTRY

FX_DUMP_DRIVER_INFO_ENTRY* typeFX_DUMP_DRIVER_INFO_ENTRY

Definition at line 71 of file version.cpp.

typeFX_OBJECT_INFO

FX_OBJECT_INFO* typeFX_OBJECT_INFO

Definition at line 66 of file version.cpp.

typeFX_POOL

FX_POOL* typeFX_POOL

Definition at line 68 of file version.cpp.

typeFX_POOL_HEADER

FX_POOL_HEADER* typeFX_POOL_HEADER

Definition at line 67 of file version.cpp.

typeFxContextHeader

FxContextHeader* typeFxContextHeader

Definition at line 70 of file version.cpp.

typeFxObject

FxObject* typeFxObject

Definition at line 69 of file version.cpp.

typeFxTargetSubmitSyncParams

FxTargetSubmitSyncParams* typeFxTargetSubmitSyncParams

Definition at line 72 of file version.cpp.

typeWDF_BIND_INFO

WDF_BIND_INFO* typeWDF_BIND_INFO

Definition at line 61 of file version.cpp.

typeWDF_BUGCHECK_CODES

WDF_BUGCHECK_CODES* typeWDF_BUGCHECK_CODES

Definition at line 64 of file version.cpp.

typeWDF_IFR_HEADER

WDF_IFR_HEADER* typeWDF_IFR_HEADER

Definition at line 58 of file version.cpp.

typeWDF_IFR_OFFSET

WDF_IFR_OFFSET* typeWDF_IFR_OFFSET

Definition at line 60 of file version.cpp.

typeWDF_IFR_RECORD

WDF_IFR_RECORD* typeWDF_IFR_RECORD

Definition at line 59 of file version.cpp.

typeWDF_OBJECT_CONTEXT_TYPE_INFO

WDF_OBJECT_CONTEXT_TYPE_INFO* typeWDF_OBJECT_CONTEXT_TYPE_INFO

Definition at line 62 of file version.cpp.

typeWDF_POWER_ROUTINE_TIMED_OUT_DATA

WDF_POWER_ROUTINE_TIMED_OUT_DATA* typeWDF_POWER_ROUTINE_TIMED_OUT_DATA

Definition at line 63 of file version.cpp.

typeWDF_REQUEST_FATAL_ERROR_CODES

WDF_REQUEST_FATAL_ERROR_CODES* typeWDF_REQUEST_FATAL_ERROR_CODES

Definition at line 65 of file version.cpp.

union { ... } uAllPublicTypes

WdfLdrDbgPrintOn

ULONG WdfLdrDbgPrintOn = 0

Definition at line 113 of file version.cpp.

Referenced by DriverEntry().

WdfLdrType

PCHAR WdfLdrType = KMDF_DEFAULT_NAME

Definition at line 115 of file version.cpp.

WdfLibraryInfo

WDF_LIBRARY_INFO WdfLibraryInfo

Initial value:

= {
    sizeof(WDF_LIBRARY_INFO),
    (PFNLIBRARYCOMMISSION)        WDF_LIBRARY_COMMISSION,
    (PFNLIBRARYDECOMMISSION)      WDF_LIBRARY_DECOMMISSION,
    (PFNLIBRARYREGISTERCLIENT)    WDF_LIBRARY_REGISTER_CLIENT,
    (PFNLIBRARYUNREGISTERCLIENT)  WDF_LIBRARY_UNREGISTER_CLIENT,
    { __WDF_MAJOR_VERSION, __WDF_MINOR_VERSION, __WDF_BUILD_NUMBER }
}

Definition at line 189 of file version.cpp.

Referenced by DriverEntry(), WDF_LIBRARY_REGISTER_CLIENT(), and WdfWriteKmdfVersionToRegistry().