class.c File Reference

#include "wdfloader.h"

Include dependency graph for class.c:

Go to the source code of this file.

Functions
VOID	ClassAcquireClientLock (_In_ PERESOURCE Resource)
VOID	ClassReleaseClientLock (_In_ PERESOURCE Resource)
NTSTATUS	ClassOpen (_Inout_ PCLASS_MODULE ClassModule, _In_ PUNICODE_STRING ObjectName)
VOID	ClassClose (_In_ PCLASS_MODULE ClassModule)
VOID	ClassCleanupAndFree (_In_ PCLASS_MODULE ClassModule)
PCLASS_MODULE	ClassCreate (_In_ PWDF_CLASS_LIBRARY_INFO ClassLibInfo, _In_ PLIBRARY_MODULE LibModule, _In_ PUNICODE_STRING ServiceName)
PCLASS_CLIENT_MODULE	ClassClientCreate ()
PCLIENT_MODULE	LibraryFindClientLocked (_In_ PLIBRARY_MODULE LibModule, _In_ PWDF_BIND_INFO BindInfo)
NTSTATUS	ClassLinkInClient (_In_ PCLASS_MODULE ClassModule, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PCLASS_CLIENT_MODULE ClassClientModule)
NTSTATUS	GetClassRegistryHandle (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PHANDLE KeyHandle)
NTSTATUS	GetDefaultClassServiceName (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PUNICODE_STRING ServiceName)
NTSTATUS	GetClassServicePath (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PUNICODE_STRING ServicePath)
NTSTATUS	ReferenceClassVersion (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PCLASS_MODULE *ClassModule)
VOID	ClassUnload (_In_ PCLASS_MODULE ClassModule, _In_ BOOLEAN RemoveFromList)
PCLASS_MODULE	FindClassByServiceNameLocked (_In_ PUNICODE_STRING ServicePath, _Out_ PLIBRARY_MODULE *LibModule)
PLIST_ENTRY	LibraryUnloadClasses (_In_ PLIBRARY_MODULE LibModule)
PLIST_ENTRY	LibraryAddToClassListLocked (_In_ PLIBRARY_MODULE LibModule, _In_ PCLASS_MODULE ClassModule)
VOID	ClassRemoveFromLibraryList (_In_ PCLASS_MODULE ClassModule)
VOID	ClassUnlinkClient (_In_ PCLASS_MODULE ClassModule, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)
VOID NTAPI	ClassAddReference (_In_ PCLASS_MODULE ClassModule)
VOID	ClassReleaseClientReference (_In_ PCLASS_MODULE ClassModule)
VOID	DereferenceClassVersion (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals)

Function Documentation

ClassAcquireClientLock()

VOID ClassAcquireClientLock

(

_In_ PERESOURCE

Resource

)

Definition at line 13 of file class.c.

{
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(Resource, TRUE);
}

Referenced by ClassLinkInClient(), and ClassUnlinkClient().

ClassAddReference()

VOID NTAPI ClassAddReference

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 761 of file class.c.

{
    InterlockedIncrement(&ClassModule->ClassRefCount);
    DPRINT_VERBOSE(("Added reference to class %wZ, RefCount=%d\n",
                   &ClassModule->Service, ClassModule->ClassRefCount));
}

Referenced by WdfRegisterClassLibrary().

ClassCleanupAndFree()

VOID ClassCleanupAndFree

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 59 of file class.c.

{
    ClassClose(ClassModule);
 
    if (ClassModule->Service.Buffer != NULL)
        ExFreePoolWithTag(ClassModule->Service.Buffer, WDFLDR_TAG);
 
    if (ClassModule->ImageName.Buffer != NULL)
        ExFreePoolWithTag(ClassModule->ImageName.Buffer, WDFLDR_TAG);
 
    ExDeleteResourceLite(&ClassModule->ClientsListLock);
    ExFreePoolWithTag(ClassModule, WDFLDR_TAG);
}

Referenced by ClassCreate(), ClassRemoveFromLibraryList(), LibraryUnloadClasses(), and ReferenceClassVersion().

ClassClientCreate()

PCLASS_CLIENT_MODULE ClassClientCreate

(

)

Definition at line 137 of file class.c.

{
    PCLASS_CLIENT_MODULE pNewClassClientModule;
 
    pNewClassClientModule = ExAllocatePoolZero(NonPagedPool, sizeof(*pNewClassClientModule), WDFLDR_TAG);
    if (pNewClassClientModule != NULL)
    {
        InitializeListHead(&pNewClassClientModule->ClassLinkage);
        InitializeListHead(&pNewClassClientModule->ClientLinkage);
    }
 
    return pNewClassClientModule;
}

Referenced by WdfVersionBindClass().

ClassClose()

VOID ClassClose

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 48 of file class.c.

{
    if (ClassModule->ClassFileObject != NULL)
    {
        ObDereferenceObject(ClassModule->ClassFileObject);
        ClassModule->ClassFileObject = NULL;
    }
}

ClassCreate()

PCLASS_MODULE ClassCreate	(	_In_ PWDF_CLASS_LIBRARY_INFO	ClassLibInfo,
		_In_ PLIBRARY_MODULE	LibModule,
		_In_ PUNICODE_STRING	ServiceName
	)

Definition at line 75 of file class.c.

{
    PCLASS_MODULE pNewClassModule;
    NTSTATUS status;
 
    pNewClassModule = ExAllocatePoolZero(NonPagedPool, sizeof(*pNewClassModule), WDFLDR_TAG);
    if (pNewClassModule == NULL)
        return NULL;
 
    if (ClassLibInfo != NULL)
    {
        pNewClassModule->ImplicitlyLoaded = TRUE;
        pNewClassModule->ClassLibraryInfo = ClassLibInfo;
        pNewClassModule->Version.Major = ClassLibInfo->Version.Major;
        pNewClassModule->Version.Minor = ClassLibInfo->Version.Minor;
        pNewClassModule->Version.Build = ClassLibInfo->Version.Build;
    }
 
    pNewClassModule->ClassRefCount = 1;
    pNewClassModule->Library = LibModule;
    ExInitializeResourceLite(&pNewClassModule->ClientsListLock);
    InitializeListHead(&pNewClassModule->ClientsListHead);
    InitializeListHead(&pNewClassModule->LibraryLinkage);
 
    pNewClassModule->Service.Buffer = ExAllocatePoolZero(PagedPool, ServiceName->MaximumLength, WDFLDR_TAG);
    if (pNewClassModule->Service.Buffer == NULL)
    {
        goto clean;
    }
    pNewClassModule->Service.MaximumLength = ServiceName->MaximumLength;
    RtlCopyUnicodeString(&pNewClassModule->Service, ServiceName);
    status = GetImageName(ServiceName, &pNewClassModule->ImageName);
 
    if (!NT_SUCCESS(status))
    {
        goto clean;
    }
 
    pNewClassModule->IsBootDriver = ServiceCheckBootStart(&pNewClassModule->Service);
    status = GetImageInfo(&pNewClassModule->ImageName,
                          &pNewClassModule->ImageAddress,
                          &pNewClassModule->ImageSize);
 
    if (NT_SUCCESS(status))
    {
        return pNewClassModule;
    }
    else
    {
        __DBGPRINT(("GetImageBase failed\n"));
    }
 
clean:
    ClassCleanupAndFree(pNewClassModule);
 
    return NULL;
}

ClassLinkInClient()

NTSTATUS ClassLinkInClient	(	_In_ PCLASS_MODULE	ClassModule,
		_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PCLASS_CLIENT_MODULE	ClassClientModule
	)

Definition at line 170 of file class.c.

{
    PCLIENT_MODULE pClienInfo;
    NTSTATUS status;
 
    ClassClientModule->Class = ClassModule;
    ClassClientModule->ClientClassBindInfo = ClassBindInfo;
    LibraryAcquireClientLock(ClassModule->Library);
    pClienInfo = LibraryFindClientLocked(ClassModule->Library, BindInfo);
 
    if (pClienInfo != NULL)
    {
        ClassClientModule->Client = pClienInfo;
        InsertTailList(&pClienInfo->ClassListHead, &ClassClientModule->ClassLinkage);
    }
 
    LibraryReleaseClientLock(ClassModule->Library);
 
    if (pClienInfo != NULL)
    {
        ClassAcquireClientLock(&ClassModule->ClientsListLock);
        InsertTailList(&ClassModule->ClientsListHead, &ClassClientModule->ClientLinkage);
        ClassReleaseClientLock(&ClassModule->ClientsListLock);
        status = STATUS_SUCCESS;
    }
    else
    {
        status = STATUS_INVALID_DEVICE_STATE;
        __DBGPRINT(("ERROR: Could not locate client from Info %p, status 0x%x\n", BindInfo, status));
    }
 
    return status;
}

Referenced by WdfVersionBindClass().

ClassOpen()

NTSTATUS ClassOpen	(	_Inout_ PCLASS_MODULE	ClassModule,
		_In_ PUNICODE_STRING	ObjectName
	)

Definition at line 29 of file class.c.

{
    NTSTATUS status;
    PDEVICE_OBJECT deviceObject;
 
    if (!ObjectName)
        return STATUS_SUCCESS;
 
    status = IoGetDeviceObjectPointer(ObjectName, FILE_READ_DATA, &ClassModule->ClassFileObject, &deviceObject);
 
    if (NT_SUCCESS(status))
        ClassModule->ClassDriverObject = deviceObject->DriverObject;
 
    return status;
}

Referenced by WdfRegisterClassLibrary().

ClassReleaseClientLock()

VOID ClassReleaseClientLock

(

_In_ PERESOURCE

Resource

)

Definition at line 21 of file class.c.

{
    ExReleaseResourceLite(Resource);
    KeLeaveCriticalRegion();
}

Referenced by ClassLinkInClient(), and ClassUnlinkClient().

ClassReleaseClientReference()

VOID ClassReleaseClientReference

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 770 of file class.c.

{
    int refs;
 
    __DBGPRINT(("Dereference module %wZ\n", &ClassModule->Service));
    refs = InterlockedDecrement(&ClassModule->ClientRefCount);
 
    if (refs <= 0)
    {
        ClassUnload(ClassModule, TRUE);
    }
    else
    {
        __DBGPRINT(("Dereference module %wZ still has %d references\n",
                   &ClassModule->Service, refs));
    }
}

Referenced by DereferenceClassVersion().

ClassRemoveFromLibraryList()

VOID ClassRemoveFromLibraryList

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 692 of file class.c.

{
    PLIST_ENTRY libLinkEntry;
    BOOLEAN removed;
 
    FxLdrAcquireLoadedModuleLock();
    libLinkEntry = &ClassModule->LibraryLinkage;
 
    if (IsListEmpty(libLinkEntry))
    {
        removed = FALSE;
    }
    else
    {
        RemoveEntryList(libLinkEntry);
        InitializeListHead(libLinkEntry);
        removed = TRUE;
    }
    FxLdrReleaseLoadedModuleLock();
 
    if (removed)
    {
        if (InterlockedExchangeAdd(&ClassModule->ClassRefCount, -1) == 1)
            ClassCleanupAndFree(ClassModule);
    }
}

Referenced by ClassUnload(), and WdfRegisterClassLibrary().

ClassUnlinkClient()

VOID ClassUnlinkClient	(	_In_ PCLASS_MODULE	ClassModule,
		_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo
	)

Definition at line 721 of file class.c.

{
    PCLASS_CLIENT_MODULE client;
    BOOLEAN isUnlinked;
    PLIST_ENTRY entry;
 
    client = NULL;
    isUnlinked = FALSE;
    ClassAcquireClientLock(&ClassModule->ClientsListLock);
 
    for (entry = ClassModule->ClientsListHead.Flink;
        entry != &ClassModule->ClientsListHead;
        entry = entry->Flink)
    {
        client = CONTAINING_RECORD(entry, CLASS_CLIENT_MODULE, ClassLinkage);
        if (CONTAINING_RECORD(entry, CLASS_CLIENT_MODULE, ClassLinkage)->ClientClassBindInfo == ClassBindInfo)
        {
            isUnlinked = TRUE;
            break;
        }
    }
 
    ClassReleaseClientLock(&ClassModule->ClientsListLock);
 
    if (isUnlinked)
    {
        RemoveEntryList(entry);
        InitializeListHead(entry);
        LibraryAcquireClientLock(ClassModule->Library);
        InitializeListHead(&client->ClientLinkage);
        RemoveEntryList(&client->ClientLinkage);
        LibraryReleaseClientLock(ClassModule->Library);
        ExFreePoolWithTag(client, WDFLDR_TAG);
    }
}

Referenced by DereferenceClassVersion().

ClassUnload()

VOID ClassUnload	(	_In_ PCLASS_MODULE	ClassModule,
		_In_ BOOLEAN	RemoveFromList
	)

Definition at line 548 of file class.c.

{
    PCLASS_MODULE pClassModule;
    PWDF_CLASS_LIBRARY_INFO pClassLibInfo;
    NTSTATUS status;
 
    pClassModule = ClassModule;
    pClassLibInfo = ClassModule->ClassLibraryInfo;
 
    if (pClassLibInfo && pClassLibInfo->ClassLibraryDeinitialize)
    {
        __DBGPRINT(("calling ClassLibraryDeinitialize (%p)\n",
                ClassModule->ClassLibraryInfo->ClassLibraryDeinitialize));
 
        ClassModule->ClassLibraryInfo->ClassLibraryDeinitialize();
    }
 
    __DBGPRINT(("Unload class library %wZ\n", &ClassModule->Service));
 
    ClassClose(ClassModule);
    status = ZwUnloadDriver(&ClassModule->Service);
 
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("unload of class %wZ returned 0x%x (this may not be a true error if someone else attempted to "
            "stop the service first)\n",
            &pClassModule->Service,
            status));
    }
 
    if (RemoveFromList)
        ClassRemoveFromLibraryList(pClassModule);
}

DereferenceClassVersion()

VOID DereferenceClassVersion	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_In_ PWDF_COMPONENT_GLOBALS	Globals
	)

Definition at line 790 of file class.c.

{
    PCLASS_MODULE pClassModule;
 
    UNREFERENCED_PARAMETER(BindInfo);
    pClassModule = ClassBindInfo->ClassModule;
 
    if (pClassModule)
    {
        if (pClassModule->ClassLibraryInfo &&
            pClassModule->ClassLibraryInfo->ClassLibraryUnbindClient)
        {
            pClassModule->ClassLibraryInfo->ClassLibraryUnbindClient(ClassBindInfo, &Globals);
        }
        ClassUnlinkClient(pClassModule, ClassBindInfo);
        ClassReleaseClientReference(pClassModule);
        ClassBindInfo->ClassModule = NULL;
    }
}

Referenced by WdfVersionBindClass(), and WdfVersionUnbindClass().

FindClassByServiceNameLocked()

PCLASS_MODULE FindClassByServiceNameLocked	(	_In_ PUNICODE_STRING	ServicePath,
		_Out_ PLIBRARY_MODULE *	LibModule
	)

Definition at line 585 of file class.c.

{
    PLIST_ENTRY libEntry;
    PLIBRARY_MODULE pLibModule;
    PLIST_ENTRY classEntry;
    PCLASS_MODULE pClassModule;
    UNICODE_STRING needleName;
 
    GetNameFromPath(ServicePath, &needleName);
 
    if (IsListEmpty(&WdfLdrGlobals.LoadedModulesList))
    {
        goto end;
    }
 
    for (libEntry = WdfLdrGlobals.LoadedModulesList.Flink;
         libEntry != &WdfLdrGlobals.LoadedModulesList;
         libEntry = libEntry->Flink)
    {
        pLibModule = CONTAINING_RECORD(libEntry, LIBRARY_MODULE, LibraryListEntry);
 
        for (classEntry = pLibModule->ClassListHead.Flink;
             classEntry != &pLibModule->ClassListHead;
             classEntry = classEntry->Flink)
        {
            UNICODE_STRING haystackName;
            pClassModule = CONTAINING_RECORD(classEntry, CLASS_MODULE, LibraryLinkage);
            GetNameFromPath(&pClassModule->Service, &haystackName);
 
            if (RtlEqualUnicodeString(&needleName, &haystackName, TRUE))
            {
                if (LibModule != NULL)
                {
                    *LibModule = pLibModule;
                }
 
                return pClassModule;
            }
        }
    }
 
end:
    if (LibModule != NULL)
        *LibModule = NULL;
 
    return NULL;
}

Referenced by ReferenceClassVersion(), and WdfRegisterClassLibrary().

GetClassRegistryHandle()

NTSTATUS GetClassRegistryHandle	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PHANDLE	KeyHandle
	)

Definition at line 209 of file class.c.

{
    UNICODE_STRING classVersions;
    OBJECT_ATTRIBUTES objectAttributes;
    HANDLE rootHandle = NULL;
    HANDLE classVersionsHandle = NULL;
    HANDLE classVersionHandle = NULL;
    NTSTATUS status;
    SIZE_T classNameLength;
    SIZE_T bufferSize;
    UNICODE_STRING objectName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Wdf\\Kmdf");
    DECLARE_UNICODE_STRING_SIZE(versionString, 11);
 
    classVersions.Length = 0;
    classVersions.Buffer = NULL;
    *KeyHandle = NULL;
 
    /* Open root registry key */
    InitializeObjectAttributes(&objectAttributes,
                               &objectName,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    status = ZwOpenKey(&rootHandle, KEY_QUERY_VALUE, &objectAttributes);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ZwOpenKey failed for root key, status 0x%08X\n", status));
        goto cleanup;
    }
 
    classNameLength = wcslen(ClassBindInfo->ClassName);
    bufferSize = (classNameLength * sizeof(WCHAR)) + sizeof(L"\\Versions");
 
    classVersions.Buffer = ExAllocatePoolWithTag(PagedPool, bufferSize, WDFLDR_TAG);
    if (classVersions.Buffer == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }
 
    classVersions.MaximumLength = (USHORT)bufferSize;
    status = RtlUnicodeStringPrintf(&classVersions, L"%s\\Versions", ClassBindInfo->ClassName);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("RtlUnicodeStringPrintf failed, status 0x%08X\n", status));
        goto cleanup;
    }
 
    InitializeObjectAttributes(&objectAttributes,
                               &classVersions,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               rootHandle,
                               NULL);
 
    status = ZwOpenKey(&classVersionsHandle, KEY_QUERY_VALUE, &objectAttributes);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ZwOpenKey failed for class versions, status 0x%08X\n", status));
        goto cleanup;
    }
 
    status = RtlIntegerToUnicodeString(ClassBindInfo->Version.Major, 10, &versionString);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("RtlIntegerToUnicodeString failed for class version, status 0x%08X\n", status));
        goto cleanup;
    }
 
    InitializeObjectAttributes(&objectAttributes,
                               &versionString,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               classVersionsHandle,
                               NULL);
 
    status = ZwOpenKey(&classVersionHandle, KEY_QUERY_VALUE, &objectAttributes);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ZwOpenKey failed for class version, status 0x%08X\n", status));
        goto cleanup;
    }
 
    status = RtlIntegerToUnicodeString(BindInfo->Version.Major, 10, &versionString);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("RtlIntegerToUnicodeString failed for bind version, status 0x%08X\n", status));
        goto cleanup;
    }
 
    InitializeObjectAttributes(&objectAttributes,
                               &versionString,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               classVersionHandle,
                               NULL);
 
    status = ZwOpenKey(KeyHandle, KEY_QUERY_VALUE, &objectAttributes);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ZwOpenKey failed for bind version, status 0x%08X\n", status));
        goto cleanup;
    }
 
cleanup:
    if (classVersionHandle)
        ZwClose(classVersionHandle);
    if (classVersionsHandle)
        ZwClose(classVersionsHandle);
    if (rootHandle)
        ZwClose(rootHandle);
 
    if (classVersions.Buffer)
    {
        ExFreePoolWithTag(classVersions.Buffer, WDFLDR_TAG);
    }
 
    return status;
}

Referenced by GetClassServicePath().

GetClassServicePath()

NTSTATUS GetClassServicePath	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PUNICODE_STRING	ServicePath
	)

Definition at line 371 of file class.c.

{
    NTSTATUS status;
    HANDLE Handle = NULL;
    PKEY_VALUE_PARTIAL_INFORMATION pKeyValPartial = NULL;
    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"Service");
 
    ServicePath->Length = 0;
    ServicePath->Buffer = NULL;
 
    status = GetClassRegistryHandle(ClassBindInfo, BindInfo, &Handle);
 
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ERROR: GetClassRegistryHandle failed with status 0x%x\n", status));
    }
    else
    {
        status = FxLdrQueryData(Handle, &ValueName, WDFLDR_TAG, &pKeyValPartial);
 
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: QueryData failed with status 0x%x\n", status));
        }
        else
        {
            status = BuildServicePath(pKeyValPartial, ServicePath);
        }
    }
 
    if (!NT_SUCCESS(status))
    {
        status = GetDefaultClassServiceName(ClassBindInfo, BindInfo, ServicePath);
 
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: GetDefaultClassServiceName failed, status 0x%x\n", status));
        }
    }
 
    if (Handle)
        ZwClose(Handle);
    if (pKeyValPartial)
        ExFreePoolWithTag(pKeyValPartial, WDFLDR_TAG);
 
    return status;
}

Referenced by ReferenceClassVersion().

GetDefaultClassServiceName()

NTSTATUS GetDefaultClassServiceName	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PUNICODE_STRING	ServiceName
	)

Definition at line 331 of file class.c.

{
    SIZE_T classNameLength;
    SIZE_T bufferSize;
    NTSTATUS status;
 
    /*
     * version numbers are 2 digits each (4 chars)
     */
    classNameLength = wcslen(ClassBindInfo->ClassName);
    bufferSize = (classNameLength * sizeof(WCHAR)) +
                 (sizeof(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\") +
                  (4 * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
 
    ServiceName->Buffer = ExAllocatePoolWithTag(PagedPool, bufferSize, WDFLDR_TAG);
    if (ServiceName->Buffer == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    ServiceName->MaximumLength = (USHORT)bufferSize;
    status = RtlUnicodeStringPrintf(
        ServiceName,
        L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\%ws%02d%02d",
        ClassBindInfo->ClassName,
        ClassBindInfo->Version.Major,
        BindInfo->Version.Major);
 
    if (!NT_SUCCESS(status))
    {
        ExFreePoolWithTag(ServiceName->Buffer, WDFLDR_TAG);
    }
 
    return status;
}

Referenced by GetClassServicePath().

LibraryAddToClassListLocked()

PLIST_ENTRY LibraryAddToClassListLocked	(	_In_ PLIBRARY_MODULE	LibModule,
		_In_ PCLASS_MODULE	ClassModule
	)

Definition at line 673 of file class.c.

{
    PLIST_ENTRY result;
 
    if (!LibModule || !ClassModule)
        return NULL;
 
    result = &ClassModule->LibraryLinkage;
    InsertHeadList(&LibModule->ClassListHead, &ClassModule->LibraryLinkage);
 
    DPRINT_VERBOSE(("Added class %wZ to library %wZ\n",
                   &ClassModule->Service, &LibModule->ServicePath));
 
    return result;
}

Referenced by ReferenceClassVersion(), and WdfRegisterClassLibrary().

LibraryFindClientLocked()

PCLIENT_MODULE LibraryFindClientLocked	(	_In_ PLIBRARY_MODULE	LibModule,
		_In_ PWDF_BIND_INFO	BindInfo
	)

Definition at line 152 of file class.c.

{
    PCLIENT_MODULE pFoundClient;
    PLIST_ENTRY entry;
 
    for (entry = LibModule->ClientsListHead.Flink; entry != &LibModule->ClientsListHead; entry = entry->Flink)
    {
        pFoundClient = CONTAINING_RECORD(entry, CLIENT_MODULE, LibListEntry);
        if (pFoundClient->Info == BindInfo)
            return pFoundClient;
    }
 
    return NULL;
}

Referenced by ClassLinkInClient().

LibraryUnloadClasses()

PLIST_ENTRY LibraryUnloadClasses

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 636 of file class.c.

{
    PLIST_ENTRY classListHead;
    PLIST_ENTRY entry;
    PCLASS_MODULE pClassModule;
    LIST_ENTRY removedList;
 
    InitializeListHead(&removedList);
    classListHead = &LibModule->ClassListHead;
 
    if (IsListEmpty(classListHead))
        return classListHead;
 
    while (!IsListEmpty(classListHead))
    {
        entry = RemoveHeadList(classListHead);
        InsertTailList(&removedList, entry);
    }
 
    while (!IsListEmpty(&removedList))
    {
        entry = RemoveHeadList(&removedList);
        InitializeListHead(entry);
        pClassModule = CONTAINING_RECORD(entry, CLASS_MODULE, LibraryLinkage);
 
        __DBGPRINT(("Unload class library %wZ (%p)\n", &pClassModule->Service, pClassModule));
 
        ClassUnload(pClassModule, 0);
        if (InterlockedExchangeAdd(&pClassModule->ClassRefCount, -1) == 1)
            ClassCleanupAndFree(pClassModule);
    }
 
    return classListHead;
}

Referenced by DllUnload().

ReferenceClassVersion()

NTSTATUS ReferenceClassVersion	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PCLASS_MODULE *	ClassModule
	)

Definition at line 423 of file class.c.

{
    PWDF_BIND_INFO pBindInfo;
    PCLASS_MODULE pClassModule;
    UNICODE_STRING driverServiceName;
    PLIBRARY_MODULE pLibModule;
    BOOLEAN created;
    NTSTATUS status;
 
    *ClassModule = NULL;
    pBindInfo = BindInfo;
    created = FALSE;
    status = GetClassServicePath(ClassBindInfo, BindInfo, &driverServiceName);
 
    if (!NT_SUCCESS(status))
    {
        RtlFreeUnicodeString(&driverServiceName);
        return status;
    }
    FxLdrAcquireLoadedModuleLock();
    pClassModule = FindClassByServiceNameLocked(&driverServiceName, &pLibModule);
 
    if (!pLibModule)
    {
        pLibModule = pBindInfo->Module;
    }
 
    if (pLibModule == pBindInfo->Module)
    {
        if (pClassModule)
        {
            InterlockedExchangeAdd(&pClassModule->ClassRefCount, 1);
        }
        else
        {
            pClassModule = ClassCreate(NULL, pLibModule, &driverServiceName);
 
            if (pClassModule)
            {
                InterlockedExchangeAdd(&pClassModule->ClassRefCount, 1);
                LibraryAddToClassListLocked(pLibModule, pClassModule);
                created = TRUE;
            }
            else
            {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
    }
    else
    {
        status = STATUS_REVISION_MISMATCH;
 
        __DBGPRINT(("class %S bound to library %p,client bound to library %p, status 0x%x\n",
                ClassBindInfo->ClassName,
                pLibModule,
                pBindInfo->Module,
                status));
    }
    FxLdrReleaseLoadedModuleLock();
 
    if (!created)
    {
        if (!NT_SUCCESS(status))
            goto clean;
 
        ClassBindInfo->ClassModule = pClassModule;
        *ClassModule = pClassModule;
    }
 
    /* Class logic: Only call ZwLoadDriver if:
     * 1. Class module was newly created, OR
     * 2. Class module exists but has no ClassLibraryInfo
     */
    if (created || (pClassModule && !pClassModule->ClassLibraryInfo))
    {
 
        status = ZwLoadDriver(&driverServiceName);
        if (!NT_SUCCESS(status))
        {
 
            if (status == STATUS_OBJECT_PATH_NOT_FOUND ||
                status == STATUS_OBJECT_NAME_NOT_FOUND ||
                status == STATUS_IMAGE_ALREADY_LOADED)
            {
                /* Driver might already be loaded as boot driver - UCX*/
                status = STATUS_SUCCESS;
            }
        }
        else if (pClassModule && !pClassModule->ClassLibraryInfo)
        {
            status = STATUS_DRIVER_INTERNAL_ERROR;
        }
    }
    else
    {
        /* Class module exists and has ClassLibraryInfo - skip ZwLoadDriver */
        status = STATUS_SUCCESS;
    }
 
    /* Always set the class module regardless of ZwLoadDriver result (Again.. UCX) */
    if (pClassModule && NT_SUCCESS(status))
    {
        ClassBindInfo->ClassModule = pClassModule;
        *ClassModule = pClassModule;
 
        InterlockedExchangeAdd(&pClassModule->ClientRefCount, 1);
        goto exit_success;
    }
 
clean:
    if (pClassModule && InterlockedExchangeAdd(&pClassModule->ClassRefCount, -1) == 1)
        ClassCleanupAndFree(pClassModule);
 
exit_success:
 
    RtlFreeUnicodeString(&driverServiceName);
 
    return status;
}

Referenced by WdfVersionBindClass().