drivers/filters/mountmgr/point.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/point.c
  22  * PURPOSE:          Mount Manager - Mount points
  23  * PROGRAMMER:       Pierre Schweitzer (pierre.schweitzer@reactos.org)
  24  */
  25
  26 #include "mntmgr.h"
  27
  28 #define NDEBUG
  29 #include <debug.h>
  30
  31 /*
  32  * @implemented
  33  */
  34 NTSTATUS
  35 MountMgrCreatePointWorker(IN PDEVICE_EXTENSION DeviceExtension,
  36                           IN PUNICODE_STRING SymbolicLinkName,
  37                           IN PUNICODE_STRING DeviceName)
  38 {
  39     NTSTATUS Status;
  40     PLIST_ENTRY DeviceEntry;
  41     PMOUNTDEV_UNIQUE_ID UniqueId;
  42     PSYMLINK_INFORMATION SymlinkInformation;
  43     UNICODE_STRING SymLink, TargetDeviceName;
  44     PDEVICE_INFORMATION DeviceInformation = NULL, DeviceInfo;
  45
  46     /* Get device name */
  47     Status = QueryDeviceInformation(SymbolicLinkName,
  48                                     &TargetDeviceName,
  49                                     NULL, NULL, NULL,
  50                                     NULL, NULL, NULL);
  51     if (!NT_SUCCESS(Status))
  52     {
  53         return Status;
  54     }
  55
  56     /* First of all, try to find device */
  57     for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
  58          DeviceEntry != &(DeviceExtension->DeviceListHead);
  59          DeviceEntry = DeviceEntry->Flink)
  60     {
  61         DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
  62
  63         if (RtlEqualUnicodeString(&TargetDeviceName, &(DeviceInformation->DeviceName), TRUE))
  64         {
  65             break;
  66         }
  67     }
  68
  69     /* Copy symbolic link name and null terminate it */
  70     SymLink.Buffer = AllocatePool(SymbolicLinkName->Length + sizeof(UNICODE_NULL));
  71     if (!SymLink.Buffer)
  72     {
  73         FreePool(TargetDeviceName.Buffer);
  74         return STATUS_INSUFFICIENT_RESOURCES;
  75     }
  76
  77     RtlCopyMemory(SymLink.Buffer, SymbolicLinkName->Buffer, SymbolicLinkName->Length);
  78     SymLink.Buffer[SymbolicLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
  79     SymLink.Length = SymbolicLinkName->Length;
  80     SymLink.MaximumLength = SymbolicLinkName->Length + sizeof(UNICODE_NULL);
  81
  82     /* If we didn't find device */
  83     if (DeviceEntry == &(DeviceExtension->DeviceListHead))
  84     {
  85         /* Then, try with unique ID */
  86         Status = QueryDeviceInformation(SymbolicLinkName,
  87                                         NULL, &UniqueId,
  88                                         NULL, NULL, NULL,
  89                                         NULL, NULL);
  90         if (!NT_SUCCESS(Status))
  91         {
  92             FreePool(TargetDeviceName.Buffer);
  93             FreePool(SymLink.Buffer);
  94             return Status;
  95         }
  96
  97         /* Create a link to the device */
  98         Status = GlobalCreateSymbolicLink(&SymLink, &TargetDeviceName);
  99         if (!NT_SUCCESS(Status))
 100         {
 101             FreePool(UniqueId);
 102             FreePool(TargetDeviceName.Buffer);
 103             FreePool(SymLink.Buffer);
 104             return Status;
 105         }
 106
 107         /* If caller provided driver letter, delete it */
 108         if (IsDriveLetter(&SymLink))
 109         {
 110             DeleteRegistryDriveLetter(UniqueId);
 111         }
 112
 113         /* Device will be identified with its unique ID */
 114         Status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
 115                                        DatabasePath,
 116                                        SymLink.Buffer,
 117                                        REG_BINARY,
 118                                        UniqueId->UniqueId,
 119                                        UniqueId->UniqueIdLength);
 120
 121         FreePool(UniqueId);
 122         FreePool(TargetDeviceName.Buffer);
 123         FreePool(SymLink.Buffer);
 124         return Status;
 125     }
 126
 127     /* If call provided a driver letter whereas device already has one
 128      * fail, this is not doable
 129      */
 130     if (IsDriveLetter(&SymLink) && HasDriveLetter(DeviceInformation))
 131     {
 132         FreePool(TargetDeviceName.Buffer);
 133         FreePool(SymLink.Buffer);
 134         return STATUS_INVALID_PARAMETER;
 135     }
 136
 137     /* Now, create a link */
 138     Status = GlobalCreateSymbolicLink(&SymLink, &TargetDeviceName);
 139     FreePool(TargetDeviceName.Buffer);
 140     if (!NT_SUCCESS(Status))
 141     {
 142         FreePool(SymLink.Buffer);
 143         return Status;
 144     }
 145
 146     /* Associate Unique ID <-> symbolic name */
 147     UniqueId = DeviceInformation->UniqueId;
 148     Status = RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
 149                                    DatabasePath,
 150                                    SymLink.Buffer,
 151                                    REG_BINARY,
 152                                    UniqueId->UniqueId,
 153                                    UniqueId->UniqueIdLength);
 154     if (!NT_SUCCESS(Status))
 155     {
 156         GlobalDeleteSymbolicLink(&SymLink);
 157         FreePool(SymLink.Buffer);
 158         return Status;
 159     }
 160
 161     /* Now, prepare to save the link with the device */
 162     SymlinkInformation = AllocatePool(sizeof(SYMLINK_INFORMATION));
 163     if (!SymlinkInformation)
 164     {
 165         Status = STATUS_INSUFFICIENT_RESOURCES;
 166         GlobalDeleteSymbolicLink(&SymLink);
 167         FreePool(SymLink.Buffer);
 168         return Status;
 169     }
 170
 171     SymlinkInformation->Name.Length = SymLink.Length;
 172     SymlinkInformation->Name.MaximumLength = SymLink.Length + sizeof(UNICODE_NULL);
 173     SymlinkInformation->Name.Buffer = AllocatePool(SymlinkInformation->Name.MaximumLength);
 174     if (!SymlinkInformation->Name.Buffer)
 175     {
 176         Status = STATUS_INSUFFICIENT_RESOURCES;
 177         FreePool(SymlinkInformation);
 178         GlobalDeleteSymbolicLink(&SymLink);
 179         FreePool(SymLink.Buffer);
 180         return Status;
 181     }
 182
 183     /* Save the link and mark it online */
 184     RtlCopyMemory(SymlinkInformation->Name.Buffer, SymLink.Buffer, SymlinkInformation->Name.Length);
 185     SymlinkInformation->Name.Buffer[SymlinkInformation->Name.Length / sizeof(WCHAR)] = UNICODE_NULL;
 186     SymlinkInformation->Online = TRUE;
 187     InsertTailList(&DeviceInformation->SymbolicLinksListHead, &SymlinkInformation->SymbolicLinksListEntry);
 188     SendLinkCreated(&(SymlinkInformation->Name));
 189
 190     /* If we have a drive letter */
 191     if (IsDriveLetter(&SymLink))
 192     {
 193         /* Then, delete the no drive letter entry */
 194         DeleteNoDriveLetterEntry(UniqueId);
 195
 196         /* And post online notification if asked */
 197         if (!DeviceInformation->SkipNotifications)
 198         {
 199             PostOnlineNotification(DeviceExtension, &DeviceInformation->SymbolicName);
 200         }
 201     }
 202
 203     /* If that's a volume with automatic drive letter, it's now time to resync databases */
 204     if (MOUNTMGR_IS_VOLUME_NAME(&SymLink) && DeviceExtension->AutomaticDriveLetter)
 205     {
 206         for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
 207              DeviceEntry != &(DeviceExtension->DeviceListHead);
 208              DeviceEntry = DeviceEntry->Flink)
 209         {
 210             DeviceInfo = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 211
 212             /* If there's one, ofc! */
 213             if (!DeviceInfo->NoDatabase)
 214             {
 215                 ReconcileThisDatabaseWithMaster(DeviceExtension, DeviceInfo);
 216             }
 217         }
 218     }
 219
 220     /* Notify & quit */
 221     FreePool(SymLink.Buffer);
 222     MountMgrNotify(DeviceExtension);
 223
 224     if (!DeviceInformation->ManuallyRegistered)
 225     {
 226         MountMgrNotifyNameChange(DeviceExtension, DeviceName, FALSE);
 227     }
 228
 229     return Status;
 230 }
 231
 232 /*
 233  * @implemented
 234  */
 235 NTSTATUS
 236 QueryPointsFromMemory(IN PDEVICE_EXTENSION DeviceExtension,
 237                       IN PIRP Irp,
 238                       IN PMOUNTDEV_UNIQUE_ID UniqueId OPTIONAL,
 239                       IN PUNICODE_STRING SymbolicName OPTIONAL)
 240 {
 241     NTSTATUS Status;
 242     PIO_STACK_LOCATION Stack;
 243     UNICODE_STRING DeviceName;
 244     ULONG TotalSize, TotalSymLinks;
 245     PMOUNTMGR_MOUNT_POINTS MountPoints;
 246     PDEVICE_INFORMATION DeviceInformation;
 247     PLIST_ENTRY DeviceEntry, SymlinksEntry;
 248     PSYMLINK_INFORMATION SymlinkInformation;
 249
 250     /* If we got a symbolic link, query device */
 251     if (SymbolicName)
 252     {
 253         Status = QueryDeviceInformation(SymbolicName,
 254                                         &DeviceName,
 255                                         NULL, NULL,
 256                                         NULL, NULL,
 257                                         NULL, NULL);
 258         if (!NT_SUCCESS(Status))
 259         {
 260             return Status;
 261         }
 262     }
 263
 264     /* Browse all the links to count number of links & size used */
 265     TotalSize = 0;
 266     TotalSymLinks = 0;
 267     for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
 268          DeviceEntry != &(DeviceExtension->DeviceListHead);
 269          DeviceEntry = DeviceEntry->Flink)
 270     {
 271         DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 272
 273         /* If we were given an unique ID, it has to match */
 274         if (UniqueId)
 275         {
 276             if (UniqueId->UniqueIdLength != DeviceInformation->UniqueId->UniqueIdLength)
 277             {
 278                 continue;
 279             }
 280
 281             if (RtlCompareMemory(UniqueId->UniqueId,
 282                                  DeviceInformation->UniqueId->UniqueId,
 283                                  UniqueId->UniqueIdLength) != UniqueId->UniqueIdLength)
 284             {
 285                 continue;
 286             }
 287         }
 288         /* Or, if we had a symlink, it has to match */
 289         else if (SymbolicName)
 290         {
 291             if (!RtlEqualUnicodeString(&DeviceName, &(DeviceInformation->DeviceName), TRUE))
 292             {
 293                 continue;
 294             }
 295         }
 296
 297         /* Once here, it matched, save device name & unique ID size */
 298         TotalSize += DeviceInformation->DeviceName.Length + DeviceInformation->UniqueId->UniqueIdLength;
 299
 300         /* And count number of symlinks (and their size) */
 301         for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
 302              SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
 303              SymlinksEntry = SymlinksEntry->Flink)
 304         {
 305             SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 306
 307             TotalSize += SymlinkInformation->Name.Length;
 308             TotalSymLinks++;
 309         }
 310
 311         /* We had a specific item to find
 312          * if we reach that point, we found it, no need to continue
 313          */
 314         if (UniqueId || SymbolicName)
 315         {
 316             break;
 317         }
 318     }
 319
 320     /* If we were looking for specific item, ensure we found it */
 321     if (UniqueId || SymbolicName)
 322     {
 323         if (DeviceEntry == &(DeviceExtension->DeviceListHead))
 324         {
 325             if (SymbolicName)
 326             {
 327                 FreePool(DeviceName.Buffer);
 328             }
 329
 330             return STATUS_INVALID_PARAMETER;
 331         }
 332     }
 333
 334     /* Now, ensure output buffer can hold everything */
 335     Stack = IoGetCurrentIrpStackLocation(Irp);
 336     MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
 337
 338     /* Ensure we set output to let user reallocate! */
 339     MountPoints->Size = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalSymLinks * sizeof(MOUNTMGR_MOUNT_POINT) + TotalSize;
 340     MountPoints->NumberOfMountPoints = TotalSymLinks;
 341     Irp->IoStatus.Information = MountPoints->Size;
 342
 343     if (MountPoints->Size > Stack->Parameters.DeviceIoControl.OutputBufferLength)
 344     {
 345         Irp->IoStatus.Information = sizeof(MOUNTMGR_MOUNT_POINTS);
 346
 347         if (SymbolicName)
 348         {
 349             FreePool(DeviceName.Buffer);
 350         }
 351
 352         return STATUS_BUFFER_OVERFLOW;
 353     }
 354
 355     /* Now, start putting mount points */
 356     TotalSize = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalSymLinks * sizeof(MOUNTMGR_MOUNT_POINT);
 357     TotalSymLinks = 0;
 358     for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
 359          DeviceEntry != &(DeviceExtension->DeviceListHead);
 360          DeviceEntry = DeviceEntry->Flink)
 361     {
 362         DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 363
 364         /* Find back correct mount point */
 365         if (UniqueId)
 366         {
 367             if (UniqueId->UniqueIdLength != DeviceInformation->UniqueId->UniqueIdLength)
 368             {
 369                 continue;
 370             }
 371
 372             if (RtlCompareMemory(UniqueId->UniqueId,
 373                                  DeviceInformation->UniqueId->UniqueId,
 374                                  UniqueId->UniqueIdLength) != UniqueId->UniqueIdLength)
 375             {
 376                 continue;
 377             }
 378         }
 379         else if (SymbolicName)
 380         {
 381             if (!RtlEqualUnicodeString(&DeviceName, &(DeviceInformation->DeviceName), TRUE))
 382             {
 383                 continue;
 384             }
 385         }
 386
 387         /* Now we've got it, but all the data */
 388         for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
 389              SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
 390              SymlinksEntry = SymlinksEntry->Flink)
 391         {
 392             SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 393
 394             MountPoints->MountPoints[TotalSymLinks].SymbolicLinkNameOffset = TotalSize;
 395             MountPoints->MountPoints[TotalSymLinks].SymbolicLinkNameLength = SymlinkInformation->Name.Length;
 396             MountPoints->MountPoints[TotalSymLinks].UniqueIdOffset = SymlinkInformation->Name.Length +
 397                                                                      TotalSize;
 398             MountPoints->MountPoints[TotalSymLinks].UniqueIdLength = DeviceInformation->UniqueId->UniqueIdLength;
 399             MountPoints->MountPoints[TotalSymLinks].DeviceNameOffset = SymlinkInformation->Name.Length +
 400                                                                        DeviceInformation->UniqueId->UniqueIdLength +
 401                                                                        TotalSize;
 402             MountPoints->MountPoints[TotalSymLinks].DeviceNameLength = DeviceInformation->DeviceName.Length;
 403
 404             RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[TotalSymLinks].SymbolicLinkNameOffset),
 405                           SymlinkInformation->Name.Buffer, SymlinkInformation->Name.Length);
 406             RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[TotalSymLinks].UniqueIdOffset),
 407                           DeviceInformation->UniqueId->UniqueId, DeviceInformation->UniqueId->UniqueIdLength);
 408             RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[TotalSymLinks].DeviceNameOffset),
 409                   DeviceInformation->DeviceName.Buffer, DeviceInformation->DeviceName.Length);
 410
 411             /* Update counters */
 412             TotalSymLinks++;
 413             TotalSize += SymlinkInformation->Name.Length + DeviceInformation->UniqueId->UniqueIdLength +
 414                          DeviceInformation->DeviceName.Length;
 415         }
 416
 417         if (UniqueId || SymbolicName)
 418         {
 419             break;
 420         }
 421     }
 422
 423     if (SymbolicName)
 424     {
 425         FreePool(DeviceName.Buffer);
 426     }
 427
 428     return STATUS_SUCCESS;
 429 }
 430
 431 /*
 432  * @implemented
 433  */
 434 NTSTATUS
 435 QueryPointsFromSymbolicLinkName(IN PDEVICE_EXTENSION DeviceExtension,
 436                                 IN PUNICODE_STRING SymbolicName,
 437                                 IN PIRP Irp)
 438 {
 439     NTSTATUS Status;
 440     ULONG TotalLength;
 441     PIO_STACK_LOCATION Stack;
 442     UNICODE_STRING DeviceName;
 443     PMOUNTMGR_MOUNT_POINTS MountPoints;
 444     PDEVICE_INFORMATION DeviceInformation = NULL;
 445     PLIST_ENTRY DeviceEntry, SymlinksEntry;
 446     PSYMLINK_INFORMATION SymlinkInformation;
 447
 448     /* Find device */
 449     Status = QueryDeviceInformation(SymbolicName, &DeviceName,
 450                                     NULL, NULL, NULL,
 451                                     NULL, NULL, NULL);
 452     if (NT_SUCCESS(Status))
 453     {
 454         /* Look for the device information */
 455         for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
 456              DeviceEntry != &(DeviceExtension->DeviceListHead);
 457              DeviceEntry = DeviceEntry->Flink)
 458         {
 459             DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 460
 461             if (RtlEqualUnicodeString(&DeviceName, &(DeviceInformation->DeviceName), TRUE))
 462             {
 463                 break;
 464             }
 465         }
 466
 467         FreePool(DeviceName.Buffer);
 468
 469         if (DeviceEntry == &(DeviceExtension->DeviceListHead))
 470         {
 471             return STATUS_INVALID_PARAMETER;
 472         }
 473
 474         /* Check for the link */
 475         for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
 476              SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
 477              SymlinksEntry = SymlinksEntry->Flink)
 478         {
 479             SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 480
 481             if (RtlEqualUnicodeString(SymbolicName, &SymlinkInformation->Name, TRUE))
 482             {
 483                 break;
 484             }
 485         }
 486
 487         if (SymlinksEntry == &(DeviceInformation->SymbolicLinksListHead))
 488         {
 489             return STATUS_INVALID_PARAMETER;
 490         }
 491     }
 492     else
 493     {
 494         /* Browse all the devices to try to find the one
 495          * that has the given link...
 496          */
 497         for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
 498              DeviceEntry != &(DeviceExtension->DeviceListHead);
 499              DeviceEntry = DeviceEntry->Flink)
 500         {
 501             DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
 502
 503             for (SymlinksEntry = DeviceInformation->SymbolicLinksListHead.Flink;
 504                  SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead);
 505                  SymlinksEntry = SymlinksEntry->Flink)
 506             {
 507                 SymlinkInformation = CONTAINING_RECORD(SymlinksEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
 508
 509                 if (RtlEqualUnicodeString(SymbolicName, &SymlinkInformation->Name, TRUE))
 510                 {
 511                     break;
 512                 }
 513             }
 514
 515             if (SymlinksEntry != &(DeviceInformation->SymbolicLinksListHead))
 516             {
 517                 break;
 518             }
 519         }
 520
 521         /* Even that way we didn't find, give up! */
 522         if (DeviceEntry == &(DeviceExtension->DeviceListHead))
 523         {
 524             return STATUS_OBJECT_NAME_NOT_FOUND;
 525         }
 526     }
 527
 528     /* Get output buffer */
 529     Stack = IoGetCurrentIrpStackLocation(Irp);
 530     MountPoints = (PMOUNTMGR_MOUNT_POINTS)Irp->AssociatedIrp.SystemBuffer;
 531
 532     /* Compute output length */
 533     TotalLength = DeviceInformation->UniqueId->UniqueIdLength +
 534                   SymlinkInformation->Name.Length + DeviceInformation->DeviceName.Length;
 535
 536     /* Give length to allow reallocation */
 537     MountPoints->Size = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalLength;
 538     MountPoints->NumberOfMountPoints = 1;
 539     Irp->IoStatus.Information = sizeof(MOUNTMGR_MOUNT_POINTS) + TotalLength;
 540
 541     if (MountPoints->Size > Stack->Parameters.DeviceIoControl.OutputBufferLength)
 542     {
 543         Irp->IoStatus.Information = sizeof(MOUNTMGR_MOUNT_POINTS);
 544
 545         return STATUS_BUFFER_OVERFLOW;
 546     }
 547
 548     /* Write out data */
 549     MountPoints->MountPoints[0].SymbolicLinkNameOffset = sizeof(MOUNTMGR_MOUNT_POINTS);
 550     MountPoints->MountPoints[0].SymbolicLinkNameLength = SymlinkInformation->Name.Length;
 551     /* If link is online write it's unique ID, otherwise, forget about it */
 552     if (SymlinkInformation->Online)
 553     {
 554         MountPoints->MountPoints[0].UniqueIdOffset = sizeof(MOUNTMGR_MOUNT_POINTS) +
 555                                                      SymlinkInformation->Name.Length;
 556         MountPoints->MountPoints[0].UniqueIdLength = DeviceInformation->UniqueId->UniqueIdLength;
 557     }
 558     else
 559     {
 560         MountPoints->MountPoints[0].UniqueIdOffset = 0;
 561         MountPoints->MountPoints[0].UniqueIdLength = 0;
 562     }
 563
 564     MountPoints->MountPoints[0].DeviceNameOffset = sizeof(MOUNTMGR_MOUNT_POINTS) +
 565                                                    SymlinkInformation->Name.Length +
 566                                                    DeviceInformation->UniqueId->UniqueIdLength;
 567     MountPoints->MountPoints[0].DeviceNameLength = DeviceInformation->DeviceName.Length;
 568
 569     RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[0].SymbolicLinkNameOffset),
 570                   SymlinkInformation->Name.Buffer, SymlinkInformation->Name.Length);
 571
 572     if (SymlinkInformation->Online)
 573     {
 574         RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[0].UniqueIdOffset),
 575                       DeviceInformation->UniqueId->UniqueId, DeviceInformation->UniqueId->UniqueIdLength);
 576     }
 577
 578     RtlCopyMemory((PWSTR)((ULONG_PTR)MountPoints + MountPoints->MountPoints[0].DeviceNameOffset),
 579                   DeviceInformation->DeviceName.Buffer, DeviceInformation->DeviceName.Length);
 580
 581     return STATUS_SUCCESS;
 582 }