mntmgr.h File Reference

#include <ntifs.h>
#include <mountdev.h>
#include <ntddvol.h>
#include <ntdddisk.h>
#include <wdmguid.h>
#include <ndk/psfuncs.h>
#include <section_attribs.h>

Include dependency graph for mntmgr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DEVICE_EXTENSION
struct	_DEVICE_INFORMATION
struct	_SYMLINK_INFORMATION
struct	_SAVED_LINK_INFORMATION
struct	_UNIQUE_ID_REPLICATE
struct	_DATABASE_ENTRY
struct	_ASSOCIATED_DEVICE_ENTRY
struct	_DEVICE_INFORMATION_ENTRY
struct	_ONLINE_NOTIFICATION_WORK_ITEM
struct	_RECONCILE_WORK_ITEM_CONTEXT
struct	_RECONCILE_WORK_ITEM
struct	_MIGRATE_WORK_ITEM
struct	_UNIQUE_ID_WORK_ITEM

Macros
#define	AllocatePool(Size)   ExAllocatePoolWithTag(PagedPool, Size, 'AtnM')
#define	FreePool(P)   ExFreePoolWithTag(P, 'AtnM')
#define	MAX(a, b)   ((a > b) ? a : b)
#define	LETTER_POSITION   0xC
#define	COLON_POSITION   0xD
#define	DRIVE_LETTER_LENGTH   0x1C

Typedefs
typedef struct _DEVICE_EXTENSION	DEVICE_EXTENSION
typedef struct _DEVICE_EXTENSION *	PDEVICE_EXTENSION
typedef struct _DEVICE_INFORMATION	DEVICE_INFORMATION
typedef struct _DEVICE_INFORMATION *	PDEVICE_INFORMATION
typedef struct _SYMLINK_INFORMATION	SYMLINK_INFORMATION
typedef struct _SYMLINK_INFORMATION *	PSYMLINK_INFORMATION
typedef struct _SAVED_LINK_INFORMATION	SAVED_LINK_INFORMATION
typedef struct _SAVED_LINK_INFORMATION *	PSAVED_LINK_INFORMATION
typedef struct _UNIQUE_ID_REPLICATE	UNIQUE_ID_REPLICATE
typedef struct _UNIQUE_ID_REPLICATE *	PUNIQUE_ID_REPLICATE
typedef struct _DATABASE_ENTRY	DATABASE_ENTRY
typedef struct _DATABASE_ENTRY *	PDATABASE_ENTRY
typedef struct _ASSOCIATED_DEVICE_ENTRY	ASSOCIATED_DEVICE_ENTRY
typedef struct _ASSOCIATED_DEVICE_ENTRY *	PASSOCIATED_DEVICE_ENTRY
typedef struct _DEVICE_INFORMATION_ENTRY	DEVICE_INFORMATION_ENTRY
typedef struct _DEVICE_INFORMATION_ENTRY *	PDEVICE_INFORMATION_ENTRY
typedef struct _ONLINE_NOTIFICATION_WORK_ITEM	ONLINE_NOTIFICATION_WORK_ITEM
typedef struct _ONLINE_NOTIFICATION_WORK_ITEM *	PONLINE_NOTIFICATION_WORK_ITEM
typedef struct _RECONCILE_WORK_ITEM_CONTEXT	RECONCILE_WORK_ITEM_CONTEXT
typedef struct _RECONCILE_WORK_ITEM_CONTEXT *	PRECONCILE_WORK_ITEM_CONTEXT
typedef struct _RECONCILE_WORK_ITEM	RECONCILE_WORK_ITEM
typedef struct _RECONCILE_WORK_ITEM *	PRECONCILE_WORK_ITEM
typedef struct _MIGRATE_WORK_ITEM	MIGRATE_WORK_ITEM
typedef struct _MIGRATE_WORK_ITEM *	PMIGRATE_WORK_ITEM
typedef struct _UNIQUE_ID_WORK_ITEM	UNIQUE_ID_WORK_ITEM
typedef struct _UNIQUE_ID_WORK_ITEM *	PUNIQUE_ID_WORK_ITEM

Functions
	_IRQL_requires_ (PASSIVE_LEVEL) NTSTATUS MountMgrSendSyncDeviceIoCtl(_In_ ULONG IoControlCode
_In_ PDEVICE_OBJECT	_In_reads_bytes_opt_ (InputBufferLength) PVOID InputBuffer
_In_ PDEVICE_OBJECT _In_ ULONG	_Out_writes_bytes_opt_ (OutputBufferLength) PVOID OutputBuffer
VOID NTAPI	MountMgrCancel (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	MountMgrMountedDeviceArrival (IN PDEVICE_EXTENSION Extension, IN PUNICODE_STRING SymbolicName, IN BOOLEAN FromVolume)
VOID	MountMgrMountedDeviceRemoval (IN PDEVICE_EXTENSION Extension, IN PUNICODE_STRING DeviceName)
NTSTATUS	FindDeviceInfo (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING SymbolicName, IN BOOLEAN DeviceNameGiven, OUT PDEVICE_INFORMATION *DeviceInformation)
VOID	MountMgrFreeDeadDeviceInfo (IN PDEVICE_INFORMATION DeviceInformation)
NTSTATUS	QueryDeviceInformation (_In_ PUNICODE_STRING SymbolicName, _Out_opt_ PUNICODE_STRING DeviceName, _Out_opt_ PMOUNTDEV_UNIQUE_ID *UniqueId, _Out_opt_ PBOOLEAN Removable, _Out_opt_ PBOOLEAN GptDriveLetter, _Out_opt_ PBOOLEAN HasGuid, _Inout_opt_ LPGUID StableGuid, _Out_opt_ PBOOLEAN IsFT)
BOOLEAN	HasDriveLetter (IN PDEVICE_INFORMATION DeviceInformation)
VOID	ReconcileThisDatabaseWithMaster (IN PDEVICE_EXTENSION DeviceExtension, IN PDEVICE_INFORMATION DeviceInformation)
NTSTATUS	WaitForRemoteDatabaseSemaphore (IN PDEVICE_EXTENSION DeviceExtension)
VOID	ReleaseRemoteDatabaseSemaphore (IN PDEVICE_EXTENSION DeviceExtension)
VOID	ChangeRemoteDatabaseUniqueId (IN PDEVICE_INFORMATION DeviceInformation, IN PMOUNTDEV_UNIQUE_ID OldUniqueId, IN PMOUNTDEV_UNIQUE_ID NewUniqueId)
VOID	ReconcileAllDatabasesWithMaster (IN PDEVICE_EXTENSION DeviceExtension)
VOID	DeleteFromLocalDatabase (IN PUNICODE_STRING SymbolicLink, IN PMOUNTDEV_UNIQUE_ID UniqueId)
VOID	DeleteRegistryDriveLetter (IN PMOUNTDEV_UNIQUE_ID UniqueId)
VOID	DeleteNoDriveLetterEntry (IN PMOUNTDEV_UNIQUE_ID UniqueId)
NTSTATUS	QueryVolumeName (IN HANDLE RootDirectory, IN PFILE_REPARSE_POINT_INFORMATION ReparsePointInformation, IN PUNICODE_STRING FileName OPTIONAL, OUT PUNICODE_STRING SymbolicName, OUT PUNICODE_STRING VolumeName)
HANDLE	OpenRemoteDatabase (IN PDEVICE_INFORMATION DeviceInformation, IN BOOLEAN MigrateDatabase)
PDATABASE_ENTRY	GetRemoteDatabaseEntry (IN HANDLE Database, IN LONG StartingOffset)
NTSTATUS	WriteRemoteDatabaseEntry (IN HANDLE Database, IN LONG Offset, IN PDATABASE_ENTRY Entry)
NTSTATUS	CloseRemoteDatabase (IN HANDLE Database)
NTSTATUS	AddRemoteDatabaseEntry (IN HANDLE Database, IN PDATABASE_ENTRY Entry)
NTSTATUS	DeleteRemoteDatabaseEntry (IN HANDLE Database, IN LONG StartingOffset)
VOID NTAPI	ReconcileThisDatabaseWithMasterWorker (IN PVOID Parameter)
VOID	IssueUniqueIdChangeNotifyWorker (IN PUNIQUE_ID_WORK_ITEM WorkItem, IN PMOUNTDEV_UNIQUE_ID UniqueId)
VOID	WaitForOnlinesToComplete (IN PDEVICE_EXTENSION DeviceExtension)
VOID	RegisterForTargetDeviceNotification (IN PDEVICE_EXTENSION DeviceExtension, IN PDEVICE_INFORMATION DeviceInformation)
VOID	SendOnlineNotification (IN PUNICODE_STRING SymbolicName)
VOID	IssueUniqueIdChangeNotify (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING DeviceName, IN PMOUNTDEV_UNIQUE_ID UniqueId)
VOID	PostOnlineNotification (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING SymbolicName)
VOID	MountMgrNotify (IN PDEVICE_EXTENSION DeviceExtension)
VOID	MountMgrNotifyNameChange (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING DeviceName, IN BOOLEAN ValidateVolume)
VOID	MountMgrUniqueIdChangeRoutine (IN PDEVICE_EXTENSION DeviceExtension, IN PMOUNTDEV_UNIQUE_ID OldUniqueId, IN PMOUNTDEV_UNIQUE_ID NewUniqueId)
VOID	CreateNoDriveLetterEntry (IN PMOUNTDEV_UNIQUE_ID UniqueId)
BOOLEAN	HasNoDriveLetterEntry (IN PMOUNTDEV_UNIQUE_ID UniqueId)
VOID	UpdateReplicatedUniqueIds (IN PDEVICE_INFORMATION DeviceInformation, IN PDATABASE_ENTRY DatabaseEntry)
BOOLEAN	IsUniqueIdPresent (IN PDEVICE_EXTENSION DeviceExtension, IN PDATABASE_ENTRY DatabaseEntry)
NTSTATUS	MountMgrCreatePointWorker (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING SymbolicLinkName, IN PUNICODE_STRING DeviceName)
NTSTATUS	QueryPointsFromSymbolicLinkName (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING SymbolicName, IN PIRP Irp)
NTSTATUS	QueryPointsFromMemory (IN PDEVICE_EXTENSION DeviceExtension, IN PIRP Irp, IN PMOUNTDEV_UNIQUE_ID UniqueId OPTIONAL, IN PUNICODE_STRING SymbolicName OPTIONAL)
NTSTATUS	GlobalCreateSymbolicLink (IN PUNICODE_STRING DosName, IN PUNICODE_STRING DeviceName)
NTSTATUS	GlobalDeleteSymbolicLink (IN PUNICODE_STRING DosName)
NTSTATUS	QuerySuggestedLinkName (IN PUNICODE_STRING SymbolicName, OUT PUNICODE_STRING SuggestedLinkName, OUT PBOOLEAN UseOnlyIfThereAreNoOtherLinks)
NTSTATUS	QuerySymbolicLinkNamesFromStorage (IN PDEVICE_EXTENSION DeviceExtension, IN PDEVICE_INFORMATION DeviceInformation, IN PUNICODE_STRING SuggestedLinkName, IN BOOLEAN UseOnlyIfThereAreNoOtherLinks, OUT PUNICODE_STRING *SymLinks, OUT PULONG SymLinkCount, IN BOOLEAN HasGuid, IN LPGUID Guid)
PSAVED_LINK_INFORMATION	RemoveSavedLinks (IN PDEVICE_EXTENSION DeviceExtension, IN PMOUNTDEV_UNIQUE_ID UniqueId)
BOOLEAN	RedirectSavedLink (IN PSAVED_LINK_INFORMATION SavedLinkInformation, IN PUNICODE_STRING DosName, IN PUNICODE_STRING NewLink)
VOID	SendLinkCreated (IN PUNICODE_STRING SymbolicName)
NTSTATUS	CreateNewVolumeName (OUT PUNICODE_STRING VolumeName, IN PGUID VolumeGuid OPTIONAL)
BOOLEAN	IsDriveLetter (PUNICODE_STRING SymbolicName)
VOID	DeleteSymbolicLinkNameFromMemory (IN PDEVICE_EXTENSION DeviceExtension, IN PUNICODE_STRING SymbolicLink, IN BOOLEAN MarkOffline)
NTSTATUS	MountMgrQuerySymbolicLink (IN PUNICODE_STRING SymbolicName, IN OUT PUNICODE_STRING LinkTarget)

Variables
UNICODE_STRING	DosDevicesMount
PDEVICE_OBJECT	gdeviceObject
UNICODE_STRING	ReparseIndex
UNICODE_STRING	DeviceFloppy
UNICODE_STRING	DeviceMount
UNICODE_STRING	DeviceCdRom
UNICODE_STRING	SafeVolumes
UNICODE_STRING	DosDevices
UNICODE_STRING	DosGlobal
UNICODE_STRING	Global
UNICODE_STRING	Volume
KEVENT	UnloadEvent
LONG	Unloading
DRIVER_INITIALIZE	DriverEntry
_In_ PDEVICE_OBJECT	DeviceObject
_In_ PDEVICE_OBJECT _In_ ULONG	InputBufferLength
_In_ PDEVICE_OBJECT _In_ ULONG _In_ ULONG	OutputBufferLength
_In_ PDEVICE_OBJECT _In_ ULONG _In_ ULONG _In_opt_ PFILE_OBJECT	FileObject
PWSTR	DatabasePath
PWSTR	OfflinePath
DRIVER_DISPATCH	MountMgrDeviceControl

Macro Definition Documentation

AllocatePool

#define AllocatePool

(

Size

)

ExAllocatePoolWithTag(PagedPool, Size, 'AtnM')

Definition at line 153 of file mntmgr.h.

COLON_POSITION

#define COLON_POSITION   0xD

Definition at line 160 of file mntmgr.h.

DRIVE_LETTER_LENGTH

#define DRIVE_LETTER_LENGTH   0x1C

Definition at line 161 of file mntmgr.h.

FreePool

#define FreePool

(

P

)

ExFreePoolWithTag(P, 'AtnM')

Definition at line 154 of file mntmgr.h.

LETTER_POSITION

#define LETTER_POSITION   0xC

Definition at line 159 of file mntmgr.h.

MAX

#define MAX	(		a,
			b
	)		((a > b) ? a : b)

Definition at line 157 of file mntmgr.h.

Typedef Documentation

ASSOCIATED_DEVICE_ENTRY

typedef struct _ASSOCIATED_DEVICE_ENTRY ASSOCIATED_DEVICE_ENTRY

DATABASE_ENTRY

typedef struct _DATABASE_ENTRY DATABASE_ENTRY

DEVICE_EXTENSION

typedef struct _DEVICE_EXTENSION DEVICE_EXTENSION

DEVICE_INFORMATION

typedef struct _DEVICE_INFORMATION DEVICE_INFORMATION

DEVICE_INFORMATION_ENTRY

typedef struct _DEVICE_INFORMATION_ENTRY DEVICE_INFORMATION_ENTRY

MIGRATE_WORK_ITEM

typedef struct _MIGRATE_WORK_ITEM MIGRATE_WORK_ITEM

ONLINE_NOTIFICATION_WORK_ITEM

typedef struct _ONLINE_NOTIFICATION_WORK_ITEM ONLINE_NOTIFICATION_WORK_ITEM

PASSOCIATED_DEVICE_ENTRY

typedef struct _ASSOCIATED_DEVICE_ENTRY * PASSOCIATED_DEVICE_ENTRY

PDATABASE_ENTRY

typedef struct _DATABASE_ENTRY * PDATABASE_ENTRY

PDEVICE_EXTENSION

typedef struct _DEVICE_EXTENSION * PDEVICE_EXTENSION

PDEVICE_INFORMATION

typedef struct _DEVICE_INFORMATION * PDEVICE_INFORMATION

PDEVICE_INFORMATION_ENTRY

typedef struct _DEVICE_INFORMATION_ENTRY * PDEVICE_INFORMATION_ENTRY

PMIGRATE_WORK_ITEM

typedef struct _MIGRATE_WORK_ITEM * PMIGRATE_WORK_ITEM

PONLINE_NOTIFICATION_WORK_ITEM

typedef struct _ONLINE_NOTIFICATION_WORK_ITEM * PONLINE_NOTIFICATION_WORK_ITEM

PRECONCILE_WORK_ITEM

typedef struct _RECONCILE_WORK_ITEM * PRECONCILE_WORK_ITEM

PRECONCILE_WORK_ITEM_CONTEXT

typedef struct _RECONCILE_WORK_ITEM_CONTEXT * PRECONCILE_WORK_ITEM_CONTEXT

PSAVED_LINK_INFORMATION

typedef struct _SAVED_LINK_INFORMATION * PSAVED_LINK_INFORMATION

PSYMLINK_INFORMATION

typedef struct _SYMLINK_INFORMATION * PSYMLINK_INFORMATION

PUNIQUE_ID_REPLICATE

typedef struct _UNIQUE_ID_REPLICATE * PUNIQUE_ID_REPLICATE

PUNIQUE_ID_WORK_ITEM

typedef struct _UNIQUE_ID_WORK_ITEM * PUNIQUE_ID_WORK_ITEM

RECONCILE_WORK_ITEM

typedef struct _RECONCILE_WORK_ITEM RECONCILE_WORK_ITEM

RECONCILE_WORK_ITEM_CONTEXT

typedef struct _RECONCILE_WORK_ITEM_CONTEXT RECONCILE_WORK_ITEM_CONTEXT

SAVED_LINK_INFORMATION

typedef struct _SAVED_LINK_INFORMATION SAVED_LINK_INFORMATION

SYMLINK_INFORMATION

typedef struct _SYMLINK_INFORMATION SYMLINK_INFORMATION

UNIQUE_ID_REPLICATE

typedef struct _UNIQUE_ID_REPLICATE UNIQUE_ID_REPLICATE

UNIQUE_ID_WORK_ITEM

typedef struct _UNIQUE_ID_WORK_ITEM UNIQUE_ID_WORK_ITEM

Function Documentation

_In_reads_bytes_opt_()

_In_ PDEVICE_OBJECT _In_reads_bytes_opt_

(

InputBufferLength

)

_IRQL_requires_()

_IRQL_requires_

(

PASSIVE_LEVEL

)

Definition at line 2121 of file class.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Entering function.\n",
                DeviceObject));
 
    //
    // Send down Inquiry for VPD_THIRD_PARTY_COPY_PAGE and cache away the device parameters
    // from WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR.
    //
    status = ClasspGetBlockDeviceTokenLimitsInfo(DeviceObject);
 
    if (NT_SUCCESS(status)) {
 
        ULONG maxListIdentifier = MaxTokenOperationListIdentifier;
 
        //
        // Query the maximum list identifier to use for TokenOperation commands.
        //
        if (NT_SUCCESS(ClasspGetMaximumTokenListIdentifier(DeviceObject, REG_DISK_CLASS_CONTROL, &maxListIdentifier))) {
            if (maxListIdentifier >= MIN_TOKEN_LIST_IDENTIFIERS) {
 
                NT_ASSERT(maxListIdentifier <= MAX_TOKEN_LIST_IDENTIFIERS);
                MaxTokenOperationListIdentifier = maxListIdentifier;
            }
        }
 
    }
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));
 
    return status;
}

_Out_writes_bytes_opt_()

_In_ PDEVICE_OBJECT _In_ ULONG _Out_writes_bytes_opt_

(

OutputBufferLength

)

AddRemoteDatabaseEntry()

NTSTATUS AddRemoteDatabaseEntry	(	IN HANDLE	Database,
		IN PDATABASE_ENTRY	Entry
	)

Definition at line 64 of file database.c.

{
    LARGE_INTEGER Size;
    IO_STATUS_BLOCK IoStatusBlock;
 
    /* Get size to append data */
    Size.QuadPart = GetRemoteDatabaseSize(Database);
 
    return ZwWriteFile(Database, NULL, NULL, NULL,
                       &IoStatusBlock, Entry,
                       Entry->EntrySize, &Size, NULL);
}

Referenced by ChangeRemoteDatabaseUniqueId(), MountMgrVolumeMountPointCreated(), and ReconcileThisDatabaseWithMasterWorker().

ChangeRemoteDatabaseUniqueId()

VOID ChangeRemoteDatabaseUniqueId	(	IN PDEVICE_INFORMATION	DeviceInformation,
		IN PMOUNTDEV_UNIQUE_ID	OldUniqueId,
		IN PMOUNTDEV_UNIQUE_ID	NewUniqueId
	)

Definition at line 1913 of file database.c.

{
    LONG Offset = 0;
    HANDLE Database;
    PDATABASE_ENTRY Entry, NewEntry;
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Open the remote database */
    Database = OpenRemoteDatabase(DeviceInformation, FALSE);
    if (!Database)
    {
        return;
    }
 
    /* Get all the entries */
    do
    {
        Entry = GetRemoteDatabaseEntry(Database, Offset);
        if (!Entry)
        {
            break;
        }
 
        /* Not the correct entry, skip it */
        if (Entry->UniqueIdLength != OldUniqueId->UniqueIdLength)
        {
            Offset += Entry->EntrySize;
            FreePool(Entry);
            continue;
        }
 
        /* Not the correct entry, skip it */
        if (RtlCompareMemory(OldUniqueId->UniqueId,
                             (PVOID)((ULONG_PTR)Entry + Entry->UniqueIdOffset),
                             Entry->UniqueIdLength) != Entry->UniqueIdLength)
        {
            Offset += Entry->EntrySize;
            FreePool(Entry);
            continue;
        }
 
        /* Here, we have the correct entry */
        NewEntry = AllocatePool(Entry->EntrySize + NewUniqueId->UniqueIdLength - OldUniqueId->UniqueIdLength);
        if (!NewEntry)
        {
            Offset += Entry->EntrySize;
            FreePool(Entry);
            continue;
        }
 
        /* Recreate the entry from the previous one */
        NewEntry->EntrySize = Entry->EntrySize + NewUniqueId->UniqueIdLength - OldUniqueId->UniqueIdLength;
        NewEntry->EntryReferences = Entry->EntryReferences;
        NewEntry->SymbolicNameOffset = sizeof(DATABASE_ENTRY);
        NewEntry->SymbolicNameLength = Entry->SymbolicNameLength;
        NewEntry->UniqueIdOffset = Entry->SymbolicNameLength + sizeof(DATABASE_ENTRY);
        NewEntry->UniqueIdLength = NewUniqueId->UniqueIdLength;
        RtlCopyMemory((PVOID)((ULONG_PTR)NewEntry + NewEntry->SymbolicNameOffset),
                      (PVOID)((ULONG_PTR)Entry + Entry->SymbolicNameOffset),
                      NewEntry->SymbolicNameLength);
        RtlCopyMemory((PVOID)((ULONG_PTR)NewEntry + NewEntry->UniqueIdOffset),
                      NewUniqueId->UniqueId, NewEntry->UniqueIdLength);
 
        /* Delete old entry */
        Status = DeleteRemoteDatabaseEntry(Database, Offset);
        if (!NT_SUCCESS(Status))
        {
            FreePool(Entry);
            FreePool(NewEntry);
            break;
        }
 
        /* And replace with new one */
        Status = AddRemoteDatabaseEntry(Database, NewEntry);
        FreePool(Entry);
        FreePool(NewEntry);
    } while (NT_SUCCESS(Status));
 
    CloseRemoteDatabase(Database);
 
    return;
}

Referenced by MountMgrUniqueIdChangeRoutine().

CloseRemoteDatabase()

NTSTATUS CloseRemoteDatabase

(

IN HANDLE

Database

)

Definition at line 82 of file database.c.

{
    return ZwClose(Database);
}

Referenced by ChangeRemoteDatabaseUniqueId(), MountMgrVolumeMountPointCreated(), MountMgrVolumeMountPointDeleted(), and ReconcileThisDatabaseWithMasterWorker().

CreateNewVolumeName()

NTSTATUS CreateNewVolumeName	(	OUT PUNICODE_STRING	VolumeName,
		IN PGUID VolumeGuid	OPTIONAL
	)

Definition at line 399 of file symlink.c.

{
    GUID Guid;
    NTSTATUS Status;
    UNICODE_STRING GuidString;
 
    /* If no GUID was provided, then create one */
    if (!VolumeGuid)
    {
        Status = ExUuidCreate(&Guid);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
    else
    {
        RtlCopyMemory(&Guid, VolumeGuid, sizeof(GUID));
    }
 
    /* Convert GUID to string */
    Status = RtlStringFromGUID(&Guid, &GuidString);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Size for volume namespace, literal GUID, and null char */
    VolumeName->MaximumLength = 0x14 + 0x4C + sizeof(UNICODE_NULL);
    VolumeName->Buffer = AllocatePool(0x14 + 0x4C + sizeof(UNICODE_NULL));
    if (!VolumeName->Buffer)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        RtlCopyUnicodeString(VolumeName, &Volume);
        RtlAppendUnicodeStringToString(VolumeName, &GuidString);
        VolumeName->Buffer[VolumeName->Length / sizeof(WCHAR)] = UNICODE_NULL;
        Status = STATUS_SUCCESS;
    }
 
    ExFreePoolWithTag(GuidString.Buffer, 0);
 
    return Status;
}

Referenced by MountMgrMountedDeviceArrival(), and QuerySymbolicLinkNamesFromStorage().

CreateNoDriveLetterEntry()

VOID CreateNoDriveLetterEntry

(

IN PMOUNTDEV_UNIQUE_ID

UniqueId

)

Definition at line 269 of file uniqueid.c.

{
    UUID Guid;
    PWCHAR String;
    UNICODE_STRING GuidString;
 
    /* Entry with no drive letter are made that way:
     * Instead of having a path with the letter,
     * you have GUID with the unique ID.
     */
    if (!NT_SUCCESS(ExUuidCreate(&Guid)))
    {
        return;
    }
 
    /* Convert to string */
    if (!NT_SUCCESS(RtlStringFromGUID(&Guid, &GuidString)))
    {
        return;
    }
 
    /* No letter entries must start with #, so allocate a proper string */
    String = AllocatePool(GuidString.Length + 2 * sizeof(WCHAR));
    if (!String)
    {
        ExFreePoolWithTag(GuidString.Buffer, 0);
        return;
    }
 
    /* Write the complete string */
    String[0] = L'#';
    RtlCopyMemory(String + 1, GuidString.Buffer, GuidString.Length);
    String[GuidString.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    /* Don't need that one anymore */
    ExFreePoolWithTag(GuidString.Buffer, 0);
 
    /* Write the entry */
    RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                          DatabasePath,
                          String,
                          REG_BINARY,
                          UniqueId->UniqueId,
                          UniqueId->UniqueIdLength);
 
    FreePool(String);
 
    return;
}

Referenced by CreateNewDriveLetterName(), MountMgrDeletePoints(), MountMgrDeletePointsDbOnly(), MountMgrMountedDeviceArrival(), MountMgrNextDriveLetterWorker(), and ProcessSuggestedDriveLetters().

DeleteFromLocalDatabase()

VOID DeleteFromLocalDatabase	(	IN PUNICODE_STRING	SymbolicLink,
		IN PMOUNTDEV_UNIQUE_ID	UniqueId
	)

Definition at line 351 of file database.c.

{
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = DeleteFromLocalDatabaseRoutine;
    QueryTable[0].Name = SymbolicLink->Buffer;
 
    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           DatabasePath,
                           QueryTable,
                           UniqueId,
                           NULL);
}

Referenced by MountMgrMountedDeviceArrival().

DeleteNoDriveLetterEntry()

VOID DeleteNoDriveLetterEntry

(

IN PMOUNTDEV_UNIQUE_ID

UniqueId

)

Definition at line 2102 of file database.c.

{
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = DeleteNoDriveLetterEntryRoutine;
 
    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           DatabasePath,
                           QueryTable,
                           UniqueId,
                           NULL);
}

Referenced by MountMgrCreatePointWorker(), and MountMgrDeletePoints().

DeleteRegistryDriveLetter()

VOID DeleteRegistryDriveLetter

(

IN PMOUNTDEV_UNIQUE_ID

UniqueId

)

Definition at line 2050 of file database.c.

{
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = DeleteDriveLetterRoutine;
 
    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           DatabasePath,
                           QueryTable,
                           UniqueId,
                           NULL);
}

Referenced by MountMgrCreatePointWorker().

DeleteRemoteDatabaseEntry()

NTSTATUS DeleteRemoteDatabaseEntry	(	IN HANDLE	Database,
		IN LONG	StartingOffset
	)

Definition at line 233 of file database.c.

{
    ULONG EndSize;
    PVOID TmpBuffer;
    NTSTATUS Status;
    ULONG DatabaseSize;
    PDATABASE_ENTRY Entry;
    IO_STATUS_BLOCK IoStatusBlock;
    LARGE_INTEGER EndEntriesOffset;
 
    /* First, get database size */
    DatabaseSize = GetRemoteDatabaseSize(Database);
    if (!DatabaseSize)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Then, get the entry to remove */
    Entry = GetRemoteDatabaseEntry(Database, StartingOffset);
    if (!Entry)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Validate parameters: ensure we won't get zero or negative size */
    if (Entry->EntrySize + StartingOffset >= DatabaseSize)
    {
        /* If we get invalid parameters, truncate the whole database
         * starting the wrong entry. We can't rely on the rest
         */
        FreePool(Entry);
        return TruncateRemoteDatabase(Database, StartingOffset);
    }
 
    /* Now, get the size of the remaining entries (those after the one to remove) */
    EndSize = DatabaseSize - Entry->EntrySize - StartingOffset;
    /* Allocate a buffer big enough to hold them */
    TmpBuffer = AllocatePool(EndSize);
    if (!TmpBuffer)
    {
        FreePool(Entry);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Get the offset of the entry right after the one to delete */
    EndEntriesOffset.QuadPart = Entry->EntrySize + StartingOffset;
    /* We don't need the entry any more */
    FreePool(Entry);
 
    /* Read the ending entries */
    Status = ZwReadFile(Database, NULL, NULL, NULL, &IoStatusBlock,
                        TmpBuffer, EndSize, &EndEntriesOffset, NULL);
    if (!NT_SUCCESS(Status))
    {
        FreePool(TmpBuffer);
        return Status;
    }
 
    /* Ensure nothing went wrong - we don't want to corrupt the DB */
    if (IoStatusBlock.Information != EndSize)
    {
        FreePool(TmpBuffer);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Remove the entry */
    Status = TruncateRemoteDatabase(Database, StartingOffset + EndSize);
    if (!NT_SUCCESS(Status))
    {
        FreePool(TmpBuffer);
        return Status;
    }
 
    /* Now, shift the ending entries to erase the entry */
    EndEntriesOffset.QuadPart = StartingOffset;
    Status = ZwWriteFile(Database, NULL, NULL, NULL, &IoStatusBlock,
                         TmpBuffer, EndSize, &EndEntriesOffset, NULL);
 
    FreePool(TmpBuffer);
 
    return Status;
}

Referenced by ChangeRemoteDatabaseUniqueId(), MountMgrVolumeMountPointDeleted(), and ReconcileThisDatabaseWithMasterWorker().

DeleteSymbolicLinkNameFromMemory()

VOID DeleteSymbolicLinkNameFromMemory	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	SymbolicLink,
		IN BOOLEAN	MarkOffline
	)

Definition at line 754 of file symlink.c.

{
    PLIST_ENTRY DeviceEntry, SymbolEntry;
    PDEVICE_INFORMATION DeviceInformation;
    PSYMLINK_INFORMATION SymlinkInformation;
 
    /* First of all, ensure we have devices */
    if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
    {
        return;
    }
 
    /* Then, look for the symbolic name */
    for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
         DeviceEntry != &(DeviceExtension->DeviceListHead);
         DeviceEntry = DeviceEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
        for (SymbolEntry = DeviceInformation->SymbolicLinksListHead.Flink;
             SymbolEntry != &(DeviceInformation->SymbolicLinksListHead);
             SymbolEntry = SymbolEntry->Flink)
        {
            SymlinkInformation = CONTAINING_RECORD(SymbolEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
            /* One we have found it */
            if (RtlCompareUnicodeString(SymbolicLink, &(SymlinkInformation->Name), TRUE) == 0)
            {
                /* Check if caller just want it to be offline */
                if (MarkOffline)
                {
                    SymlinkInformation->Online = FALSE;
                }
                else
                {
                    /* If not, delete it & notify */
                    SendLinkDeleted(&(DeviceInformation->SymbolicName), SymbolicLink);
                    RemoveEntryList(&(SymlinkInformation->SymbolicLinksListEntry));
 
                    FreePool(SymlinkInformation->Name.Buffer);
                    FreePool(SymlinkInformation);
                }
 
                /* No need to go farther */
                return;
            }
        }
    }
 
    return;
}

Referenced by MountMgrDeletePoints(), and MountMgrDeletePointsDbOnly().

FindDeviceInfo()

NTSTATUS FindDeviceInfo	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	SymbolicName,
		IN BOOLEAN	DeviceNameGiven,
		OUT PDEVICE_INFORMATION *	DeviceInformation
	)

Definition at line 561 of file mountmgr.c.

{
    NTSTATUS Status;
    PLIST_ENTRY NextEntry;
    UNICODE_STRING DeviceName;
    PDEVICE_INFORMATION DeviceInfo = NULL;
 
    /* If a device name was given, use it */
    if (DeviceNameGiven)
    {
        DeviceName.Length = SymbolicName->Length;
        DeviceName.Buffer = SymbolicName->Buffer;
    }
    else
    {
        /* Otherwise, query it */
        Status = QueryDeviceInformation(SymbolicName,
                                        &DeviceName,
                                        NULL, NULL,
                                        NULL, NULL,
                                        NULL, NULL);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
 
    /* Look for device information matching devive */
    for (NextEntry = DeviceExtension->DeviceListHead.Flink;
         NextEntry != &(DeviceExtension->DeviceListHead);
         NextEntry = NextEntry->Flink)
    {
        DeviceInfo = CONTAINING_RECORD(NextEntry,
                                       DEVICE_INFORMATION,
                                       DeviceListEntry);
 
        if (RtlEqualUnicodeString(&DeviceName, &(DeviceInfo->DeviceName), TRUE))
        {
            break;
        }
    }
 
    /* Release our buffer if required */
    if (!DeviceNameGiven)
    {
        FreePool(DeviceName.Buffer);
    }
 
    /* Return found information */
    if (NextEntry == &(DeviceExtension->DeviceListHead))
    {
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    *DeviceInformation = DeviceInfo;
    return STATUS_SUCCESS;
}

Referenced by MountMgrKeepLinksWhenOffline(), MountMgrQueryDosVolumePath(), MountMgrQueryDosVolumePaths(), MountMgrVolumeMountPointChanged(), MountMgrVolumeMountPointCreated(), MountMgrVolumeMountPointDeleted(), OnlineMountedVolumes(), QueryUniqueIdFromMaster(), and ReconcileThisDatabaseWithMasterWorker().

GetRemoteDatabaseEntry()

PDATABASE_ENTRY GetRemoteDatabaseEntry	(	IN HANDLE	Database,
		IN LONG	StartingOffset
	)

Definition at line 125 of file database.c.

{
    NTSTATUS Status;
    ULONG EntrySize;
    PDATABASE_ENTRY Entry;
    LARGE_INTEGER ByteOffset;
    IO_STATUS_BLOCK IoStatusBlock;
 
    /* Get the entry at the given position */
    ByteOffset.QuadPart = StartingOffset;
    Status = ZwReadFile(Database,
                        NULL,
                        NULL,
                        NULL,
                        &IoStatusBlock,
                        &EntrySize,
                        sizeof(EntrySize),
                        &ByteOffset,
                        NULL);
    if (!NT_SUCCESS(Status))
    {
        return NULL;
    }
 
    /* If entry doesn't exist, truncate database */
    if (!EntrySize)
    {
        TruncateRemoteDatabase(Database, StartingOffset);
        return NULL;
    }
 
    /* Allocate the entry */
    Entry = AllocatePool(EntrySize);
    if (!Entry)
    {
        return NULL;
    }
 
    /* Effectively read the entry */
    Status = ZwReadFile(Database,
                        NULL,
                        NULL,
                        NULL,
                        &IoStatusBlock,
                        Entry,
                        EntrySize,
                        &ByteOffset,
                        NULL);
    /* If it fails or returns inconsistent data, drop it (= truncate) */
    if (!NT_SUCCESS(Status) ||
        (IoStatusBlock.Information != EntrySize) ||
        (EntrySize < sizeof(DATABASE_ENTRY)) )
    {
        TruncateRemoteDatabase(Database, StartingOffset);
        FreePool(Entry);
        return NULL;
    }
 
    /* Validate entry */
    if (MAX(Entry->SymbolicNameOffset + Entry->SymbolicNameLength,
            Entry->UniqueIdOffset + Entry->UniqueIdLength) > (LONG)EntrySize)
    {
        TruncateRemoteDatabase(Database, StartingOffset);
        FreePool(Entry);
        return NULL;
    }
 
    return Entry;
}

Referenced by ChangeRemoteDatabaseUniqueId(), DeleteRemoteDatabaseEntry(), MountMgrVolumeMountPointCreated(), MountMgrVolumeMountPointDeleted(), and ReconcileThisDatabaseWithMasterWorker().

GlobalCreateSymbolicLink()

NTSTATUS GlobalCreateSymbolicLink	(	IN PUNICODE_STRING	DosName,
		IN PUNICODE_STRING	DeviceName
	)

Definition at line 120 of file symlink.c.

{
    NTSTATUS Status;
    UNICODE_STRING GlobalName;
 
    /* First create the global string */
    Status = CreateStringWithGlobal(DosName, &GlobalName);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Then, create the symlink */
    Status = IoCreateSymbolicLink(&GlobalName, DeviceName);
 
    FreePool(GlobalName.Buffer);
 
    return Status;
}

Referenced by CreateNewDriveLetterName(), DriverEntry(), MountMgrCreatePointWorker(), MountMgrMountedDeviceArrival(), and RedirectSavedLink().

GlobalDeleteSymbolicLink()

NTSTATUS GlobalDeleteSymbolicLink

(

IN PUNICODE_STRING

DosName

)

Definition at line 145 of file symlink.c.

{
    NTSTATUS Status;
    UNICODE_STRING GlobalName;
 
    /* Recreate the string (to find the link) */
    Status = CreateStringWithGlobal(DosName, &GlobalName);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* And delete the link */
    Status = IoDeleteSymbolicLink(&GlobalName);
 
    FreePool(GlobalName.Buffer);
 
    return Status;
}

Referenced by MountMgrCreatePointWorker(), MountMgrDeletePoints(), MountMgrFreeMountedDeviceInfo(), MountMgrFreeSavedLink(), MountMgrMountedDeviceArrival(), MountMgrMountedDeviceRemoval(), MountMgrUnload(), and RedirectSavedLink().

HasDriveLetter()

BOOLEAN HasDriveLetter

(

IN PDEVICE_INFORMATION

DeviceInformation

)

Definition at line 167 of file mountmgr.c.

{
    PLIST_ENTRY NextEntry;
    PSYMLINK_INFORMATION SymlinkInfo;
 
    /* Browse all the symlinks to check if there is at least a drive letter */
    for (NextEntry = DeviceInformation->SymbolicLinksListHead.Flink;
         NextEntry != &DeviceInformation->SymbolicLinksListHead;
         NextEntry = NextEntry->Flink)
    {
        SymlinkInfo = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
        if (IsDriveLetter(&SymlinkInfo->Name) && SymlinkInfo->Online)
        {
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by MountMgrCreatePointWorker(), and ProcessSuggestedDriveLetters().

HasNoDriveLetterEntry()

BOOLEAN HasNoDriveLetterEntry

(

IN PMOUNTDEV_UNIQUE_ID

UniqueId

)

Definition at line 354 of file uniqueid.c.

{
    BOOLEAN EntryPresent = FALSE;
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = CheckForNoDriveLetterEntry;
    QueryTable[0].EntryContext = &EntryPresent;
 
    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           DatabasePath,
                           QueryTable,
                           UniqueId,
                           NULL);
 
    return EntryPresent;
}

Referenced by MountMgrMountedDeviceArrival(), MountMgrNextDriveLetterWorker(), and ProcessSuggestedDriveLetters().

IsDriveLetter()

BOOLEAN IsDriveLetter

(

PUNICODE_STRING

SymbolicName

)

Definition at line 812 of file symlink.c.

{
    WCHAR Letter, Colon;
 
    /* We must have a precise length */
    if (SymbolicName->Length != DosDevices.Length + 2 * sizeof(WCHAR))
    {
        return FALSE;
    }
 
    /* Must start with the DosDevices prefix */
    if (!RtlPrefixUnicodeString(&DosDevices, SymbolicName, TRUE))
    {
        return FALSE;
    }
 
    /* Check if letter is correct */
    Letter = SymbolicName->Buffer[DosDevices.Length / sizeof(WCHAR)];
    if ((Letter < L'A' || Letter > L'Z') && Letter != (WCHAR)-1)
    {
        return FALSE;
    }
 
    /* And finally it must end with a colon */
    Colon = SymbolicName->Buffer[DosDevices.Length / sizeof(WCHAR) + 1];
    if (Colon != L':')
    {
        return FALSE;
    }
 
    return TRUE;
}

Referenced by DeleteDriveLetterRoutine(), HasDriveLetter(), MountMgrCreatePointWorker(), MountMgrDeletePoints(), MountMgrDeletePointsDbOnly(), MountMgrMountedDeviceArrival(), MountMgrNextDriveLetterWorker(), and QuerySymbolicLinkNamesFromStorage().

IssueUniqueIdChangeNotify()

VOID IssueUniqueIdChangeNotify	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	DeviceName,
		IN PMOUNTDEV_UNIQUE_ID	UniqueId
	)

Definition at line 637 of file notify.c.

{
    NTSTATUS Status;
    PVOID IrpBuffer = NULL;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    PUNIQUE_ID_WORK_ITEM WorkItem = NULL;
 
    /* Get the associated device object */
    Status = IoGetDeviceObjectPointer(DeviceName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return;
    }
 
    /* And then, get attached device */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    ObDereferenceObject(FileObject);
 
    /* Allocate a work item */
    WorkItem = AllocatePool(sizeof(UNIQUE_ID_WORK_ITEM));
    if (!WorkItem)
    {
        ObDereferenceObject(DeviceObject);
        return;
    }
 
    WorkItem->Event = NULL;
    WorkItem->WorkItem = IoAllocateWorkItem(DeviceExtension->DeviceObject);
    if (!WorkItem->WorkItem)
    {
        ObDereferenceObject(DeviceObject);
        goto Cleanup;
    }
 
    WorkItem->DeviceExtension = DeviceExtension;
    WorkItem->StackSize = DeviceObject->StackSize;
    /* Already provide the IRP */
    WorkItem->Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
 
    ObDereferenceObject(DeviceObject);
 
    if (!WorkItem->Irp)
    {
        goto Cleanup;
    }
 
    /* Ensure it has enough space */
    IrpBuffer = AllocatePool(sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) + 1024);
    if (!IrpBuffer)
    {
        goto Cleanup;
    }
 
    WorkItem->DeviceName.Length = DeviceName->Length;
    WorkItem->DeviceName.MaximumLength = DeviceName->Length + sizeof(WCHAR);
    WorkItem->DeviceName.Buffer = AllocatePool(WorkItem->DeviceName.MaximumLength);
    if (!WorkItem->DeviceName.Buffer)
    {
        goto Cleanup;
    }
 
    RtlCopyMemory(WorkItem->DeviceName.Buffer, DeviceName->Buffer, DeviceName->Length);
    WorkItem->DeviceName.Buffer[DeviceName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    WorkItem->IrpBuffer = IrpBuffer;
    WorkItem->IrpBufferLength = sizeof(MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY_OUTPUT) + 1024;
 
    /* Add the worker in the list */
    KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
    InsertHeadList(&(DeviceExtension->UniqueIdWorkerItemListHead), &(WorkItem->UniqueIdWorkerItemListEntry));
    KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 
    /* And call the worker */
    IssueUniqueIdChangeNotifyWorker(WorkItem, UniqueId);
 
    return;
 
Cleanup:
    if (IrpBuffer)
    {
        FreePool(IrpBuffer);
    }
 
    if (WorkItem->Irp)
    {
        IoFreeIrp(WorkItem->Irp);
    }
 
    if (WorkItem->WorkItem)
    {
        IoFreeWorkItem(WorkItem->WorkItem);
    }
 
    if (WorkItem)
    {
        FreePool(WorkItem);
    }
}

Referenced by MountMgrMountedDeviceArrival().

IssueUniqueIdChangeNotifyWorker()

VOID IssueUniqueIdChangeNotifyWorker	(	IN PUNIQUE_ID_WORK_ITEM	WorkItem,
		IN PMOUNTDEV_UNIQUE_ID	UniqueId
	)

Definition at line 567 of file notify.c.

{
    PIRP Irp;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT DeviceObject;
 
    /* Get the device object */
    Status = IoGetDeviceObjectPointer(&(WorkItem->DeviceName),
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        RemoveWorkItem(WorkItem);
        return;
    }
 
    /* And then, the attached device */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    /* Initialize the IRP */
    Irp = WorkItem->Irp;
    IoInitializeIrp(Irp, IoSizeOfIrp(WorkItem->StackSize), (CCHAR)WorkItem->StackSize);
 
    if (InterlockedExchange((PLONG)&(WorkItem->Event), 0) != 0)
    {
        ObDereferenceObject(FileObject);
        ObDereferenceObject(DeviceObject);
        RemoveWorkItem(WorkItem);
        return;
    }
 
    Irp->AssociatedIrp.SystemBuffer = WorkItem->IrpBuffer;
    Irp->Tail.Overlay.Thread = PsGetCurrentThread();
    RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, UniqueId, UniqueId->UniqueIdLength + sizeof(USHORT));
 
    Stack = IoGetNextIrpStackLocation(Irp);
 
    Stack->Parameters.DeviceIoControl.InputBufferLength = UniqueId->UniqueIdLength + sizeof(USHORT);
    Stack->Parameters.DeviceIoControl.OutputBufferLength = WorkItem->IrpBufferLength;
    Stack->Parameters.DeviceIoControl.Type3InputBuffer = 0;
    Stack->Parameters.DeviceIoControl.IoControlCode = IOCTL_MOUNTDEV_UNIQUE_ID_CHANGE_NOTIFY;
    Stack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
 
    Status = IoSetCompletionRoutineEx(WorkItem->DeviceExtension->DeviceObject,
                                      Irp,
                                      UniqueIdChangeNotifyCompletion,
                                      WorkItem,
                                      TRUE, TRUE, TRUE);
    if (!NT_SUCCESS(Status))
    {
        ObDereferenceObject(FileObject);
        ObDereferenceObject(DeviceObject);
        RemoveWorkItem(WorkItem);
        return;
    }
 
    /* Call the driver */
    IoCallDriver(DeviceObject, Irp);
    ObDereferenceObject(FileObject);
    ObDereferenceObject(DeviceObject);
}

Referenced by IssueUniqueIdChangeNotify(), and UniqueIdChangeNotifyWorker().

IsUniqueIdPresent()

BOOLEAN IsUniqueIdPresent	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PDATABASE_ENTRY	DatabaseEntry
	)

Definition at line 221 of file uniqueid.c.

{
    PLIST_ENTRY NextEntry;
    PDEVICE_INFORMATION DeviceInformation;
 
    /* If no device, no unique ID (O'rly?!)
     * ./)/).
     * (°-°)
     * (___) ORLY?
     *  " "
     */
    if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
    {
        return FALSE;
    }
 
    /* Now we know that we have devices, find the one */
    for (NextEntry = DeviceExtension->DeviceListHead.Flink;
         NextEntry != &(DeviceExtension->DeviceListHead);
         NextEntry = NextEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(NextEntry,
                                              DEVICE_INFORMATION,
                                              DeviceListEntry);
 
        if (DeviceInformation->UniqueId->UniqueIdLength != DatabaseEntry->UniqueIdLength)
        {
            continue;
        }
 
        /* It's matching! */
        if (RtlCompareMemory((PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->UniqueIdOffset),
                             DeviceInformation->UniqueId->UniqueId,
                             DatabaseEntry->UniqueIdLength) == DatabaseEntry->UniqueIdLength)
        {
            return TRUE;
        }
    }
 
    /* No luck... */
    return FALSE;
}

Referenced by ReconcileThisDatabaseWithMasterWorker().

MountMgrCancel()

VOID NTAPI MountMgrCancel	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1592 of file mountmgr.c.

{
    UNREFERENCED_PARAMETER(DeviceObject);
 
    RemoveEntryList(&(Irp->Tail.Overlay.ListEntry));
 
    IoReleaseCancelSpinLock(Irp->CancelIrql);
 
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = STATUS_CANCELLED;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
}

Referenced by MountMgrChangeNotify(), and MountMgrCleanup().

MountMgrCreatePointWorker()

NTSTATUS MountMgrCreatePointWorker	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	SymbolicLinkName,
		IN PUNICODE_STRING	DeviceName
	)

Definition at line 35 of file point.c.

{
    NTSTATUS Status;
    PLIST_ENTRY DeviceEntry;
    PMOUNTDEV_UNIQUE_ID UniqueId;
    PSYMLINK_INFORMATION SymlinkInformation;
    UNICODE_STRING SymLink, TargetDeviceName;
    PDEVICE_INFORMATION DeviceInformation = NULL, DeviceInfo;
 
    /* Get device name */
    Status = QueryDeviceInformation(DeviceName,
                                    &TargetDeviceName,
                                    NULL, NULL, NULL,
                                    NULL, NULL, NULL);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* First of all, try to find device */
    for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
         DeviceEntry != &(DeviceExtension->DeviceListHead);
         DeviceEntry = DeviceEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
        if (RtlEqualUnicodeString(&TargetDeviceName, &(DeviceInformation->DeviceName), TRUE))
        {
            break;
        }
    }
 
    /* Copy symbolic link name and null terminate it */
    SymLink.Buffer = AllocatePool(SymbolicLinkName->Length + sizeof(UNICODE_NULL));
    if (!SymLink.Buffer)
    {
        FreePool(TargetDeviceName.Buffer);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(SymLink.Buffer, SymbolicLinkName->Buffer, SymbolicLinkName->Length);
    SymLink.Buffer[SymbolicLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    SymLink.Length = SymbolicLinkName->Length;
    SymLink.MaximumLength = SymbolicLinkName->Length + sizeof(UNICODE_NULL);
 
    /* If we didn't find device */
    if (DeviceEntry == &(DeviceExtension->DeviceListHead))
    {
        /* Then, try with unique ID */
        Status = QueryDeviceInformation(SymbolicLinkName,
                                        NULL, &UniqueId,
                                        NULL, NULL, NULL,
                                        NULL, NULL);
        if (!NT_SUCCESS(Status))
        {
            FreePool(TargetDeviceName.Buffer);
            FreePool(SymLink.Buffer);
            return Status;
        }
 
        /* Create a link to the device */
        Status = GlobalCreateSymbolicLink(&SymLink, &TargetDeviceName);
        if (!NT_SUCCESS(Status))
        {
            FreePool(UniqueId);
            FreePool(TargetDeviceName.Buffer);
            FreePool(SymLink.Buffer);
            return Status;
        }
 
        /* If caller provided driver letter, delete it */
        if (IsDriveLetter(&SymLink))
        {
            DeleteRegistryDriveLetter(UniqueId);
        }
 
        /* Device will be identified with its unique ID */
        Status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                       DatabasePath,
                                       SymLink.Buffer,
                                       REG_BINARY,
                                       UniqueId->UniqueId,
                                       UniqueId->UniqueIdLength);
 
        FreePool(UniqueId);
        FreePool(TargetDeviceName.Buffer);
        FreePool(SymLink.Buffer);
        return Status;
    }
 
    /* If call provided a driver letter whereas device already has one
     * fail, this is not doable
     */
    if (IsDriveLetter(&SymLink) && HasDriveLetter(DeviceInformation))
    {
        FreePool(TargetDeviceName.Buffer);
        FreePool(SymLink.Buffer);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Now, create a link */
    Status = GlobalCreateSymbolicLink(&SymLink, &TargetDeviceName);
    FreePool(TargetDeviceName.Buffer);
    if (!NT_SUCCESS(Status))
    {
        FreePool(SymLink.Buffer);
        return Status;
    }
 
    /* Associate Unique ID <-> symbolic name */
    UniqueId = DeviceInformation->UniqueId;
    Status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                   DatabasePath,
                                   SymLink.Buffer,
                                   REG_BINARY,
                                   UniqueId->UniqueId,
                                   UniqueId->UniqueIdLength);
    if (!NT_SUCCESS(Status))
    {
        GlobalDeleteSymbolicLink(&SymLink);
        FreePool(SymLink.Buffer);
        return Status;
    }
 
    /* Now, prepare to save the link with the device */
    SymlinkInformation = AllocatePool(sizeof(SYMLINK_INFORMATION));
    if (!SymlinkInformation)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        GlobalDeleteSymbolicLink(&SymLink);
        FreePool(SymLink.Buffer);
        return Status;
    }
 
    SymlinkInformation->Name.Length = SymLink.Length;
    SymlinkInformation->Name.MaximumLength = SymLink.Length + sizeof(UNICODE_NULL);
    SymlinkInformation->Name.Buffer = AllocatePool(SymlinkInformation->Name.MaximumLength);
    if (!SymlinkInformation->Name.Buffer)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        FreePool(SymlinkInformation);
        GlobalDeleteSymbolicLink(&SymLink);
        FreePool(SymLink.Buffer);
        return Status;
    }
 
    /* Save the link and mark it online */
    RtlCopyMemory(SymlinkInformation->Name.Buffer, SymLink.Buffer, SymlinkInformation->Name.Length);
    SymlinkInformation->Name.Buffer[SymlinkInformation->Name.Length / sizeof(WCHAR)] = UNICODE_NULL;
    SymlinkInformation->Online = TRUE;
    InsertTailList(&DeviceInformation->SymbolicLinksListHead, &SymlinkInformation->SymbolicLinksListEntry);
    SendLinkCreated(&(SymlinkInformation->Name));
 
    /* If we have a drive letter */
    if (IsDriveLetter(&SymLink))
    {
        /* Then, delete the no drive letter entry */
        DeleteNoDriveLetterEntry(UniqueId);
 
        /* And post online notification if asked */
        if (!DeviceInformation->SkipNotifications)
        {
            PostOnlineNotification(DeviceExtension, &DeviceInformation->SymbolicName);
        }
    }
 
    /* If that's a volume with automatic drive letter, it's now time to resync databases */
    if (MOUNTMGR_IS_VOLUME_NAME(&SymLink) && DeviceExtension->AutomaticDriveLetter)
    {
        for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
             DeviceEntry != &(DeviceExtension->DeviceListHead);
             DeviceEntry = DeviceEntry->Flink)
        {
            DeviceInfo = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
            /* If there's one, ofc! */
            if (!DeviceInfo->NoDatabase)
            {
                ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInfo);
            }
        }
    }
 
    /* Notify & quit */
    FreePool(SymLink.Buffer);
    MountMgrNotify(DeviceExtension);
 
    if (!DeviceInformation->ManuallyRegistered)
    {
        MountMgrNotifyNameChange(DeviceExtension, DeviceName, FALSE);
    }
 
    return Status;
}

Referenced by MountMgrCreatePoint(), MountMgrNextDriveLetterWorker(), ProcessSuggestedDriveLetters(), and WriteUniqueIdToMaster().

MountMgrFreeDeadDeviceInfo()

VOID MountMgrFreeDeadDeviceInfo

(

IN PDEVICE_INFORMATION

DeviceInformation

)

Definition at line 626 of file mountmgr.c.

{
    FreePool(DeviceInformation->SymbolicName.Buffer);
    FreePool(DeviceInformation);
}

Referenced by MountMgrCheckUnprocessedVolumes(), MountMgrMountedDeviceArrival(), MountMgrMountedDeviceRemoval(), and MountMgrUnload().

MountMgrMountedDeviceArrival()

NTSTATUS MountMgrMountedDeviceArrival	(	IN PDEVICE_EXTENSION	Extension,
		IN PUNICODE_STRING	SymbolicName,
		IN BOOLEAN	FromVolume
	)

Definition at line 855 of file mountmgr.c.

{
    WCHAR Letter;
    GUID StableGuid;
    HANDLE LinkHandle;
    ULONG SymLinkCount, i;
    PLIST_ENTRY NextEntry;
    PUNICODE_STRING SymLinks;
    NTSTATUS Status, IntStatus;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PSYMLINK_INFORMATION SymlinkInformation;
    PMOUNTDEV_UNIQUE_ID UniqueId, NewUniqueId;
    PSAVED_LINK_INFORMATION SavedLinkInformation;
    PDEVICE_INFORMATION DeviceInformation, CurrentDevice;
    WCHAR CSymLinkBuffer[RTL_NUMBER_OF(Cunc)], LinkTargetBuffer[MAX_PATH];
    UNICODE_STRING TargetDeviceName, SuggestedLinkName, DeviceName, VolumeName, DriveLetter, LinkTarget, CSymLink;
    BOOLEAN HasGuid, HasGptDriveLetter, IsFT, UseOnlyIfThereAreNoOtherLinks;
    BOOLEAN IsDrvLetter, IsOff, IsVolumeName, SetOnline;
 
    /* New device = new structure to represent it */
    DeviceInformation = AllocatePool(sizeof(DEVICE_INFORMATION));
    if (!DeviceInformation)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Initialise device structure */
    RtlZeroMemory(DeviceInformation, sizeof(DEVICE_INFORMATION));
    InitializeListHead(&(DeviceInformation->SymbolicLinksListHead));
    InitializeListHead(&(DeviceInformation->ReplicatedUniqueIdsListHead));
    InitializeListHead(&(DeviceInformation->AssociatedDevicesHead));
    DeviceInformation->SymbolicName.Length = SymbolicName->Length;
    DeviceInformation->SymbolicName.MaximumLength = SymbolicName->Length + sizeof(UNICODE_NULL);
    DeviceInformation->SymbolicName.Buffer = AllocatePool(DeviceInformation->SymbolicName.MaximumLength);
    if (!DeviceInformation->SymbolicName.Buffer)
    {
        FreePool(DeviceInformation);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Copy symbolic name */
    RtlCopyMemory(DeviceInformation->SymbolicName.Buffer, SymbolicName->Buffer, SymbolicName->Length);
    DeviceInformation->SymbolicName.Buffer[DeviceInformation->SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
    DeviceInformation->ManuallyRegistered = ManuallyRegistered;
    DeviceInformation->DeviceExtension = DeviceExtension;
 
    /* Query as much data as possible about device */
    Status = QueryDeviceInformation(SymbolicName,
                                    &TargetDeviceName,
                                    &UniqueId,
                                    &(DeviceInformation->Removable),
                                    &HasGptDriveLetter,
                                    &HasGuid,
                                    &StableGuid,
                                    &IsFT);
    if (!NT_SUCCESS(Status))
    {
        KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 
        for (NextEntry = DeviceExtension->OfflineDeviceListHead.Flink;
             NextEntry != &(DeviceExtension->OfflineDeviceListHead);
             NextEntry = NextEntry->Flink)
        {
            CurrentDevice = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 
            if (RtlEqualUnicodeString(&(DeviceInformation->SymbolicName), &(CurrentDevice->SymbolicName), TRUE))
            {
                break;
            }
        }
 
        if (NextEntry != &(DeviceExtension->OfflineDeviceListHead))
        {
            MountMgrFreeDeadDeviceInfo(DeviceInformation);
        }
        else
        {
            InsertTailList(&(DeviceExtension->OfflineDeviceListHead), &(DeviceInformation->DeviceListEntry));
        }
 
        KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 
        return Status;
    }
 
    /* Save gathered data */
    DeviceInformation->UniqueId = UniqueId;
    DeviceInformation->DeviceName = TargetDeviceName;
    DeviceInformation->KeepLinks = FALSE;
 
    /* If we found system partition, mark it */
    if (DeviceExtension->DriveLetterData && UniqueId->UniqueIdLength == DeviceExtension->DriveLetterData->UniqueIdLength)
    {
        if (RtlCompareMemory(UniqueId->UniqueId, DeviceExtension->DriveLetterData->UniqueId, UniqueId->UniqueIdLength)
            == UniqueId->UniqueIdLength)
        {
            IoSetSystemPartition(&TargetDeviceName);
        }
    }
 
    /* Check suggested link name */
    Status = QuerySuggestedLinkName(&(DeviceInformation->SymbolicName),
                                    &SuggestedLinkName,
                                    &UseOnlyIfThereAreNoOtherLinks);
    if (!NT_SUCCESS(Status))
    {
        SuggestedLinkName.Buffer = NULL;
    }
 
    /* If it's OK, set it and save its letter (if any) */
    if (SuggestedLinkName.Buffer && IsDriveLetter(&SuggestedLinkName))
    {
        DeviceInformation->SuggestedDriveLetter = (UCHAR)SuggestedLinkName.Buffer[LETTER_POSITION];
    }
 
    /* Acquire driver exclusively */
    KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 
    /* Check if we already have device in to prevent double registration */
    for (NextEntry = DeviceExtension->DeviceListHead.Flink;
         NextEntry != &(DeviceExtension->DeviceListHead);
         NextEntry = NextEntry->Flink)
    {
        CurrentDevice = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 
        if (RtlEqualUnicodeString(&(CurrentDevice->DeviceName), &TargetDeviceName, TRUE))
        {
            break;
        }
    }
 
    /* If we found it, clear ours, and return success, all correct */
    if (NextEntry != &(DeviceExtension->DeviceListHead))
    {
        if (SuggestedLinkName.Buffer)
        {
            FreePool(SuggestedLinkName.Buffer);
        }
 
        FreePool(UniqueId);
        FreePool(TargetDeviceName.Buffer);
        FreePool(DeviceInformation->SymbolicName.Buffer);
        FreePool(DeviceInformation);
 
        KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 
        return STATUS_SUCCESS;
    }
 
    /* Check if there are symlinks associated with our device in registry */
    Status = QuerySymbolicLinkNamesFromStorage(DeviceExtension,
                                               DeviceInformation,
                                               (SuggestedLinkName.Buffer) ? &SuggestedLinkName : NULL,
                                               UseOnlyIfThereAreNoOtherLinks,
                                               &SymLinks,
                                               &SymLinkCount,
                                               HasGuid,
                                               &StableGuid);
 
    /* If our device is a CD-ROM */
    if (RtlPrefixUnicodeString(&DeviceCdRom, &TargetDeviceName, TRUE))
    {
        LinkTarget.Length = 0;
        LinkTarget.MaximumLength = sizeof(LinkTargetBuffer);
        LinkTarget.Buffer = LinkTargetBuffer;
 
        RtlCopyMemory(CSymLinkBuffer, Cunc, sizeof(Cunc));
        RtlInitUnicodeString(&CSymLink, CSymLinkBuffer);
 
        /* Start checking all letters that could have been associated */
        for (Letter = L'D'; Letter <= L'Z'; Letter++)
        {
            CSymLink.Buffer[Cunc_LETTER_POSITION] = Letter;
 
            InitializeObjectAttributes(&ObjectAttributes,
                                       &CSymLink,
                                       OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                       NULL,
                                       NULL);
 
            /* Try to open the associated symlink */
            Status = ZwOpenSymbolicLinkObject(&LinkHandle, SYMBOLIC_LINK_QUERY, &ObjectAttributes);
            if (!NT_SUCCESS(Status))
            {
                continue;
            }
 
            /* And query its target */
            Status = ZwQuerySymbolicLinkObject(LinkHandle, &LinkTarget, NULL);
            ZwClose(LinkHandle);
 
            if (!NT_SUCCESS(Status))
            {
                continue;
            }
 
            IntStatus = STATUS_UNSUCCESSFUL;
            if (!RtlEqualUnicodeString(&LinkTarget, &DeviceInformation->DeviceName, FALSE))
            {
                continue;
            }
 
            /* This link is matching our device, whereas it's not supposed to have any
             * symlink associated.
             * Delete it
             */
            if (!SymLinkCount)
            {
                IoDeleteSymbolicLink(&CSymLink);
                continue;
            }
 
            /* Now, for all the symlinks, check for ours */
            for (i = 0; i < SymLinkCount; i++)
            {
                if (IsDriveLetter(&(SymLinks[i])))
                {
                    /* If it exists, that's correct */
                    if (SymLinks[i].Buffer[LETTER_POSITION] == Letter)
                    {
                        IntStatus = STATUS_SUCCESS;
                    }
                }
            }
 
            /* Useless link, delete it */
            if (IntStatus == STATUS_UNSUCCESSFUL)
            {
                IoDeleteSymbolicLink(&CSymLink);
            }
        }
    }
 
    /* Suggested name is no longer required */
    if (SuggestedLinkName.Buffer)
    {
        FreePool(SuggestedLinkName.Buffer);
    }
 
    /* If if failed, ensure we don't take symlinks into account */
    if (!NT_SUCCESS(Status))
    {
        SymLinks = NULL;
        SymLinkCount = 0;
    }
 
    /* Now we queried them, remove the symlinks */
    SavedLinkInformation = RemoveSavedLinks(DeviceExtension, UniqueId);
 
    IsDrvLetter = FALSE;
    IsOff = FALSE;
    IsVolumeName = FALSE;
    /* For all the symlinks */
    for (i = 0; i < SymLinkCount; i++)
    {
        /* Check if our device is a volume */
        if (MOUNTMGR_IS_VOLUME_NAME(&(SymLinks[i])))
        {
            IsVolumeName = TRUE;
        }
        /* If it has a drive letter */
        else if (IsDriveLetter(&(SymLinks[i])))
        {
            if (IsDrvLetter)
            {
                DeleteFromLocalDatabase(&(SymLinks[i]), UniqueId);
                continue;
            }
            else
            {
                IsDrvLetter = TRUE;
            }
        }
 
        /* And recreate the symlink to our device */
        Status = GlobalCreateSymbolicLink(&(SymLinks[i]), &TargetDeviceName);
        if (!NT_SUCCESS(Status))
        {
            BOOLEAN LinkError = TRUE;
 
            if ((SavedLinkInformation && !RedirectSavedLink(SavedLinkInformation, &(SymLinks[i]), &TargetDeviceName)) ||
                !SavedLinkInformation)
            {
                Status = QueryDeviceInformation(&(SymLinks[i]), &DeviceName, NULL, NULL, NULL, NULL, NULL, NULL);
                if (NT_SUCCESS(Status))
                {
                    LinkError = RtlEqualUnicodeString(&TargetDeviceName, &DeviceName, TRUE);
                    FreePool(DeviceName.Buffer);
                }
 
                if (!LinkError)
                {
                    if (IsDriveLetter(&(SymLinks[i])))
                    {
                        IsDrvLetter = FALSE;
                        DeleteFromLocalDatabase(&(SymLinks[i]), UniqueId);
                    }
 
                    FreePool(SymLinks[i].Buffer);
                    continue;
                }
            }
        }
 
        /* Check if was offline */
        if (IsOffline(&(SymLinks[i])))
        {
            IsOff = TRUE;
        }
 
        /* Finally, associate this symlink with the device */
        SymlinkInformation = AllocatePool(sizeof(SYMLINK_INFORMATION));
        if (!SymlinkInformation)
        {
            GlobalDeleteSymbolicLink(&(SymLinks[i]));
            FreePool(SymLinks[i].Buffer);
            continue;
        }
 
        SymlinkInformation->Name = SymLinks[i];
        SymlinkInformation->Online = TRUE;
 
        InsertTailList(&(DeviceInformation->SymbolicLinksListHead),
                       &(SymlinkInformation->SymbolicLinksListEntry));
    }
 
    /* Now, for all the recreated symlinks, notify their recreation */
    for (NextEntry = DeviceInformation->SymbolicLinksListHead.Flink;
         NextEntry != &(DeviceInformation->SymbolicLinksListHead);
         NextEntry = NextEntry->Flink)
    {
        SymlinkInformation = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
        SendLinkCreated(&(SymlinkInformation->Name));
    }
 
    /* If we had saved links, it's time to free them */
    if (SavedLinkInformation)
    {
        MountMgrFreeSavedLink(SavedLinkInformation);
    }
 
    /* If our device doesn't have a volume name */
    if (!IsVolumeName)
    {
        /* It's time to create one */
        Status = CreateNewVolumeName(&VolumeName, NULL);
        if (NT_SUCCESS(Status))
        {
            /* Write it to global database */
            RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                  DatabasePath,
                                  VolumeName.Buffer,
                                  REG_BINARY,
                                  UniqueId->UniqueId,
                                  UniqueId->UniqueIdLength);
 
            /* And create the symlink */
            GlobalCreateSymbolicLink(&VolumeName, &TargetDeviceName);
 
            SymlinkInformation = AllocatePool(sizeof(SYMLINK_INFORMATION));
            if (!SymlinkInformation)
            {
                FreePool(VolumeName.Buffer);
            }
            /* Finally, associate it with the device and notify creation */
            else
            {
                SymlinkInformation->Name = VolumeName;
                SymlinkInformation->Online = TRUE;
                InsertTailList(&(DeviceInformation->SymbolicLinksListHead),
                               &(SymlinkInformation->SymbolicLinksListEntry));
 
                SendLinkCreated(&VolumeName);
            }
        }
    }
 
    /* If we found a drive letter, then, ignore the suggested one */
    if (IsDrvLetter)
    {
        DeviceInformation->SuggestedDriveLetter = 0;
    }
    /* Else, it's time to set up one */
    else if ((!DeviceExtension->NoAutoMount || DeviceInformation->Removable) &&
             DeviceExtension->AutomaticDriveLetter &&
             (HasGptDriveLetter || DeviceInformation->SuggestedDriveLetter) &&
             !HasNoDriveLetterEntry(UniqueId))
    {
        /* Create a new drive letter */
        Status = CreateNewDriveLetterName(&DriveLetter, &TargetDeviceName,
                                          DeviceInformation->SuggestedDriveLetter,
                                          NULL);
        if (!NT_SUCCESS(Status))
        {
            CreateNoDriveLetterEntry(UniqueId);
        }
        else
        {
            /* Save it to global database */
            RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                  DatabasePath,
                                  DriveLetter.Buffer,
                                  REG_BINARY,
                                  UniqueId->UniqueId,
                                  UniqueId->UniqueIdLength);
 
            /* Associate it with the device and notify creation */
            SymlinkInformation = AllocatePool(sizeof(SYMLINK_INFORMATION));
            if (!SymlinkInformation)
            {
                FreePool(DriveLetter.Buffer);
            }
            else
            {
                SymlinkInformation->Name = DriveLetter;
                SymlinkInformation->Online = TRUE;
                InsertTailList(&(DeviceInformation->SymbolicLinksListHead),
                               &(SymlinkInformation->SymbolicLinksListEntry));
 
                SendLinkCreated(&DriveLetter);
            }
        }
    }
 
    /* If that's a PnP device, register for notifications */
    if (!ManuallyRegistered)
    {
        RegisterForTargetDeviceNotification(DeviceExtension, DeviceInformation);
    }
 
    /* Finally, insert the device into our devices list */
    InsertTailList(&(DeviceExtension->DeviceListHead), &(DeviceInformation->DeviceListEntry));
 
    /* Copy device unique ID */
    NewUniqueId = AllocatePool(UniqueId->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
    if (NewUniqueId)
    {
        NewUniqueId->UniqueIdLength = UniqueId->UniqueIdLength;
        RtlCopyMemory(NewUniqueId->UniqueId, UniqueId->UniqueId, UniqueId->UniqueIdLength);
    }
 
    /* Skip online notifications if the device is offline or a FT volume */
    if (IsOff || IsFT)
        DeviceInformation->SkipNotifications = TRUE;
 
    /* If automount is enabled or the device was already mounted, send now
     * the online notification if needed; otherwise, defer its posting */
    if (!DeviceExtension->NoAutoMount || IsDrvLetter)
        SetOnline = !DeviceInformation->SkipNotifications;
    else
        SetOnline = FALSE;
 
    /* Finally, release the exclusive lock */
    KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 
    /* Set the device online now if necessary */
    if (SetOnline)
        SendOnlineNotification(SymbolicName);
 
    /* If we had symlinks (from storage), free them */
    if (SymLinks)
    {
        FreePool(SymLinks);
    }
 
    /* Notify about unique id change */
    if (NewUniqueId)
    {
        IssueUniqueIdChangeNotify(DeviceExtension, SymbolicName, NewUniqueId);
        FreePool(NewUniqueId);
    }
 
    /* If this drive was set to have a drive letter automatically
     * Now it's back, local databases sync will be required
     */
    if (DeviceExtension->AutomaticDriveLetter)
    {
        KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 
        ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInformation);
 
        NextEntry = DeviceExtension->DeviceListHead.Flink;
        CurrentDevice = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
        while (CurrentDevice != DeviceInformation)
        {
            if (!CurrentDevice->NoDatabase)
            {
                ReconcileThisDatabaseWithMaster(DeviceExtension, CurrentDevice);
            }
 
            NextEntry = NextEntry->Flink;
            CurrentDevice = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
        }
 
        KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
    }
 
    return STATUS_SUCCESS;
}

Referenced by MountMgrCheckUnprocessedVolumes(), MountMgrMountedDeviceNotification(), and MountMgrVolumeArrivalNotification().

MountMgrMountedDeviceRemoval()

VOID MountMgrMountedDeviceRemoval	(	IN PDEVICE_EXTENSION	Extension,
		IN PUNICODE_STRING	DeviceName
	)

Definition at line 1362 of file mountmgr.c.

{
    PLIST_ENTRY NextEntry, DeviceEntry;
    PUNIQUE_ID_REPLICATE UniqueIdReplicate;
    PSYMLINK_INFORMATION SymlinkInformation;
    PASSOCIATED_DEVICE_ENTRY AssociatedDevice;
    PSAVED_LINK_INFORMATION SavedLinkInformation = NULL;
    PDEVICE_INFORMATION DeviceInformation, CurrentDevice;
 
    /* Acquire device exclusively */
    KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 
    /* Look for the leaving device */
    for (NextEntry = DeviceExtension->DeviceListHead.Flink;
         NextEntry != &(DeviceExtension->DeviceListHead);
         NextEntry = NextEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 
        if (!RtlCompareUnicodeString(&(DeviceInformation->SymbolicName), DeviceName, TRUE))
        {
            break;
        }
    }
 
    /* If we found it */
    if (NextEntry != &(DeviceExtension->DeviceListHead))
    {
        /* If it's asked to keep links, then, prepare to save them */
        if (DeviceInformation->KeepLinks)
        {
            SavedLinkInformation = AllocatePool(sizeof(SAVED_LINK_INFORMATION));
            if (!SavedLinkInformation)
            {
                DeviceInformation->KeepLinks = FALSE;
            }
        }
 
        /* If it's possible (and asked), start to save them */
        if (DeviceInformation->KeepLinks)
        {
            InsertTailList(&(DeviceExtension->SavedLinksListHead), &(SavedLinkInformation->SavedLinksListEntry));
            InitializeListHead(&(SavedLinkInformation->SymbolicLinksListHead));
            SavedLinkInformation->UniqueId = DeviceInformation->UniqueId;
        }
 
        /* For all the symlinks */
        while (!IsListEmpty(&(DeviceInformation->SymbolicLinksListHead)))
        {
            NextEntry = RemoveHeadList(&(DeviceInformation->SymbolicLinksListHead));
            SymlinkInformation = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
            /* If we have to, save the link */
            if (DeviceInformation->KeepLinks)
            {
                InsertTailList(&(SavedLinkInformation->SymbolicLinksListHead), &(SymlinkInformation->SymbolicLinksListEntry));
            }
            /* Otherwise, just release it */
            else
            {
                GlobalDeleteSymbolicLink(&(SymlinkInformation->Name));
                FreePool(SymlinkInformation->Name.Buffer);
                FreePool(SymlinkInformation);
            }
        }
 
        /* Free all the replicated unique IDs */
        while (!IsListEmpty(&(DeviceInformation->ReplicatedUniqueIdsListHead)))
        {
            NextEntry = RemoveHeadList(&(DeviceInformation->ReplicatedUniqueIdsListHead));
            UniqueIdReplicate = CONTAINING_RECORD(NextEntry, UNIQUE_ID_REPLICATE, ReplicatedUniqueIdsListEntry);
 
 
            FreePool(UniqueIdReplicate->UniqueId);
            FreePool(UniqueIdReplicate);
        }
 
        while (!IsListEmpty(&(DeviceInformation->AssociatedDevicesHead)))
        {
            NextEntry = RemoveHeadList(&(DeviceInformation->AssociatedDevicesHead));
            AssociatedDevice = CONTAINING_RECORD(NextEntry, ASSOCIATED_DEVICE_ENTRY, AssociatedDevicesEntry);
 
            DeviceInformation->NoDatabase = TRUE;
            FreePool(AssociatedDevice->String.Buffer);
            FreePool(AssociatedDevice);
        }
 
        /* Remove device from the device list */
        RemoveEntryList(&(DeviceInformation->DeviceListEntry));
 
        /* If there are still devices, check if some were associated with ours */
        if (!IsListEmpty(&(DeviceInformation->DeviceListEntry)))
        {
            for (NextEntry = DeviceExtension->DeviceListHead.Flink;
                 NextEntry != &(DeviceExtension->DeviceListHead);
                 NextEntry = NextEntry->Flink)
            {
                CurrentDevice = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 
                /* And then, remove them */
                DeviceEntry = CurrentDevice->AssociatedDevicesHead.Flink;
                while (DeviceEntry != &(CurrentDevice->AssociatedDevicesHead))
                {
                    AssociatedDevice = CONTAINING_RECORD(NextEntry, ASSOCIATED_DEVICE_ENTRY, AssociatedDevicesEntry);
                    DeviceEntry = DeviceEntry->Flink;
 
                    if (AssociatedDevice->DeviceInformation != DeviceInformation)
                    {
                        continue;
                    }
 
                    RemoveEntryList(&(AssociatedDevice->AssociatedDevicesEntry));
                    FreePool(AssociatedDevice->String.Buffer);
                    FreePool(AssociatedDevice);
                }
            }
        }
 
        /* Finally, clean up device name, symbolic name */
        FreePool(DeviceInformation->SymbolicName.Buffer);
        if (!DeviceInformation->KeepLinks)
        {
            FreePool(DeviceInformation->UniqueId);
        }
        FreePool(DeviceInformation->DeviceName.Buffer);
 
        /* Unregister notifications */
        if (DeviceInformation->TargetDeviceNotificationEntry)
        {
            IoUnregisterPlugPlayNotification(DeviceInformation->TargetDeviceNotificationEntry);
        }
 
        /*  And leave */
        FreePool(DeviceInformation);
    }
    else
    {
        /* We didn't find device, perhaps because it was offline */
        for (NextEntry = DeviceExtension->OfflineDeviceListHead.Flink;
             NextEntry != &(DeviceExtension->OfflineDeviceListHead);
             NextEntry = NextEntry->Flink)
        {
            DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 
            /* It was, remove it */
            if (RtlCompareUnicodeString(&(DeviceInformation->SymbolicName), DeviceName, TRUE) == 0)
            {
                RemoveEntryList(&(DeviceInformation->DeviceListEntry));
                MountMgrFreeDeadDeviceInfo(DeviceInformation);
                break;
            }
        }
    }
 
    /* Release driver */
    KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
}

Referenced by MountMgrMountedDeviceNotification().

MountMgrNotify()

VOID MountMgrNotify

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 288 of file notify.c.

{
    PIRP Irp;
    KIRQL OldIrql;
    LIST_ENTRY CopyList;
    PLIST_ENTRY NextEntry;
 
    /* Increase the epic number */
    DeviceExtension->EpicNumber++;
 
    InitializeListHead(&CopyList);
 
    /* Copy all the pending IRPs for notification */
    IoAcquireCancelSpinLock(&OldIrql);
    while (!IsListEmpty(&(DeviceExtension->IrpListHead)))
    {
        NextEntry = RemoveHeadList(&(DeviceExtension->IrpListHead));
        Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
        IoSetCancelRoutine(Irp, NULL);
        InsertTailList(&CopyList, &(Irp->Tail.Overlay.ListEntry));
    }
    IoReleaseCancelSpinLock(OldIrql);
 
    /* Then, notify them one by one */
    while (!IsListEmpty(&CopyList))
    {
        NextEntry = RemoveHeadList(&CopyList);
        Irp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
 
        *((PULONG)Irp->AssociatedIrp.SystemBuffer) = DeviceExtension->EpicNumber;
        Irp->IoStatus.Information = sizeof(DeviceExtension->EpicNumber);
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
}

Referenced by MountMgrCreatePointWorker(), MountMgrDeletePoints(), and MountMgrVolumeMountPointChanged().

MountMgrNotifyNameChange()

VOID MountMgrNotifyNameChange	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	DeviceName,
		IN BOOLEAN	ValidateVolume
	)

Definition at line 328 of file notify.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    PLIST_ENTRY NextEntry;
    PFILE_OBJECT FileObject;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
    PDEVICE_RELATIONS DeviceRelations;
    PDEVICE_INFORMATION DeviceInformation;
    TARGET_DEVICE_CUSTOM_NOTIFICATION DeviceNotification;
 
    /* If we have to validate volume */
    if (ValidateVolume)
    {
        /* Then, ensure we can find the device */
        for (NextEntry = DeviceExtension->DeviceListHead.Flink;
             NextEntry != &DeviceExtension->DeviceListHead;
             NextEntry = NextEntry->Flink)
        {
            DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
            if (RtlCompareUnicodeString(DeviceName, &(DeviceInformation->DeviceName), TRUE) == 0)
            {
                break;
            }
        }
 
        /* No need to notify for a PnP device or if we didn't find the device */
        if (NextEntry == &(DeviceExtension->DeviceListHead) ||
            !DeviceInformation->ManuallyRegistered)
        {
            return;
        }
    }
 
    /* Then, get device object */
    Status = IoGetDeviceObjectPointer(DeviceName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return;
    }
 
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Set up empty IRP (yes, yes!) */
    Irp = IoBuildDeviceIoControlRequest(0,
                                        DeviceObject,
                                        NULL,
                                        0,
                                        NULL,
                                        0,
                                        FALSE,
                                        &Event,
                                        &IoStatusBlock);
    if (!Irp)
    {
        ObDereferenceObject(DeviceObject);
        ObDereferenceObject(FileObject);
        return;
    }
 
    Stack = IoGetNextIrpStackLocation(Irp);
 
    Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
    Irp->IoStatus.Information = 0;
 
    /* Properly set it, we want to query device relations */
    Stack->MajorFunction = IRP_MJ_PNP;
    Stack->MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
    Stack->Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
    Stack->FileObject = FileObject;
 
    /* And call driver */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatusBlock.Status;
    }
 
    ObDereferenceObject(DeviceObject);
    ObDereferenceObject(FileObject);
 
    if (!NT_SUCCESS(Status))
    {
        return;
    }
 
    /* Validate device return */
    DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
    if (DeviceRelations->Count < 1)
    {
        ExFreePool(DeviceRelations);
        return;
    }
 
    DeviceObject = DeviceRelations->Objects[0];
    ExFreePool(DeviceRelations);
 
    /* Set up real notification */
    DeviceNotification.Version = 1;
    DeviceNotification.Size = sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION);
    DeviceNotification.Event = GUID_IO_VOLUME_NAME_CHANGE;
    DeviceNotification.FileObject = NULL;
    DeviceNotification.NameBufferOffset = -1;
 
    /* And report */
    IoReportTargetDeviceChangeAsynchronous(DeviceObject,
                                           &DeviceNotification,
                                           NULL, NULL);
 
    ObDereferenceObject(DeviceObject);
 
    return;
}

Referenced by MountMgrCreatePointWorker(), MountMgrDeletePoints(), MountMgrQueryDosVolumePaths(), and MountMgrVolumeMountPointChanged().

MountMgrQuerySymbolicLink()

NTSTATUS MountMgrQuerySymbolicLink	(	IN PUNICODE_STRING	SymbolicName,
		IN OUT PUNICODE_STRING	LinkTarget
	)

Definition at line 849 of file symlink.c.

{
    NTSTATUS Status;
    HANDLE LinkHandle;
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    /* Open the symbolic link */
    InitializeObjectAttributes(&ObjectAttributes,
                               SymbolicName,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = ZwOpenSymbolicLinkObject(&LinkHandle,
                                      GENERIC_READ,
                                      &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Query its target */
    Status = ZwQuerySymbolicLinkObject(LinkHandle,
                                       LinkTarget,
                                       NULL);
 
    ZwClose(LinkHandle);
 
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    if (LinkTarget->Length <= sizeof(WCHAR))
    {
        return Status;
    }
 
    /* If it's not finished by \, just return */
    if (LinkTarget->Buffer[LinkTarget->Length / sizeof(WCHAR) - 1] != L'\\')
    {
        return Status;
    }
 
    /* Otherwise, ensure to drop the tailing \ */
    LinkTarget->Length -= sizeof(WCHAR);
    LinkTarget->Buffer[LinkTarget->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    return Status;
}

Referenced by MountMgrVolumeMountPointCreated(), and MountMgrVolumeMountPointDeleted().

MountMgrUniqueIdChangeRoutine()

VOID MountMgrUniqueIdChangeRoutine	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PMOUNTDEV_UNIQUE_ID	OldUniqueId,
		IN PMOUNTDEV_UNIQUE_ID	NewUniqueId
	)

Definition at line 71 of file uniqueid.c.

{
    NTSTATUS Status;
    BOOLEAN ResyncNeeded;
    PUNIQUE_ID_REPLICATE DuplicateId;
    PDEVICE_INFORMATION DeviceInformation;
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
    PMOUNTDEV_UNIQUE_ID UniqueId, NewDuplicateId;
    PLIST_ENTRY ListHead, NextEntry, ReplicatedHead, NextReplicated;
 
    /* Synchronise with remote databases */
    Status = WaitForRemoteDatabaseSemaphore(DeviceExtension);
    KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
 
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = ChangeUniqueIdRoutine;
    QueryTable[0].EntryContext = NewUniqueId;
 
    /* Write new data */
    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           DatabasePath,
                           QueryTable,
                           OldUniqueId,
                           NULL);
 
    /* Browse all the devices to find the one that
     * owns the old unique ID
     */
    ListHead = &(DeviceExtension->DeviceListHead);
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        DeviceInformation = CONTAINING_RECORD(NextEntry,
                                              DEVICE_INFORMATION,
                                              DeviceListEntry);
 
        if (DeviceInformation->UniqueId->UniqueIdLength == OldUniqueId->UniqueIdLength &&
            RtlCompareMemory(OldUniqueId->UniqueId,
                             DeviceInformation->UniqueId->UniqueId,
                             OldUniqueId->UniqueIdLength) == OldUniqueId->UniqueIdLength)
        {
            break;
        }
 
        NextEntry = NextEntry->Flink;
    }
 
    /* If we didn't find any release everything and quit */
    if (ListHead == NextEntry)
    {
        KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT,
                           1, FALSE);
 
        if (NT_SUCCESS(Status))
        {
            ReleaseRemoteDatabaseSemaphore(DeviceExtension);
        }
 
        return;
    }
 
    /* If lock failed, then, just update this database */
    if (!NT_SUCCESS(Status))
    {
        ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInformation);
        KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT,
                           1, FALSE);
        return;
    }
 
    /* Allocate new unique ID */
    UniqueId = AllocatePool(NewUniqueId->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
    if (!UniqueId)
    {
        KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT,
                           1, FALSE);
        ReleaseRemoteDatabaseSemaphore(DeviceExtension);
        return;
    }
 
    /* Release old one */
    FreePool(DeviceInformation->UniqueId);
    /* And set new one */
    DeviceInformation->UniqueId = UniqueId;
    UniqueId->UniqueIdLength = NewUniqueId->UniqueIdLength;
    RtlCopyMemory(UniqueId->UniqueId, NewUniqueId->UniqueId, NewUniqueId->UniqueIdLength);
 
    /* Now, check if it's required to update replicated unique IDs as well */
    ListHead = &(DeviceExtension->DeviceListHead);
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        DeviceInformation = CONTAINING_RECORD(NextEntry,
                                              DEVICE_INFORMATION,
                                              DeviceListEntry);
        ResyncNeeded = FALSE;
 
        ReplicatedHead = &(DeviceInformation->ReplicatedUniqueIdsListHead);
        NextReplicated = ReplicatedHead->Flink;
        while (ReplicatedHead != NextReplicated)
        {
            DuplicateId = CONTAINING_RECORD(NextReplicated,
                                            UNIQUE_ID_REPLICATE,
                                            ReplicatedUniqueIdsListEntry);
 
            if (DuplicateId->UniqueId->UniqueIdLength == OldUniqueId->UniqueIdLength)
            {
                if (RtlCompareMemory(DuplicateId->UniqueId->UniqueId,
                                     OldUniqueId->UniqueId,
                                     OldUniqueId->UniqueIdLength) == OldUniqueId->UniqueIdLength)
                {
                    /* It was our old unique ID */
                    NewDuplicateId = AllocatePool(NewUniqueId->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
                    if (NewDuplicateId)
                    {
                        /* Update it */
                        ResyncNeeded = TRUE;
                        FreePool(DuplicateId->UniqueId);
 
                        DuplicateId->UniqueId = NewDuplicateId;
                        DuplicateId->UniqueId->UniqueIdLength = NewUniqueId->UniqueIdLength;
                        RtlCopyMemory(NewDuplicateId->UniqueId, NewUniqueId->UniqueId, NewUniqueId->UniqueIdLength);
                    }
                }
            }
 
            NextReplicated = NextReplicated->Flink;
        }
 
        /* If resync is required on this device, do it */
        if (ResyncNeeded)
        {
            ChangeRemoteDatabaseUniqueId(DeviceInformation, OldUniqueId, NewUniqueId);
        }
 
        NextEntry = NextEntry->Flink;
    }
 
    KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
    ReleaseRemoteDatabaseSemaphore(DeviceExtension);
 
    return;
}

Referenced by UniqueIdChangeNotifyWorker().

OpenRemoteDatabase()

HANDLE OpenRemoteDatabase	(	IN PDEVICE_INFORMATION	DeviceInformation,
		IN BOOLEAN	MigrateDatabase
	)

Definition at line 1839 of file database.c.

{
    HANDLE Database;
    NTSTATUS Status;
    BOOLEAN PreviousMode;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING DeviceRemoteDatabase;
 
    Database = 0;
 
    /* Get database name */
    DeviceRemoteDatabase.Length = 0;
    DeviceRemoteDatabase.MaximumLength = DeviceInformation->DeviceName.Length
                                         + RemoteDatabase.Length
                                         + sizeof(UNICODE_NULL);
    DeviceRemoteDatabase.Buffer = AllocatePool(DeviceRemoteDatabase.MaximumLength);
    if (!DeviceRemoteDatabase.Buffer)
    {
        return 0;
    }
 
    RtlAppendUnicodeStringToString(&DeviceRemoteDatabase, &DeviceInformation->DeviceName);
    RtlAppendUnicodeStringToString(&DeviceRemoteDatabase, &RemoteDatabase);
    DeviceRemoteDatabase.Buffer[DeviceRemoteDatabase.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    /* Open database */
    InitializeObjectAttributes(&ObjectAttributes,
                               &DeviceRemoteDatabase,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Disable hard errors */
    PreviousMode = IoSetThreadHardErrorMode(FALSE);
 
    Status = IoCreateFile(&Database,
                          SYNCHRONIZE | READ_CONTROL | FILE_WRITE_ATTRIBUTES |
                          FILE_READ_ATTRIBUTES | FILE_WRITE_EA | FILE_READ_EA |
                          FILE_APPEND_DATA | FILE_WRITE_DATA | FILE_READ_DATA,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN,
                          0,
                          (!MigrateDatabase || DeviceInformation->Migrated == 0) ? FILE_OPEN_IF : FILE_OPEN,
                          FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_ALERT,
                          NULL,
                          0,
                          CreateFileTypeNone,
                          NULL,
                          IO_STOP_ON_SYMLINK | IO_NO_PARAMETER_CHECKING);
    if (Status == STATUS_STOPPED_ON_SYMLINK)
    {
        DPRINT1("Attempt to exploit CVE-2015-1769. See CORE-10216\n");
    }
 
    /* If base it to be migrated and was opened successfully, go ahead */
    if (MigrateDatabase && NT_SUCCESS(Status))
    {
        CreateRemoteDatabase(DeviceInformation, &Database);
    }
 
    IoSetThreadHardErrorMode(PreviousMode);
    FreePool(DeviceRemoteDatabase.Buffer);
 
    return Database;
}

Referenced by ChangeRemoteDatabaseUniqueId(), MountMgrVolumeMountPointCreated(), MountMgrVolumeMountPointDeleted(), and ReconcileThisDatabaseWithMasterWorker().

PostOnlineNotification()

VOID PostOnlineNotification	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	SymbolicName
	)

Definition at line 122 of file notify.c.

{
    KIRQL OldIrql;
    PONLINE_NOTIFICATION_WORK_ITEM WorkItem;
 
    /* Allocate a notification work item */
    WorkItem = AllocatePool(sizeof(ONLINE_NOTIFICATION_WORK_ITEM));
    if (!WorkItem)
    {
        return;
    }
 
    ExInitializeWorkItem(&WorkItem->WorkItem, SendOnlineNotificationWorker, WorkItem);
    WorkItem->DeviceExtension = DeviceExtension;
    WorkItem->SymbolicName.Length = SymbolicName->Length;
    WorkItem->SymbolicName.MaximumLength = SymbolicName->Length + sizeof(WCHAR);
    WorkItem->SymbolicName.Buffer = AllocatePool(WorkItem->SymbolicName.MaximumLength);
    if (!WorkItem->SymbolicName.Buffer)
    {
        FreePool(WorkItem);
        return;
    }
 
    RtlCopyMemory(WorkItem->SymbolicName.Buffer, SymbolicName->Buffer, SymbolicName->Length);
    WorkItem->SymbolicName.Buffer[SymbolicName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
    DeviceExtension->OnlineNotificationCount++;
 
    /* If no worker are active */
    if (DeviceExtension->OnlineNotificationWorkerActive == 0)
    {
        /* Queue that one for execution */
        DeviceExtension->OnlineNotificationWorkerActive = 1;
        ExQueueWorkItem(&WorkItem->WorkItem, DelayedWorkQueue);
    }
    else
    {
        /* Otherwise, just put it in the queue list */
        InsertTailList(&(DeviceExtension->OnlineNotificationListHead), &(WorkItem->WorkItem.List));
    }
 
    KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 
    return;
}

Referenced by MountMgrCreatePointWorker(), MountMgrVolumeMountPointCreated(), OnlineMountedVolumes(), and ReconcileThisDatabaseWithMasterWorker().

QueryDeviceInformation()

NTSTATUS QueryDeviceInformation	(	_In_ PUNICODE_STRING	SymbolicName,
		_Out_opt_ PUNICODE_STRING	DeviceName,
		_Out_opt_ PMOUNTDEV_UNIQUE_ID *	UniqueId,
		_Out_opt_ PBOOLEAN	Removable,
		_Out_opt_ PBOOLEAN	GptDriveLetter,
		_Out_opt_ PBOOLEAN	HasGuid,
		_Inout_opt_ LPGUID	StableGuid,
		_Out_opt_ PBOOLEAN	IsFT
	)

Definition at line 274 of file mountmgr.c.

{
    NTSTATUS Status;
    USHORT Size;
    BOOLEAN IsRemovable;
    PMOUNTDEV_NAME Name;
    PMOUNTDEV_UNIQUE_ID Id;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    PARTITION_INFORMATION_EX PartitionInfo;
    STORAGE_DEVICE_NUMBER StorageDeviceNumber;
    VOLUME_GET_GPT_ATTRIBUTES_INFORMATION GptAttributes;
 
    /* Get device associated with the symbolic name */
    Status = IoGetDeviceObjectPointer(SymbolicName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* The associate FO can't have a file name */
    if (FileObject->FileName.Length)
    {
        ObDereferenceObject(FileObject);
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    /* Check if it's removable & return to the user (if asked to) */
    IsRemovable = (FileObject->DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA);
    if (Removable)
    {
        *Removable = IsRemovable;
    }
 
    /* Get the attached device */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    /* If we've been asked for a GPT drive letter */
    if (GptDriveLetter)
    {
        /* Consider it has one */
        *GptDriveLetter = TRUE;
 
        if (!IsRemovable)
        {
            /* Query the GPT attributes */
            Status = MountMgrSendSyncDeviceIoCtl(IOCTL_VOLUME_GET_GPT_ATTRIBUTES,
                                                 DeviceObject,
                                                 NULL,
                                                 0,
                                                 &GptAttributes,
                                                 sizeof(GptAttributes),
                                                 NULL);
            /* Failure isn't major */
            if (!NT_SUCCESS(Status))
            {
                Status = STATUS_SUCCESS;
            }
            /* Check if it has a drive letter */
            else if (GptAttributes.GptAttributes & GPT_BASIC_DATA_ATTRIBUTE_NO_DRIVE_LETTER)
            {
                *GptDriveLetter = FALSE;
            }
        }
    }
 
    /* If caller wants to know if this is a FT volume */
    if (IsFT)
    {
        /* Suppose it's not */
        *IsFT = FALSE;
 
        /* FT volume can't be removable */
        if (!IsRemovable)
        {
            /* Query partition information */
            Status = MountMgrSendSyncDeviceIoCtl(IOCTL_DISK_GET_PARTITION_INFO_EX,
                                                 DeviceObject,
                                                 NULL,
                                                 0,
                                                 &PartitionInfo,
                                                 sizeof(PartitionInfo),
                                                 NULL);
            /* Failure isn't major */
            if (!NT_SUCCESS(Status))
            {
                Status = STATUS_SUCCESS;
            }
            /* Check if this is a FT volume */
            else if ((PartitionInfo.PartitionStyle == PARTITION_STYLE_MBR) &&
                     IsFTPartition(PartitionInfo.Mbr.PartitionType))
            {
                *IsFT = TRUE;
            }
 
            /* It looks like a FT volume. Verify it is really one by checking
             * that it does NOT lie on a specific storage device (i.e. it is
             * not a basic volume). */
            if (*IsFT)
            {
                Status = MountMgrSendSyncDeviceIoCtl(IOCTL_STORAGE_GET_DEVICE_NUMBER,
                                                     DeviceObject,
                                                     NULL,
                                                     0,
                                                     &StorageDeviceNumber,
                                                     sizeof(StorageDeviceNumber),
                                                     NULL);
                if (!NT_SUCCESS(Status))
                    Status = STATUS_SUCCESS;
                else
                    *IsFT = FALSE; // Succeeded, so this cannot be a FT volume.
            }
        }
    }
 
    /* If caller needs device name */
    if (DeviceName)
    {
        /* Allocate a buffer just to request length */
        Name = AllocatePool(sizeof(MOUNTDEV_NAME));
        if (!Name)
        {
            ObDereferenceObject(DeviceObject);
            ObDereferenceObject(FileObject);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Query device name */
        Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
                                             DeviceObject,
                                             NULL,
                                             0,
                                             Name,
                                             sizeof(MOUNTDEV_NAME),
                                             FileObject);
        /* Retry with appropriate length */
        if (Status == STATUS_BUFFER_OVERFLOW)
        {
            Size = Name->NameLength + sizeof(MOUNTDEV_NAME);
 
            FreePool(Name);
 
            /* Allocate proper size */
            Name = AllocatePool(Size);
            if (!Name)
            {
                ObDereferenceObject(DeviceObject);
                ObDereferenceObject(FileObject);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            /* And query name (for real that time) */
            Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_DEVICE_NAME,
                                                 DeviceObject,
                                                 NULL,
                                                 0,
                                                 Name,
                                                 Size,
                                                 FileObject);
        }
 
        if (NT_SUCCESS(Status))
        {
            /* Copy back found name to the caller */
            DeviceName->Length = Name->NameLength;
            DeviceName->MaximumLength = Name->NameLength + sizeof(WCHAR);
            DeviceName->Buffer = AllocatePool(DeviceName->MaximumLength);
            if (!DeviceName->Buffer)
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
            }
            else
            {
                RtlCopyMemory(DeviceName->Buffer, Name->Name, Name->NameLength);
                DeviceName->Buffer[Name->NameLength / sizeof(WCHAR)] = UNICODE_NULL;
            }
        }
 
        FreePool(Name);
    }
 
    if (!NT_SUCCESS(Status))
    {
        ObDereferenceObject(DeviceObject);
        ObDereferenceObject(FileObject);
        return Status;
    }
 
    /* If caller wants device unique ID */
    if (UniqueId)
    {
        /* Prepare buffer to probe length */
        Id = AllocatePool(sizeof(MOUNTDEV_UNIQUE_ID));
        if (!Id)
        {
            ObDereferenceObject(DeviceObject);
            ObDereferenceObject(FileObject);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Query unique ID length */
        Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_UNIQUE_ID,
                                             DeviceObject,
                                             NULL,
                                             0,
                                             Id,
                                             sizeof(MOUNTDEV_UNIQUE_ID),
                                             FileObject);
        /* Retry with appropriate length */
        if (Status == STATUS_BUFFER_OVERFLOW)
        {
            Size = Id->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID);
 
            FreePool(Id);
 
            /* Allocate the correct buffer */
            Id = AllocatePool(Size);
            if (!Id)
            {
                ObDereferenceObject(DeviceObject);
                ObDereferenceObject(FileObject);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            /* Query unique ID */
            Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_UNIQUE_ID,
                                                 DeviceObject,
                                                 NULL,
                                                 0,
                                                 Id,
                                                 Size,
                                                 FileObject);
        }
 
        /* Hands back unique ID */
        if (NT_SUCCESS(Status))
        {
            *UniqueId = Id;
        }
        else
        {
            /* In case of failure, also free the rest */
            FreePool(Id);
            if (DeviceName->Length)
                FreePool(DeviceName->Buffer);
 
            ObDereferenceObject(DeviceObject);
            ObDereferenceObject(FileObject);
            return Status;
        }
    }
 
    /* If user wants to know about GUID */
    if (HasGuid)
    {
        /* Query device stable GUID */
        NTSTATUS IntStatus;
        IntStatus = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_STABLE_GUID,
                                                DeviceObject,
                                                NULL,
                                                0,
                                                StableGuid,
                                                sizeof(GUID),
                                                FileObject);
        *HasGuid = NT_SUCCESS(IntStatus);
    }
 
    ObDereferenceObject(DeviceObject);
    ObDereferenceObject(FileObject);
    return Status;
}

Referenced by FindDeviceInfo(), and MountMgrMountedDeviceArrival().

QueryPointsFromMemory()

NTSTATUS QueryPointsFromMemory	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PIRP	Irp,
		IN PMOUNTDEV_UNIQUE_ID UniqueId	OPTIONAL,
		IN PUNICODE_STRING SymbolicName	OPTIONAL
	)

Definition at line 236 of file point.c.

{
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    UNICODE_STRING DeviceName;
    PMOUNTMGR_MOUNT_POINTS MountPoints;
    PDEVICE_INFORMATION DeviceInformation;
    PLIST_ENTRY DeviceEntry, SymlinksEntry;
    PSYMLINK_INFORMATION SymlinkInformation;
    USHORT UniqueIdLength, DeviceNameLength;
    ULONG TotalSize, TotalSymLinks, UniqueIdOffset, DeviceNameOffset;
 
    /* If we got a symbolic link, query device */
    if (SymbolicName)
    {
        Status = QueryDeviceInformation(SymbolicName,
                                        &DeviceName,
                                        NULL, NULL,
                                        NULL, NULL,
                                        NULL, NULL);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
    }
 
    /* Browse all the links to count number of links & size used */
    TotalSize = 0;
    TotalSymLinks = 0;
    for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
         DeviceEntry != &(DeviceExtension->DeviceListHead);
         DeviceEntry = DeviceEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
        /* If we were given an unique ID, it has to match */
        if (UniqueId)
        {
            if (UniqueId->UniqueIdLength != DeviceInformation->UniqueId->UniqueIdLength)
            {
                continue;
            }
 
            if (RtlCompareMemory(UniqueId->UniqueId,
                                 DeviceInformation->UniqueId->UniqueId,
                                 UniqueId->UniqueIdLength) != UniqueId->UniqueIdLength)
            {
                continue;
            }
        }
        /* Or, if we had a symlink, it has to match */
        else if (SymbolicName)
        {
            if (!RtlEqualUnicodeString(&DeviceName, &(DeviceInformation->DeviceName), TRUE))
            {
                continue;
            }
        }
 
        /* Once here, it matched, save device name & unique ID size */
        TotalSize += DeviceInformation->DeviceName.Length + DeviceInformation->UniqueId->UniqueIdLength;
 
        /* And count number of symlinks (and their size) */
        for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
             SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
             SymlinksEntry = SymlinksEntry->Flink)
        {
            SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
            TotalSize += SymlinkInformation->Name.Length;
            TotalSymLinks++;
        }
 
        /* We had a specific item to find
         * if we reach that point, we found it, no need to continue
         */
        if (UniqueId || SymbolicName)
        {
            break;
        }
    }
 
    /* If we were looking for specific item, ensure we found it */
    if (UniqueId || SymbolicName)
    {
        if (DeviceEntry == &(DeviceExtension->DeviceListHead))
        {
            if (SymbolicName)
            {
                FreePool(DeviceName.Buffer);
            }
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    /* Now, ensure output buffer can hold everything */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
    RtlZeroMemory(MountPoints, Stack->Parameters.DeviceIoControl.OutputBufferLength);
 
    /* Ensure we set output to let user reallocate! */
    MountPoints->Size = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalSymLinks * sizeof(MOUNTMGR_MOUNT_POINT) + TotalSize;
    MountPoints->NumberOfMountPoints = TotalSymLinks;
    Irp->IoStatus.Information = MountPoints->Size;
 
    if (MountPoints->Size > Stack->Parameters.DeviceIoControl.OutputBufferLength)
    {
        Irp->IoStatus.Information = sizeof(MOUNTMGR_MOUNT_POINTS);
 
        if (SymbolicName)
        {
            FreePool(DeviceName.Buffer);
        }
 
        return STATUS_BUFFER_OVERFLOW;
    }
 
    /* Now, start putting mount points */
    TotalSize = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalSymLinks * sizeof(MOUNTMGR_MOUNT_POINT);
    TotalSymLinks = 0;
    for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
         DeviceEntry != &(DeviceExtension->DeviceListHead);
         DeviceEntry = DeviceEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
        /* Find back correct mount point */
        if (UniqueId)
        {
            if (UniqueId->UniqueIdLength != DeviceInformation->UniqueId->UniqueIdLength)
            {
                continue;
            }
 
            if (RtlCompareMemory(UniqueId->UniqueId,
                                 DeviceInformation->UniqueId->UniqueId,
                                 UniqueId->UniqueIdLength) != UniqueId->UniqueIdLength)
            {
                continue;
            }
        }
        else if (SymbolicName)
        {
            if (!RtlEqualUnicodeString(&DeviceName, &(DeviceInformation->DeviceName), TRUE))
            {
                continue;
            }
        }
 
        /* Save our information about shared data */
        UniqueIdOffset = TotalSize;
        UniqueIdLength = DeviceInformation->UniqueId->UniqueIdLength;
        DeviceNameOffset = TotalSize + UniqueIdLength;
        DeviceNameLength = DeviceInformation->DeviceName.Length;
 
        /* Initialize first symlink */
        MountPoints->MountPoints[TotalSymLinks].UniqueIdOffset = UniqueIdOffset;
        MountPoints->MountPoints[TotalSymLinks].UniqueIdLength = UniqueIdLength;
        MountPoints->MountPoints[TotalSymLinks].DeviceNameOffset = DeviceNameOffset;
        MountPoints->MountPoints[TotalSymLinks].DeviceNameLength = DeviceNameLength;
 
        /* And copy data */
        RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + UniqueIdOffset),
                      DeviceInformation->UniqueId->UniqueId, UniqueIdLength);
        RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + DeviceNameOffset),
                      DeviceInformation->DeviceName.Buffer, DeviceNameLength);
 
        TotalSize += DeviceInformation->UniqueId->UniqueIdLength + DeviceInformation->DeviceName.Length;
 
        /* Now we've got it, but all the data */
        for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
             SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
             SymlinksEntry = SymlinksEntry->Flink)
        {
            SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
            /* First, set shared data */
 
            /* Only put UniqueID if online */
            if (SymlinkInformation->Online)
            {
                MountPoints->MountPoints[TotalSymLinks].UniqueIdOffset = UniqueIdOffset;
                MountPoints->MountPoints[TotalSymLinks].UniqueIdLength = UniqueIdLength;
            }
            else
            {
                MountPoints->MountPoints[TotalSymLinks].UniqueIdOffset = 0;
                MountPoints->MountPoints[TotalSymLinks].UniqueIdLength = 0;
            }
 
            MountPoints->MountPoints[TotalSymLinks].DeviceNameOffset = DeviceNameOffset;
            MountPoints->MountPoints[TotalSymLinks].DeviceNameLength = DeviceNameLength;
 
            /* And now, copy specific symlink info */
            MountPoints->MountPoints[TotalSymLinks].SymbolicLinkNameOffset = TotalSize;
            MountPoints->MountPoints[TotalSymLinks].SymbolicLinkNameLength = SymlinkInformation->Name.Length;
 
            RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[TotalSymLinks].SymbolicLinkNameOffset),
                          SymlinkInformation->Name.Buffer, SymlinkInformation->Name.Length);
 
            /* Update counters */
            TotalSymLinks++;
            TotalSize += SymlinkInformation->Name.Length;
        }
 
        if (UniqueId || SymbolicName)
        {
            break;
        }
    }
 
    if (SymbolicName)
    {
        FreePool(DeviceName.Buffer);
    }
 
    return STATUS_SUCCESS;
}

Referenced by MountMgrQueryPoints().

QueryPointsFromSymbolicLinkName()

NTSTATUS QueryPointsFromSymbolicLinkName	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PUNICODE_STRING	SymbolicName,
		IN PIRP	Irp
	)

Definition at line 463 of file point.c.

{
    NTSTATUS Status;
    ULONG TotalLength;
    PIO_STACK_LOCATION Stack;
    UNICODE_STRING DeviceName;
    PMOUNTMGR_MOUNT_POINTS MountPoints;
    PDEVICE_INFORMATION DeviceInformation = NULL;
    PLIST_ENTRY DeviceEntry, SymlinksEntry;
    PSYMLINK_INFORMATION SymlinkInformation;
 
    /* Find device */
    Status = QueryDeviceInformation(SymbolicName, &DeviceName,
                                    NULL, NULL, NULL,
                                    NULL, NULL, NULL);
    if (NT_SUCCESS(Status))
    {
        /* Look for the device information */
        for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
             DeviceEntry != &(DeviceExtension->DeviceListHead);
             DeviceEntry = DeviceEntry->Flink)
        {
            DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
            if (RtlEqualUnicodeString(&DeviceName, &(DeviceInformation->DeviceName), TRUE))
            {
                break;
            }
        }
 
        FreePool(DeviceName.Buffer);
 
        if (DeviceEntry == &(DeviceExtension->DeviceListHead))
        {
            return STATUS_INVALID_PARAMETER;
        }
 
        /* Check for the link */
        for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
             SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
             SymlinksEntry = SymlinksEntry->Flink)
        {
            SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
            if (RtlEqualUnicodeString(SymbolicName, &SymlinkInformation->Name, TRUE))
            {
                break;
            }
        }
 
        if (SymlinksEntry == &(DeviceInformation->SymbolicLinksListHead))
        {
            return STATUS_INVALID_PARAMETER;
        }
    }
    else
    {
        /* Browse all the devices to try to find the one
         * that has the given link...
         */
        for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
             DeviceEntry != &(DeviceExtension->DeviceListHead);
             DeviceEntry = DeviceEntry->Flink)
        {
            DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 
            for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
                 SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
                 SymlinksEntry = SymlinksEntry->Flink)
            {
                SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
                if (RtlEqualUnicodeString(SymbolicName, &SymlinkInformation->Name, TRUE))
                {
                    break;
                }
            }
 
            if (SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead))
            {
                break;
            }
        }
 
        /* Even that way we didn't find, give up! */
        if (DeviceEntry == &(DeviceExtension->DeviceListHead))
        {
            return STATUS_OBJECT_NAME_NOT_FOUND;
        }
    }
 
    /* Get output buffer */
    Stack = IoGetCurrentIrpStackLocation(Irp);
    MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
 
    /* Compute output length */
    TotalLength = DeviceInformation->UniqueId->UniqueIdLength +
                  SymlinkInformation->Name.Length + DeviceInformation->DeviceName.Length;
 
    /* Give length to allow reallocation */
    MountPoints->Size = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalLength;
    MountPoints->NumberOfMountPoints = 1;
    Irp->IoStatus.Information = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalLength;
 
    if (MountPoints->Size > Stack->Parameters.DeviceIoControl.OutputBufferLength)
    {
        Irp->IoStatus.Information = sizeof(MOUNTMGR_MOUNT_POINTS);
 
        return STATUS_BUFFER_OVERFLOW;
    }
 
    /* Write out data */
    MountPoints->MountPoints[0].SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINTS);
    MountPoints->MountPoints[0].SymbolicLinkNameLength = SymlinkInformation->Name.Length;
    /* If link is online write it's unique ID, otherwise, forget about it */
    if (SymlinkInformation->Online)
    {
        MountPoints->MountPoints[0].UniqueIdOffset = sizeof(MOUNTMGR_MOUNT_POINTS) +
                                                     SymlinkInformation->Name.Length;
        MountPoints->MountPoints[0].UniqueIdLength = DeviceInformation->UniqueId->UniqueIdLength;
    }
    else
    {
        MountPoints->MountPoints[0].UniqueIdOffset = 0;
        MountPoints->MountPoints[0].UniqueIdLength = 0;
    }
 
    MountPoints->MountPoints[0].DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINTS) +
                                                   SymlinkInformation->Name.Length +
                                                   DeviceInformation->UniqueId->UniqueIdLength;
    MountPoints->MountPoints[0].DeviceNameLength = DeviceInformation->DeviceName.Length;
 
    RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[0].SymbolicLinkNameOffset),
                  SymlinkInformation->Name.Buffer, SymlinkInformation->Name.Length);
 
    if (SymlinkInformation->Online)
    {
        RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[0].UniqueIdOffset),
                      DeviceInformation->UniqueId->UniqueId, DeviceInformation->UniqueId->UniqueIdLength);
    }
 
    RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[0].DeviceNameOffset),
                  DeviceInformation->DeviceName.Buffer, DeviceInformation->DeviceName.Length);
 
    return STATUS_SUCCESS;
}

Referenced by MountMgrQueryPoints().

QuerySuggestedLinkName()

NTSTATUS QuerySuggestedLinkName	(	IN PUNICODE_STRING	SymbolicName,
		OUT PUNICODE_STRING	SuggestedLinkName,
		OUT PBOOLEAN	UseOnlyIfThereAreNoOtherLinks
	)

Definition at line 621 of file symlink.c.

{
    NTSTATUS Status;
    USHORT NameLength;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    PMOUNTDEV_SUGGESTED_LINK_NAME IoCtlSuggested;
 
    /* First, get device */
    Status = IoGetDeviceObjectPointer(SymbolicName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Then, get attached device */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    /* Then, prepare buffer to query suggested name */
    IoCtlSuggested = AllocatePool(sizeof(MOUNTDEV_SUGGESTED_LINK_NAME));
    if (!IoCtlSuggested)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Dereference;
    }
 
    /* Prepare request */
    Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME,
                                         DeviceObject,
                                         NULL,
                                         0,
                                         IoCtlSuggested,
                                         sizeof(MOUNTDEV_SUGGESTED_LINK_NAME),
                                         FileObject);
    /* Retry with appropriate length */
    if (Status == STATUS_BUFFER_OVERFLOW)
    {
        /* Reallocate big enough buffer */
        NameLength = IoCtlSuggested->NameLength + sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
        FreePool(IoCtlSuggested);
 
        IoCtlSuggested = AllocatePool(NameLength);
        if (!IoCtlSuggested)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto Dereference;
        }
 
        /* And re-ask */
        Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME,
                                             DeviceObject,
                                             NULL,
                                             0,
                                             IoCtlSuggested,
                                             NameLength,
                                             FileObject);
    }
    if (!NT_SUCCESS(Status))
        goto Release;
 
    /* Now we have suggested name, copy it */
    SuggestedLinkName->Length = IoCtlSuggested->NameLength;
    SuggestedLinkName->MaximumLength = IoCtlSuggested->NameLength + sizeof(UNICODE_NULL);
    SuggestedLinkName->Buffer = AllocatePool(IoCtlSuggested->NameLength + sizeof(UNICODE_NULL));
    if (!SuggestedLinkName->Buffer)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        RtlCopyMemory(SuggestedLinkName->Buffer, IoCtlSuggested->Name, IoCtlSuggested->NameLength);
        SuggestedLinkName->Buffer[SuggestedLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
 
    /* Also return its priority */
    *UseOnlyIfThereAreNoOtherLinks = IoCtlSuggested->UseOnlyIfThereAreNoOtherLinks;
 
Release:
    FreePool(IoCtlSuggested);
 
Dereference:
    ObDereferenceObject(DeviceObject);
    ObDereferenceObject(FileObject);
 
    return Status;
}

Referenced by MountMgrMountedDeviceArrival().

QuerySymbolicLinkNamesFromStorage()

NTSTATUS QuerySymbolicLinkNamesFromStorage	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PDEVICE_INFORMATION	DeviceInformation,
		IN PUNICODE_STRING	SuggestedLinkName,
		IN BOOLEAN	UseOnlyIfThereAreNoOtherLinks,
		OUT PUNICODE_STRING *	SymLinks,
		OUT PULONG	SymLinkCount,
		IN BOOLEAN	HasGuid,
		IN LPGUID	Guid
	)

Definition at line 451 of file symlink.c.

{
    NTSTATUS Status;
    BOOLEAN WriteNew;
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    /* First of all, count links */
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdCount;
    QueryTable[0].EntryContext = SymLinkCount;
    *SymLinkCount = 0;
 
    Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                    DatabasePath,
                                    QueryTable,
                                    DeviceInformation->UniqueId,
                                    NULL);
    if (!NT_SUCCESS(Status))
    {
        *SymLinkCount = 0;
    }
 
    /* Check if we have to write a new one first */
    if (SuggestedLinkName && !IsDriveLetter(SuggestedLinkName) &&
        UseOnlyIfThereAreNoOtherLinks && *SymLinkCount == 0)
    {
        WriteNew = TRUE;
    }
    else
    {
        WriteNew = FALSE;
    }
 
    /* If has GUID, it makes one more link */
    if (HasGuid)
    {
        (*SymLinkCount)++;
    }
 
    if (WriteNew)
    {
        /* Write link */
        RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                              DatabasePath,
                              SuggestedLinkName->Buffer,
                              REG_BINARY,
                              DeviceInformation->UniqueId->UniqueId,
                              DeviceInformation->UniqueId->UniqueIdLength);
 
        /* And recount all the needed links */
        RtlZeroMemory(QueryTable, sizeof(QueryTable));
        QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdCount;
        QueryTable[0].EntryContext = SymLinkCount;
        *SymLinkCount = 0;
 
        Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                        DatabasePath,
                                        QueryTable,
                                        DeviceInformation->UniqueId,
                                        NULL);
        if (!NT_SUCCESS(Status))
        {
            return STATUS_NOT_FOUND;
        }
    }
 
    /* Not links found? */
    if (!*SymLinkCount)
    {
        return STATUS_NOT_FOUND;
    }
 
    /* Allocate a buffer big enough to hold symlinks (table of unicode strings) */
    *SymLinks = AllocatePool(*SymLinkCount * sizeof(UNICODE_STRING));
    if (!*SymLinks)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Prepare to query links */
    RtlZeroMemory(*SymLinks, *SymLinkCount * sizeof(UNICODE_STRING));
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdQuery;
 
    /* No GUID? Keep it that way */
    if (!HasGuid)
    {
        QueryTable[0].EntryContext = *SymLinks;
    }
    /* Otherwise, first create volume name */
    else
    {
        Status = CreateNewVolumeName(SymLinks[0], Guid);
        if (!NT_SUCCESS(Status))
        {
            FreePool(*SymLinks);
            return Status;
        }
 
        /* Skip first link (ours) */
        QueryTable[0].EntryContext = *SymLinks + 1;
    }
 
    /* Now, query */
    RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                           DatabasePath,
                           QueryTable,
                           DeviceInformation->UniqueId,
                           NULL);
 
    return STATUS_SUCCESS;
}

Referenced by MountMgrMountedDeviceArrival().

QueryVolumeName()

NTSTATUS QueryVolumeName	(	IN HANDLE	RootDirectory,
		IN PFILE_REPARSE_POINT_INFORMATION	ReparsePointInformation,
		IN PUNICODE_STRING FileName	OPTIONAL,
		OUT PUNICODE_STRING	SymbolicName,
		OUT PUNICODE_STRING	VolumeName
	)

Definition at line 1292 of file database.c.

{
    HANDLE Handle;
    NTSTATUS Status;
    ULONG NeededLength;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PFILE_NAME_INFORMATION FileNameInfo;
    PREPARSE_DATA_BUFFER ReparseDataBuffer;
 
    if (!FileName)
    {
        UNICODE_STRING Reference;
 
        Reference.Length = Reference.MaximumLength = sizeof(ReparsePointInformation->FileReference);
        Reference.Buffer = (PWSTR)&(ReparsePointInformation->FileReference);
        InitializeObjectAttributes(&ObjectAttributes,
                                   &Reference,
                                   OBJ_KERNEL_HANDLE,
                                   RootDirectory,
                                   NULL);
    }
    else
    {
        InitializeObjectAttributes(&ObjectAttributes,
                                   FileName,
                                   OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
    }
 
    /* Open volume */
    Status = ZwOpenFile(&Handle,
                        SYNCHRONIZE | FILE_READ_ATTRIBUTES,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                        (FileName) ? FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT :
                                     FILE_OPEN_BY_FILE_ID | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Get the reparse point data */
    ReparseDataBuffer = AllocatePool(MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
    if (!ReparseDataBuffer)
    {
        ZwClose(Handle);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = ZwFsControlFile(Handle,
                             0,
                             NULL,
                             NULL,
                             &IoStatusBlock,
                             FSCTL_GET_REPARSE_POINT,
                             NULL,
                             0,
                             ReparseDataBuffer,
                             MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
    if (!NT_SUCCESS(Status))
    {
        FreePool(ReparseDataBuffer);
        ZwClose(Handle);
        return Status;
    }
 
    /* Check that name can fit in buffer */
    if (ReparseDataBuffer->MountPointReparseBuffer.SubstituteNameLength + sizeof(UNICODE_NULL) > SymbolicName->MaximumLength)
    {
        FreePool(ReparseDataBuffer);
        ZwClose(Handle);
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    /* Copy symbolic name */
    SymbolicName->Length = ReparseDataBuffer->MountPointReparseBuffer.SubstituteNameLength;
    RtlCopyMemory(SymbolicName->Buffer,
                  (PWSTR)((ULONG_PTR)ReparseDataBuffer->MountPointReparseBuffer.PathBuffer +
                                     ReparseDataBuffer->MountPointReparseBuffer.SubstituteNameOffset),
                  ReparseDataBuffer->MountPointReparseBuffer.SubstituteNameLength);
 
    FreePool(ReparseDataBuffer);
 
    /* Name has to \ terminated */
    if (SymbolicName->Buffer[SymbolicName->Length / sizeof(WCHAR) - 1] != L'\\')
    {
        ZwClose(Handle);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* So that we can delete it, and match mountmgr requirements */
    SymbolicName->Length -= sizeof(WCHAR);
    SymbolicName->Buffer[SymbolicName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    /* Also ensure it's really a volume name... */
    if (!MOUNTMGR_IS_VOLUME_NAME(SymbolicName))
    {
        ZwClose(Handle);
        return STATUS_INVALID_PARAMETER;
    }
 
    /* Now prepare to really get the name */
    FileNameInfo = AllocatePool(sizeof(FILE_NAME_INFORMATION) + 2 * sizeof(WCHAR));
    if (!FileNameInfo)
    {
        ZwClose(Handle);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = ZwQueryInformationFile(Handle,
                                    &IoStatusBlock,
                                    FileNameInfo,
                                    sizeof(FILE_NAME_INFORMATION) + 2 * sizeof(WCHAR),
                                    FileNameInformation);
    if (Status == STATUS_BUFFER_OVERFLOW)
    {
        /* As expected... Reallocate with proper size */
        NeededLength = FileNameInfo->FileNameLength;
        FreePool(FileNameInfo);
 
        FileNameInfo = AllocatePool(sizeof(FILE_NAME_INFORMATION) + NeededLength);
        if (!FileNameInfo)
        {
            ZwClose(Handle);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* And query name */
        Status = ZwQueryInformationFile(Handle,
                                        &IoStatusBlock,
                                        FileNameInfo,
                                        sizeof(FILE_NAME_INFORMATION) + NeededLength,
                                        FileNameInformation);
    }
 
    ZwClose(Handle);
 
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Return the volume name */
    VolumeName->Length = (USHORT)FileNameInfo->FileNameLength;
    VolumeName->MaximumLength = (USHORT)FileNameInfo->FileNameLength + sizeof(WCHAR);
    VolumeName->Buffer = AllocatePool(VolumeName->MaximumLength);
    if (!VolumeName->Buffer)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyMemory(VolumeName->Buffer, FileNameInfo->FileName, FileNameInfo->FileNameLength);
    VolumeName->Buffer[FileNameInfo->FileNameLength / sizeof(WCHAR)] = UNICODE_NULL;
 
    FreePool(FileNameInfo);
 
    return STATUS_SUCCESS;
}

Referenced by MountMgrVolumeMountPointCreated(), MountMgrVolumeMountPointDeleted(), OnlineMountedVolumes(), and ReconcileThisDatabaseWithMasterWorker().

ReconcileAllDatabasesWithMaster()

VOID ReconcileAllDatabasesWithMaster

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 1661 of file database.c.

{
    PLIST_ENTRY NextEntry;
    PDEVICE_INFORMATION DeviceInformation;
 
    /* Browse all the devices */
    for (NextEntry = DeviceExtension->DeviceListHead.Flink;
         NextEntry != &(DeviceExtension->DeviceListHead);
         NextEntry = NextEntry->Flink)
    {
        DeviceInformation = CONTAINING_RECORD(NextEntry,
                                              DEVICE_INFORMATION,
                                              DeviceListEntry);
        /* If it's not removable, then, it might have a database to sync */
        if (!DeviceInformation->Removable)
        {
            ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInformation);
        }
    }
}

Referenced by MountMgrDeviceControl().

ReconcileThisDatabaseWithMaster()

VOID ReconcileThisDatabaseWithMaster	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PDEVICE_INFORMATION	DeviceInformation
	)

Definition at line 1615 of file database.c.

{
    PRECONCILE_WORK_ITEM WorkItem;
 
    /* Removable devices don't have remote database */
    if (DeviceInformation->Removable)
    {
        return;
    }
 
    /* Allocate a work item */
    WorkItem = AllocatePool(sizeof(RECONCILE_WORK_ITEM));
    if (!WorkItem)
    {
        return;
    }
 
    WorkItem->WorkItem = IoAllocateWorkItem(DeviceExtension->DeviceObject);
    if (!WorkItem->WorkItem)
    {
        FreePool(WorkItem);
        return;
    }
 
    /* And queue it */
    WorkItem->WorkerRoutine = ReconcileThisDatabaseWithMasterWorker;
    WorkItem->DeviceExtension = DeviceExtension;
    WorkItem->DeviceInformation = DeviceInformation;
    QueueWorkItem(DeviceExtension, WorkItem, &(WorkItem->DeviceExtension));
 
    /* If the worker thread isn't started yet, automatic drive letter is
     * enabled but automount disabled, manually set mounted volumes online.
     * Otherwise, they will be set online during database reconciliation. */
    if (DeviceExtension->WorkerThreadStatus == 0 &&
        DeviceExtension->AutomaticDriveLetter &&
        DeviceExtension->NoAutoMount)
    {
        OnlineMountedVolumes(DeviceExtension, DeviceInformation);
    }
}

Referenced by MountMgrCreatePointWorker(), MountMgrMountedDeviceArrival(), MountMgrTargetDeviceNotification(), MountMgrUniqueIdChangeRoutine(), MountMgrVolumeMountPointChanged(), and ReconcileAllDatabasesWithMaster().

ReconcileThisDatabaseWithMasterWorker()

VOID NTAPI ReconcileThisDatabaseWithMasterWorker

(

IN PVOID

Parameter

)

Definition at line 560 of file database.c.

{
    ULONG Offset;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
    PMOUNTDEV_UNIQUE_ID UniqueId;
    PDATABASE_ENTRY DatabaseEntry;
    HANDLE DatabaseHandle, Handle;
    IO_STATUS_BLOCK IoStatusBlock;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PDEVICE_INFORMATION ListDeviceInfo;
    PLIST_ENTRY Entry, EntryInfo, NextEntry;
    PASSOCIATED_DEVICE_ENTRY AssociatedDevice;
    BOOLEAN HardwareErrors, Restart, FailedFinding;
    WCHAR FileNameBuffer[0x8], SymbolicNameBuffer[100];
    UNICODE_STRING ReparseFile, FileName, SymbolicName, VolumeName;
    FILE_REPARSE_POINT_INFORMATION ReparsePointInformation, SavedReparsePointInformation;
    PDEVICE_EXTENSION DeviceExtension = ((PRECONCILE_WORK_ITEM_CONTEXT)Parameter)->DeviceExtension;
    PDEVICE_INFORMATION DeviceInformation = ((PRECONCILE_WORK_ITEM_CONTEXT)Parameter)->DeviceInformation;
 
    /* We're unloading, do nothing */
    if (Unloading)
    {
        return;
    }
 
    /* Lock remote DB */
    if (!NT_SUCCESS(WaitForRemoteDatabaseSemaphore(DeviceExtension)))
    {
        return;
    }
 
    /* Recheck for unloading */
    if (Unloading)
    {
        goto ReleaseRDS;
    }
 
    /* Find the DB to reconcile */
    KeWaitForSingleObject(&DeviceExtension->DeviceLock, Executive, KernelMode, FALSE, NULL);
    for (Entry = DeviceExtension->DeviceListHead.Flink;
         Entry != &DeviceExtension->DeviceListHead;
         Entry = Entry->Flink)
    {
        ListDeviceInfo = CONTAINING_RECORD(Entry, DEVICE_INFORMATION, DeviceListEntry);
        if (ListDeviceInfo == DeviceInformation)
        {
            break;
        }
    }
 
    /* If not found, or if removable, bail out */
    if (Entry == &DeviceExtension->DeviceListHead || DeviceInformation->Removable)
    {
        KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
        goto ReleaseRDS;
    }
 
    /* Get our device object */
    Status = IoGetDeviceObjectPointer(&ListDeviceInfo->DeviceName, FILE_READ_ATTRIBUTES, &FileObject, &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
        goto ReleaseRDS;
    }
 
    /* Mark mounted only if not unloading */
    if (!(DeviceObject->Flags & DO_UNLOAD_PENDING))
    {
        InterlockedExchangeAdd(&ListDeviceInfo->MountState, 1);
    }
 
    ObDereferenceObject(FileObject);
 
    /* Force default: no DB, and need for reconcile */
    DeviceInformation->NeedsReconcile = TRUE;
    DeviceInformation->NoDatabase = TRUE;
    FailedFinding = FALSE;
 
    /* Remove any associated device that refers to the DB to reconcile */
    for (Entry = DeviceExtension->DeviceListHead.Flink;
         Entry != &DeviceExtension->DeviceListHead;
         Entry = Entry->Flink)
    {
        ListDeviceInfo = CONTAINING_RECORD(Entry, DEVICE_INFORMATION, DeviceListEntry);
 
        EntryInfo = ListDeviceInfo->AssociatedDevicesHead.Flink;
        while (EntryInfo != &ListDeviceInfo->AssociatedDevicesHead)
        {
            AssociatedDevice = CONTAINING_RECORD(EntryInfo, ASSOCIATED_DEVICE_ENTRY, AssociatedDevicesEntry);
            NextEntry = EntryInfo->Flink;
 
            if (AssociatedDevice->DeviceInformation == DeviceInformation)
            {
                RemoveEntryList(&AssociatedDevice->AssociatedDevicesEntry);
                FreePool(AssociatedDevice->String.Buffer);
                FreePool(AssociatedDevice);
            }
 
            EntryInfo = NextEntry;
        }
    }
 
    /* Open the remote database */
    DatabaseHandle = OpenRemoteDatabase(DeviceInformation, FALSE);
 
    /* Prepare a string with reparse point index */
    ReparseFile.Length = 0;
    ReparseFile.MaximumLength = DeviceInformation->DeviceName.Length
                                + ReparseIndex.Length
                                + sizeof(UNICODE_NULL);
    ReparseFile.Buffer = AllocatePool(ReparseFile.MaximumLength);
    if (!ReparseFile.Buffer)
    {
        if (DatabaseHandle != 0)
        {
            CloseRemoteDatabase(DatabaseHandle);
        }
        KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
        goto ReleaseRDS;
    }
 
    RtlAppendUnicodeStringToString(&ReparseFile, &DeviceInformation->DeviceName);
    RtlAppendUnicodeStringToString(&ReparseFile, &ReparseIndex);
    ReparseFile.Buffer[ReparseFile.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &ReparseFile,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    /* Open reparse point directory */
    HardwareErrors = IoSetThreadHardErrorMode(FALSE);
    Status = ZwOpenFile(&Handle,
                        FILE_GENERIC_READ,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_SYNCHRONOUS_IO_ALERT);
    IoSetThreadHardErrorMode(HardwareErrors);
 
    FreePool(ReparseFile.Buffer);
 
    if (!NT_SUCCESS(Status))
    {
        if (DatabaseHandle != 0)
        {
            TruncateRemoteDatabase(DatabaseHandle, 0);
            CloseRemoteDatabase(DatabaseHandle);
        }
        KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
        goto ReleaseRDS;
    }
 
    /* Query reparse point information
     * We only pay attention to mout point
     */
    RtlZeroMemory(FileNameBuffer, sizeof(FileNameBuffer));
    FileName.Buffer = FileNameBuffer;
    FileName.Length = sizeof(FileNameBuffer);
    FileName.MaximumLength = sizeof(FileNameBuffer);
    ((PULONG)FileNameBuffer)[0] = IO_REPARSE_TAG_MOUNT_POINT;
    Status = ZwQueryDirectoryFile(Handle,
                                  NULL,
                                  NULL,
                                  NULL,
                                  &IoStatusBlock,
                                  &ReparsePointInformation,
                                  sizeof(FILE_REPARSE_POINT_INFORMATION),
                                  FileReparsePointInformation,
                                  TRUE,
                                  &FileName,
                                  FALSE);
    if (!NT_SUCCESS(Status))
    {
        ZwClose(Handle);
        if (DatabaseHandle != 0)
        {
            TruncateRemoteDatabase(DatabaseHandle, 0);
            CloseRemoteDatabase(DatabaseHandle);
        }
        KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
        goto ReleaseRDS;
    }
 
    /* If we failed to open the remote DB previously,
     * retry this time allowing migration (and thus, creation if required)
     */
    if (DatabaseHandle == 0)
    {
        DatabaseHandle = OpenRemoteDatabase(DeviceInformation, TRUE);
        if (DatabaseHandle == 0)
        {
            KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
            goto ReleaseRDS;
        }
    }
 
    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
 
    /* Reset all the references to our DB entries */
    Offset = 0;
    for (;;)
    {
        DatabaseEntry = GetRemoteDatabaseEntry(DatabaseHandle, Offset);
        if (DatabaseEntry == NULL)
        {
            break;
        }
 
        DatabaseEntry->EntryReferences = 0;
        Status = WriteRemoteDatabaseEntry(DatabaseHandle, Offset, DatabaseEntry);
        if (!NT_SUCCESS(Status))
        {
            FreePool(DatabaseEntry);
            goto CloseReparse;
        }
 
        Offset += DatabaseEntry->EntrySize;
        FreePool(DatabaseEntry);
    }
 
    /* Init string for QueryVolumeName call */
    SymbolicName.MaximumLength = sizeof(SymbolicNameBuffer);
    SymbolicName.Length = 0;
    SymbolicName.Buffer = SymbolicNameBuffer;
    Restart = TRUE;
 
    /* Start looping on reparse points */
    for (;;)
    {
        RtlCopyMemory(&SavedReparsePointInformation, &ReparsePointInformation, sizeof(FILE_REPARSE_POINT_INFORMATION));
        Status = ZwQueryDirectoryFile(Handle,
                                      NULL,
                                      NULL,
                                      NULL,
                                      &IoStatusBlock,
                                      &ReparsePointInformation,
                                      sizeof(FILE_REPARSE_POINT_INFORMATION),
                                      FileReparsePointInformation,
                                      TRUE,
                                      Restart ? &FileName : NULL,
                                      Restart);
        /* Restart only once */
        if (Restart)
        {
            Restart = FALSE;
        }
        else
        {
            /* If we get the same one, we're done, bail out */
            if (ReparsePointInformation.FileReference == SavedReparsePointInformation.FileReference &&
                ReparsePointInformation.Tag == SavedReparsePointInformation.Tag)
            {
                break;
            }
        }
 
        /* If querying failed, or if onloading, or if not returning mount points, bail out */
        if (!NT_SUCCESS(Status) || Unloading || ReparsePointInformation.Tag != IO_REPARSE_TAG_MOUNT_POINT)
        {
            break;
        }
 
        /* Get the volume name associated to the mount point */
        Status = QueryVolumeName(Handle, &ReparsePointInformation, 0, &SymbolicName, &VolumeName);
        if (!NT_SUCCESS(Status))
        {
            continue;
        }
 
        /* Browse the DB to find the name */
        Offset = 0;
        for (;;)
        {
            UNICODE_STRING DbName;
 
            DatabaseEntry = GetRemoteDatabaseEntry(DatabaseHandle, Offset);
            if (DatabaseEntry == NULL)
            {
                break;
            }
 
            DbName.MaximumLength = DatabaseEntry->SymbolicNameLength;
            DbName.Length = DbName.MaximumLength;
            DbName.Buffer = (PWSTR)((ULONG_PTR)DatabaseEntry + DatabaseEntry->SymbolicNameOffset);
            /* Found, we're done! */
            if (RtlEqualUnicodeString(&DbName, &SymbolicName, TRUE))
            {
                break;
            }
 
            Offset += DatabaseEntry->EntrySize;
            FreePool(DatabaseEntry);
        }
 
        /* If we found the mount point.... */
        if (DatabaseEntry != NULL)
        {
            /* If it was referenced, reference it once more and update to remote */
            if (DatabaseEntry->EntryReferences)
            {
                ++DatabaseEntry->EntryReferences;
                Status = WriteRemoteDatabaseEntry(DatabaseHandle, Offset, DatabaseEntry);
                if (!NT_SUCCESS(Status))
                {
                    goto FreeDBEntry;
                }
 
                FreePool(DatabaseEntry);
            }
            else
            {
                /* Query the Unique ID associated to that mount point in case it changed */
                KeWaitForSingleObject(&DeviceExtension->DeviceLock, Executive, KernelMode, FALSE, NULL);
                Status = QueryUniqueIdFromMaster(DeviceExtension, &SymbolicName, &UniqueId);
                if (!NT_SUCCESS(Status))
                {
                    /* If we failed doing so, reuse the old Unique ID and push it to master */
                    Status = WriteUniqueIdToMaster(DeviceExtension, DatabaseEntry);
                    if (!NT_SUCCESS(Status))
                    {
                        goto ReleaseDeviceLock;
                    }
 
                    /* And then, reference & write the entry */
                    ++DatabaseEntry->EntryReferences;
                    Status = WriteRemoteDatabaseEntry(DatabaseHandle, Offset, DatabaseEntry);
                    if (!NT_SUCCESS(Status))
                    {
                        goto ReleaseDeviceLock;
                    }
 
                    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
                    FreePool(DatabaseEntry);
                }
                /* If the Unique ID didn't change */
                else if (UniqueId->UniqueIdLength == DatabaseEntry->UniqueIdLength &&
                         RtlCompareMemory(UniqueId->UniqueId,
                                          (PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->UniqueIdOffset),
                                          UniqueId->UniqueIdLength) == UniqueId->UniqueIdLength)
                {
                    /* Reference the entry, and update to remote */
                    ++DatabaseEntry->EntryReferences;
                    Status = WriteRemoteDatabaseEntry(DatabaseHandle, Offset, DatabaseEntry);
                    if (!NT_SUCCESS(Status))
                    {
                        goto FreeUniqueId;
                    }
 
                    FreePool(UniqueId);
                    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
                    FreePool(DatabaseEntry);
                }
                /* Would, by chance, the Unique ID be present elsewhere? */
                else if (IsUniqueIdPresent(DeviceExtension, DatabaseEntry))
                {
                    /* Push the ID to master */
                    Status = WriteUniqueIdToMaster(DeviceExtension, DatabaseEntry);
                    if (!NT_SUCCESS(Status))
                    {
                        goto FreeUniqueId;
                    }
 
                    /* And then, reference & write the entry */
                    ++DatabaseEntry->EntryReferences;
                    Status = WriteRemoteDatabaseEntry(DatabaseHandle, Offset, DatabaseEntry);
                    if (!NT_SUCCESS(Status))
                    {
                        goto FreeUniqueId;
                    }
 
                    FreePool(UniqueId);
                    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
                    FreePool(DatabaseEntry);
                }
                else
                {
                    /* OK, at that point, we're facing a totally unknown unique ID
                     * So, get rid of the old entry, and recreate a new one with
                     * the know unique ID
                     */
                    Status = DeleteRemoteDatabaseEntry(DatabaseHandle, Offset);
                    if (!NT_SUCCESS(Status))
                    {
                        goto FreeUniqueId;
                    }
 
                    FreePool(DatabaseEntry);
                    /* Allocate a new entry big enough */
                    DatabaseEntry = AllocatePool(UniqueId->UniqueIdLength + SymbolicName.Length + sizeof(DATABASE_ENTRY));
                    if (DatabaseEntry == NULL)
                    {
                       goto FreeUniqueId;
                    }
 
                    /* Configure it */
                    DatabaseEntry->EntrySize = UniqueId->UniqueIdLength + SymbolicName.Length + sizeof(DATABASE_ENTRY);
                    DatabaseEntry->EntryReferences = 1;
                    DatabaseEntry->SymbolicNameOffset = sizeof(DATABASE_ENTRY);
                    DatabaseEntry->SymbolicNameLength = SymbolicName.Length;
                    DatabaseEntry->UniqueIdOffset = SymbolicName.Length + sizeof(DATABASE_ENTRY);
                    DatabaseEntry->UniqueIdLength = UniqueId->UniqueIdLength;
                    RtlCopyMemory((PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->SymbolicNameOffset), SymbolicName.Buffer, DatabaseEntry->SymbolicNameLength);
                    RtlCopyMemory((PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->UniqueIdOffset), UniqueId->UniqueId, UniqueId->UniqueIdLength);
 
                    /* And write it remotely */
                    Status = AddRemoteDatabaseEntry(DatabaseHandle, DatabaseEntry);
                    if (!NT_SUCCESS(Status))
                    {
                       FreePool(DatabaseEntry);
                       goto FreeUniqueId;
                    }
 
                    FreePool(UniqueId);
                    FreePool(DatabaseEntry);
                    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
                }
            }
        }
        else
        {
            /* We failed finding it remotely
             * So, let's allocate a new remote DB entry
             */
            KeWaitForSingleObject(&DeviceExtension->DeviceLock, Executive, KernelMode, FALSE, NULL);
            /* To be able to do so, we need the device Unique ID, ask master */
            Status = QueryUniqueIdFromMaster(DeviceExtension, &SymbolicName, &UniqueId);
            KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
            if (NT_SUCCESS(Status))
            {
                /* Allocate a new entry big enough */
                DatabaseEntry = AllocatePool(UniqueId->UniqueIdLength + SymbolicName.Length + sizeof(DATABASE_ENTRY));
                if (DatabaseEntry != NULL)
                {
                    /* Configure it */
                    DatabaseEntry->EntrySize = UniqueId->UniqueIdLength + SymbolicName.Length + sizeof(DATABASE_ENTRY);
                    DatabaseEntry->EntryReferences = 1;
                    DatabaseEntry->SymbolicNameOffset = sizeof(DATABASE_ENTRY);
                    DatabaseEntry->SymbolicNameLength = SymbolicName.Length;
                    DatabaseEntry->UniqueIdOffset = SymbolicName.Length + sizeof(DATABASE_ENTRY);
                    DatabaseEntry->UniqueIdLength = UniqueId->UniqueIdLength;
                    RtlCopyMemory((PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->SymbolicNameOffset), SymbolicName.Buffer, DatabaseEntry->SymbolicNameLength);
                    RtlCopyMemory((PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->UniqueIdOffset), UniqueId->UniqueId, UniqueId->UniqueIdLength);
 
                    /* And write it remotely */
                    Status = AddRemoteDatabaseEntry(DatabaseHandle, DatabaseEntry);
                    FreePool(DatabaseEntry);
                    FreePool(UniqueId);
 
                    if (!NT_SUCCESS(Status))
                    {
                        goto FreeVolume;
                    }
                }
                else
                {
                    FreePool(UniqueId);
                }
            }
        }
 
        /* Find info about the device associated associated with the mount point */
        KeWaitForSingleObject(&DeviceExtension->DeviceLock, Executive, KernelMode, FALSE, NULL);
        Status = FindDeviceInfo(DeviceExtension, &SymbolicName, FALSE, &ListDeviceInfo);
        if (!NT_SUCCESS(Status))
        {
            FailedFinding = TRUE;
            FreePool(VolumeName.Buffer);
        }
        else
        {
            /* Associate the device with the currrent DB */
            AssociatedDevice = AllocatePool(sizeof(ASSOCIATED_DEVICE_ENTRY));
            if (AssociatedDevice == NULL)
            {
                FreePool(VolumeName.Buffer);
            }
            else
            {
                AssociatedDevice->DeviceInformation = DeviceInformation;
                AssociatedDevice->String.Length = VolumeName.Length;
                AssociatedDevice->String.MaximumLength = VolumeName.MaximumLength;
                AssociatedDevice->String.Buffer = VolumeName.Buffer;
                InsertTailList(&ListDeviceInfo->AssociatedDevicesHead, &AssociatedDevice->AssociatedDevicesEntry);
            }
 
            /* If we don't have to skip notifications, notify */
            if (!ListDeviceInfo->SkipNotifications)
            {
                PostOnlineNotification(DeviceExtension, &ListDeviceInfo->SymbolicName);
            }
        }
 
        KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
    }
 
    /* We don't need mount points any longer */
    ZwClose(Handle);
 
    /* Look for the DB again */
    KeWaitForSingleObject(&DeviceExtension->DeviceLock, Executive, KernelMode, FALSE, NULL);
    for (Entry = DeviceExtension->DeviceListHead.Flink;
         Entry != &DeviceExtension->DeviceListHead;
         Entry = Entry->Flink)
    {
        ListDeviceInfo = CONTAINING_RECORD(Entry, DEVICE_INFORMATION, DeviceListEntry);
        if (ListDeviceInfo == DeviceInformation)
        {
            break;
        }
    }
 
    if (Entry == &DeviceExtension->DeviceListHead)
    {
        ListDeviceInfo = NULL;
    }
 
    /* Start the pruning loop */
    Offset = 0;
    for (;;)
    {
        /* Get the entry */
        DatabaseEntry = GetRemoteDatabaseEntry(DatabaseHandle, Offset);
        if (DatabaseEntry == NULL)
        {
            break;
        }
 
        /* It's not referenced anylonger? Prune it */
        if (DatabaseEntry->EntryReferences == 0)
        {
            Status = DeleteRemoteDatabaseEntry(DatabaseHandle, Offset);
            if (!NT_SUCCESS(Status))
            {
                FreePool(DatabaseEntry);
                KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
                goto CloseRDB;
            }
        }
        /* Update the Unique IDs to reflect the changes we might have done previously */
        else
        {
            if (ListDeviceInfo != NULL)
            {
                UpdateReplicatedUniqueIds(ListDeviceInfo, DatabaseEntry);
            }
 
            Offset += DatabaseEntry->EntrySize;
        }
 
        FreePool(DatabaseEntry);
    }
 
    /* We do have a DB now :-) */
    if (ListDeviceInfo != NULL && !FailedFinding)
    {
        DeviceInformation->NoDatabase = FALSE;
    }
 
    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
 
    goto CloseRDB;
 
FreeUniqueId:
    FreePool(UniqueId);
ReleaseDeviceLock:
    KeReleaseSemaphore(&DeviceExtension->DeviceLock, IO_NO_INCREMENT, 1, FALSE);
FreeDBEntry:
    FreePool(DatabaseEntry);
FreeVolume:
    FreePool(VolumeName.Buffer);
CloseReparse:
    ZwClose(Handle);
CloseRDB:
    CloseRemoteDatabase(DatabaseHandle);
ReleaseRDS:
    ReleaseRemoteDatabaseSemaphore(DeviceExtension);
    return;
}

Referenced by MountMgrQueryDosVolumePaths(), and ReconcileThisDatabaseWithMaster().

RedirectSavedLink()

BOOLEAN RedirectSavedLink	(	IN PSAVED_LINK_INFORMATION	SavedLinkInformation,
		IN PUNICODE_STRING	DosName,
		IN PUNICODE_STRING	NewLink
	)

Definition at line 717 of file symlink.c.

{
    PLIST_ENTRY NextEntry;
    PSYMLINK_INFORMATION SymlinkInformation;
 
    /* Find the link */
    for (NextEntry = SavedLinkInformation->SymbolicLinksListHead.Flink;
         NextEntry != &(SavedLinkInformation->SymbolicLinksListHead);
         NextEntry = NextEntry->Flink)
    {
        SymlinkInformation = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 
        if (!RtlEqualUnicodeString(DosName, &(SymlinkInformation->Name), TRUE))
        {
            /* Delete old link */
            GlobalDeleteSymbolicLink(DosName);
            /* Set its new location */
            GlobalCreateSymbolicLink(DosName, NewLink);
 
            /* And remove it from the list (not valid any more) */
            RemoveEntryList(&(SymlinkInformation->SymbolicLinksListEntry));
            FreePool(SymlinkInformation->Name.Buffer);
            FreePool(SymlinkInformation);
 
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by MountMgrMountedDeviceArrival().

RegisterForTargetDeviceNotification()

VOID RegisterForTargetDeviceNotification	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PDEVICE_INFORMATION	DeviceInformation
	)

Definition at line 250 of file notify.c.

{
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
 
    /* Get device object */
    Status = IoGetDeviceObjectPointer(&(DeviceInformation->DeviceName),
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return;
    }
 
    /* And simply register for notifications */
    Status = IoRegisterPlugPlayNotification(EventCategoryTargetDeviceChange,
                                            0, FileObject,
                                            DeviceExtension->DriverObject,
                                            MountMgrTargetDeviceNotification,
                                            DeviceInformation,
                                            &(DeviceInformation->TargetDeviceNotificationEntry));
    if (!NT_SUCCESS(Status))
    {
        DeviceInformation->TargetDeviceNotificationEntry = NULL;
    }
 
    ObDereferenceObject(FileObject);
 
    return;
}

Referenced by MountMgrMountedDeviceArrival().

ReleaseRemoteDatabaseSemaphore()

VOID ReleaseRemoteDatabaseSemaphore

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 391 of file database.c.

{
    KeReleaseSemaphore(&(DeviceExtension->RemoteDatabaseLock), IO_NO_INCREMENT, 1, FALSE);
}

Referenced by MountMgrDeviceControl(), MountMgrUniqueIdChangeRoutine(), and ReconcileThisDatabaseWithMasterWorker().

RemoveSavedLinks()

PSAVED_LINK_INFORMATION RemoveSavedLinks	(	IN PDEVICE_EXTENSION	DeviceExtension,
		IN PMOUNTDEV_UNIQUE_ID	UniqueId
	)

Definition at line 577 of file symlink.c.

{
    PLIST_ENTRY NextEntry;
    PSAVED_LINK_INFORMATION SavedLinkInformation;
 
    /* No saved links? Easy! */
    if (IsListEmpty(&(DeviceExtension->SavedLinksListHead)))
    {
        return NULL;
    }
 
    /* Now, browse saved links */
    for (NextEntry = DeviceExtension->SavedLinksListHead.Flink;
         NextEntry != &(DeviceExtension->SavedLinksListHead);
         NextEntry = NextEntry->Flink)
    {
        SavedLinkInformation = CONTAINING_RECORD(NextEntry,
                                                 SAVED_LINK_INFORMATION,
                                                 SavedLinksListEntry);
 
        /* Find the one that matches */
        if (SavedLinkInformation->UniqueId->UniqueIdLength == UniqueId->UniqueIdLength)
        {
            if (RtlCompareMemory(SavedLinkInformation->UniqueId->UniqueId,
                                 UniqueId->UniqueId,
                                 UniqueId->UniqueIdLength) ==
                UniqueId->UniqueIdLength)
            {
                /* Remove it and return it */
                RemoveEntryList(&(SavedLinkInformation->SavedLinksListEntry));
                return SavedLinkInformation;
            }
        }
    }
 
    /* None found (none removed) */
    return NULL;
}

Referenced by MountMgrMountedDeviceArrival().

SendLinkCreated()

VOID SendLinkCreated

(

IN PUNICODE_STRING

SymbolicName

)

Definition at line 169 of file symlink.c.

{
    NTSTATUS Status;
    ULONG NameSize;
    PFILE_OBJECT FileObject;
    PMOUNTDEV_NAME Name = NULL;
    PDEVICE_OBJECT DeviceObject;
 
    /* Get the device associated with the name */
    Status = IoGetDeviceObjectPointer(SymbolicName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
        return;
 
    /* Get attached device (will notify it) */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    /* NameSize is the size of the whole MOUNTDEV_NAME structure */
    NameSize = sizeof(USHORT) + SymbolicName->Length;
    Name = AllocatePool(NameSize);
    if (!Name)
        goto Cleanup;
 
    /* Initialize structure */
    Name->NameLength = SymbolicName->Length;
    RtlCopyMemory(Name->Name, SymbolicName->Buffer, SymbolicName->Length);
 
    /* Send the notification, using the new (Windows 2003+) IOCTL definition
     * (with limited access) first. If this fails, the called driver may be
     * for an older NT version, and so, we send again the notification using
     * the old (Windows 2000) IOCTL definition (with any access). */
    Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_LINK_CREATED,
                                         DeviceObject,
                                         Name,
                                         NameSize,
                                         NULL,
                                         0,
                                         FileObject);
    /* This one can fail, no one matters */
    UNREFERENCED_PARAMETER(Status);
#if (NTDDI_VERSION >= NTDDI_WS03)
    /* Then, second one */
    Status = MountMgrSendSyncDeviceIoCtl(IOCTL_MOUNTDEV_LINK_CREATED_UNSECURE_DEPRECATED,
                                         DeviceObject,
                                         Name,
                                         NameSize,
                                         NULL,
                                         0,
                                         FileObject);
    UNREFERENCED_PARAMETER(Status);
#endif // (NTDDI_VERSION >= NTDDI_WS03)
 
Cleanup:
    if (Name)
        FreePool(Name);
 
    ObDereferenceObject(DeviceObject);
    ObDereferenceObject(FileObject);
 
    return;
}

Referenced by MountMgrCreatePointWorker(), and MountMgrMountedDeviceArrival().

SendOnlineNotification()

VOID SendOnlineNotification

(

IN PUNICODE_STRING

SymbolicName

)

Definition at line 38 of file notify.c.

{
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PDEVICE_OBJECT DeviceObject;
 
    /* Get device object */
    Status = IoGetDeviceObjectPointer(SymbolicName,
                                      FILE_READ_ATTRIBUTES,
                                      &FileObject,
                                      &DeviceObject);
    if (!NT_SUCCESS(Status))
        return;
 
    /* And attached device object */
    DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
 
    /* And send VOLUME_ONLINE */
    Status = MountMgrSendSyncDeviceIoCtl(IOCTL_VOLUME_ONLINE,
                                         DeviceObject,
                                         NULL, 0,
                                         NULL, 0,
                                         FileObject);
    UNREFERENCED_PARAMETER(Status);
 
    ObDereferenceObject(DeviceObject);
    ObDereferenceObject(FileObject);
    return;
}

Referenced by MountMgrMountedDeviceArrival(), and SendOnlineNotificationWorker().

UpdateReplicatedUniqueIds()

VOID UpdateReplicatedUniqueIds	(	IN PDEVICE_INFORMATION	DeviceInformation,
		IN PDATABASE_ENTRY	DatabaseEntry
	)

Definition at line 376 of file uniqueid.c.

{
    PLIST_ENTRY NextEntry;
    PUNIQUE_ID_REPLICATE ReplicatedUniqueId, NewEntry;
 
    /* Browse all the device replicated unique IDs */
    for (NextEntry = DeviceInformation->ReplicatedUniqueIdsListHead.Flink;
         NextEntry != &(DeviceInformation->ReplicatedUniqueIdsListHead);
         NextEntry = NextEntry->Flink)
    {
        ReplicatedUniqueId = CONTAINING_RECORD(NextEntry,
                                               UNIQUE_ID_REPLICATE,
                                               ReplicatedUniqueIdsListEntry);
 
        if (ReplicatedUniqueId->UniqueId->UniqueIdLength != DatabaseEntry->UniqueIdLength)
        {
            continue;
        }
 
        /* If we find the UniqueId to update, break */
        if (RtlCompareMemory(ReplicatedUniqueId->UniqueId->UniqueId,
                             (PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->UniqueIdOffset),
                             ReplicatedUniqueId->UniqueId->UniqueIdLength) == ReplicatedUniqueId->UniqueId->UniqueIdLength)
        {
            break;
        }
    }
 
    /* We found the unique ID, no need to continue */
    if (NextEntry != &(DeviceInformation->ReplicatedUniqueIdsListHead))
    {
        return;
    }
 
    /* Allocate a new entry for unique ID */
    NewEntry = AllocatePool(sizeof(UNIQUE_ID_REPLICATE));
    if (!NewEntry)
    {
        return;
    }
 
    /* Allocate the unique ID */
    NewEntry->UniqueId = AllocatePool(DatabaseEntry->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
    if (!NewEntry->UniqueId)
    {
        FreePool(NewEntry);
        return;
    }
 
    /* Copy */
    NewEntry->UniqueId->UniqueIdLength = DatabaseEntry->UniqueIdLength;
    RtlCopyMemory(NewEntry->UniqueId->UniqueId,
                  (PVOID)((ULONG_PTR)DatabaseEntry + DatabaseEntry->UniqueIdOffset),
                  DatabaseEntry->UniqueIdLength);
    /* And insert into replicated unique IDs list */
    InsertTailList(&DeviceInformation->ReplicatedUniqueIdsListHead, &NewEntry->ReplicatedUniqueIdsListEntry);
 
    return;
}

Referenced by ReconcileThisDatabaseWithMasterWorker().

WaitForOnlinesToComplete()

VOID WaitForOnlinesToComplete

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 174 of file notify.c.

{
    KIRQL OldIrql;
 
    KeInitializeEvent(&(DeviceExtension->OnlineNotificationEvent), NotificationEvent, FALSE);
 
    KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
 
    /* Just wait all the worker are done */
    if (DeviceExtension->OnlineNotificationCount != 1)
    {
        DeviceExtension->OnlineNotificationCount--;
        KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
 
        KeWaitForSingleObject(&(DeviceExtension->OnlineNotificationEvent),
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
 
        KeAcquireSpinLock(&(DeviceExtension->WorkerLock), &OldIrql);
        DeviceExtension->OnlineNotificationCount++;
    }
 
    KeReleaseSpinLock(&(DeviceExtension->WorkerLock), OldIrql);
}

Referenced by MountMgrDeviceControl().

WaitForRemoteDatabaseSemaphore()

NTSTATUS WaitForRemoteDatabaseSemaphore

(

IN PDEVICE_EXTENSION

DeviceExtension

)

Definition at line 371 of file database.c.

{
    NTSTATUS Status;
    LARGE_INTEGER Timeout;
 
    /* Wait for 7 minutes */
    Timeout.QuadPart = 0xFA0A1F00;
    Status = KeWaitForSingleObject(&(DeviceExtension->RemoteDatabaseLock), Executive, KernelMode, FALSE, &Timeout);
    if (Status != STATUS_TIMEOUT)
    {
        return Status;
    }
 
    return STATUS_IO_TIMEOUT;
}

Referenced by MountMgrDeviceControl(), MountMgrUniqueIdChangeRoutine(), and ReconcileThisDatabaseWithMasterWorker().

WriteRemoteDatabaseEntry()

NTSTATUS WriteRemoteDatabaseEntry	(	IN HANDLE	Database,
		IN LONG	Offset,
		IN PDATABASE_ENTRY	Entry
	)

Definition at line 200 of file database.c.

{
    NTSTATUS Status;
    LARGE_INTEGER ByteOffset;
    IO_STATUS_BLOCK IoStatusBlock;
 
    ByteOffset.QuadPart = Offset;
    Status = ZwWriteFile(Database,
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         Entry,
                         Entry->EntrySize,
                         &ByteOffset,
                         NULL);
    if (NT_SUCCESS(Status))
    {
        if (IoStatusBlock.Information < Entry->EntrySize)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    return Status;
}

Referenced by MountMgrVolumeMountPointCreated(), MountMgrVolumeMountPointDeleted(), and ReconcileThisDatabaseWithMasterWorker().

Variable Documentation

DatabasePath

PWSTR DatabasePath

extern

Definition at line 31 of file database.c.

Referenced by ChangeUniqueIdRoutine(), CreateNoDriveLetterEntry(), DeleteDriveLetterRoutine(), DeleteFromLocalDatabase(), DeleteFromLocalDatabaseRoutine(), DeleteNoDriveLetterEntry(), DeleteNoDriveLetterEntryRoutine(), DeleteRegistryDriveLetter(), DriverEntry(), GetProtoOpenNetworkDatabase(), HasNoDriveLetterEntry(), MountMgrCreatePointWorker(), MountMgrDeletePoints(), MountMgrDeletePointsDbOnly(), MountMgrMountedDeviceArrival(), MountMgrScrubRegistry(), MountMgrUniqueIdChangeRoutine(), OpenHostsFile(), OpenNetworkDatabase(), QuerySymbolicLinkNamesFromStorage(), QueryUniqueIdFromMaster(), ScrubRegistryRoutine(), and WriteUniqueIdToMaster().

DeviceCdRom

UNICODE_STRING DeviceCdRom

extern

Definition at line 44 of file symlink.c.

Referenced by CreateNewDriveLetterName(), MountMgrMountedDeviceArrival(), and MountMgrNextDriveLetterWorker().

DeviceFloppy

UNICODE_STRING DeviceFloppy

extern

Definition at line 43 of file symlink.c.

Referenced by CreateNewDriveLetterName(), InstallBootcodeToRemovable(), and MountMgrNextDriveLetterWorker().

DeviceMount

UNICODE_STRING DeviceMount

extern

Definition at line 40 of file symlink.c.

Referenced by DriverEntry().

DeviceObject

_In_ PDEVICE_OBJECT DeviceObject

Definition at line 186 of file mntmgr.h.

DosDevices

UNICODE_STRING DosDevices

extern

Definition at line 42 of file symlink.c.

Referenced by CreateNewDriveLetterName(), CreateStringWithGlobal(), IsDriveLetter(), MountMgrNextDriveLetterWorker(), and ProcessSuggestedDriveLetters().

DosDevicesMount

UNICODE_STRING DosDevicesMount

extern

Definition at line 41 of file symlink.c.

Referenced by DriverEntry(), and MountMgrUnload().

DosGlobal

UNICODE_STRING DosGlobal

extern

Definition at line 45 of file symlink.c.

Referenced by CreateStringWithGlobal().

DriverEntry

DRIVER_INITIALIZE DriverEntry

Definition at line 180 of file mntmgr.h.

FileObject

_In_ PDEVICE_OBJECT _In_ ULONG _In_ ULONG _In_opt_ PFILE_OBJECT FileObject

Definition at line 191 of file mntmgr.h.

gdeviceObject

PDEVICE_OBJECT gdeviceObject

extern

Definition at line 35 of file mountmgr.c.

Referenced by DriverEntry(), and MountMgrUnload().

Global

UNICODE_STRING Global

extern

Definition at line 46 of file symlink.c.

Referenced by co_HOOK_CallHooks(), CreateStringWithGlobal(), HandlePropertyInstances(), KdbpCmdBreakPoint(), KdbpCmdBreakPointList(), KdbpGetBreakPointInfo(), and KdbpInsertBreakPoint().

InputBufferLength

_In_ PDEVICE_OBJECT _In_ ULONG InputBufferLength

Definition at line 188 of file mntmgr.h.

MountMgrDeviceControl

DRIVER_DISPATCH MountMgrDeviceControl

Definition at line 344 of file mntmgr.h.

Referenced by DriverEntry().

OfflinePath

PWSTR OfflinePath

extern

Definition at line 32 of file database.c.

Referenced by IsOffline().

OutputBufferLength

_In_ PDEVICE_OBJECT _In_ ULONG _In_ ULONG OutputBufferLength

Definition at line 190 of file mntmgr.h.

ReparseIndex

UNICODE_STRING ReparseIndex

extern

Definition at line 49 of file symlink.c.

Referenced by OnlineMountedVolumes(), and ReconcileThisDatabaseWithMasterWorker().

SafeVolumes

UNICODE_STRING SafeVolumes

extern

Definition at line 47 of file symlink.c.

Referenced by WorkerThread().

UnloadEvent

KEVENT UnloadEvent

extern

Definition at line 36 of file mountmgr.c.

Referenced by MountMgrShutdown(), MountMgrUnload(), and WorkerThread().

Unloading

LONG Unloading

extern

Definition at line 37 of file mountmgr.c.

Referenced by MountMgrShutdown(), and MountMgrUnload().

Volume

_In_ PFLT_VOLUME Volume

extern

Definition at line 1172 of file fltkernel.h.

Referenced by AddPartitionToDisk(), auxMessage(), BroadcastDriveLetterChange(), CheckFileSystemPage(), ChkdskVolume(), CreateNewVolumeName(), CreateNTOSInstallationsList(), DismountMain(), DismountPartition(), DismountVolume(), DoChecking(), DoFormatting(), ExtCopyBlockPointersByExtents(), ExtCopyDoubleIndirectBlockPointers(), ExtCopyIndirectBlockPointers(), ExtCopyTripleIndirectBlockPointers(), ExtGetInodeBlockNumber(), ExtGetInodeGroupNumber(), ExtGetInodeOffsetInBlock(), ExtLookupFile(), ExtMount(), ExtOpen(), ExtOpenFile(), ExtOpenVolume(), ExtReadBlock(), ExtReadBlockPointerList(), ExtReadDirectory(), ExtReadFileBig(), ExtReadGroupDescriptor(), ExtReadGroupDescriptors(), ExtReadInode(), ExtReadPartialBlock(), ExtReadSuperBlock(), ExtReadVolumeSectors(), FatBufferDirectory(), FatCountClustersInChain(), FatGetFatEntry(), FatGetFatSector(), FatLookupFile(), FatMount(), FatOpenVolume(), FatReadAdjacentClusters(), FatReadClusterChain(), FatReadFile(), FatReadPartialCluster(), FatReadVolumeSectors(), FatSeek(), FilterInstanceSetup(), FindNTOSInstallations(), FindVolCreateInTreeByVolume(), FltEnumerateVolumes(), FltGetDiskDeviceObject(), FltGetVolumeName(), FltGetVolumeProperties(), FormatDlgProcWorker(), FormatPartitionPage(), FormatVolume(), FsVolCommitOpsQueue(), GetNextUnformattedVolume(), InitDestinationPaths(), InitVolume(), InitVolumeDeviceName(), IsoLookupFile(), IsoMount(), IsSupportedActivePartition(), LockOrUnlockVolume(), MMixerGetChannelCountLegacy(), MountVolume(), NtfsDiskRead(), NtfsFindAttribute(), NtfsFindAttributeHelper(), NtfsFindMftRecord(), NtfsFixupRecord(), NtfsInfoMain(), NtfsLookupFile(), NtfsMount(), NtfsOpen(), NtfsReadAttribute(), NtfsReadMftRecord(), OpenVolume(), PopFlushVolumes(), PopFlushVolumeWorker(), QueryMain(), RawMountVolume(), SelectFileSystemPage(), SetMain(), SetMountedDeviceValue(), SetMountedDeviceValues(), CAC97MiniportTopology::SetMultichannelVolume(), SmpCreatePagingFileOnAnyDrive(), SmpCreatePagingFileOnFixedDrive(), SmpCreateVolumeDescriptors(), SmpGetVolumeFreeSpace(), SmpSearchVolumeDescriptor(), StatisticsMain(), and WritePartitionsToDisk().