drivers/filters/mountmgr/device.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2011-2012 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * COPYRIGHT:        See COPYING in the top level directory
  20  * PROJECT:          ReactOS kernel
  21  * FILE:             drivers/filesystem/mountmgr/device.c
  22  * PURPOSE:          Mount Manager - Device Control
  23  * PROGRAMMER:       Pierre Schweitzer (pierre.schweitzer@reactos.org)
  24  */
  25
  26 /* INCLUDES *****************************************************************/
  27
  28 #include "mntmgr.h"
  29
  30 #define NDEBUG
  31 #include <debug.h>
  32
  33 /*
  34  * @implemented
  35  */
  36 NTSTATUS
  37 MountMgrChangeNotify(IN PDEVICE_EXTENSION DeviceExtension,
  38                      IN PIRP Irp)
  39 {
  40     KIRQL OldIrql;
  41     NTSTATUS Status;
  42     PIO_STACK_LOCATION Stack;
  43     PMOUNTMGR_CHANGE_NOTIFY_INFO ChangeNotify;
  44
  45     /* Get the I/O buffer */
  46     Stack = IoGetCurrentIrpStackLocation(Irp);
  47     ChangeNotify = (PMOUNTMGR_CHANGE_NOTIFY_INFO)Irp->AssociatedIrp.SystemBuffer;
  48
  49     /* Validate it */
  50     if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO) ||
  51         Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_CHANGE_NOTIFY_INFO))
  52     {
  53         return STATUS_INVALID_PARAMETER;
  54     }
  55
  56     /* If epic number doesn't match, just return now one */
  57     if (DeviceExtension->EpicNumber != ChangeNotify->EpicNumber)
  58     {
  59         ChangeNotify->EpicNumber = DeviceExtension->EpicNumber;
  60         Irp->IoStatus.Information = 0;
  61         return STATUS_SUCCESS;
  62     }
  63
  64     /* If IRP is to be canceled, forget about that */
  65     IoAcquireCancelSpinLock(&OldIrql);
  66     if (Irp->Cancel)
  67     {
  68         Status = STATUS_CANCELLED;
  69     }
  70     /* Otherwise queue the IRP to be notified with the next epic number change */
  71     else
  72     {
  73         InsertTailList(&(DeviceExtension->IrpListHead), &(Irp->Tail.Overlay.ListEntry));
  74         IoMarkIrpPending(Irp);
  75         IoSetCancelRoutine(Irp, MountMgrCancel);
  76         Status = STATUS_PENDING;
  77     }
  78     IoReleaseCancelSpinLock(OldIrql);
  79
  80     return Status;
  81 }
  82
  83 /*
  84  * @implemented
  85  */
  86 NTSTATUS
  87 MountmgrWriteNoAutoMount(IN PDEVICE_EXTENSION DeviceExtension)
  88 {
  89     ULONG Value = DeviceExtension->NoAutoMount;
  90
  91     return RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
  92                                  DeviceExtension->RegistryPath.Buffer,
  93                                  L"NoAutoMount",
  94                                  REG_DWORD,
  95                                  &Value,
  96                                  sizeof(Value));
  97
  98 }
  99
 100 /*
 101  * @implemented
 102  */
 103 NTSTATUS
 104 MountMgrSetAutoMount(IN PDEVICE_EXTENSION DeviceExtension,
 105                      IN PIRP Irp)
 106 {
 107     PIO_STACK_LOCATION Stack;
 108     PMOUNTMGR_SET_AUTO_MOUNT SetState;
 109
 110     Stack = IoGetCurrentIrpStackLocation(Irp);
 111
 112     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_SET_AUTO_MOUNT))
 113     {
 114         Irp->IoStatus.Information = 0;
 115         return STATUS_INVALID_PARAMETER;
 116     }
 117
 118     /* Only change if there's a real difference */
 119     SetState = (PMOUNTMGR_SET_AUTO_MOUNT)Irp->AssociatedIrp.SystemBuffer;
 120     if (SetState->NewState == !DeviceExtension->NoAutoMount)
 121     {
 122         Irp->IoStatus.Information = 0;
 123         return STATUS_SUCCESS;
 124     }
 125
 126     /* Set new state; ! on purpose */
 127     DeviceExtension->NoAutoMount = !SetState->NewState;
 128     Irp->IoStatus.Information = 0;
 129     return MountmgrWriteNoAutoMount(DeviceExtension);
 130 }
 131
 132 /*
 133  * @implemented
 134  */
 135 NTSTATUS
 136 MountMgrQueryAutoMount(IN PDEVICE_EXTENSION DeviceExtension,
 137                        IN PIRP Irp)
 138 {
 139     PIO_STACK_LOCATION Stack;
 140     PMOUNTMGR_QUERY_AUTO_MOUNT QueryState;
 141
 142     Stack = IoGetCurrentIrpStackLocation(Irp);
 143
 144     if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_QUERY_AUTO_MOUNT))
 145     {
 146         Irp->IoStatus.Information = 0;
 147         return STATUS_INVALID_PARAMETER;
 148     }
 149
 150     QueryState = (PMOUNTMGR_QUERY_AUTO_MOUNT)Irp->AssociatedIrp.SystemBuffer;
 151     QueryState->CurrentState = !DeviceExtension->NoAutoMount;
 152     Irp->IoStatus.Information = sizeof(MOUNTMGR_QUERY_AUTO_MOUNT);
 153
 154     return STATUS_SUCCESS;
 155 }
 156
 157 /*
 158  * @implemented
 159  */
 160 NTSTATUS
 161 NTAPI
 162 ScrubRegistryRoutine(IN PWSTR ValueName,
 163                      IN ULONG ValueType,
 164                      IN PVOID ValueData,
 165                      IN ULONG ValueLength,
 166                      IN PVOID Context,
 167                      IN PVOID EntryContext)
 168 {
 169     NTSTATUS Status;
 170     PLIST_ENTRY NextEntry;
 171     PDEVICE_INFORMATION DeviceInfo;
 172     PBOOLEAN Continue = EntryContext;
 173     PDEVICE_EXTENSION DeviceExtension = Context;
 174
 175     if (ValueType != REG_BINARY)
 176     {
 177         return STATUS_SUCCESS;
 178     }
 179
 180     /* Delete values for devices that don't have the matching unique ID */
 181     if (!IsListEmpty(&(DeviceExtension->DeviceListHead)))
 182     {
 183         for (NextEntry = DeviceExtension->DeviceListHead.Flink;
 184              NextEntry != &(DeviceExtension->DeviceListHead);
 185              NextEntry = NextEntry->Flink)
 186         {
 187             DeviceInfo = CONTAINING_RECORD(NextEntry,
 188                                            DEVICE_INFORMATION,
 189                                            DeviceListEntry);
 190
 191              if (!DeviceInfo->UniqueId || DeviceInfo->UniqueId->UniqueIdLength != ValueLength)
 192              {
 193                  continue;
 194              }
 195
 196              if (RtlCompareMemory(DeviceInfo->UniqueId->UniqueId, ValueData, ValueLength) == ValueLength)
 197              {
 198                  return STATUS_SUCCESS;
 199              }
 200         }
 201     }
 202
 203     /* Wrong unique ID, scrub it */
 204     Status = RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
 205                                     DatabasePath,
 206                                     ValueName);
 207     if (!NT_SUCCESS(Status))
 208     {
 209         *Continue = TRUE;
 210         return STATUS_UNSUCCESSFUL;
 211     }
 212
 213     *Continue = FALSE;
 214     return Status;
 215 }
 216
 217 /*
 218  * @implemented
 219  */
 220 NTSTATUS
 221 MountMgrScrubRegistry(IN PDEVICE_EXTENSION DeviceExtension)
 222 {
 223     NTSTATUS Status;
 224     BOOLEAN Continue;
 225     RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 226
 227     do
 228     {
 229         RtlZeroMemory(QueryTable, sizeof(QueryTable));
 230         QueryTable[0].QueryRoutine = ScrubRegistryRoutine;
 231         QueryTable[0].EntryContext = &Continue;
 232         Continue = FALSE;
 233
 234         Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
 235                                         DatabasePath,
 236                                         QueryTable,
 237                                         DeviceExtension,
 238                                         NULL);
 239     }
 240     while (Continue);
 241
 242     return Status;
 243 }
 244
 245 /*
 246  * @implemented
 247  */
 248 NTSTATUS
 249 MountMgrCreatePoint(IN PDEVICE_EXTENSION DeviceExtension,
 250                     IN PIRP Irp)
 251 {
 252     ULONG MaxLength;
 253     PIO_STACK_LOCATION Stack;
 254     PMOUNTMGR_CREATE_POINT_INPUT Point;
 255     UNICODE_STRING DeviceName, SymbolicName;
 256
 257     Stack = IoGetCurrentIrpStackLocation(Irp);
 258
 259     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_CREATE_POINT_INPUT))
 260     {
 261         return STATUS_INVALID_PARAMETER;
 262     }
 263
 264     Point = (PMOUNTMGR_CREATE_POINT_INPUT)Irp->AssociatedIrp.SystemBuffer;
 265
 266     MaxLength = MAX((Point->DeviceNameOffset + Point->DeviceNameLength),
 267                     (Point->SymbolicLinkNameLength + Point->SymbolicLinkNameOffset));
 268     if (MaxLength >= Stack->Parameters.DeviceIoControl.InputBufferLength)
 269     {
 270         return STATUS_INVALID_PARAMETER;
 271     }
 272
 273     /* Get all the strings and call the worker */
 274     SymbolicName.Length = Point->SymbolicLinkNameLength;
 275     SymbolicName.MaximumLength = Point->SymbolicLinkNameLength;
 276     DeviceName.Length = Point->DeviceNameLength;
 277     DeviceName.MaximumLength = Point->DeviceNameLength;
 278     SymbolicName.Buffer = (PVOID)((ULONG_PTR)Point + Point->SymbolicLinkNameOffset);
 279     DeviceName.Buffer = (PVOID)((ULONG_PTR)Point + Point->DeviceNameOffset);
 280
 281     return MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &DeviceName);
 282 }
 283
 284 /*
 285  * @implemented
 286  */
 287 NTSTATUS
 288 MountMgrCheckUnprocessedVolumes(IN PDEVICE_EXTENSION DeviceExtension,
 289                                 IN PIRP Irp)
 290 {
 291     PLIST_ENTRY NextEntry;
 292     PDEVICE_INFORMATION DeviceInformation;
 293     NTSTATUS ArrivalStatus, Status = STATUS_SUCCESS;
 294
 295     /* No offline volumes, nothing more to do */
 296     if (IsListEmpty(&(DeviceExtension->OfflineDeviceListHead)))
 297     {
 298         KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 299         return STATUS_SUCCESS;
 300     }
 301
 302     KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
 303
 304     /* Reactivate all the offline volumes */
 305     while (!IsListEmpty(&(DeviceExtension->OfflineDeviceListHead)))
 306     {
 307         NextEntry = RemoveHeadList(&(DeviceExtension->OfflineDeviceListHead));
 308         DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 309
 310         ArrivalStatus = MountMgrMountedDeviceArrival(DeviceExtension,
 311                                                      &(DeviceInformation->SymbolicName),
 312                                                      DeviceInformation->Volume);
 313         /* Then, remove them dead information */
 314         MountMgrFreeDeadDeviceInfo(DeviceInformation);
 315
 316         if (NT_SUCCESS(Status))
 317         {
 318             Status = ArrivalStatus;
 319         }
 320     }
 321
 322     return Status;
 323 }
 324
 325 /*
 326  * @implemented
 327  */
 328 BOOLEAN
 329 IsFtVolume(IN PUNICODE_STRING SymbolicName)
 330 {
 331     PIRP Irp;
 332     KEVENT Event;
 333     NTSTATUS Status;
 334     PFILE_OBJECT FileObject;
 335     IO_STATUS_BLOCK IoStatusBlock;
 336     PARTITION_INFORMATION PartitionInfo;
 337     PDEVICE_OBJECT DeviceObject, FileDeviceObject;
 338
 339     /* Get device object */
 340     Status = IoGetDeviceObjectPointer(SymbolicName,
 341                                       FILE_READ_ATTRIBUTES,
 342                                       &FileObject,
 343                                       &DeviceObject);
 344     if (!NT_SUCCESS(Status))
 345     {
 346         return FALSE;
 347     }
 348
 349     /* Get attached device */
 350     FileDeviceObject = FileObject->DeviceObject;
 351     DeviceObject = IoGetAttachedDeviceReference(FileDeviceObject);
 352
 353     /* FT volume can't be removable */
 354     if (FileDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
 355     {
 356         ObDereferenceObject(DeviceObject);
 357         ObDereferenceObject(FileObject);
 358         return FALSE;
 359     }
 360
 361     ObDereferenceObject(FileObject);
 362
 363     /* Get partition information */
 364     KeInitializeEvent(&Event, NotificationEvent, FALSE);
 365     Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_PARTITION_INFO,
 366                                         DeviceObject,
 367                                         NULL,
 368                                         0,
 369                                         &PartitionInfo,
 370                                         sizeof(PartitionInfo),
 371                                         FALSE,
 372                                         &Event,
 373                                         &IoStatusBlock);
 374     if (!Irp)
 375     {
 376         ObDereferenceObject(DeviceObject);
 377         return FALSE;
 378     }
 379
 380     Status = IoCallDriver(DeviceObject, Irp);
 381     if (Status == STATUS_PENDING)
 382     {
 383         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
 384         Status = IoStatusBlock.Status;
 385     }
 386
 387     ObDereferenceObject(DeviceObject);
 388     if (!NT_SUCCESS(Status))
 389     {
 390         return FALSE;
 391     }
 392
 393     /* Check if this is a FT volume */
 394     return IsRecognizedPartition(PartitionInfo.PartitionType);
 395 }
 396
 397 /*
 398  * @implemented
 399  */
 400 VOID
 401 ProcessSuggestedDriveLetters(IN PDEVICE_EXTENSION DeviceExtension)
 402 {
 403     WCHAR NameBuffer[DRIVE_LETTER_LENGTH / sizeof(WCHAR)];
 404     PLIST_ENTRY NextEntry;
 405     UNICODE_STRING SymbolicName;
 406     PDEVICE_INFORMATION DeviceInformation;
 407
 408     /* No devices? Nothing to do! */
 409     if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
 410     {
 411         return;
 412     }
 413
 414     /* For all the devices */
 415     for (NextEntry = DeviceExtension->DeviceListHead.Flink;
 416          NextEntry != &(DeviceExtension->DeviceListHead);
 417          NextEntry = NextEntry->Flink)
 418     {
 419         DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 420
 421         /* If no drive letter */
 422         if (DeviceInformation->SuggestedDriveLetter == (UCHAR)-1)
 423         {
 424             /* Ensure it has no entry yet */
 425             if (!HasDriveLetter(DeviceInformation) &&
 426                 !HasNoDriveLetterEntry(DeviceInformation->UniqueId))
 427             {
 428                 /* And create one */
 429                 CreateNoDriveLetterEntry(DeviceInformation->UniqueId);
 430             }
 431
 432             DeviceInformation->SuggestedDriveLetter = 0;
 433         }
 434         /* Suggested letter & no entry */
 435         else if (DeviceInformation->SuggestedDriveLetter &&
 436                  !HasNoDriveLetterEntry(DeviceInformation->UniqueId))
 437         {
 438             /* Just create a mount point */
 439             SymbolicName.Buffer = NameBuffer;
 440             RtlCopyMemory(NameBuffer, DosDevices.Buffer, DosDevices.Length);
 441             NameBuffer[LETTER_POSITION] = DeviceInformation->SuggestedDriveLetter;
 442             NameBuffer[COLON_POSITION] = L':';
 443             SymbolicName.Length =
 444             SymbolicName.MaximumLength = DRIVE_LETTER_LENGTH;
 445
 446             MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &(DeviceInformation->DeviceName));
 447         }
 448     }
 449 }
 450
 451 /*
 452  * @implemented
 453  */
 454 NTSTATUS
 455 MountMgrNextDriveLetterWorker(IN PDEVICE_EXTENSION DeviceExtension,
 456                               IN PUNICODE_STRING DeviceName,
 457                               OUT PMOUNTMGR_DRIVE_LETTER_INFORMATION DriveLetterInfo)
 458 {
 459     NTSTATUS Status;
 460     UCHAR DriveLetter;
 461     PLIST_ENTRY NextEntry;
 462     PMOUNTDEV_UNIQUE_ID UniqueId;
 463     BOOLEAN Removable, GptDriveLetter;
 464     PDEVICE_INFORMATION DeviceInformation;
 465     WCHAR NameBuffer[DRIVE_LETTER_LENGTH];
 466     PSYMLINK_INFORMATION SymlinkInformation;
 467     UNICODE_STRING TargetDeviceName, SymbolicName;
 468
 469     /* First, process suggested letters */
 470     if (!DeviceExtension->ProcessedSuggestions)
 471     {
 472         ProcessSuggestedDriveLetters(DeviceExtension);
 473         DeviceExtension->ProcessedSuggestions = TRUE;
 474     }
 475
 476     /* Then, get information about the device */
 477     Status = QueryDeviceInformation(DeviceName, &TargetDeviceName, NULL, &Removable, &GptDriveLetter, NULL, NULL, NULL);
 478     if (!NT_SUCCESS(Status))
 479     {
 480         return Status;
 481     }
 482
 483     /* Ensure we have such device */
 484     NextEntry = DeviceExtension->DeviceListHead.Flink;
 485     while (NextEntry != &(DeviceExtension->DeviceListHead))
 486     {
 487         DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 488
 489         if (RtlCompareUnicodeString(&(DeviceInformation->DeviceName), &TargetDeviceName, TRUE) == 0)
 490         {
 491             break;
 492         }
 493
 494         NextEntry = NextEntry->Flink;
 495     }
 496
 497     if (NextEntry == &(DeviceExtension->DeviceListHead))
 498     {
 499         FreePool(TargetDeviceName.Buffer);
 500         return STATUS_OBJECT_NAME_NOT_FOUND;
 501     }
 502
 503     /* Now, mark we have assigned a letter (assumption) */
 504     DeviceInformation->LetterAssigned =
 505     DriveLetterInfo->DriveLetterWasAssigned = TRUE;
 506
 507     /* Browse all the symlink to see if there's already a drive letter */
 508     NextEntry = DeviceInformation->SymbolicLinksListHead.Flink;
 509     while (NextEntry != &(DeviceInformation->SymbolicLinksListHead))
 510     {
 511         SymlinkInformation = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 512
 513         /* This is a driver letter & online one, forget about new drive eltter */
 514         if (IsDriveLetter(&(SymlinkInformation->Name)) && SymlinkInformation->Online)
 515         {
 516             DriveLetterInfo->DriveLetterWasAssigned = FALSE;
 517             DriveLetterInfo->CurrentDriveLetter = (CHAR)SymlinkInformation->Name.Buffer[LETTER_POSITION];
 518             break;
 519         }
 520
 521         NextEntry = NextEntry->Flink;
 522     }
 523
 524     /* If we didn't find a drive letter online
 525      * ensure there's no GPT drive letter nor no drive entry
 526      */
 527     if (NextEntry == &(DeviceInformation->SymbolicLinksListHead))
 528     {
 529         if (GptDriveLetter || HasNoDriveLetterEntry(DeviceInformation->UniqueId))
 530         {
 531             DriveLetterInfo->DriveLetterWasAssigned = FALSE;
 532             DriveLetterInfo->CurrentDriveLetter = 0;
 533
 534             goto Release;
 535         }
 536     }
 537
 538     /* No, ensure that the device is not automonted nor removable */
 539     if (!DeviceExtension->NoAutoMount && !Removable)
 540     {
 541         if (DriveLetterInfo->DriveLetterWasAssigned)
 542         {
 543             DriveLetterInfo->DriveLetterWasAssigned = FALSE;
 544             DriveLetterInfo->CurrentDriveLetter = 0;
 545
 546             goto Release;
 547         }
 548     }
 549
 550     if (!DriveLetterInfo->DriveLetterWasAssigned)
 551     {
 552         goto Release;
 553     }
 554
 555     /* Now everything is fine, start processing */
 556     if (RtlPrefixUnicodeString(&DeviceFloppy, &TargetDeviceName, TRUE))
 557     {
 558         DriveLetter = 'A';
 559     }
 560     else
 561     {
 562         DriveLetter = 'C' + RtlPrefixUnicodeString(&DeviceCdRom, &TargetDeviceName, TRUE);
 563     }
 564
 565     /* We cannot set NO drive letter */
 566     ASSERT(DeviceInformation->SuggestedDriveLetter != (UCHAR)-1);
 567
 568     /* If we don't have suggested letter but it's a FT volume, fail */
 569     if (!DeviceInformation->SuggestedDriveLetter && IsFtVolume(&(DeviceInformation->DeviceName)))
 570     {
 571         DriveLetterInfo->DriveLetterWasAssigned = FALSE;
 572         DriveLetterInfo->CurrentDriveLetter = 0;
 573
 574         goto Release;
 575     }
 576
 577     /* Prepare buffer */
 578     RtlCopyMemory(NameBuffer, DosDevices.Buffer, DosDevices.Length);
 579     NameBuffer[COLON_POSITION] = L':';
 580     SymbolicName.Buffer = NameBuffer;
 581     SymbolicName.Length =
 582     SymbolicName.MaximumLength = DRIVE_LETTER_LENGTH;
 583
 584     /* It's all prepared, create mount point */
 585     if (DeviceInformation->SuggestedDriveLetter)
 586     {
 587         DriveLetterInfo->CurrentDriveLetter = DeviceInformation->SuggestedDriveLetter;
 588         NameBuffer[LETTER_POSITION] = DeviceInformation->SuggestedDriveLetter;
 589
 590         Status = MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &TargetDeviceName);
 591         if (NT_SUCCESS(Status))
 592         {
 593             goto Release;
 594         }
 595     }
 596
 597     /* It failed with this letter... Try another one! */
 598     for (DriveLetterInfo->CurrentDriveLetter = DriveLetter;
 599          DriveLetterInfo->CurrentDriveLetter <= L'Z';
 600          DriveLetterInfo->CurrentDriveLetter++)
 601     {
 602         NameBuffer[LETTER_POSITION] = DeviceInformation->SuggestedDriveLetter;
 603
 604         Status = MountMgrCreatePointWorker(DeviceExtension, &SymbolicName, &TargetDeviceName);
 605         if (NT_SUCCESS(Status))
 606         {
 607             break;
 608         }
 609     }
 610
 611     /* We failed setting a letter */
 612     if (DriveLetterInfo->CurrentDriveLetter > L'Z')
 613     {
 614         DriveLetterInfo->DriveLetterWasAssigned = FALSE;
 615         DriveLetterInfo->CurrentDriveLetter = 0;
 616
 617         /* Try at least to add a no drive letter entry */
 618         Status = QueryDeviceInformation(&TargetDeviceName, NULL, &UniqueId, NULL, NULL, NULL, NULL, NULL);
 619         if (NT_SUCCESS(Status))
 620         {
 621             CreateNoDriveLetterEntry(UniqueId);
 622             FreePool(UniqueId);
 623         }
 624     }
 625
 626 Release:
 627     FreePool(TargetDeviceName.Buffer);
 628
 629     return STATUS_SUCCESS;
 630 }
 631
 632
 633 /*
 634  * @implemented
 635  */
 636 NTSTATUS
 637 MountMgrNextDriveLetter(IN PDEVICE_EXTENSION DeviceExtension,
 638                         IN PIRP Irp)
 639 {
 640     NTSTATUS Status;
 641     PIO_STACK_LOCATION Stack;
 642     UNICODE_STRING DeviceName;
 643     PMOUNTMGR_DRIVE_LETTER_TARGET DriveLetterTarget;
 644     MOUNTMGR_DRIVE_LETTER_INFORMATION DriveLetterInformation;
 645
 646     Stack = IoGetNextIrpStackLocation(Irp);
 647
 648     /* Validate input */
 649     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_DRIVE_LETTER_TARGET) ||
 650         Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION))
 651     {
 652         return STATUS_INVALID_PARAMETER;
 653     }
 654
 655     DriveLetterTarget = (PMOUNTMGR_DRIVE_LETTER_TARGET)Irp->AssociatedIrp.SystemBuffer;
 656     if (DriveLetterTarget->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength)
 657     {
 658         return STATUS_INVALID_PARAMETER;
 659     }
 660
 661     /* Call the worker */
 662     DeviceName.Buffer = DriveLetterTarget->DeviceName;
 663     DeviceName.Length =
 664     DeviceName.MaximumLength = DriveLetterTarget->DeviceNameLength;
 665
 666     Status = MountMgrNextDriveLetterWorker(DeviceExtension, &DeviceName,
 667                                            &DriveLetterInformation);
 668     if (NT_SUCCESS(Status))
 669     {
 670         *(PMOUNTMGR_DRIVE_LETTER_INFORMATION)Irp->AssociatedIrp.SystemBuffer =
 671             DriveLetterInformation;
 672         Irp->IoStatus.Information = sizeof(MOUNTMGR_DRIVE_LETTER_INFORMATION);
 673     }
 674
 675     return Status;
 676 }
 677
 678 /*
 679  * @implemented
 680  */
 681 NTSTATUS
 682 NTAPI
 683 MountMgrQuerySystemVolumeNameQueryRoutine(IN PWSTR ValueName,
 684                                           IN ULONG ValueType,
 685                                           IN PVOID ValueData,
 686                                           IN ULONG ValueLength,
 687                                           IN PVOID Context,
 688                                           IN PVOID EntryContext)
 689 {
 690     UNICODE_STRING ValueString;
 691     PUNICODE_STRING SystemVolumeName;
 692
 693     if (ValueType != REG_SZ)
 694     {
 695         return STATUS_SUCCESS;
 696     }
 697
 698     RtlInitUnicodeString(&ValueString, ValueData);
 699     SystemVolumeName = Context;
 700
 701     /* Return a string containing system volume name */
 702     SystemVolumeName->Length = ValueString.Length;
 703     SystemVolumeName->MaximumLength = ValueString.Length + sizeof(WCHAR);
 704     SystemVolumeName->Buffer = AllocatePool(SystemVolumeName->MaximumLength);
 705     if (SystemVolumeName->Buffer)
 706     {
 707         RtlCopyMemory(SystemVolumeName->Buffer, ValueData, ValueString.Length);
 708         SystemVolumeName->Buffer[ValueString.Length / sizeof(WCHAR)] = UNICODE_NULL;
 709     }
 710
 711     return STATUS_SUCCESS;
 712
 713 }
 714
 715 /*
 716  * @implemented
 717  */
 718 NTSTATUS
 719 MountMgrQuerySystemVolumeName(OUT PUNICODE_STRING SystemVolumeName)
 720 {
 721     RTL_QUERY_REGISTRY_TABLE QueryTable[2];
 722
 723     RtlZeroMemory(QueryTable, sizeof(QueryTable));
 724     QueryTable[0].QueryRoutine = MountMgrQuerySystemVolumeNameQueryRoutine;
 725     QueryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED;
 726     QueryTable[0].Name = L"SystemPartition";
 727
 728     SystemVolumeName->Buffer = NULL;
 729
 730     RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
 731                            L"\\Registry\\Machine\\System\\Setup",
 732                            QueryTable,
 733                            SystemVolumeName,
 734                            NULL);
 735
 736     if (SystemVolumeName->Buffer)
 737     {
 738         return STATUS_SUCCESS;
 739     }
 740
 741     return STATUS_UNSUCCESSFUL;
 742 }
 743
 744 /*
 745  * @implemented
 746  */
 747 VOID
 748 MountMgrAssignDriveLetters(IN PDEVICE_EXTENSION DeviceExtension)
 749 {
 750     NTSTATUS Status;
 751     PLIST_ENTRY NextEntry;
 752     UNICODE_STRING SystemVolumeName;
 753     PDEVICE_INFORMATION DeviceInformation;
 754     MOUNTMGR_DRIVE_LETTER_INFORMATION DriveLetterInformation;
 755
 756     /* First, get system volume name */
 757     Status = MountMgrQuerySystemVolumeName(&SystemVolumeName);
 758
 759     /* If there are no device, it's all done */
 760     if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
 761     {
 762         if (NT_SUCCESS(Status))
 763         {
 764             FreePool(SystemVolumeName.Buffer);
 765         }
 766
 767         return;
 768     }
 769
 770     /* Now, for all the devices... */
 771     for (NextEntry = DeviceExtension->DeviceListHead.Flink;
 772          NextEntry != &(DeviceExtension->DeviceListHead);
 773          NextEntry = NextEntry->Flink)
 774     {
 775         DeviceInformation = CONTAINING_RECORD(NextEntry, DEVICE_INFORMATION, DeviceListEntry);
 776
 777         /* If the device doesn't have a letter assigned, do it! */
 778         if (!DeviceInformation->LetterAssigned)
 779         {
 780             MountMgrNextDriveLetterWorker(DeviceExtension,
 781                                           &(DeviceInformation->DeviceName),
 782                                           &DriveLetterInformation);
 783         }
 784
 785         /* If it was the system volume */
 786         if (NT_SUCCESS(Status) && RtlEqualUnicodeString(&SystemVolumeName, &(DeviceInformation->DeviceName), TRUE))
 787         {
 788             /* Keep track of it */
 789             DeviceExtension->DriveLetterData = AllocatePool(DeviceInformation->UniqueId->UniqueIdLength +
 790                                                             sizeof(MOUNTDEV_UNIQUE_ID));
 791             if (DeviceExtension->DriveLetterData)
 792             {
 793                 RtlCopyMemory(DeviceExtension->DriveLetterData,
 794                               DeviceInformation->UniqueId,
 795                               DeviceInformation->UniqueId->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
 796             }
 797
 798             /* If it was not automount, ensure it gets mounted */
 799             if (!DeviceExtension->NoAutoMount)
 800             {
 801                 DeviceExtension->NoAutoMount = TRUE;
 802
 803                 MountMgrNextDriveLetterWorker(DeviceExtension,
 804                                               &(DeviceInformation->DeviceName),
 805                                               &DriveLetterInformation);
 806
 807                 DeviceExtension->NoAutoMount = FALSE;
 808             }
 809         }
 810     }
 811
 812     if (NT_SUCCESS(Status))
 813     {
 814         FreePool(SystemVolumeName.Buffer);
 815     }
 816 }
 817
 818 NTSTATUS
 819 MountMgrQueryDosVolumePath(IN PDEVICE_EXTENSION DeviceExtension,
 820                            IN PIRP Irp)
 821 {
 822     return STATUS_NOT_IMPLEMENTED;
 823 }
 824
 825 NTSTATUS
 826 MountMgrQueryDosVolumePaths(IN PDEVICE_EXTENSION DeviceExtension,
 827                             IN PIRP Irp)
 828 {
 829     return STATUS_NOT_IMPLEMENTED;
 830 }
 831
 832 /*
 833  * @implemented
 834  */
 835 NTSTATUS
 836 MountMgrKeepLinksWhenOffline(IN PDEVICE_EXTENSION DeviceExtension,
 837                              IN PIRP Irp)
 838 {
 839     NTSTATUS Status;
 840     PIO_STACK_LOCATION Stack;
 841     UNICODE_STRING SymbolicName;
 842     PMOUNTMGR_TARGET_NAME Target;
 843     PDEVICE_INFORMATION DeviceInformation;
 844
 845     Stack = IoGetNextIrpStackLocation(Irp);
 846
 847     /* Validate input */
 848     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_TARGET_NAME))
 849     {
 850         return STATUS_INVALID_PARAMETER;
 851     }
 852
 853     Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer;
 854     if (Target->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength)
 855     {
 856         return STATUS_INVALID_PARAMETER;
 857     }
 858
 859     SymbolicName.Length =
 860     SymbolicName.MaximumLength = Target->DeviceNameLength;
 861     SymbolicName.Buffer = Target->DeviceName;
 862
 863     /* Find the associated device */
 864     Status = FindDeviceInfo(DeviceExtension, &SymbolicName, FALSE, &DeviceInformation);
 865     if (!NT_SUCCESS(Status))
 866     {
 867         return Status;
 868     }
 869
 870     /* Mark we want to keep links */
 871     DeviceInformation->KeepLinks = TRUE;
 872
 873     return STATUS_SUCCESS;
 874 }
 875
 876 /*
 877  * @implemented
 878  */
 879 NTSTATUS
 880 MountMgrVolumeArrivalNotification(IN PDEVICE_EXTENSION DeviceExtension,
 881                                   IN PIRP Irp)
 882 {
 883     NTSTATUS Status;
 884     BOOLEAN OldState;
 885     PIO_STACK_LOCATION Stack;
 886     UNICODE_STRING SymbolicName;
 887     PMOUNTMGR_TARGET_NAME Target;
 888
 889     Stack = IoGetNextIrpStackLocation(Irp);
 890
 891     /* Validate input */
 892     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_TARGET_NAME))
 893     {
 894         return STATUS_INVALID_PARAMETER;
 895     }
 896
 897     Target = (PMOUNTMGR_TARGET_NAME)Irp->AssociatedIrp.SystemBuffer;
 898     if (Target->DeviceNameLength + sizeof(USHORT) > Stack->Parameters.DeviceIoControl.InputBufferLength)
 899     {
 900         return STATUS_INVALID_PARAMETER;
 901     }
 902
 903     SymbolicName.Length =
 904     SymbolicName.MaximumLength = Target->DeviceNameLength;
 905     SymbolicName.Buffer = Target->DeviceName;
 906
 907     /* Disable hard errors */
 908     OldState = PsGetThreadHardErrorsAreDisabled(PsGetCurrentThread());
 909     PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), TRUE);
 910
 911     /* Call real worker */
 912     Status = MountMgrMountedDeviceArrival(DeviceExtension, &SymbolicName, TRUE);
 913
 914     PsSetThreadHardErrorsAreDisabled(PsGetCurrentThread(), OldState);
 915
 916     return Status;
 917 }
 918
 919 /*
 920  * @implemented
 921  */
 922 NTSTATUS
 923 MountMgrQueryPoints(IN PDEVICE_EXTENSION DeviceExtension,
 924                     IN PIRP Irp)
 925 {
 926     NTSTATUS Status;
 927     PIO_STACK_LOCATION Stack;
 928     PMOUNTDEV_UNIQUE_ID UniqueId;
 929     PMOUNTMGR_MOUNT_POINT MountPoint;
 930     UNICODE_STRING SymbolicName, DeviceName;
 931
 932     Stack = IoGetNextIrpStackLocation(Irp);
 933
 934     /* Validate input... */
 935     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_MOUNT_POINT))
 936     {
 937         return STATUS_INVALID_PARAMETER;
 938     }
 939
 940     MountPoint = (PMOUNTMGR_MOUNT_POINT)Irp->AssociatedIrp.SystemBuffer;
 941     if (!MountPoint->SymbolicLinkNameLength)
 942     {
 943         MountPoint->SymbolicLinkNameOffset = 0;
 944     }
 945
 946     if (!MountPoint->UniqueIdLength)
 947     {
 948         MountPoint->UniqueIdOffset = 0;
 949     }
 950
 951     if (!MountPoint->DeviceNameLength)
 952     {
 953         MountPoint->DeviceNameOffset = 0;
 954     }
 955
 956     /* Addresses can't be odd */
 957     if ((MountPoint->SymbolicLinkNameOffset & 1) ||
 958         (MountPoint->SymbolicLinkNameLength & 1))
 959     {
 960         return STATUS_INVALID_PARAMETER;
 961     }
 962
 963     if ((MountPoint->UniqueIdOffset & 1) ||
 964         (MountPoint->UniqueIdLength & 1))
 965     {
 966         return STATUS_INVALID_PARAMETER;
 967     }
 968
 969     if ((MountPoint->DeviceNameOffset & 1) ||
 970         (MountPoint->DeviceNameLength & 1))
 971     {
 972         return STATUS_INVALID_PARAMETER;
 973     }
 974
 975     /* We can't go beyond */
 976     if (((ULONG)MountPoint->SymbolicLinkNameLength + MountPoint->UniqueIdLength +
 977         MountPoint->DeviceNameLength) < Stack->Parameters.DeviceIoControl.InputBufferLength)
 978     {
 979         return STATUS_INVALID_PARAMETER;
 980     }
 981
 982     if (Stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(MOUNTMGR_MOUNT_POINTS))
 983     {
 984         return STATUS_INVALID_PARAMETER;
 985     }
 986
 987     /* If caller provided a Symlink, use it */
 988     if (MountPoint->SymbolicLinkNameLength != 0)
 989     {
 990         if (MountPoint->SymbolicLinkNameLength > MAXSHORT)
 991         {
 992             return STATUS_INVALID_PARAMETER;
 993         }
 994
 995         SymbolicName.Length = MountPoint->SymbolicLinkNameLength;
 996         SymbolicName.MaximumLength = MountPoint->SymbolicLinkNameLength + sizeof(WCHAR);
 997         SymbolicName.Buffer = AllocatePool(SymbolicName.MaximumLength);
 998         if (!SymbolicName.Buffer)
 999         {
1000             return STATUS_INSUFFICIENT_RESOURCES;
1001         }
1002
1003         RtlCopyMemory(SymbolicName.Buffer,
1004                       (PWSTR)((ULONG_PTR)MountPoint + MountPoint->SymbolicLinkNameOffset),
1005                       SymbolicName.Length);
1006         SymbolicName.Buffer[SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1007
1008         /* Query links using it */
1009         Status = QueryPointsFromSymbolicLinkName(DeviceExtension, &SymbolicName, Irp);
1010         FreePool(SymbolicName.Buffer);
1011     }
1012     /* If user provided an unique ID */
1013     else if (MountPoint->UniqueIdLength != 0)
1014     {
1015         UniqueId = AllocatePool(MountPoint->UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
1016         if (!UniqueId)
1017         {
1018             return STATUS_INSUFFICIENT_RESOURCES;
1019         }
1020
1021         UniqueId->UniqueIdLength = MountPoint->UniqueIdLength;
1022         RtlCopyMemory(UniqueId->UniqueId,
1023                       (PVOID)((ULONG_PTR)MountPoint + MountPoint->UniqueIdOffset),
1024                       MountPoint->UniqueIdLength);
1025
1026          /* Query links using it */
1027          Status = QueryPointsFromMemory(DeviceExtension, Irp, UniqueId, NULL);
1028          FreePool(UniqueId);
1029     }
1030     /* If caller provided a device name */
1031     else if (MountPoint->DeviceNameLength != 0)
1032     {
1033         if (MountPoint->DeviceNameLength > MAXSHORT)
1034         {
1035             return STATUS_INVALID_PARAMETER;
1036         }
1037
1038         DeviceName.Length = MountPoint->DeviceNameLength;
1039         DeviceName.MaximumLength = MountPoint->DeviceNameLength + sizeof(WCHAR);
1040         DeviceName.Buffer = AllocatePool(DeviceName.MaximumLength);
1041         if (!DeviceName.Buffer)
1042         {
1043             return STATUS_INSUFFICIENT_RESOURCES;
1044         }
1045
1046         RtlCopyMemory(DeviceName.Buffer,
1047                       (PWSTR)((ULONG_PTR)MountPoint + MountPoint->DeviceNameOffset),
1048                       DeviceName.Length);
1049         DeviceName.Buffer[DeviceName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1050
1051          /* Query links using it */
1052         Status = QueryPointsFromMemory(DeviceExtension, Irp, NULL, &DeviceName);
1053         FreePool(DeviceName.Buffer);
1054     }
1055     else
1056     {
1057         /* Otherwise, query all links */
1058         Status = QueryPointsFromMemory(DeviceExtension, Irp, NULL, NULL);
1059     }
1060
1061     return Status;
1062 }
1063
1064 /*
1065  * @implemented
1066  */
1067 NTSTATUS
1068 MountMgrDeletePoints(IN PDEVICE_EXTENSION DeviceExtension,
1069                      IN PIRP Irp)
1070 {
1071     ULONG Link;
1072     NTSTATUS Status;
1073     BOOLEAN CreateNoDrive;
1074     PIO_STACK_LOCATION Stack;
1075     PMOUNTDEV_UNIQUE_ID UniqueId;
1076     PMOUNTMGR_MOUNT_POINT MountPoint;
1077     PMOUNTMGR_MOUNT_POINTS MountPoints;
1078     UNICODE_STRING SymbolicName, DeviceName;
1079
1080     Stack = IoGetNextIrpStackLocation(Irp);
1081
1082     /* Validate input */
1083     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_MOUNT_POINT))
1084     {
1085         return STATUS_INVALID_PARAMETER;
1086     }
1087
1088     /* Query points */
1089     MountPoint = (PMOUNTMGR_MOUNT_POINT)Irp->AssociatedIrp.SystemBuffer;
1090     CreateNoDrive = (MountPoint->SymbolicLinkNameOffset && MountPoint->SymbolicLinkNameLength);
1091
1092     Status = MountMgrQueryPoints(DeviceExtension, Irp);
1093     if (!NT_SUCCESS(Status))
1094     {
1095         return Status;
1096     }
1097
1098     /* For all the points matching the request */
1099     MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
1100     for (Link = 0; Link < MountPoints->NumberOfMountPoints; Link++)
1101     {
1102         SymbolicName.Length = MountPoints->MountPoints[Link].SymbolicLinkNameLength;
1103         SymbolicName.MaximumLength = SymbolicName.Length + sizeof(WCHAR);
1104         SymbolicName.Buffer = AllocatePool(SymbolicName.MaximumLength);
1105         if (!SymbolicName.Buffer)
1106         {
1107             return STATUS_INSUFFICIENT_RESOURCES;
1108         }
1109
1110         RtlCopyMemory(SymbolicName.Buffer,
1111                       (PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].SymbolicLinkNameOffset),
1112                       SymbolicName.Length);
1113         SymbolicName.Buffer[SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1114
1115         /* Create a no drive entry for the drive letters */
1116         if (CreateNoDrive && IsDriveLetter(&SymbolicName))
1117         {
1118             UniqueId = AllocatePool(MountPoints->MountPoints[Link].UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
1119             if (UniqueId)
1120             {
1121                 UniqueId->UniqueIdLength = MountPoints->MountPoints[Link].UniqueIdLength;
1122                 RtlCopyMemory(UniqueId->UniqueId,
1123                               (PMOUNTDEV_UNIQUE_ID)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].UniqueIdOffset),
1124                               MountPoints->MountPoints[Link].UniqueIdLength);
1125
1126                 CreateNoDriveLetterEntry(UniqueId);
1127                 FreePool(UniqueId);
1128             }
1129         }
1130
1131         /* If there are no link any more, and no need to create a no drive entry */
1132         if (Link == 0 && !CreateNoDrive)
1133         {
1134             /* Then, delete everything */
1135             UniqueId = AllocatePool(MountPoints->MountPoints[Link].UniqueIdLength);
1136             if (UniqueId)
1137             {
1138                 RtlCopyMemory(UniqueId,
1139                               (PMOUNTDEV_UNIQUE_ID)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].UniqueIdOffset),
1140                               MountPoints->MountPoints[Link].UniqueIdLength);
1141
1142                 DeleteNoDriveLetterEntry(UniqueId);
1143                 FreePool(UniqueId);
1144             }
1145         }
1146
1147         /* Delete all the information about the mount point */
1148         GlobalDeleteSymbolicLink(&SymbolicName);
1149         DeleteSymbolicLinkNameFromMemory(DeviceExtension, &SymbolicName, FALSE);
1150         RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE, DatabasePath, SymbolicName.Buffer);
1151         FreePool(SymbolicName.Buffer);
1152
1153         /* Notify the change */
1154         DeviceName.Length = DeviceName.MaximumLength =
1155         MountPoints->MountPoints[Link].DeviceNameLength;
1156         DeviceName.Buffer = (PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].DeviceNameOffset);
1157         MountMgrNotifyNameChange(DeviceExtension, &DeviceName, TRUE);
1158     }
1159
1160     MountMgrNotify(DeviceExtension);
1161
1162     return Status;
1163 }
1164
1165 /*
1166  * @implemented
1167  */
1168 NTSTATUS
1169 MountMgrDeletePointsDbOnly(IN PDEVICE_EXTENSION DeviceExtension,
1170                            IN PIRP Irp)
1171 {
1172     ULONG Link;
1173     NTSTATUS Status;
1174     UNICODE_STRING SymbolicName;
1175     PMOUNTDEV_UNIQUE_ID UniqueId;
1176     PMOUNTMGR_MOUNT_POINTS MountPoints;
1177
1178     /* Query points */
1179     Status = MountMgrQueryPoints(DeviceExtension, Irp);
1180     if (!NT_SUCCESS(Status))
1181     {
1182         return Status;
1183     }
1184
1185     MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
1186     if (MountPoints->NumberOfMountPoints == 0)
1187     {
1188         return Status;
1189     }
1190
1191     /* For all the mount points */
1192     for (Link = 0; Link < MountPoints->NumberOfMountPoints; Link++)
1193     {
1194         SymbolicName.Length = MountPoints->MountPoints[Link].SymbolicLinkNameLength;
1195         SymbolicName.MaximumLength = SymbolicName.Length + sizeof(WCHAR);
1196         SymbolicName.Buffer = AllocatePool(SymbolicName.MaximumLength);
1197         if (!SymbolicName.Buffer)
1198         {
1199             return STATUS_INSUFFICIENT_RESOURCES;
1200         }
1201
1202         RtlCopyMemory(SymbolicName.Buffer,
1203                       (PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].SymbolicLinkNameOffset),
1204                       SymbolicName.Length);
1205         SymbolicName.Buffer[SymbolicName.Length / sizeof(WCHAR)] = UNICODE_NULL;
1206
1207         /* If the only mount point is a drive letter, then create a no letter drive entry */
1208         if (MountPoints->NumberOfMountPoints == 1 && IsDriveLetter(&SymbolicName))
1209         {
1210             UniqueId = AllocatePool(MountPoints->MountPoints[Link].UniqueIdLength + sizeof(MOUNTDEV_UNIQUE_ID));
1211             if (UniqueId)
1212             {
1213                 UniqueId->UniqueIdLength = MountPoints->MountPoints[Link].UniqueIdLength;
1214                 RtlCopyMemory(UniqueId->UniqueId,
1215                               (PMOUNTDEV_UNIQUE_ID)((ULONG_PTR)MountPoints + MountPoints->MountPoints[Link].UniqueIdOffset),
1216                               MountPoints->MountPoints[Link].UniqueIdLength);
1217
1218                 CreateNoDriveLetterEntry(UniqueId);
1219                 FreePool(UniqueId);
1220             }
1221         }
1222
1223         /* Simply delete mount point from DB */
1224         DeleteSymbolicLinkNameFromMemory(DeviceExtension, &SymbolicName, TRUE);
1225         RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE, DatabasePath, SymbolicName.Buffer);
1226         FreePool(SymbolicName.Buffer);
1227     }
1228
1229     return Status;
1230 }
1231
1232 /*
1233  * @implemented
1234  */
1235 NTSTATUS
1236 MountMgrVolumeMountPointChanged(IN PDEVICE_EXTENSION DeviceExtension,
1237                                 IN PIRP Irp,
1238                                 IN NTSTATUS LockStatus,
1239                                 OUT PUNICODE_STRING SourceDeviceName,
1240                                 OUT PUNICODE_STRING SourceSymbolicName,
1241                                 OUT PUNICODE_STRING TargetVolumeName)
1242 {
1243     HANDLE Handle;
1244     NTSTATUS Status;
1245     PFILE_OBJECT FileObject;
1246     PIO_STACK_LOCATION Stack;
1247     ULONG Length, SavedLength;
1248     BOOLEAN FOReferenced = FALSE;
1249     IO_STATUS_BLOCK IoStatusBlock;
1250     OBJECT_ATTRIBUTES ObjectAttributes;
1251     PDEVICE_INFORMATION DeviceInformation;
1252     OBJECT_NAME_INFORMATION ObjectNameInfo;
1253     FILE_FS_DEVICE_INFORMATION FsDeviceInfo;
1254     PFILE_NAME_INFORMATION FileNameInfo = NULL;
1255     PMOUNTMGR_VOLUME_MOUNT_POINT VolumeMountPoint;
1256     POBJECT_NAME_INFORMATION ObjectNameInfoPtr = NULL;
1257     UNICODE_STRING SourceVolumeName, TargetDeviceName;
1258
1259     Stack = IoGetNextIrpStackLocation(Irp);
1260
1261     /* Validate input */
1262     if (Stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(MOUNTMGR_VOLUME_MOUNT_POINT))
1263     {
1264         return STATUS_INVALID_PARAMETER;
1265     }
1266
1267     VolumeMountPoint = (PMOUNTMGR_VOLUME_MOUNT_POINT)Irp->AssociatedIrp.SystemBuffer;
1268
1269     if (((ULONG)VolumeMountPoint->SourceVolumeNameLength + VolumeMountPoint->TargetVolumeNameLength) <
1270         Stack->Parameters.DeviceIoControl.InputBufferLength)
1271     {
1272         return STATUS_INVALID_PARAMETER;
1273     }
1274
1275     /* Get source volume name */
1276     SourceVolumeName.Length =
1277     SourceVolumeName.MaximumLength = VolumeMountPoint->SourceVolumeNameLength;
1278     SourceVolumeName.Buffer = (PWSTR)((ULONG_PTR)VolumeMountPoint + VolumeMountPoint->SourceVolumeNameOffset);
1279
1280     InitializeObjectAttributes(&ObjectAttributes,
1281                                &SourceVolumeName,
1282                                OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
1283                                NULL,
1284                                NULL);
1285
1286     /* Open it */
1287     Status = ZwOpenFile(&Handle,
1288                         SYNCHRONIZE | FILE_READ_ATTRIBUTES,
1289                         &ObjectAttributes,
1290                         &IoStatusBlock,
1291                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1292                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_REPARSE_POINT);
1293     if (!NT_SUCCESS(Status))
1294     {
1295         return Status;
1296     }
1297
1298     TargetDeviceName.Buffer = NULL;
1299
1300     /* Query its attributes */
1301     Status = ZwQueryVolumeInformationFile(Handle,
1302                                           &IoStatusBlock,
1303                                           &FsDeviceInfo,
1304                                           sizeof(FsDeviceInfo),
1305                                           FileFsDeviceInformation);
1306     if (!NT_SUCCESS(Status))
1307     {
1308         goto Cleanup;
1309     }
1310
1311     if (FsDeviceInfo.DeviceType != FILE_DEVICE_DISK && FsDeviceInfo.DeviceType != FILE_DEVICE_VIRTUAL_DISK)
1312     {
1313         goto Cleanup;
1314     }
1315
1316     if (FsDeviceInfo.Characteristics != (FILE_REMOTE_DEVICE | FILE_REMOVABLE_MEDIA))
1317     {
1318         goto Cleanup;
1319     }
1320
1321     /* Reference it */
1322     Status = ObReferenceObjectByHandle(Handle, 0, IoFileObjectType, KernelMode, (PVOID *)&FileObject, NULL);
1323     if (!NT_SUCCESS(Status))
1324     {
1325         goto Cleanup;
1326     }
1327     FOReferenced = TRUE;
1328
1329     /* Get file name */
1330     FileNameInfo = AllocatePool(sizeof(FILE_NAME_INFORMATION));
1331     if (!FileNameInfo)
1332     {
1333         Status = STATUS_INSUFFICIENT_RESOURCES;
1334         goto Cleanup;
1335     }
1336
1337     Status = ZwQueryInformationFile(Handle, &IoStatusBlock, FileNameInfo,
1338                                     sizeof(FILE_NAME_INFORMATION),
1339                                     FileNameInformation);
1340     if (Status == STATUS_BUFFER_OVERFLOW)
1341     {
1342         /* Now we have real length, use it */
1343         Length = FileNameInfo->FileNameLength;
1344         FreePool(FileNameInfo);
1345
1346         FileNameInfo = AllocatePool(sizeof(FILE_NAME_INFORMATION) + Length);
1347         if (!FileNameInfo)
1348         {
1349             Status = STATUS_INSUFFICIENT_RESOURCES;
1350             goto Cleanup;
1351         }
1352
1353         /* Really query file name */
1354         Status = ZwQueryInformationFile(Handle, &IoStatusBlock, FileNameInfo,
1355                                         sizeof(FILE_NAME_INFORMATION) + Length,
1356                                         FileNameInformation);
1357     }
1358
1359     if (!NT_SUCCESS(Status))
1360     {
1361         goto Cleanup;
1362     }
1363
1364     /* Get symbolic name */
1365     ObjectNameInfoPtr = &ObjectNameInfo;
1366     SavedLength = sizeof(OBJECT_NAME_INFORMATION);
1367     Status = ObQueryNameString(FileObject->DeviceObject, ObjectNameInfoPtr, sizeof(OBJECT_NAME_INFORMATION), &Length);
1368     if (Status == STATUS_INFO_LENGTH_MISMATCH)
1369     {
1370         /* Once again, with proper size, it works better */
1371         ObjectNameInfoPtr = AllocatePool(Length);
1372         if (!ObjectNameInfoPtr)
1373         {
1374             Status = STATUS_INSUFFICIENT_RESOURCES;
1375             goto Cleanup;
1376         }
1377
1378         SavedLength = Length;
1379         Status = ObQueryNameString(FileObject->DeviceObject, ObjectNameInfoPtr, SavedLength, &Length);
1380     }
1381
1382     if (!NT_SUCCESS(Status))
1383     {
1384         goto Cleanup;
1385     }
1386
1387     /* Now, query the device name */
1388     Status = QueryDeviceInformation(&ObjectNameInfoPtr->Name, SourceDeviceName,
1389                                     NULL, NULL, NULL, NULL, NULL, NULL);
1390     if (!NT_SUCCESS(Status))
1391     {
1392         goto Cleanup;
1393     }
1394
1395     /* For target volume name, use input */
1396     TargetVolumeName->Length =
1397     TargetVolumeName->MaximumLength = VolumeMountPoint->TargetVolumeNameLength;
1398     TargetVolumeName->Buffer = (PWSTR)((ULONG_PTR)VolumeMountPoint + VolumeMountPoint->TargetVolumeNameOffset);
1399
1400     /* Query its device name */
1401     Status = QueryDeviceInformation(TargetVolumeName, &TargetDeviceName,
1402                                     NULL, NULL, NULL, NULL, NULL, NULL);
1403     if (!NT_SUCCESS(Status))
1404     {
1405         goto Cleanup;
1406     }
1407
1408     /* Return symbolic name */
1409     SourceSymbolicName->Length =
1410     SourceSymbolicName->MaximumLength = (USHORT)FileNameInfo->FileNameLength;
1411     SourceSymbolicName->Buffer = (PWSTR)FileNameInfo;
1412     /* memmove allows memory overlap */
1413     RtlMoveMemory(SourceSymbolicName->Buffer, FileNameInfo->FileName, SourceSymbolicName->Length);
1414     FileNameInfo = NULL;
1415
1416     /* Notify the change */
1417     MountMgrNotify(DeviceExtension);
1418     MountMgrNotifyNameChange(DeviceExtension, &TargetDeviceName, TRUE);
1419
1420     /* If we are locked, sync databases if possible */
1421     if (NT_SUCCESS(LockStatus))
1422     {
1423         Status = FindDeviceInfo(DeviceExtension, SourceDeviceName, FALSE, &DeviceInformation);
1424         if (NT_SUCCESS(Status))
1425         {
1426             ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInformation);
1427         }
1428         else
1429         {
1430             Status = STATUS_PENDING;
1431         }
1432     }
1433
1434 Cleanup:
1435     if (TargetDeviceName.Buffer)
1436     {
1437         FreePool(TargetDeviceName.Buffer);
1438     }
1439
1440     if (ObjectNameInfoPtr && ObjectNameInfoPtr != &ObjectNameInfo)
1441     {
1442         FreePool(ObjectNameInfoPtr);
1443     }
1444
1445     if (FileNameInfo)
1446     {
1447         FreePool(FileNameInfo);
1448     }
1449
1450     if (FOReferenced)
1451     {
1452         ObDereferenceObject(FileObject);
1453     }
1454
1455     return Status;
1456 }
1457
1458 NTSTATUS
1459 MountMgrVolumeMountPointCreated(IN PDEVICE_EXTENSION DeviceExtension,
1460                                 IN PIRP Irp,
1461                                 IN NTSTATUS LockStatus)
1462 {
1463     return STATUS_NOT_IMPLEMENTED;
1464 }
1465
1466 NTSTATUS
1467 MountMgrVolumeMountPointDeleted(IN PDEVICE_EXTENSION DeviceExtension,
1468                                 IN PIRP Irp,
1469                                 IN NTSTATUS LockStatus)
1470 {
1471     return STATUS_NOT_IMPLEMENTED;
1472 }
1473
1474 /*
1475  * @implemented
1476  */
1477 NTSTATUS
1478 NTAPI
1479 MountMgrDeviceControl(IN PDEVICE_OBJECT DeviceObject,
1480                       IN PIRP Irp)
1481 {
1482     PIO_STACK_LOCATION Stack;
1483     NTSTATUS Status, LockStatus;
1484     PDEVICE_EXTENSION DeviceExtension;
1485
1486     Stack = IoGetNextIrpStackLocation(Irp);
1487     DeviceExtension = DeviceObject->DeviceExtension;
1488
1489     KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
1490
1491     switch (Stack->Parameters.DeviceIoControl.IoControlCode)
1492     {
1493         case IOCTL_MOUNTMGR_CREATE_POINT:
1494             Status = MountMgrCreatePoint(DeviceExtension, Irp);
1495             break;
1496
1497         case IOCTL_MOUNTMGR_DELETE_POINTS:
1498             Status = MountMgrDeletePoints(DeviceExtension, Irp);
1499             break;
1500
1501         case IOCTL_MOUNTMGR_QUERY_POINTS:
1502             Status = MountMgrQueryPoints(DeviceExtension, Irp);
1503             break;
1504
1505         case IOCTL_MOUNTMGR_DELETE_POINTS_DBONLY:
1506             Status = MountMgrDeletePointsDbOnly(DeviceExtension, Irp);
1507             break;
1508
1509         case IOCTL_MOUNTMGR_NEXT_DRIVE_LETTER:
1510             Status = MountMgrNextDriveLetter(DeviceExtension, Irp);
1511             break;
1512
1513         case IOCTL_MOUNTMGR_AUTO_DL_ASSIGNMENTS:
1514             DeviceExtension->AutomaticDriveLetter = TRUE;
1515             Status = STATUS_SUCCESS;
1516
1517             MountMgrAssignDriveLetters(DeviceExtension);
1518             ReconcileAllDatabasesWithMaster(DeviceExtension);
1519             WaitForOnlinesToComplete(DeviceExtension);
1520             break;
1521
1522         case IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_CREATED:
1523             KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1524
1525             LockStatus = WaitForRemoteDatabaseSemaphore(DeviceExtension);
1526             KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
1527             Status = MountMgrVolumeMountPointCreated(DeviceExtension, Irp, LockStatus);
1528             if (NT_SUCCESS(LockStatus))
1529             {
1530                 ReleaseRemoteDatabaseSemaphore(DeviceExtension);
1531             }
1532
1533             break;
1534
1535         case IOCTL_MOUNTMGR_VOLUME_MOUNT_POINT_DELETED:
1536             KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1537
1538             LockStatus = WaitForRemoteDatabaseSemaphore(DeviceExtension);
1539             KeWaitForSingleObject(&(DeviceExtension->DeviceLock), Executive, KernelMode, FALSE, NULL);
1540             Status = MountMgrVolumeMountPointDeleted(DeviceExtension, Irp, LockStatus);
1541             if (NT_SUCCESS(LockStatus))
1542             {
1543                 ReleaseRemoteDatabaseSemaphore(DeviceExtension);
1544             }
1545
1546             break;
1547
1548         case IOCTL_MOUNTMGR_CHANGE_NOTIFY:
1549             Status = MountMgrChangeNotify(DeviceExtension, Irp);
1550             break;
1551
1552         case IOCTL_MOUNTMGR_KEEP_LINKS_WHEN_OFFLINE:
1553             Status = MountMgrKeepLinksWhenOffline(DeviceExtension, Irp);
1554             break;
1555
1556         case IOCTL_MOUNTMGR_CHECK_UNPROCESSED_VOLUMES:
1557             Status = MountMgrCheckUnprocessedVolumes(DeviceExtension, Irp);
1558             goto Complete;
1559
1560         case IOCTL_MOUNTMGR_VOLUME_ARRIVAL_NOTIFICATION:
1561             KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1562             Status = MountMgrVolumeArrivalNotification(DeviceExtension, Irp);
1563             goto Complete;
1564
1565         case IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATH:
1566             Status = MountMgrQueryDosVolumePath(DeviceExtension, Irp);
1567             break;
1568
1569         case IOCTL_MOUNTMGR_QUERY_DOS_VOLUME_PATHS:
1570             Status = MountMgrQueryDosVolumePaths(DeviceExtension, Irp);
1571             break;
1572
1573         case IOCTL_MOUNTMGR_SCRUB_REGISTRY:
1574             Status = MountMgrScrubRegistry(DeviceExtension);
1575             break;
1576
1577         case IOCTL_MOUNTMGR_QUERY_AUTO_MOUNT:
1578             Status = MountMgrQueryAutoMount(DeviceExtension, Irp);
1579             break;
1580
1581         case IOCTL_MOUNTMGR_SET_AUTO_MOUNT:
1582             Status = MountMgrSetAutoMount(DeviceExtension, Irp);
1583             break;
1584
1585         default:
1586             Status = STATUS_INVALID_DEVICE_REQUEST;
1587     }
1588
1589     KeReleaseSemaphore(&(DeviceExtension->DeviceLock), IO_NO_INCREMENT, 1, FALSE);
1590
1591     if (Status != STATUS_PENDING)
1592     {
1593         goto Complete;
1594     }
1595
1596     return Status;
1597
1598 Complete:
1599     Irp->IoStatus.Status = Status;
1600     IoCompleteRequest(Irp, IO_NO_INCREMENT);
1601
1602     return Status;
1603 }