Sync with trunk head (part 1 of x)
[reactos.git] / ntoskrnl / io / iomgr / arcname.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/io/iomgr/arcname.c
5 * PURPOSE: ARC Path Initialization Functions
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Eric Kohl
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* GLOBALS *******************************************************************/
17
18 UNICODE_STRING IoArcHalDeviceName, IoArcBootDeviceName;
19 PCHAR IoLoaderArcBootDeviceName;
20 extern PROS_LOADER_PARAMETER_BLOCK KeRosLoaderBlock;
21
22 /* FUNCTIONS *****************************************************************/
23
24 BOOLEAN
25 INIT_FUNCTION
26 NTAPI
27 IopApplyRosCdromArcHack(IN ULONG i)
28 {
29 ULONG DeviceNumber = -1;
30 OBJECT_ATTRIBUTES ObjectAttributes;
31 ANSI_STRING InstallName;
32 UNICODE_STRING DeviceName;
33 CHAR Buffer[128], RosSysPath[16];
34 FILE_BASIC_INFORMATION FileInfo;
35 NTSTATUS Status;
36 PCHAR p, q;
37 PCONFIGURATION_INFORMATION ConfigInfo = IoGetConfigurationInformation();
38 extern BOOLEAN InitIsWinPEMode, ExpInTextModeSetup;
39
40 /* Change this if you want ROS to boot properly from another directory */
41 sprintf(RosSysPath, "%s", "reactos");
42
43 /* Only ARC Name left - Build full ARC Name */
44 p = strstr(KeLoaderBlock->ArcBootDeviceName, "cdrom");
45 if (p)
46 {
47 /* Build installer name */
48 sprintf(Buffer, "\\Device\\CdRom%lu\\%s\\ntoskrnl.exe", i, RosSysPath);
49 RtlInitAnsiString(&InstallName, Buffer);
50 Status = RtlAnsiStringToUnicodeString(&DeviceName, &InstallName, TRUE);
51 if (!NT_SUCCESS(Status)) return FALSE;
52
53 /* Try to find the installer */
54 InitializeObjectAttributes(&ObjectAttributes,
55 &DeviceName,
56 0,
57 NULL,
58 NULL);
59 Status = ZwQueryAttributesFile(&ObjectAttributes, &FileInfo);
60
61 /* Free the string */
62 RtlFreeUnicodeString(&DeviceName);
63
64 /* Check if we found the file */
65 if (NT_SUCCESS(Status))
66 {
67 /* We did, save the device number */
68 DeviceNumber = i;
69 }
70 else
71 {
72 /* Build live CD kernel name */
73 sprintf(Buffer,
74 "\\Device\\CdRom%lu\\%s\\system32\\ntoskrnl.exe",
75 i, RosSysPath);
76 RtlInitAnsiString(&InstallName, Buffer);
77 Status = RtlAnsiStringToUnicodeString(&DeviceName,
78 &InstallName,
79 TRUE);
80 if (!NT_SUCCESS(Status)) return FALSE;
81
82 /* Try to find it */
83 InitializeObjectAttributes(&ObjectAttributes,
84 &DeviceName,
85 0,
86 NULL,
87 NULL);
88 Status = ZwQueryAttributesFile(&ObjectAttributes, &FileInfo);
89 if (NT_SUCCESS(Status)) DeviceNumber = i;
90
91 /* Free the string */
92 RtlFreeUnicodeString(&DeviceName);
93 }
94
95 if (!InitIsWinPEMode)
96 {
97 /* Build the name */
98 sprintf(p, "cdrom(%lu)", DeviceNumber);
99
100 /* Adjust original command line */
101 q = strchr(p, ')');
102 if (q)
103 {
104 q++;
105 strcpy(Buffer, q);
106 sprintf(p, "cdrom(%lu)", DeviceNumber);
107 strcat(p, Buffer);
108 }
109 }
110 }
111
112 /* OK, how many disks are there? */
113 DeviceNumber += ConfigInfo->DiskCount;
114
115 /* Return whether this is the CD or not */
116 if ((InitIsWinPEMode) || (ExpInTextModeSetup))
117 {
118 return TRUE;
119 }
120
121 /* Failed */
122 return FALSE;
123 }
124
125 BOOLEAN
126 INIT_FUNCTION
127 NTAPI
128 IopGetDiskInformation(IN ULONG i,
129 OUT PULONG CheckSum,
130 OUT PULONG Signature,
131 OUT PULONG PartitionCount,
132 OUT PDEVICE_OBJECT *DiskDeviceObject)
133 {
134 ULONG j, Checksum;
135 ANSI_STRING TempString;
136 CHAR Buffer[128];
137 UNICODE_STRING DeviceName;
138 NTSTATUS Status;
139 PDEVICE_OBJECT DeviceObject;
140 PFILE_OBJECT FileObject;
141 DISK_GEOMETRY DiskGeometry;
142 PDRIVE_LAYOUT_INFORMATION DriveLayout;
143 KEVENT Event;
144 PIRP Irp;
145 IO_STATUS_BLOCK StatusBlock;
146 LARGE_INTEGER PartitionOffset;
147 PULONG PartitionBuffer;
148
149 /* Build the name */
150 sprintf(Buffer, "\\Device\\Harddisk%lu\\Partition0", i);
151
152 /* Convert it to Unicode */
153 RtlInitAnsiString(&TempString, Buffer);
154 Status = RtlAnsiStringToUnicodeString(&DeviceName, &TempString, TRUE);
155 if (!NT_SUCCESS(Status)) return FALSE;
156
157 /* Get the device pointer */
158 Status = IoGetDeviceObjectPointer(&DeviceName,
159 FILE_READ_ATTRIBUTES,
160 &FileObject,
161 &DeviceObject);
162 *DiskDeviceObject = DeviceObject;
163
164 /* Free the string */
165 RtlFreeUnicodeString(&DeviceName);
166
167 /* Move on if we failed */
168 if (!NT_SUCCESS(Status)) return FALSE;
169
170 /* Build an IRP to determine the sector size */
171 KeInitializeEvent(&Event, NotificationEvent, FALSE);
172 Irp = IoBuildDeviceIoControlRequest(IOCTL_DISK_GET_DRIVE_GEOMETRY,
173 DeviceObject,
174 NULL,
175 0,
176 &DiskGeometry,
177 sizeof(DISK_GEOMETRY),
178 FALSE,
179 &Event,
180 &StatusBlock);
181 if (!Irp)
182 {
183 /* Try again */
184 ObDereferenceObject(FileObject);
185 return FALSE;
186 }
187
188 /* Call the driver and check if we have to wait on it */
189 Status = IoCallDriver(DeviceObject, Irp);
190 if (Status == STATUS_PENDING)
191 {
192 /* Wait on the driver */
193 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
194 Status = StatusBlock.Status;
195 }
196
197 /* Check if we failed */
198 if (!NT_SUCCESS(Status))
199 {
200 /* Try again */
201 ObDereferenceObject(FileObject);
202 return FALSE;
203 }
204
205 /* Read the partition table */
206 Status = IoReadPartitionTable(DeviceObject,
207 DiskGeometry.BytesPerSector,
208 TRUE,
209 &DriveLayout);
210
211 /* Dereference the file object */
212 ObDereferenceObject(FileObject);
213 if (!NT_SUCCESS(Status)) return FALSE;
214
215 /* Set the offset to 0 */
216 PartitionOffset.QuadPart = 0;
217
218 /* Allocate a buffer for the partition */
219 PartitionBuffer = ExAllocatePoolWithTag(NonPagedPool,
220 DiskGeometry.BytesPerSector,
221 TAG_IO);
222 if (!PartitionBuffer)
223 {
224 /* Try again */
225 ExFreePoolWithTag(DriveLayout, TAG_FILE_SYSTEM);
226 return FALSE;
227 }
228
229 /* Build an IRP to read the partition sector */
230 KeInitializeEvent(&Event, NotificationEvent, FALSE);
231 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
232 DeviceObject,
233 PartitionBuffer,
234 DiskGeometry.BytesPerSector,
235 &PartitionOffset,
236 &Event,
237 &StatusBlock);
238 if (!Irp)
239 {
240 /* Try again */
241 ExFreePoolWithTag(PartitionBuffer, TAG_IO);
242 ExFreePoolWithTag(DriveLayout, TAG_FILE_SYSTEM);
243 return FALSE;
244 }
245
246 /* Call the driver and check if we have to wait */
247 Status = IoCallDriver(DeviceObject, Irp);
248 if (Status == STATUS_PENDING)
249 {
250 /* Wait for completion */
251 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
252 Status = StatusBlock.Status;
253 }
254
255 /* Check if we failed */
256 if (!NT_SUCCESS(Status))
257 {
258 /* Try again */
259 ExFreePoolWithTag(PartitionBuffer, TAG_IO);
260 ExFreePoolWithTag(DriveLayout, TAG_FILE_SYSTEM);
261 return FALSE;
262 }
263
264 /* Calculate the MBR checksum */
265 Checksum = 0;
266 for (j = 0; j < 128; j++) Checksum += PartitionBuffer[j];
267
268 /* Save the signature and checksum */
269 *CheckSum = ~Checksum + 1;
270 *Signature = DriveLayout->Signature;
271 *PartitionCount = DriveLayout->PartitionCount;
272
273 /* Free the buffer */
274 ExFreePoolWithTag(PartitionBuffer, TAG_IO);
275 ExFreePoolWithTag(DriveLayout, TAG_FILE_SYSTEM);
276 return TRUE;
277 }
278
279 BOOLEAN
280 INIT_FUNCTION
281 NTAPI
282 IopAssignArcNamesToCdrom(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
283 IN PULONG Buffer,
284 IN ULONG DiskNumber)
285 {
286 CHAR ArcBuffer[128];
287 ANSI_STRING TempString;
288 UNICODE_STRING DeviceName, ArcName;
289 NTSTATUS Status;
290 LARGE_INTEGER PartitionOffset;
291 KEVENT Event;
292 IO_STATUS_BLOCK IoStatusBlock;
293 PIRP Irp;
294 ULONG i, CheckSum = 0;
295 PDEVICE_OBJECT DeviceObject;
296 PFILE_OBJECT FileObject;
297 PARC_DISK_INFORMATION ArcDiskInfo = LoaderBlock->ArcDiskInformation;
298 PLIST_ENTRY NextEntry;
299 PARC_DISK_SIGNATURE ArcDiskEntry;
300 BOOLEAN IsBootCdRom = FALSE;
301
302 /* Build the device name */
303 sprintf(ArcBuffer, "\\Device\\CdRom%lu", DiskNumber);
304
305 /* Convert it to Unicode */
306 RtlInitAnsiString(&TempString, ArcBuffer);
307 Status = RtlAnsiStringToUnicodeString(&DeviceName, &TempString, TRUE);
308 if (!NT_SUCCESS(Status)) return FALSE;
309
310 /* Get the device for it */
311 Status = IoGetDeviceObjectPointer(&DeviceName,
312 FILE_READ_ATTRIBUTES,
313 &FileObject,
314 &DeviceObject);
315 if (!NT_SUCCESS(Status))
316 {
317 /* Free the string and fail */
318 RtlFreeUnicodeString(&DeviceName);
319 return FALSE;
320 }
321
322 /* Setup the event */
323 KeInitializeEvent(&Event, NotificationEvent, FALSE);
324
325 /* Set the offset and build the read IRP */
326 PartitionOffset.QuadPart = 0x8000;
327 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
328 DeviceObject,
329 Buffer,
330 2048,
331 &PartitionOffset,
332 &Event,
333 &IoStatusBlock);
334 if (!Irp)
335 {
336 /* Free the string and fail */
337 RtlFreeUnicodeString(&DeviceName);
338 return FALSE;
339 }
340
341 /* Call the driver and check if we have to wait on it */
342 Status = IoCallDriver(DeviceObject, Irp);
343 if (Status == STATUS_PENDING)
344 {
345 /* Wait for completion */
346 KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
347 Status = IoStatusBlock.Status;
348 }
349
350 /* Dereference the file object */
351 ObDereferenceObject(FileObject);
352 if (!NT_SUCCESS(Status)) return FALSE;
353
354 /* Now calculate the checksum */
355 for (i = 0; i < 2048 / sizeof(ULONG); i++) CheckSum += Buffer[i];
356
357 if (KeRosLoaderBlock) goto freeldrhack;
358
359 /* Search if this device is the actual boot CD */
360 for (NextEntry = ArcDiskInfo->DiskSignatureListHead.Flink;
361 NextEntry != &ArcDiskInfo->DiskSignatureListHead;
362 NextEntry = NextEntry->Flink)
363 {
364 /* Get the current ARC disk signature entry */
365 ArcDiskEntry = CONTAINING_RECORD(NextEntry,
366 ARC_DISK_SIGNATURE,
367 ListEntry);
368 /* And check if checksums and arc names match */
369 if (CheckSum == ArcDiskEntry->CheckSum &&
370 strcmp(KeLoaderBlock->ArcBootDeviceName, ArcDiskEntry->ArcName) == 0)
371 {
372 IsBootCdRom = TRUE;
373 break;
374 }
375 }
376 goto checkbootcd;
377
378 freeldrhack:
379 /*
380 * FIXME: In normal conditions, NTLDR/FreeLdr sends the *proper* CDROM
381 * ARC Path name, and what happens here is a comparision of both checksums
382 * in order to see if this is the actual boot CD.
383 *
384 * In ReactOS this doesn't currently happen, instead we have a hack on top
385 * of this file which scans the CD for the ntoskrnl.exe file, then modifies
386 * the LoaderBlock's ARC Path with the right CDROM path. Consequently, we
387 * get the same state as if NTLDR had properly booted us, except that we do
388 * not actually need to check the signature, since the hack already did the
389 * check for ntoskrnl.exe, which is just as good.
390 *
391 * The signature code stays however, because eventually FreeLDR will work
392 * like NTLDR, and, conversly, we do want to be able to be booted by NTLDR.
393 */
394 IsBootCdRom = IopApplyRosCdromArcHack(DiskNumber);
395
396 checkbootcd:
397 if (IsBootCdRom)
398 {
399 /* This is the boot CD-ROM, build the ARC name */
400 sprintf(ArcBuffer, "\\ArcName\\%s", KeLoaderBlock->ArcBootDeviceName);
401
402 /* Convert it to Unicode */
403 RtlInitAnsiString(&TempString, ArcBuffer);
404 Status = RtlAnsiStringToUnicodeString(&ArcName, &TempString, TRUE);
405 if (!NT_SUCCESS(Status)) return FALSE;
406
407 /* Create the symbolic link and free the strings */
408 IoAssignArcName(&ArcName, &DeviceName);
409 RtlFreeUnicodeString(&ArcName);
410 RtlFreeUnicodeString(&DeviceName);
411
412 /* Let caller know that we've found the boot CD */
413 return TRUE;
414 }
415
416 /* No boot CD found */
417 return FALSE;
418 }
419
420 NTSTATUS
421 INIT_FUNCTION
422 NTAPI
423 IopCreateArcNames(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
424 {
425 PCONFIGURATION_INFORMATION ConfigInfo = IoGetConfigurationInformation();
426 PARC_DISK_INFORMATION ArcDiskInfo = LoaderBlock->ArcDiskInformation;
427 CHAR Buffer[128];
428 ANSI_STRING ArcBootString, ArcSystemString, ArcString;
429 UNICODE_STRING ArcName, BootPath, DeviceName;
430 BOOLEAN SingleDisk;
431 ULONG i, j, Length;
432 PDEVICE_OBJECT DeviceObject;
433 ULONG Signature, Checksum, PartitionCount;
434 PLIST_ENTRY NextEntry;
435 PARC_DISK_SIGNATURE ArcDiskEntry;
436 NTSTATUS Status;
437 BOOLEAN FoundBoot = FALSE;
438 PULONG PartitionBuffer;
439
440 /* Check if we only have one disk on the machine */
441 SingleDisk = ArcDiskInfo->DiskSignatureListHead.Flink->Flink ==
442 (&ArcDiskInfo->DiskSignatureListHead);
443
444 /* Create the global HAL partition name */
445 sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcHalDeviceName);
446 RtlInitAnsiString(&ArcString, Buffer);
447 RtlAnsiStringToUnicodeString(&IoArcHalDeviceName, &ArcString, TRUE);
448
449 /* Create the global system partition name */
450 sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcBootDeviceName);
451 RtlInitAnsiString(&ArcString, Buffer);
452 RtlAnsiStringToUnicodeString(&IoArcBootDeviceName, &ArcString, TRUE);
453
454 /* Allocate memory for the string */
455 Length = strlen(LoaderBlock->ArcBootDeviceName) + sizeof(ANSI_NULL);
456 IoLoaderArcBootDeviceName = ExAllocatePoolWithTag(PagedPool,
457 Length,
458 TAG_IO);
459 if (IoLoaderArcBootDeviceName)
460 {
461 /* Copy the name */
462 RtlCopyMemory(IoLoaderArcBootDeviceName,
463 LoaderBlock->ArcBootDeviceName,
464 Length);
465 }
466
467 /* Check if we only found a disk, but we're booting from CD-ROM */
468 if ((SingleDisk) && strstr(LoaderBlock->ArcBootDeviceName, "cdrom"))
469 {
470 /* Then disable single-disk mode, since there's a CD drive out there */
471 SingleDisk = FALSE;
472 }
473
474 /* Build the boot strings */
475 RtlInitAnsiString(&ArcBootString, LoaderBlock->ArcBootDeviceName);
476 RtlInitAnsiString(&ArcSystemString, LoaderBlock->ArcHalDeviceName);
477
478 /* Loop every detected disk */
479 for (i = 0; i < ConfigInfo->DiskCount; i++)
480 {
481 /* Get information about the disk */
482 if (!IopGetDiskInformation(i,
483 &Checksum,
484 &Signature,
485 &PartitionCount,
486 &DeviceObject))
487 {
488 /* Skip this disk */
489 continue;
490 }
491
492 /* Loop ARC disks */
493 for (NextEntry = ArcDiskInfo->DiskSignatureListHead.Flink;
494 NextEntry != &ArcDiskInfo->DiskSignatureListHead;
495 NextEntry = NextEntry->Flink)
496 {
497 /* Get the current ARC disk signature entry */
498 ArcDiskEntry = CONTAINING_RECORD(NextEntry,
499 ARC_DISK_SIGNATURE,
500 ListEntry);
501
502 /*
503 * Now check if the signature and checksum match, unless this is
504 * the only disk that was in the ARC list, and also in the device
505 * tree, in which case the check is bypassed and we accept the disk
506 */
507 if (((SingleDisk) && (ConfigInfo->DiskCount == 1)) ||
508 ((Checksum == ArcDiskEntry->CheckSum) &&
509 (Signature == ArcDiskEntry->Signature)))
510 {
511 /* Build the NT Device Name */
512 sprintf(Buffer, "\\Device\\Harddisk%lu\\Partition0", i);
513
514 /* Convert it to Unicode */
515 RtlInitAnsiString(&ArcString, Buffer);
516 Status = RtlAnsiStringToUnicodeString(&DeviceName,
517 &ArcString,
518 TRUE);
519 if (!NT_SUCCESS(Status)) continue;
520
521 /* Build the ARC Device Name */
522 sprintf(Buffer, "\\ArcName\\%s", ArcDiskEntry->ArcName);
523
524 /* Convert it to Unicode */
525 RtlInitAnsiString(&ArcString, Buffer);
526 Status = RtlAnsiStringToUnicodeString(&ArcName,
527 &ArcString,
528 TRUE);
529 if (!NT_SUCCESS(Status)) continue;
530
531 /* Create the symbolic link and free the strings */
532 IoAssignArcName(&ArcName, &DeviceName);
533 RtlFreeUnicodeString(&ArcName);
534 RtlFreeUnicodeString(&DeviceName);
535
536 /* Loop all the partitions */
537 for (j = 0; j < PartitionCount; j++)
538 {
539 /* Build the partition device name */
540 sprintf(Buffer,
541 "\\Device\\Harddisk%lu\\Partition%lu",
542 i,
543 j + 1);
544
545 /* Convert it to Unicode */
546 RtlInitAnsiString(&ArcString, Buffer);
547 Status = RtlAnsiStringToUnicodeString(&DeviceName,
548 &ArcString,
549 TRUE);
550 if (!NT_SUCCESS(Status)) continue;
551
552 /* Build the partial ARC name for this partition */
553 sprintf(Buffer,
554 "%spartition(%lu)",
555 ArcDiskEntry->ArcName,
556 j + 1);
557 RtlInitAnsiString(&ArcString, Buffer);
558
559 /* Check if this is the boot device */
560 if (RtlEqualString(&ArcString, &ArcBootString, TRUE))
561 {
562 /* Remember that we found a Hard Disk Boot Device */
563 FoundBoot = TRUE;
564 }
565
566 /* Check if it's the system boot partition */
567 if (RtlEqualString(&ArcString, &ArcSystemString, TRUE))
568 {
569 /* It is, create a Unicode string for it */
570 RtlInitAnsiString(&ArcString,
571 LoaderBlock->NtHalPathName);
572 Status = RtlAnsiStringToUnicodeString(&BootPath,
573 &ArcString,
574 TRUE);
575 if (NT_SUCCESS(Status))
576 {
577 /* FIXME: Save in registry */
578
579 /* Free the string now */
580 RtlFreeUnicodeString(&BootPath);
581 }
582 }
583
584 /* Build the full ARC name */
585 sprintf(Buffer,
586 "\\ArcName\\%spartition(%lu)",
587 ArcDiskEntry->ArcName,
588 j + 1);
589
590 /* Convert it to Unicode */
591 RtlInitAnsiString(&ArcString, Buffer);
592 Status = RtlAnsiStringToUnicodeString(&ArcName,
593 &ArcString,
594 TRUE);
595 if (!NT_SUCCESS(Status)) continue;
596
597 /* Create the symbolic link and free the strings */
598 IoAssignArcName(&ArcName, &DeviceName);
599 RtlFreeUnicodeString(&ArcName);
600 RtlFreeUnicodeString(&DeviceName);
601 }
602 }
603 }
604 }
605
606 /* Check if we didn't find the boot disk */
607 if (!FoundBoot)
608 {
609 /* Allocate a buffer for the CD-ROM MBR */
610 PartitionBuffer = ExAllocatePoolWithTag(NonPagedPool, 2048, TAG_IO);
611 if (!PartitionBuffer) return STATUS_INSUFFICIENT_RESOURCES;
612
613 /* Loop every CD-ROM */
614 for (i = 0; i < ConfigInfo->CdRomCount; i++)
615 {
616 /* Give it an ARC name */
617 if (IopAssignArcNamesToCdrom(LoaderBlock, PartitionBuffer, i)) break;
618 }
619
620 /* Free the buffer */
621 ExFreePoolWithTag(PartitionBuffer, TAG_IO);
622 }
623
624 /* Return success */
625 return STATUS_SUCCESS;
626 }
627
628 NTSTATUS
629 NTAPI
630 IopReassignSystemRoot(IN PLOADER_PARAMETER_BLOCK LoaderBlock,
631 OUT PANSI_STRING NtBootPath)
632 {
633 OBJECT_ATTRIBUTES ObjectAttributes;
634 NTSTATUS Status;
635 CHAR Buffer[256], AnsiBuffer[256];
636 WCHAR ArcNameBuffer[64];
637 ANSI_STRING TargetString, ArcString, TempString;
638 UNICODE_STRING LinkName, TargetName, ArcName;
639 HANDLE LinkHandle;
640
641 /* Create the Unicode name for the current ARC boot device */
642 sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcBootDeviceName);
643 RtlInitAnsiString(&TargetString, Buffer);
644 Status = RtlAnsiStringToUnicodeString(&TargetName, &TargetString, TRUE);
645 if (!NT_SUCCESS(Status)) return FALSE;
646
647 /* Initialize the attributes and open the link */
648 InitializeObjectAttributes(&ObjectAttributes,
649 &TargetName,
650 OBJ_CASE_INSENSITIVE,
651 NULL,
652 NULL);
653 Status = NtOpenSymbolicLinkObject(&LinkHandle,
654 SYMBOLIC_LINK_ALL_ACCESS,
655 &ObjectAttributes);
656 if (!NT_SUCCESS(Status))
657 {
658 /* We failed, free the string */
659 RtlFreeUnicodeString(&TargetName);
660 return FALSE;
661 }
662
663 /* Query the current \\SystemRoot */
664 ArcName.Buffer = ArcNameBuffer;
665 ArcName.Length = 0;
666 ArcName.MaximumLength = sizeof(ArcNameBuffer);
667 Status = NtQuerySymbolicLinkObject(LinkHandle, &ArcName, NULL);
668 if (!NT_SUCCESS(Status))
669 {
670 /* We failed, free the string */
671 RtlFreeUnicodeString(&TargetName);
672 return FALSE;
673 }
674
675 /* Convert it to Ansi */
676 ArcString.Buffer = AnsiBuffer;
677 ArcString.Length = 0;
678 ArcString.MaximumLength = sizeof(AnsiBuffer);
679 Status = RtlUnicodeStringToAnsiString(&ArcString, &ArcName, FALSE);
680 AnsiBuffer[ArcString.Length] = ANSI_NULL;
681
682 /* Close the link handle and free the name */
683 ObCloseHandle(LinkHandle, KernelMode);
684 RtlFreeUnicodeString(&TargetName);
685
686 /* Setup the system root name again */
687 RtlInitAnsiString(&TempString, "\\SystemRoot");
688 Status = RtlAnsiStringToUnicodeString(&LinkName, &TempString, TRUE);
689 if (!NT_SUCCESS(Status)) return FALSE;
690
691 /* Open the symbolic link for it */
692 InitializeObjectAttributes(&ObjectAttributes,
693 &LinkName,
694 OBJ_CASE_INSENSITIVE,
695 NULL,
696 NULL);
697 Status = NtOpenSymbolicLinkObject(&LinkHandle,
698 SYMBOLIC_LINK_ALL_ACCESS,
699 &ObjectAttributes);
700 if (!NT_SUCCESS(Status)) return FALSE;
701
702 /* Destroy it */
703 NtMakeTemporaryObject(LinkHandle);
704 ObCloseHandle(LinkHandle, KernelMode);
705
706 /* Now create the new name for it */
707 sprintf(Buffer, "%s%s", ArcString.Buffer, LoaderBlock->NtBootPathName);
708
709 /* Copy it into the passed parameter and null-terminate it */
710 RtlCopyString(NtBootPath, &ArcString);
711 Buffer[strlen(Buffer) - 1] = ANSI_NULL;
712
713 /* Setup the Unicode-name for the new symbolic link value */
714 RtlInitAnsiString(&TargetString, Buffer);
715 InitializeObjectAttributes(&ObjectAttributes,
716 &LinkName,
717 OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
718 NULL,
719 NULL);
720 Status = RtlAnsiStringToUnicodeString(&ArcName, &TargetString, TRUE);
721 if (!NT_SUCCESS(Status)) return FALSE;
722
723 /* Create it */
724 Status = NtCreateSymbolicLinkObject(&LinkHandle,
725 SYMBOLIC_LINK_ALL_ACCESS,
726 &ObjectAttributes,
727 &ArcName);
728
729 /* Free all the strings and close the handle and return success */
730 RtlFreeUnicodeString(&ArcName);
731 RtlFreeUnicodeString(&LinkName);
732 ObCloseHandle(LinkHandle, KernelMode);
733 return TRUE;
734 }
735
736 /* EOF */