xref: /reactos/drivers/storage/mountmgr/symlink.c (revision 53221834) 
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/symlink.c
22  * PURPOSE:          Mount Manager - Symbolic links functions
23  * PROGRAMMER:       Pierre Schweitzer (pierre.schweitzer@reactos.org)
24  */
25 
26 #include "mntmgr.h"
27 
28 #define NDEBUG
29 #include <debug.h>
30 
31 UNICODE_STRING DeviceMount = RTL_CONSTANT_STRING(MOUNTMGR_DEVICE_NAME);
32 UNICODE_STRING DosDevicesMount = RTL_CONSTANT_STRING(L"\\DosDevices\\MountPointManager");
33 UNICODE_STRING DosDevices = RTL_CONSTANT_STRING(L"\\DosDevices\\");
34 UNICODE_STRING DeviceFloppy = RTL_CONSTANT_STRING(L"\\Device\\Floppy");
35 UNICODE_STRING DeviceCdRom = RTL_CONSTANT_STRING(L"\\Device\\CdRom");
36 UNICODE_STRING DosGlobal = RTL_CONSTANT_STRING(L"\\GLOBAL??\\");
37 UNICODE_STRING Global = RTL_CONSTANT_STRING(L"\\??\\");
38 UNICODE_STRING SafeVolumes = RTL_CONSTANT_STRING(L"\\Device\\VolumesSafeForWriteAccess");
39 UNICODE_STRING Volume = RTL_CONSTANT_STRING(L"\\??\\Volume");
40 UNICODE_STRING ReparseIndex = RTL_CONSTANT_STRING(L"\\$Extend\\$Reparse:$R:$INDEX_ALLOCATION");
41 
42 /*
43  * @implemented
44  */
45 NTSTATUS
46 CreateStringWithGlobal(IN PUNICODE_STRING DosName,
47                        OUT PUNICODE_STRING GlobalString)
48 {
49     UNICODE_STRING IntGlobal;
50 
51     if (RtlPrefixUnicodeString(&DosDevices, DosName, TRUE))
52     {
53         /* DOS device - use DOS global */
54         IntGlobal.Length = DosName->Length - DosDevices.Length + DosGlobal.Length;
55         IntGlobal.MaximumLength = IntGlobal.Length + sizeof(WCHAR);
56         IntGlobal.Buffer = AllocatePool(IntGlobal.MaximumLength);
57         if (!IntGlobal.Buffer)
58         {
59             return STATUS_INSUFFICIENT_RESOURCES;
60         }
61 
62         RtlCopyMemory(IntGlobal.Buffer, DosGlobal.Buffer, DosGlobal.Length);
63         RtlCopyMemory(IntGlobal.Buffer + (DosGlobal.Length / sizeof(WCHAR)),
64                       DosName->Buffer + (DosDevices.Length / sizeof(WCHAR)),
65                       DosName->Length - DosDevices.Length);
66         IntGlobal.Buffer[IntGlobal.Length / sizeof(WCHAR)] = UNICODE_NULL;
67     }
68     else if (RtlPrefixUnicodeString(&Global, DosName, TRUE))
69     {
70         /* Switch to DOS global */
71         IntGlobal.Length = DosName->Length - Global.Length + DosGlobal.Length;
72         IntGlobal.MaximumLength = IntGlobal.Length + sizeof(WCHAR);
73         IntGlobal.Buffer = AllocatePool(IntGlobal.MaximumLength);
74         if (!IntGlobal.Buffer)
75         {
76             return STATUS_INSUFFICIENT_RESOURCES;
77         }
78 
79         RtlCopyMemory(IntGlobal.Buffer, DosGlobal.Buffer, DosGlobal.Length);
80         RtlCopyMemory(IntGlobal.Buffer + (DosGlobal.Length / sizeof(WCHAR)),
81                       DosName->Buffer + (Global.Length / sizeof(WCHAR)),
82                       DosName->Length - Global.Length);
83         IntGlobal.Buffer[IntGlobal.Length / sizeof(WCHAR)] = UNICODE_NULL;
84     }
85     else
86     {
87         /* Simply duplicate string */
88         IntGlobal.Length = DosName->Length;
89         IntGlobal.MaximumLength = DosName->MaximumLength;
90         IntGlobal.Buffer = AllocatePool(IntGlobal.MaximumLength);
91         if (!IntGlobal.Buffer)
92         {
93             return STATUS_INSUFFICIENT_RESOURCES;
94         }
95 
96         RtlCopyMemory(IntGlobal.Buffer, DosName->Buffer, IntGlobal.MaximumLength);
97     }
98 
99     /* Return string */
100     GlobalString->Length = IntGlobal.Length;
101     GlobalString->MaximumLength = IntGlobal.MaximumLength;
102     GlobalString->Buffer = IntGlobal.Buffer;
103 
104     return STATUS_SUCCESS;
105 }
106 
107 /*
108  * @implemented
109  */
110 NTSTATUS
111 GlobalCreateSymbolicLink(IN PUNICODE_STRING DosName,
112                          IN PUNICODE_STRING DeviceName)
113 {
114     NTSTATUS Status;
115     UNICODE_STRING GlobalName;
116 
117     /* First create the global string */
118     Status = CreateStringWithGlobal(DosName, &GlobalName);
119     if (!NT_SUCCESS(Status))
120     {
121         return Status;
122     }
123 
124     /* Then, create the symlink */
125     Status = IoCreateSymbolicLink(&GlobalName, DeviceName);
126 
127     FreePool(GlobalName.Buffer);
128 
129     return Status;
130 }
131 
132 /*
133  * @implemented
134  */
135 NTSTATUS
136 GlobalDeleteSymbolicLink(IN PUNICODE_STRING DosName)
137 {
138     NTSTATUS Status;
139     UNICODE_STRING GlobalName;
140 
141     /* Recreate the string (to find the link) */
142     Status = CreateStringWithGlobal(DosName, &GlobalName);
143     if (!NT_SUCCESS(Status))
144     {
145         return Status;
146     }
147 
148     /* And delete the link */
149     Status = IoDeleteSymbolicLink(&GlobalName);
150 
151     FreePool(GlobalName.Buffer);
152 
153     return Status;
154 }
155 
156 /*
157  * @implemented
158  */
159 VOID
160 SendLinkCreated(IN PUNICODE_STRING SymbolicName)
161 {
162     PIRP Irp;
163     KEVENT Event;
164     ULONG NameSize;
165     NTSTATUS Status;
166     PFILE_OBJECT FileObject;
167     PIO_STACK_LOCATION Stack;
168     PMOUNTDEV_NAME Name = NULL;
169     PDEVICE_OBJECT DeviceObject;
170     IO_STATUS_BLOCK IoStatusBlock;
171 
172     /* Get the device associated with the name */
173     Status = IoGetDeviceObjectPointer(SymbolicName,
174                                       FILE_READ_ATTRIBUTES,
175                                       &FileObject,
176                                       &DeviceObject);
177     if (!NT_SUCCESS(Status))
178     {
179         return;
180     }
181 
182     /* Get attached device (will notify it) */
183     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
184 
185     /* NameSize is the size of the whole MOUNTDEV_NAME struct */
186     NameSize = sizeof(USHORT) + SymbolicName->Length;
187     Name = AllocatePool(NameSize);
188     if (!Name)
189     {
190         goto Cleanup;
191     }
192 
193     /* Initialize struct */
194     Name->NameLength = SymbolicName->Length;
195     RtlCopyMemory(Name->Name, SymbolicName->Buffer, SymbolicName->Length);
196 
197     KeInitializeEvent(&Event, NotificationEvent, FALSE);
198     /* Microsoft does it twice... Once with limited access, second with any
199      * So, first one here
200      */
201     Irp = IoBuildDeviceIoControlRequest(CTL_CODE(MOUNTDEVCONTROLTYPE, 4, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
202                                         DeviceObject,
203                                         Name,
204                                         NameSize,
205                                         NULL,
206                                         0,
207                                         FALSE,
208                                         &Event,
209                                         &IoStatusBlock);
210     /* This one can fail, no one matters */
211     if (Irp)
212     {
213         Stack = IoGetNextIrpStackLocation(Irp);
214         Stack->FileObject = FileObject;
215 
216         Status = IoCallDriver(DeviceObject, Irp);
217         if (Status == STATUS_PENDING)
218         {
219             KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
220         }
221     }
222 
223     /* Then, second one */
224     KeInitializeEvent(&Event, NotificationEvent, FALSE);
225     Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_LINK_CREATED,
226                                         DeviceObject,
227                                         Name,
228                                         NameSize,
229                                         NULL,
230                                         0,
231                                         FALSE,
232                                         &Event,
233                                         &IoStatusBlock);
234     if (!Irp)
235     {
236         goto Cleanup;
237     }
238 
239     Stack = IoGetNextIrpStackLocation(Irp);
240     Stack->FileObject = FileObject;
241 
242     /* Really notify */
243     Status = IoCallDriver(DeviceObject, Irp);
244     if (Status == STATUS_PENDING)
245     {
246         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
247     }
248 
249 Cleanup:
250     if (Name)
251     {
252         FreePool(Name);
253     }
254 
255     ObDereferenceObject(DeviceObject);
256     ObDereferenceObject(FileObject);
257 
258     return;
259 }
260 
261 /*
262  * @implemented
263  */
264 VOID
265 SendLinkDeleted(IN PUNICODE_STRING DeviceName,
266                 IN PUNICODE_STRING SymbolicName)
267 {
268     PIRP Irp;
269     KEVENT Event;
270     ULONG NameSize;
271     NTSTATUS Status;
272     PFILE_OBJECT FileObject;
273     PIO_STACK_LOCATION Stack;
274     PMOUNTDEV_NAME Name = NULL;
275     PDEVICE_OBJECT DeviceObject;
276     IO_STATUS_BLOCK IoStatusBlock;
277 
278     /* Get the device associated with the name */
279     Status = IoGetDeviceObjectPointer(DeviceName,
280                                       FILE_READ_ATTRIBUTES,
281                                       &FileObject,
282                                       &DeviceObject);
283     if (!NT_SUCCESS(Status))
284     {
285         return;
286     }
287 
288     /* Get attached device (will notify it) */
289     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
290 
291     /* NameSize is the size of the whole MOUNTDEV_NAME struct */
292     NameSize = sizeof(USHORT) + SymbolicName->Length;
293     Name = AllocatePool(NameSize);
294     if (!Name)
295     {
296         goto Cleanup;
297     }
298 
299     /* Initialize struct */
300     Name->NameLength = SymbolicName->Length;
301     RtlCopyMemory(Name->Name, SymbolicName->Buffer, SymbolicName->Length);
302 
303     KeInitializeEvent(&Event, NotificationEvent, FALSE);
304     /* Cf: SendLinkCreated comment */
305     Irp = IoBuildDeviceIoControlRequest(CTL_CODE(MOUNTDEVCONTROLTYPE, 5, METHOD_BUFFERED, FILE_READ_ACCESS | FILE_WRITE_ACCESS),
306                                         DeviceObject,
307                                         Name,
308                                         NameSize,
309                                         NULL,
310                                         0,
311                                         FALSE,
312                                         &Event,
313                                         &IoStatusBlock);
314     /* This one can fail, no one matters */
315     if (Irp)
316     {
317         Stack = IoGetNextIrpStackLocation(Irp);
318         Stack->FileObject = FileObject;
319 
320         Status = IoCallDriver(DeviceObject, Irp);
321         if (Status == STATUS_PENDING)
322         {
323             KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
324         }
325     }
326 
327     /* Then, second one */
328     KeInitializeEvent(&Event, NotificationEvent, FALSE);
329     Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_LINK_DELETED,
330                                         DeviceObject,
331                                         Name,
332                                         NameSize,
333                                         NULL,
334                                         0,
335                                         FALSE,
336                                         &Event,
337                                         &IoStatusBlock);
338     if (!Irp)
339     {
340         goto Cleanup;
341     }
342 
343     Stack = IoGetNextIrpStackLocation(Irp);
344     Stack->FileObject = FileObject;
345 
346     /* Really notify */
347     Status = IoCallDriver(DeviceObject, Irp);
348     if (Status == STATUS_PENDING)
349     {
350         KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
351     }
352 
353 Cleanup:
354     if (Name)
355     {
356         FreePool(Name);
357     }
358 
359     ObDereferenceObject(DeviceObject);
360     ObDereferenceObject(FileObject);
361 
362     return;
363 }
364 
365 /*
366  * @implemented
367  */
368 NTSTATUS
369 NTAPI
370 SymbolicLinkNamesFromUniqueIdCount(IN PWSTR ValueName,
371                                    IN ULONG ValueType,
372                                    IN PVOID ValueData,
373                                    IN ULONG ValueLength,
374                                    IN PVOID Context,
375                                    IN PVOID EntryContext)
376 {
377     UNICODE_STRING ValueNameString;
378     PMOUNTDEV_UNIQUE_ID UniqueId = Context;
379 
380     if (ValueName[0] != L'#' || ValueType != REG_BINARY ||
381         (UniqueId->UniqueIdLength != ValueLength))
382     {
383         return STATUS_SUCCESS;
384     }
385 
386     if (RtlCompareMemory(UniqueId->UniqueId, ValueData, ValueLength) != ValueLength)
387     {
388         return STATUS_SUCCESS;
389     }
390 
391     /* That one matched, increase count */
392     RtlInitUnicodeString(&ValueNameString, ValueName);
393     if (ValueNameString.Length)
394     {
395         (*((PULONG)EntryContext))++;
396     }
397 
398     return STATUS_SUCCESS;
399 }
400 
401 /*
402  * @implemented
403  */
404 NTSTATUS
405 NTAPI
406 SymbolicLinkNamesFromUniqueIdQuery(IN PWSTR ValueName,
407                                    IN ULONG ValueType,
408                                    IN PVOID ValueData,
409                                    IN ULONG ValueLength,
410                                    IN PVOID Context,
411                                    IN PVOID EntryContext)
412 {
413     UNICODE_STRING ValueNameString;
414     PMOUNTDEV_UNIQUE_ID UniqueId = Context;
415     /* Unicode strings table */
416     PUNICODE_STRING ReturnString = EntryContext;
417 
418     if (ValueName[0] != L'#' || ValueType != REG_BINARY ||
419         (UniqueId->UniqueIdLength != ValueLength))
420     {
421         return STATUS_SUCCESS;
422     }
423 
424     if (RtlCompareMemory(UniqueId->UniqueId, ValueData, ValueLength) != ValueLength)
425     {
426         return STATUS_SUCCESS;
427     }
428 
429     /* Unique ID matches, let's put the symlink */
430     RtlInitUnicodeString(&ValueNameString, ValueName);
431     if (!ValueNameString.Length)
432     {
433         return STATUS_SUCCESS;
434     }
435 
436     /* Allocate string to copy */
437     ValueNameString.Buffer = AllocatePool(ValueNameString.MaximumLength);
438     if (!ValueNameString.Buffer)
439     {
440         return STATUS_SUCCESS;
441     }
442 
443     /* Copy */
444     RtlCopyMemory(ValueNameString.Buffer, ValueName, ValueNameString.Length);
445     ValueNameString.Buffer[ValueNameString.Length / sizeof(WCHAR)] = UNICODE_NULL;
446 
447     while (ReturnString->Length)
448     {
449         ReturnString++;
450     }
451 
452     /* And return that string */
453     *ReturnString = ValueNameString;
454 
455     return STATUS_SUCCESS;
456 }
457 
458 /*
459  * @implemented
460  */
461 NTSTATUS
462 CreateNewVolumeName(OUT PUNICODE_STRING VolumeName,
463                     IN PGUID VolumeGuid OPTIONAL)
464 {
465     GUID Guid;
466     NTSTATUS Status;
467     UNICODE_STRING GuidString;
468 
469     /* If no GUID was provided, then create one */
470     if (!VolumeGuid)
471     {
472         Status = ExUuidCreate(&Guid);
473         if (!NT_SUCCESS(Status))
474         {
475             return Status;
476         }
477     }
478     else
479     {
480         RtlCopyMemory(&Guid, VolumeGuid, sizeof(GUID));
481     }
482 
483     /* Convert GUID to string */
484     Status = RtlStringFromGUID(&Guid, &GuidString);
485     if (!NT_SUCCESS(Status))
486     {
487         return Status;
488     }
489 
490     /* Size for volume namespace, literal GUID, and null char */
491     VolumeName->MaximumLength = 0x14 + 0x4C + sizeof(UNICODE_NULL);
492     VolumeName->Buffer = AllocatePool(0x14 + 0x4C + sizeof(UNICODE_NULL));
493     if (!VolumeName->Buffer)
494     {
495         Status = STATUS_INSUFFICIENT_RESOURCES;
496     }
497     else
498     {
499         RtlCopyUnicodeString(VolumeName, &Volume);
500         RtlAppendUnicodeStringToString(VolumeName, &GuidString);
501         VolumeName->Buffer[VolumeName->Length / sizeof(WCHAR)] = UNICODE_NULL;
502         Status = STATUS_SUCCESS;
503     }
504 
505     ExFreePoolWithTag(GuidString.Buffer, 0);
506 
507     return Status;
508 }
509 
510 /*
511  * @implemented
512  */
513 NTSTATUS
514 QuerySymbolicLinkNamesFromStorage(IN PDEVICE_EXTENSION DeviceExtension,
515                                   IN PDEVICE_INFORMATION DeviceInformation,
516                                   IN PUNICODE_STRING SuggestedLinkName,
517                                   IN BOOLEAN UseOnlyIfThereAreNoOtherLinks,
518                                   OUT PUNICODE_STRING * SymLinks,
519                                   OUT PULONG SymLinkCount,
520                                   IN BOOLEAN HasGuid,
521                                   IN LPGUID Guid)
522 {
523     NTSTATUS Status;
524     BOOLEAN WriteNew;
525     RTL_QUERY_REGISTRY_TABLE QueryTable[2];
526 
527     UNREFERENCED_PARAMETER(DeviceExtension);
528 
529     /* First of all, count links */
530     RtlZeroMemory(QueryTable, sizeof(QueryTable));
531     QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdCount;
532     QueryTable[0].EntryContext = SymLinkCount;
533     *SymLinkCount = 0;
534 
535     Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
536                                     DatabasePath,
537                                     QueryTable,
538                                     DeviceInformation->UniqueId,
539                                     NULL);
540     if (!NT_SUCCESS(Status))
541     {
542         *SymLinkCount = 0;
543     }
544 
545     /* Check if we have to write a new one first */
546     if (SuggestedLinkName && !IsDriveLetter(SuggestedLinkName) &&
547         UseOnlyIfThereAreNoOtherLinks && *SymLinkCount == 0)
548     {
549         WriteNew = TRUE;
550     }
551     else
552     {
553         WriteNew = FALSE;
554     }
555 
556     /* If has GUID, it makes one more link */
557     if (HasGuid)
558     {
559         (*SymLinkCount)++;
560     }
561 
562     if (WriteNew)
563     {
564         /* Write link */
565         RtlWriteRegistryValue(RTL_REGISTRY_ABSOLUTE,
566                               DatabasePath,
567                               SuggestedLinkName->Buffer,
568                               REG_BINARY,
569                               DeviceInformation->UniqueId->UniqueId,
570                               DeviceInformation->UniqueId->UniqueIdLength);
571 
572         /* And recount all the needed links */
573         RtlZeroMemory(QueryTable, sizeof(QueryTable));
574         QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdCount;
575         QueryTable[0].EntryContext = SymLinkCount;
576         *SymLinkCount = 0;
577 
578         Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
579                                         DatabasePath,
580                                         QueryTable,
581                                         DeviceInformation->UniqueId,
582                                         NULL);
583         if (!NT_SUCCESS(Status))
584         {
585             return STATUS_NOT_FOUND;
586         }
587     }
588 
589     /* Not links found? */
590     if (!*SymLinkCount)
591     {
592         return STATUS_NOT_FOUND;
593     }
594 
595     /* Allocate a buffer big enough to hold symlinks (table of unicode strings) */
596     *SymLinks = AllocatePool(*SymLinkCount * sizeof(UNICODE_STRING));
597     if (!*SymLinks)
598     {
599         return STATUS_INSUFFICIENT_RESOURCES;
600     }
601 
602     /* Prepare to query links */
603     RtlZeroMemory(*SymLinks, *SymLinkCount * sizeof(UNICODE_STRING));
604     RtlZeroMemory(QueryTable, sizeof(QueryTable));
605     QueryTable[0].QueryRoutine = SymbolicLinkNamesFromUniqueIdQuery;
606 
607     /* No GUID? Keep it that way */
608     if (!HasGuid)
609     {
610         QueryTable[0].EntryContext = *SymLinks;
611     }
612     /* Otherwise, first create volume name */
613     else
614     {
615         Status = CreateNewVolumeName(SymLinks[0], Guid);
616         if (!NT_SUCCESS(Status))
617         {
618             FreePool(*SymLinks);
619             return Status;
620         }
621 
622         /* Skip first link (ours) */
623         QueryTable[0].EntryContext = *SymLinks + 1;
624     }
625 
626     /* Now, query */
627     RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
628                            DatabasePath,
629                            QueryTable,
630                            DeviceInformation->UniqueId,
631                            NULL);
632 
633     return STATUS_SUCCESS;
634 }
635 
636 /*
637  * @implemented
638  */
639 PSAVED_LINK_INFORMATION
640 RemoveSavedLinks(IN PDEVICE_EXTENSION DeviceExtension,
641                  IN PMOUNTDEV_UNIQUE_ID UniqueId)
642 {
643     PLIST_ENTRY NextEntry;
644     PSAVED_LINK_INFORMATION SavedLinkInformation;
645 
646     /* No saved links? Easy! */
647     if (IsListEmpty(&(DeviceExtension->SavedLinksListHead)))
648     {
649         return NULL;
650     }
651 
652     /* Now, browse saved links */
653     for (NextEntry = DeviceExtension->SavedLinksListHead.Flink;
654          NextEntry != &(DeviceExtension->SavedLinksListHead);
655          NextEntry = NextEntry->Flink)
656     {
657         SavedLinkInformation = CONTAINING_RECORD(NextEntry,
658                                                  SAVED_LINK_INFORMATION,
659                                                  SavedLinksListEntry);
660 
661         /* Find the one that matches */
662         if (SavedLinkInformation->UniqueId->UniqueIdLength == UniqueId->UniqueIdLength)
663         {
664             if (RtlCompareMemory(SavedLinkInformation->UniqueId->UniqueId,
665                                  UniqueId->UniqueId,
666                                  UniqueId->UniqueIdLength) ==
667                 UniqueId->UniqueIdLength)
668             {
669                 /* Remove it and return it */
670                 RemoveEntryList(&(SavedLinkInformation->SavedLinksListEntry));
671                 return SavedLinkInformation;
672             }
673         }
674     }
675 
676     /* None found (none removed) */
677     return NULL;
678 }
679 
680 /*
681  * @implemented
682  */
683 NTSTATUS
684 QuerySuggestedLinkName(IN PUNICODE_STRING SymbolicName,
685                        OUT PUNICODE_STRING SuggestedLinkName,
686                        OUT PBOOLEAN UseOnlyIfThereAreNoOtherLinks)
687 {
688     PIRP Irp;
689     KEVENT Event;
690     NTSTATUS Status;
691     USHORT NameLength;
692     PFILE_OBJECT FileObject;
693     PDEVICE_OBJECT DeviceObject;
694     IO_STATUS_BLOCK IoStatusBlock;
695     PIO_STACK_LOCATION IoStackLocation;
696     PMOUNTDEV_SUGGESTED_LINK_NAME IoCtlSuggested;
697 
698     /* First, get device */
699     Status = IoGetDeviceObjectPointer(SymbolicName,
700                                       FILE_READ_ATTRIBUTES,
701                                       &FileObject,
702                                       &DeviceObject);
703     if (!NT_SUCCESS(Status))
704     {
705         return Status;
706     }
707 
708     /* Then, get attached device */
709     DeviceObject = IoGetAttachedDeviceReference(FileObject->DeviceObject);
710 
711     /* Then, prepare buffer to query suggested name */
712     IoCtlSuggested = AllocatePool(sizeof(MOUNTDEV_SUGGESTED_LINK_NAME));
713     if (!IoCtlSuggested)
714     {
715         Status = STATUS_INSUFFICIENT_RESOURCES;
716         goto Dereference;
717     }
718 
719     /* Prepare request */
720     KeInitializeEvent(&Event, NotificationEvent, FALSE);
721     Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME,
722                                         DeviceObject,
723                                         NULL,
724                                         0,
725                                         IoCtlSuggested,
726                                         sizeof(MOUNTDEV_SUGGESTED_LINK_NAME),
727                                         FALSE,
728                                         &Event,
729                                         &IoStatusBlock);
730     if (!Irp)
731     {
732         Status = STATUS_INSUFFICIENT_RESOURCES;
733         goto Release;
734     }
735 
736     IoStackLocation = IoGetNextIrpStackLocation(Irp);
737     IoStackLocation->FileObject = FileObject;
738 
739     /* And ask */
740     Status = IoCallDriver(DeviceObject, Irp);
741     if (Status == STATUS_PENDING)
742     {
743         KeWaitForSingleObject(&Event, Executive, KernelMode,
744                               FALSE, NULL);
745         Status = IoStatusBlock.Status;
746     }
747 
748     /* Overflow? Normal */
749     if (Status == STATUS_BUFFER_OVERFLOW)
750     {
751         /* Reallocate big enough buffer */
752         NameLength = IoCtlSuggested->NameLength + sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
753         FreePool(IoCtlSuggested);
754 
755         IoCtlSuggested = AllocatePool(NameLength);
756         if (!IoCtlSuggested)
757         {
758             Status = STATUS_INSUFFICIENT_RESOURCES;
759             goto Dereference;
760         }
761 
762         /* And reask */
763         KeInitializeEvent(&Event, NotificationEvent, FALSE);
764         Irp = IoBuildDeviceIoControlRequest(IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME,
765                                             DeviceObject,
766                                             NULL,
767                                             0,
768                                             IoCtlSuggested,
769                                             NameLength,
770                                             FALSE,
771                                             &Event,
772                                             &IoStatusBlock);
773         if (!Irp)
774         {
775             Status = STATUS_INSUFFICIENT_RESOURCES;
776             goto Release;
777         }
778 
779         IoStackLocation = IoGetNextIrpStackLocation(Irp);
780         IoStackLocation->FileObject = FileObject;
781 
782         Status = IoCallDriver(DeviceObject, Irp);
783         if (Status == STATUS_PENDING)
784         {
785             KeWaitForSingleObject(&Event, Executive, KernelMode,
786                                   FALSE, NULL);
787             Status = IoStatusBlock.Status;
788         }
789     }
790 
791     if (!NT_SUCCESS(Status))
792     {
793         goto Release;
794     }
795 
796     /* Now we have suggested name, copy it */
797     SuggestedLinkName->Length = IoCtlSuggested->NameLength;
798     SuggestedLinkName->MaximumLength = IoCtlSuggested->NameLength + sizeof(UNICODE_NULL);
799     SuggestedLinkName->Buffer = AllocatePool(IoCtlSuggested->NameLength + sizeof(UNICODE_NULL));
800     if (!SuggestedLinkName->Buffer)
801     {
802         Status = STATUS_INSUFFICIENT_RESOURCES;
803     }
804     else
805     {
806         RtlCopyMemory(SuggestedLinkName->Buffer, IoCtlSuggested->Name, IoCtlSuggested->NameLength);
807         SuggestedLinkName->Buffer[SuggestedLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
808     }
809 
810     /* Also return its priority */
811     *UseOnlyIfThereAreNoOtherLinks = IoCtlSuggested->UseOnlyIfThereAreNoOtherLinks;
812 
813 Release:
814     FreePool(IoCtlSuggested);
815 
816 Dereference:
817     ObDereferenceObject(DeviceObject);
818     ObDereferenceObject(FileObject);
819 
820     return Status;
821 }
822 
823 /*
824  * @implemented
825  */
826 BOOLEAN
827 RedirectSavedLink(IN PSAVED_LINK_INFORMATION SavedLinkInformation,
828                   IN PUNICODE_STRING DosName,
829                   IN PUNICODE_STRING NewLink)
830 {
831     PLIST_ENTRY NextEntry;
832     PSYMLINK_INFORMATION SymlinkInformation;
833 
834     /* Find the link */
835     for (NextEntry = SavedLinkInformation->SymbolicLinksListHead.Flink;
836          NextEntry != &(SavedLinkInformation->SymbolicLinksListHead);
837          NextEntry = NextEntry->Flink)
838     {
839         SymlinkInformation = CONTAINING_RECORD(NextEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
840 
841         if (!RtlEqualUnicodeString(DosName, &(SymlinkInformation->Name), TRUE))
842         {
843             /* Delete old link */
844             GlobalDeleteSymbolicLink(DosName);
845             /* Set its new location */
846             GlobalCreateSymbolicLink(DosName, NewLink);
847 
848             /* And remove it from the list (not valid any more) */
849             RemoveEntryList(&(SymlinkInformation->SymbolicLinksListEntry));
850             FreePool(SymlinkInformation->Name.Buffer);
851             FreePool(SymlinkInformation);
852 
853             return TRUE;
854         }
855     }
856 
857     return FALSE;
858 }
859 
860 /*
861  * @implemented
862  */
863 VOID
864 DeleteSymbolicLinkNameFromMemory(IN PDEVICE_EXTENSION DeviceExtension,
865                                  IN PUNICODE_STRING SymbolicLink,
866                                  IN BOOLEAN MarkOffline)
867 {
868     PLIST_ENTRY DeviceEntry, SymbolEntry;
869     PDEVICE_INFORMATION DeviceInformation;
870     PSYMLINK_INFORMATION SymlinkInformation;
871 
872     /* First of all, ensure we have devices */
873     if (IsListEmpty(&(DeviceExtension->DeviceListHead)))
874     {
875         return;
876     }
877 
878     /* Then, look for the symbolic name */
879     for (DeviceEntry = DeviceExtension->DeviceListHead.Flink;
880          DeviceEntry != &(DeviceExtension->DeviceListHead);
881          DeviceEntry = DeviceEntry->Flink)
882     {
883         DeviceInformation = CONTAINING_RECORD(DeviceEntry, DEVICE_INFORMATION, DeviceListEntry);
884 
885         for (SymbolEntry = DeviceInformation->SymbolicLinksListHead.Flink;
886              SymbolEntry != &(DeviceInformation->SymbolicLinksListHead);
887              SymbolEntry = SymbolEntry->Flink)
888         {
889             SymlinkInformation = CONTAINING_RECORD(SymbolEntry, SYMLINK_INFORMATION, SymbolicLinksListEntry);
890 
891             /* One we have found it */
892             if (RtlCompareUnicodeString(SymbolicLink, &(SymlinkInformation->Name), TRUE) == 0)
893             {
894                 /* Check if caller just want it to be offline */
895                 if (MarkOffline)
896                 {
897                     SymlinkInformation->Online = FALSE;
898                 }
899                 else
900                 {
901                     /* If not, delete it & notify */
902                     SendLinkDeleted(&(DeviceInformation->SymbolicName), SymbolicLink);
903                     RemoveEntryList(&(SymlinkInformation->SymbolicLinksListEntry));
904 
905                     FreePool(SymlinkInformation->Name.Buffer);
906                     FreePool(SymlinkInformation);
907                 }
908 
909                 /* No need to go farther */
910                 return;
911             }
912         }
913     }
914 
915     return;
916 }
917 
918 /*
919  * @implemented
920  */
921 BOOLEAN
922 IsDriveLetter(PUNICODE_STRING SymbolicName)
923 {
924     WCHAR Letter, Colon;
925 
926     /* We must have a precise length */
927     if (SymbolicName->Length != DosDevices.Length + 2 * sizeof(WCHAR))
928     {
929         return FALSE;
930     }
931 
932     /* Must start with the DosDevices prefix */
933     if (!RtlPrefixUnicodeString(&DosDevices, SymbolicName, TRUE))
934     {
935         return FALSE;
936     }
937 
938     /* Check if letter is correct */
939     Letter = SymbolicName->Buffer[DosDevices.Length / sizeof(WCHAR)];
940     if ((Letter < L'A' || Letter > L'Z') && Letter != (WCHAR)-1)
941     {
942         return FALSE;
943     }
944 
945     /* And finally it must end with a colon */
946     Colon = SymbolicName->Buffer[DosDevices.Length / sizeof(WCHAR) + 1];
947     if (Colon != L':')
948     {
949         return FALSE;
950     }
951 
952     return TRUE;
953 }
954 
955 /*
956  * @implemented
957  */
958 NTSTATUS
959 MountMgrQuerySymbolicLink(IN PUNICODE_STRING SymbolicName,
960                           IN OUT PUNICODE_STRING LinkTarget)
961 {
962     NTSTATUS Status;
963     HANDLE LinkHandle;
964     OBJECT_ATTRIBUTES ObjectAttributes;
965 
966     /* Open the symbolic link */
967     InitializeObjectAttributes(&ObjectAttributes,
968                                SymbolicName,
969                                OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
970                                NULL,
971                                NULL);
972 
973     Status = ZwOpenSymbolicLinkObject(&LinkHandle,
974                                       GENERIC_READ,
975                                       &ObjectAttributes);
976     if (!NT_SUCCESS(Status))
977     {
978         return Status;
979     }
980 
981     /* Query its target */
982     Status = ZwQuerySymbolicLinkObject(LinkHandle,
983                                        LinkTarget,
984                                        NULL);
985 
986     ZwClose(LinkHandle);
987 
988     if (!NT_SUCCESS(Status))
989     {
990         return Status;
991     }
992 
993     if (LinkTarget->Length <= sizeof(WCHAR))
994     {
995         return Status;
996     }
997 
998     /* If it's not finished by \, just return */
999     if (LinkTarget->Buffer[LinkTarget->Length / sizeof(WCHAR) - 1] != L'\\')
1000     {
1001         return Status;
1002     }
1003 
1004     /* Otherwise, ensure to drop the tailing \ */
1005     LinkTarget->Length -= sizeof(WCHAR);
1006     LinkTarget->Buffer[LinkTarget->Length / sizeof(WCHAR)] = UNICODE_NULL;
1007 
1008     return Status;
1009 }
1010