[USETUP]: Add an entry in freeldr.ini for EMS testing.
[reactos.git] / reactos / base / setup / usetup / bootsup.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS text-mode setup
4 * FILE: subsys/system/usetup/bootsup.c
5 * PURPOSE: Bootloader support functions
6 * PROGRAMMER: Eric Kohl
7 */
8
9 #include "usetup.h"
10
11 #define NDEBUG
12 #include <debug.h>
13
14 #define SECTORSIZE 512
15
16 #include <pshpack1.h>
17 typedef struct _FAT_BOOTSECTOR
18 {
19 UCHAR JumpBoot[3]; // Jump instruction to boot code
20 CHAR OemName[8]; // "MSWIN4.1" for MS formatted volumes
21 USHORT BytesPerSector; // Bytes per sector
22 UCHAR SectorsPerCluster; // Number of sectors in a cluster
23 USHORT ReservedSectors; // Reserved sectors, usually 1 (the bootsector)
24 UCHAR NumberOfFats; // Number of FAT tables
25 USHORT RootDirEntries; // Number of root directory entries (fat12/16)
26 USHORT TotalSectors; // Number of total sectors on the drive, 16-bit
27 UCHAR MediaDescriptor; // Media descriptor byte
28 USHORT SectorsPerFat; // Sectors per FAT table (fat12/16)
29 USHORT SectorsPerTrack; // Number of sectors in a track
30 USHORT NumberOfHeads; // Number of heads on the disk
31 ULONG HiddenSectors; // Hidden sectors (sectors before the partition start like the partition table)
32 ULONG TotalSectorsBig; // This field is the new 32-bit total count of sectors on the volume
33 UCHAR DriveNumber; // Int 0x13 drive number (e.g. 0x80)
34 UCHAR Reserved1; // Reserved (used by Windows NT). Code that formats FAT volumes should always set this byte to 0.
35 UCHAR BootSignature; // Extended boot signature (0x29). This is a signature byte that indicates that the following three fields in the boot sector are present.
36 ULONG VolumeSerialNumber; // Volume serial number
37 CHAR VolumeLabel[11]; // Volume label. This field matches the 11-byte volume label recorded in the root directory
38 CHAR FileSystemType[8]; // One of the strings "FAT12 ", "FAT16 ", or "FAT "
39
40 UCHAR BootCodeAndData[448]; // The remainder of the boot sector
41
42 USHORT BootSectorMagic; // 0xAA55
43
44 } FAT_BOOTSECTOR, *PFAT_BOOTSECTOR;
45
46 typedef struct _FAT32_BOOTSECTOR
47 {
48 UCHAR JumpBoot[3]; // Jump instruction to boot code
49 CHAR OemName[8]; // "MSWIN4.1" for MS formatted volumes
50 USHORT BytesPerSector; // Bytes per sector
51 UCHAR SectorsPerCluster; // Number of sectors in a cluster
52 USHORT ReservedSectors; // Reserved sectors, usually 1 (the bootsector)
53 UCHAR NumberOfFats; // Number of FAT tables
54 USHORT RootDirEntries; // Number of root directory entries (fat12/16)
55 USHORT TotalSectors; // Number of total sectors on the drive, 16-bit
56 UCHAR MediaDescriptor; // Media descriptor byte
57 USHORT SectorsPerFat; // Sectors per FAT table (fat12/16)
58 USHORT SectorsPerTrack; // Number of sectors in a track
59 USHORT NumberOfHeads; // Number of heads on the disk
60 ULONG HiddenSectors; // Hidden sectors (sectors before the partition start like the partition table)
61 ULONG TotalSectorsBig; // This field is the new 32-bit total count of sectors on the volume
62 ULONG SectorsPerFatBig; // This field is the FAT32 32-bit count of sectors occupied by ONE FAT. BPB_FATSz16 must be 0
63 USHORT ExtendedFlags; // Extended flags (fat32)
64 USHORT FileSystemVersion; // File system version (fat32)
65 ULONG RootDirStartCluster; // Starting cluster of the root directory (fat32)
66 USHORT FsInfo; // Sector number of FSINFO structure in the reserved area of the FAT32 volume. Usually 1.
67 USHORT BackupBootSector; // If non-zero, indicates the sector number in the reserved area of the volume of a copy of the boot record. Usually 6.
68 UCHAR Reserved[12]; // Reserved for future expansion
69 UCHAR DriveNumber; // Int 0x13 drive number (e.g. 0x80)
70 UCHAR Reserved1; // Reserved (used by Windows NT). Code that formats FAT volumes should always set this byte to 0.
71 UCHAR BootSignature; // Extended boot signature (0x29). This is a signature byte that indicates that the following three fields in the boot sector are present.
72 ULONG VolumeSerialNumber; // Volume serial number
73 CHAR VolumeLabel[11]; // Volume label. This field matches the 11-byte volume label recorded in the root directory
74 CHAR FileSystemType[8]; // Always set to the string "FAT32 "
75
76 UCHAR BootCodeAndData[420]; // The remainder of the boot sector
77
78 USHORT BootSectorMagic; // 0xAA55
79
80 } FAT32_BOOTSECTOR, *PFAT32_BOOTSECTOR;
81 #include <poppack.h>
82
83 extern PPARTLIST PartitionList;
84
85 /* FUNCTIONS ****************************************************************/
86
87
88 static
89 VOID
90 CreateCommonFreeLoaderSections(PINICACHE IniCache)
91 {
92 PINICACHESECTION IniSection;
93
94 /* Create "FREELOADER" section */
95 IniSection = IniCacheAppendSection(IniCache,
96 L"FREELOADER");
97
98 #if DBG
99 if (IsUnattendedSetup)
100 {
101 /* DefaultOS=ReactOS */
102 IniCacheInsertKey(IniSection,
103 NULL,
104 INSERT_LAST,
105 L"DefaultOS",
106 #ifndef _WINKD_
107 L"ReactOS_KdSerial");
108 #else
109 L"ReactOS_Debug");
110 #endif
111 }
112 else
113 #endif
114 {
115 /* DefaultOS=ReactOS */
116 IniCacheInsertKey(IniSection,
117 NULL,
118 INSERT_LAST,
119 L"DefaultOS",
120 L"ReactOS");
121 }
122
123 #if DBG
124 if (IsUnattendedSetup)
125 #endif
126 {
127 /* Timeout=0 for unattended or non debug*/
128 IniCacheInsertKey(IniSection,
129 NULL,
130 INSERT_LAST,
131 L"TimeOut",
132 L"0");
133 }
134 #if DBG
135 else
136 {
137 /* Timeout=0 or 10 */
138 IniCacheInsertKey(IniSection,
139 NULL,
140 INSERT_LAST,
141 L"TimeOut",
142 L"10");
143 }
144 #endif
145
146 /* Create "Display" section */
147 IniSection = IniCacheAppendSection(IniCache, L"Display");
148
149 /* TitleText=ReactOS Boot Manager */
150 IniCacheInsertKey(IniSection,
151 NULL,
152 INSERT_LAST,
153 L"TitleText",
154 L"ReactOS Boot Manager");
155
156 /* StatusBarColor=Cyan */
157 IniCacheInsertKey(IniSection,
158 NULL,
159 INSERT_LAST,
160 L"StatusBarColor",
161 L"Cyan");
162
163 /* StatusBarTextColor=Black */
164 IniCacheInsertKey(IniSection,
165 NULL,
166 INSERT_LAST,
167 L"StatusBarTextColor",
168 L"Black");
169
170 /* BackdropTextColor=White */
171 IniCacheInsertKey(IniSection,
172 NULL,
173 INSERT_LAST,
174 L"BackdropTextColor",
175 L"White");
176
177 /* BackdropColor=Blue */
178 IniCacheInsertKey(IniSection,
179 NULL,
180 INSERT_LAST,
181 L"BackdropColor",
182 L"Blue");
183
184 /* BackdropFillStyle=Medium */
185 IniCacheInsertKey(IniSection,
186 NULL,
187 INSERT_LAST,
188 L"BackdropFillStyle",
189 L"Medium");
190
191 /* TitleBoxTextColor=White */
192 IniCacheInsertKey(IniSection,
193 NULL,
194 INSERT_LAST,
195 L"TitleBoxTextColor",
196 L"White");
197
198 /* TitleBoxColor=Red */
199 IniCacheInsertKey(IniSection,
200 NULL,
201 INSERT_LAST,
202 L"TitleBoxColor",
203 L"Red");
204
205 /* MessageBoxTextColor=White */
206 IniCacheInsertKey(IniSection,
207 NULL,
208 INSERT_LAST,
209 L"MessageBoxTextColor",
210 L"White");
211
212 /* MessageBoxColor=Blue */
213 IniCacheInsertKey(IniSection,
214 NULL,
215 INSERT_LAST,
216 L"MessageBoxColor",
217 L"Blue");
218
219 /* MenuTextColor=White */
220 IniCacheInsertKey(IniSection,
221 NULL,
222 INSERT_LAST,
223 L"MenuTextColor",
224 L"Gray");
225
226 /* MenuColor=Blue */
227 IniCacheInsertKey(IniSection,
228 NULL,
229 INSERT_LAST,
230 L"MenuColor",
231 L"Black");
232
233 /* TextColor=Yellow */
234 IniCacheInsertKey(IniSection,
235 NULL,
236 INSERT_LAST,
237 L"TextColor",
238 L"Gray");
239
240 /* SelectedTextColor=Black */
241 IniCacheInsertKey(IniSection,
242 NULL,
243 INSERT_LAST,
244 L"SelectedTextColor",
245 L"Black");
246
247 /* SelectedColor=Gray */
248 IniCacheInsertKey(IniSection,
249 NULL,
250 INSERT_LAST,
251 L"SelectedColor",
252 L"Gray");
253
254 /* SelectedColor=Gray */
255 IniCacheInsertKey(IniSection,
256 NULL,
257 INSERT_LAST,
258 L"ShowTime",
259 L"No");
260
261 /* SelectedColor=Gray */
262 IniCacheInsertKey(IniSection,
263 NULL,
264 INSERT_LAST,
265 L"MenuBox",
266 L"No");
267
268 /* SelectedColor=Gray */
269 IniCacheInsertKey(IniSection,
270 NULL,
271 INSERT_LAST,
272 L"CenterMenu",
273 L"No");
274
275 /* SelectedColor=Gray */
276 IniCacheInsertKey(IniSection,
277 NULL,
278 INSERT_LAST,
279 L"MinimalUI",
280 L"Yes");
281
282 /* SelectedColor=Gray */
283 IniCacheInsertKey(IniSection,
284 NULL,
285 INSERT_LAST,
286 L"TimeText",
287 L"Seconds until highlighted choice will be started automatically: ");
288 }
289
290
291 NTSTATUS
292 CreateFreeLoaderIniForDos(
293 PWCHAR IniPath,
294 PWCHAR ArcPath)
295 {
296 PINICACHE IniCache;
297 PINICACHESECTION IniSection;
298
299 IniCache = IniCacheCreate();
300
301 CreateCommonFreeLoaderSections(IniCache);
302
303 /* Create "Operating Systems" section */
304 IniSection = IniCacheAppendSection(IniCache, L"Operating Systems");
305
306 /* REACTOS=ReactOS */
307 IniCacheInsertKey(IniSection,
308 NULL,
309 INSERT_LAST,
310 L"ReactOS",
311 L"\"ReactOS\"");
312
313 /* ReactOS_Debug="ReactOS (Debug)" */
314 IniCacheInsertKey(IniSection,
315 NULL,
316 INSERT_LAST,
317 L"ReactOS_Debug",
318 L"\"ReactOS (Debug)\"");
319
320 /* DOS=Dos/Windows */
321 IniCacheInsertKey(IniSection,
322 NULL,
323 INSERT_LAST,
324 L"DOS",
325 L"\"DOS/Windows\"");
326
327 /* Create "ReactOS" section */
328 IniSection = IniCacheAppendSection(IniCache, L"ReactOS");
329
330 /* BootType=ReactOS */
331 IniCacheInsertKey(IniSection,
332 NULL,
333 INSERT_LAST,
334 L"BootType",
335 L"ReactOS");
336
337 /* SystemPath=<ArcPath> */
338 IniCacheInsertKey(IniSection,
339 NULL,
340 INSERT_LAST,
341 L"SystemPath",
342 ArcPath);
343
344 /* Create "ReactOS_Debug" section */
345 IniSection = IniCacheAppendSection(IniCache, L"ReactOS_Debug");
346
347 /* BootType=ReactOS */
348 IniCacheInsertKey(IniSection,
349 NULL,
350 INSERT_LAST,
351 L"BootType",
352 L"ReactOS");
353
354 /* SystemPath=<ArcPath> */
355 IniCacheInsertKey(IniSection,
356 NULL,
357 INSERT_LAST,
358 L"SystemPath",
359 ArcPath);
360
361 /* Options=/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS */
362 IniCacheInsertKey(IniSection,
363 NULL,
364 INSERT_LAST,
365 L"Options",
366 L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS");
367
368 /* Create "DOS" section */
369 IniSection = IniCacheAppendSection(IniCache,
370 L"DOS");
371
372 /* BootType=BootSector */
373 IniCacheInsertKey(IniSection,
374 NULL,
375 INSERT_LAST,
376 L"BootType",
377 L"BootSector");
378
379 /* BootDrive=hd0 */
380 IniCacheInsertKey(IniSection,
381 NULL,
382 INSERT_LAST,
383 L"BootDrive",
384 L"hd0");
385
386 /* BootPartition=1 */
387 IniCacheInsertKey(IniSection,
388 NULL,
389 INSERT_LAST,
390 L"BootPartition",
391 L"1");
392
393 /* BootSector=BOOTSECT.DOS */
394 IniCacheInsertKey(IniSection,
395 NULL,
396 INSERT_LAST,
397 L"BootSectorFile",
398 L"BOOTSECT.DOS");
399
400 IniCacheSave(IniCache, IniPath);
401 IniCacheDestroy(IniCache);
402
403 return STATUS_SUCCESS;
404 }
405
406
407 NTSTATUS
408 CreateFreeLoaderEntry(
409 PINICACHE IniCache,
410 PINICACHESECTION OSSection,
411 PWCHAR Section,
412 PWCHAR Description,
413 PWCHAR BootType,
414 PWCHAR ArcPath,
415 PWCHAR Options)
416 {
417 PINICACHESECTION IniSection;
418
419 /* Insert entry into "Operating Systems" section */
420 IniCacheInsertKey(OSSection,
421 NULL,
422 INSERT_LAST,
423 Section,
424 Description);
425
426 /* Create new section */
427 IniSection = IniCacheAppendSection(IniCache, Section);
428
429 /* BootType= */
430 IniCacheInsertKey(IniSection,
431 NULL,
432 INSERT_LAST,
433 L"BootType",
434 BootType);
435
436 /* SystemPath= */
437 IniCacheInsertKey(IniSection,
438 NULL,
439 INSERT_LAST,
440 L"SystemPath",
441 ArcPath);
442
443 /* Options=*/
444 IniCacheInsertKey(IniSection,
445 NULL,
446 INSERT_LAST,
447 L"Options",
448 Options);
449
450 return STATUS_SUCCESS;
451 }
452
453 NTSTATUS
454 CreateFreeLoaderIniForReactos(
455 PWCHAR IniPath,
456 PWCHAR ArcPath)
457 {
458 PINICACHE IniCache;
459 PINICACHESECTION IniSection;
460
461 IniCache = IniCacheCreate();
462
463 CreateCommonFreeLoaderSections(IniCache);
464
465 /* Create "Operating Systems" section */
466 IniSection = IniCacheAppendSection(IniCache, L"Operating Systems");
467
468 /* ReactOS */
469 CreateFreeLoaderEntry(IniCache, IniSection,
470 L"ReactOS", L"\"ReactOS\"",
471 L"Windows2003", ArcPath,
472 L"");
473
474 /* ReactOS_Debug */
475 CreateFreeLoaderEntry(IniCache, IniSection,
476 L"ReactOS_Debug", L"\"ReactOS (Debug)\"",
477 L"Windows2003", ArcPath,
478 L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS");
479
480 #if DBG
481 #ifndef _WINKD_
482 /* ReactOS_KdSerial */
483 CreateFreeLoaderEntry(IniCache, IniSection,
484 L"ReactOS_KdSerial", L"\"ReactOS (RosDbg)\"",
485 L"Windows2003", ArcPath,
486 L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS /KDSERIAL");
487 #endif
488
489 /* ReactOS_Screen */
490 CreateFreeLoaderEntry(IniCache, IniSection,
491 L"ReactOS_Screen", L"\"ReactOS (Screen)\"",
492 L"Windows2003", ArcPath,
493 L"/DEBUG /DEBUGPORT=SCREEN /SOS");
494
495 /* ReactOS_LogFile */
496 CreateFreeLoaderEntry(IniCache, IniSection,
497 L"ReactOS_LogFile", L"\"ReactOS (Log file)\"",
498 L"Windows2003", ArcPath,
499 L"/DEBUG /DEBUGPORT=FILE /SOS");
500
501 /* ReactOS_Ram */
502 CreateFreeLoaderEntry(IniCache, IniSection,
503 L"ReactOS_Ram", L"\"ReactOS (RAM Disk)\"",
504 L"Windows2003", L"ramdisk(0)\\ReactOS",
505 L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS /RDIMAGEPATH=reactos.img /RDIMAGEOFFSET=32256");
506
507 /* ReactOS_EMS */
508 CreateFreeLoaderEntry(IniCache, IniSection,
509 L"ReactOS_EMS", L"\"ReactOS (Emergency Management Services)\"",
510 L"Windows2003", ArcPath,
511 L"/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /SOS /redirect=com2 /redirectbaudrate=115200");
512 #endif
513
514 /* Save the ini file */
515 IniCacheSave(IniCache, IniPath);
516 IniCacheDestroy(IniCache);
517
518 return STATUS_SUCCESS;
519 }
520
521
522 NTSTATUS
523 UpdateFreeLoaderIni(
524 PWCHAR IniPath,
525 PWCHAR ArcPath)
526 {
527 UNICODE_STRING Name;
528 PINICACHE IniCache;
529 PINICACHESECTION IniSection;
530 PINICACHESECTION OsIniSection;
531 WCHAR SectionName[80];
532 WCHAR OsName[80];
533 WCHAR SystemPath[200];
534 WCHAR SectionName2[200];
535 PWCHAR KeyData;
536 ULONG i,j;
537 NTSTATUS Status;
538
539 RtlInitUnicodeString(&Name, IniPath);
540
541 Status = IniCacheLoad(&IniCache, &Name, FALSE);
542 if (!NT_SUCCESS(Status))
543 return Status;
544
545 /* Get "Operating Systems" section */
546 IniSection = IniCacheGetSection(IniCache, L"Operating Systems");
547 if (IniSection == NULL)
548 {
549 IniCacheDestroy(IniCache);
550 return STATUS_UNSUCCESSFUL;
551 }
552
553 /* Find an existing usable or an unused section name */
554 i = 1;
555 wcscpy(SectionName, L"ReactOS");
556 wcscpy(OsName, L"\"ReactOS\"");
557 while(TRUE)
558 {
559 Status = IniCacheGetKey(IniSection, SectionName, &KeyData);
560 if (!NT_SUCCESS(Status))
561 break;
562
563 /* Get operation system section */
564 if (KeyData[0] == '"')
565 {
566 wcscpy(SectionName2, &KeyData[1]);
567 j = wcslen(SectionName2);
568 if (j > 0)
569 {
570 SectionName2[j-1] = 0;
571 }
572 }
573 else
574 {
575 wcscpy(SectionName2, KeyData);
576 }
577
578 OsIniSection = IniCacheGetSection(IniCache, SectionName2);
579 if (OsIniSection != NULL)
580 {
581 BOOLEAN UseExistingEntry = TRUE;
582
583 /* Check BootType */
584 Status = IniCacheGetKey(OsIniSection, L"BootType", &KeyData);
585 if (NT_SUCCESS(Status))
586 {
587 if ((KeyData == NULL) ||
588 ( (_wcsicmp(KeyData, L"ReactOS") != 0) &&
589 (_wcsicmp(KeyData, L"\"ReactOS\"") != 0) ))
590 {
591 /* This is not a ReactOS entry */
592 UseExistingEntry = FALSE;
593 }
594 }
595 else
596 {
597 UseExistingEntry = FALSE;
598 }
599
600 if (UseExistingEntry)
601 {
602 /* BootType is ReactOS. Now check SystemPath */
603 Status = IniCacheGetKey(OsIniSection, L"SystemPath", &KeyData);
604 if (NT_SUCCESS(Status))
605 {
606 swprintf(SystemPath, L"\"%S\"", ArcPath);
607 if ((KeyData == NULL) ||
608 ((_wcsicmp(KeyData, ArcPath) != 0) &&
609 (_wcsicmp(KeyData, SystemPath) != 0) ))
610 {
611 /* This entry is a ReactOS entry, but the SystemRoot does not
612 match the one we are looking for */
613 UseExistingEntry = FALSE;
614 }
615 }
616 else
617 {
618 UseExistingEntry = FALSE;
619 }
620 }
621
622 if (UseExistingEntry)
623 {
624 IniCacheDestroy(IniCache);
625 return STATUS_SUCCESS;
626 }
627 }
628
629 swprintf(SectionName, L"ReactOS_%lu", i);
630 swprintf(OsName, L"\"ReactOS %lu\"", i);
631 i++;
632 }
633
634 /* <SectionName>=<OsName> */
635 IniCacheInsertKey(IniSection,
636 NULL,
637 INSERT_LAST,
638 SectionName,
639 OsName);
640
641 /* Create <SectionName> section */
642 IniSection = IniCacheAppendSection(IniCache, SectionName);
643
644 /* BootType=ReactOS */
645 IniCacheInsertKey(IniSection,
646 NULL,
647 INSERT_LAST,
648 L"BootType",
649 L"ReactOS");
650
651 /* SystemPath=<ArcPath> */
652 IniCacheInsertKey(IniSection,
653 NULL,
654 INSERT_LAST,
655 L"SystemPath",
656 ArcPath);
657
658 IniCacheSave(IniCache, IniPath);
659 IniCacheDestroy(IniCache);
660
661 return STATUS_SUCCESS;
662 }
663
664
665 NTSTATUS
666 SaveCurrentBootSector(
667 PWSTR RootPath,
668 PWSTR DstPath)
669 {
670 OBJECT_ATTRIBUTES ObjectAttributes;
671 IO_STATUS_BLOCK IoStatusBlock;
672 UNICODE_STRING Name;
673 HANDLE FileHandle;
674 NTSTATUS Status;
675 PUCHAR BootSector;
676
677 /* Allocate buffer for bootsector */
678 BootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
679 if (BootSector == NULL)
680 return STATUS_INSUFFICIENT_RESOURCES;
681
682 /* Read current boot sector into buffer */
683 RtlInitUnicodeString(&Name, RootPath);
684
685 InitializeObjectAttributes(&ObjectAttributes,
686 &Name,
687 OBJ_CASE_INSENSITIVE,
688 NULL,
689 NULL);
690
691 Status = NtOpenFile(&FileHandle,
692 GENERIC_READ | SYNCHRONIZE,
693 &ObjectAttributes,
694 &IoStatusBlock,
695 0,
696 FILE_SYNCHRONOUS_IO_NONALERT);
697 if (!NT_SUCCESS(Status))
698 {
699 RtlFreeHeap(ProcessHeap, 0, BootSector);
700 return Status;
701 }
702
703 Status = NtReadFile(FileHandle,
704 NULL,
705 NULL,
706 NULL,
707 &IoStatusBlock,
708 BootSector,
709 SECTORSIZE,
710 NULL,
711 NULL);
712 NtClose(FileHandle);
713 if (!NT_SUCCESS(Status))
714 {
715 RtlFreeHeap(ProcessHeap, 0, BootSector);
716 return Status;
717 }
718
719 /* Write bootsector to DstPath */
720 RtlInitUnicodeString(&Name, DstPath);
721
722 InitializeObjectAttributes(&ObjectAttributes,
723 &Name,
724 0,
725 NULL,
726 NULL);
727
728 Status = NtCreateFile(&FileHandle,
729 GENERIC_WRITE | SYNCHRONIZE,
730 &ObjectAttributes,
731 &IoStatusBlock,
732 NULL,
733 FILE_ATTRIBUTE_NORMAL,
734 0,
735 FILE_SUPERSEDE,
736 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY,
737 NULL,
738 0);
739 if (!NT_SUCCESS(Status))
740 {
741 RtlFreeHeap(ProcessHeap, 0, BootSector);
742 return Status;
743 }
744
745 Status = NtWriteFile(FileHandle,
746 NULL,
747 NULL,
748 NULL,
749 &IoStatusBlock,
750 BootSector,
751 SECTORSIZE,
752 NULL,
753 NULL);
754 NtClose(FileHandle);
755
756 /* Free the new boot sector */
757 RtlFreeHeap(ProcessHeap, 0, BootSector);
758
759 return Status;
760 }
761
762
763 NTSTATUS
764 InstallFat16BootCodeToFile(
765 PWSTR SrcPath,
766 PWSTR DstPath,
767 PWSTR RootPath)
768 {
769 OBJECT_ATTRIBUTES ObjectAttributes;
770 IO_STATUS_BLOCK IoStatusBlock;
771 UNICODE_STRING Name;
772 HANDLE FileHandle;
773 NTSTATUS Status;
774 PFAT_BOOTSECTOR OrigBootSector;
775 PFAT_BOOTSECTOR NewBootSector;
776
777 /* Allocate buffer for original bootsector */
778 OrigBootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
779 if (OrigBootSector == NULL)
780 return STATUS_INSUFFICIENT_RESOURCES ;
781
782 /* Read current boot sector into buffer */
783 RtlInitUnicodeString(&Name, RootPath);
784
785 InitializeObjectAttributes(&ObjectAttributes,
786 &Name,
787 OBJ_CASE_INSENSITIVE,
788 NULL,
789 NULL);
790
791 Status = NtOpenFile(&FileHandle,
792 GENERIC_READ | SYNCHRONIZE,
793 &ObjectAttributes,
794 &IoStatusBlock,
795 0,
796 FILE_SYNCHRONOUS_IO_NONALERT);
797 if (!NT_SUCCESS(Status))
798 {
799 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
800 return Status;
801 }
802
803 Status = NtReadFile(FileHandle,
804 NULL,
805 NULL,
806 NULL,
807 &IoStatusBlock,
808 OrigBootSector,
809 SECTORSIZE,
810 NULL,
811 NULL);
812 NtClose(FileHandle);
813 if (!NT_SUCCESS(Status))
814 {
815 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
816 return Status;
817 }
818
819 /* Allocate buffer for new bootsector */
820 NewBootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
821 if (NewBootSector == NULL)
822 {
823 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
824 return STATUS_INSUFFICIENT_RESOURCES;
825 }
826
827 /* Read new bootsector from SrcPath */
828 RtlInitUnicodeString(&Name, SrcPath);
829
830 InitializeObjectAttributes(&ObjectAttributes,
831 &Name,
832 OBJ_CASE_INSENSITIVE,
833 NULL,
834 NULL);
835
836 Status = NtOpenFile(&FileHandle,
837 GENERIC_READ | SYNCHRONIZE,
838 &ObjectAttributes,
839 &IoStatusBlock,
840 0,
841 FILE_SYNCHRONOUS_IO_NONALERT);
842 if (!NT_SUCCESS(Status))
843 {
844 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
845 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
846 return Status;
847 }
848
849 Status = NtReadFile(FileHandle,
850 NULL,
851 NULL,
852 NULL,
853 &IoStatusBlock,
854 NewBootSector,
855 SECTORSIZE,
856 NULL,
857 NULL);
858 NtClose(FileHandle);
859 if (!NT_SUCCESS(Status))
860 {
861 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
862 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
863 return Status;
864 }
865
866 /* Adjust bootsector (copy a part of the FAT BPB) */
867 memcpy(&NewBootSector->OemName,
868 &OrigBootSector->OemName,
869 FIELD_OFFSET(FAT_BOOTSECTOR, BootCodeAndData) -
870 FIELD_OFFSET(FAT_BOOTSECTOR, OemName));
871
872 /* Free the original boot sector */
873 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
874
875 /* Write new bootsector to DstPath */
876 RtlInitUnicodeString(&Name, DstPath);
877
878 InitializeObjectAttributes(&ObjectAttributes,
879 &Name,
880 0,
881 NULL,
882 NULL);
883
884 Status = NtCreateFile(&FileHandle,
885 GENERIC_WRITE | SYNCHRONIZE,
886 &ObjectAttributes,
887 &IoStatusBlock,
888 NULL,
889 FILE_ATTRIBUTE_NORMAL,
890 0,
891 FILE_OVERWRITE_IF,
892 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY,
893 NULL,
894 0);
895 if (!NT_SUCCESS(Status))
896 {
897 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
898 return Status;
899 }
900
901 #if 0
902 FilePosition.QuadPart = 0;
903 #endif
904 Status = NtWriteFile(FileHandle,
905 NULL,
906 NULL,
907 NULL,
908 &IoStatusBlock,
909 NewBootSector,
910 SECTORSIZE,
911 NULL,
912 NULL);
913 NtClose(FileHandle);
914
915 /* Free the new boot sector */
916 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
917
918 return Status;
919 }
920
921
922 NTSTATUS
923 InstallFat32BootCodeToFile(
924 PWSTR SrcPath,
925 PWSTR DstPath,
926 PWSTR RootPath)
927 {
928 OBJECT_ATTRIBUTES ObjectAttributes;
929 IO_STATUS_BLOCK IoStatusBlock;
930 UNICODE_STRING Name;
931 HANDLE FileHandle;
932 NTSTATUS Status;
933 PFAT32_BOOTSECTOR OrigBootSector;
934 PFAT32_BOOTSECTOR NewBootSector;
935 LARGE_INTEGER FileOffset;
936
937 /* Allocate buffer for original bootsector */
938 OrigBootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
939 if (OrigBootSector == NULL)
940 return STATUS_INSUFFICIENT_RESOURCES;
941
942 /* Read current boot sector into buffer */
943 RtlInitUnicodeString(&Name, RootPath);
944
945 InitializeObjectAttributes(&ObjectAttributes,
946 &Name,
947 OBJ_CASE_INSENSITIVE,
948 NULL,
949 NULL);
950
951 Status = NtOpenFile(&FileHandle,
952 GENERIC_READ | SYNCHRONIZE,
953 &ObjectAttributes,
954 &IoStatusBlock,
955 0,
956 FILE_SYNCHRONOUS_IO_NONALERT);
957 if (!NT_SUCCESS(Status))
958 {
959 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
960 return Status;
961 }
962
963 Status = NtReadFile(FileHandle,
964 NULL,
965 NULL,
966 NULL,
967 &IoStatusBlock,
968 OrigBootSector,
969 SECTORSIZE,
970 NULL,
971 NULL);
972 NtClose(FileHandle);
973 if (!NT_SUCCESS(Status))
974 {
975 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
976 return Status;
977 }
978
979 /* Allocate buffer for new bootsector (2 sectors) */
980 NewBootSector = RtlAllocateHeap(ProcessHeap, 0, 2 * SECTORSIZE);
981 if (NewBootSector == NULL)
982 {
983 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
984 return STATUS_INSUFFICIENT_RESOURCES;
985 }
986
987 /* Read new bootsector from SrcPath */
988 RtlInitUnicodeString(&Name, SrcPath);
989
990 InitializeObjectAttributes(&ObjectAttributes,
991 &Name,
992 OBJ_CASE_INSENSITIVE,
993 NULL,
994 NULL);
995
996 Status = NtOpenFile(&FileHandle,
997 GENERIC_READ | SYNCHRONIZE,
998 &ObjectAttributes,
999 &IoStatusBlock,
1000 0,
1001 FILE_SYNCHRONOUS_IO_NONALERT);
1002 if (!NT_SUCCESS(Status))
1003 {
1004 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1005 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1006 return Status;
1007 }
1008
1009 Status = NtReadFile(FileHandle,
1010 NULL,
1011 NULL,
1012 NULL,
1013 &IoStatusBlock,
1014 NewBootSector,
1015 2 * SECTORSIZE,
1016 NULL,
1017 NULL);
1018 NtClose(FileHandle);
1019 if (!NT_SUCCESS(Status))
1020 {
1021 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1022 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1023 return Status;
1024 }
1025
1026 /* Adjust bootsector (copy a part of the FAT32 BPB) */
1027 memcpy(&NewBootSector->OemName,
1028 &OrigBootSector->OemName,
1029 FIELD_OFFSET(FAT32_BOOTSECTOR, BootCodeAndData) -
1030 FIELD_OFFSET(FAT32_BOOTSECTOR, OemName));
1031
1032 /* Disable the backup boot sector */
1033 NewBootSector->BackupBootSector = 0;
1034
1035 /* Free the original boot sector */
1036 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1037
1038 /* Write the first sector of the new bootcode to DstPath */
1039 RtlInitUnicodeString(&Name, DstPath);
1040
1041 InitializeObjectAttributes(&ObjectAttributes,
1042 &Name,
1043 0,
1044 NULL,
1045 NULL);
1046
1047 Status = NtCreateFile(&FileHandle,
1048 GENERIC_WRITE | SYNCHRONIZE,
1049 &ObjectAttributes,
1050 &IoStatusBlock,
1051 NULL,
1052 FILE_ATTRIBUTE_NORMAL,
1053 0,
1054 FILE_SUPERSEDE,
1055 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY,
1056 NULL,
1057 0);
1058 if (!NT_SUCCESS(Status))
1059 {
1060 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1061 return Status;
1062 }
1063
1064 Status = NtWriteFile(FileHandle,
1065 NULL,
1066 NULL,
1067 NULL,
1068 &IoStatusBlock,
1069 NewBootSector,
1070 SECTORSIZE,
1071 NULL,
1072 NULL);
1073 NtClose(FileHandle);
1074 if (!NT_SUCCESS(Status))
1075 {
1076 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1077 return Status;
1078 }
1079
1080 /* Write the second sector of the new bootcode to boot disk sector 14 */
1081 RtlInitUnicodeString(&Name, RootPath);
1082
1083 InitializeObjectAttributes(&ObjectAttributes,
1084 &Name,
1085 0,
1086 NULL,
1087 NULL);
1088
1089 Status = NtOpenFile(&FileHandle,
1090 GENERIC_WRITE | SYNCHRONIZE,
1091 &ObjectAttributes,
1092 &IoStatusBlock,
1093 0,
1094 FILE_SYNCHRONOUS_IO_NONALERT);
1095 if (!NT_SUCCESS(Status))
1096 {
1097 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1098 return Status;
1099 }
1100
1101 FileOffset.QuadPart = (ULONGLONG)(14 * SECTORSIZE);
1102 Status = NtWriteFile(FileHandle,
1103 NULL,
1104 NULL,
1105 NULL,
1106 &IoStatusBlock,
1107 ((PUCHAR)NewBootSector + SECTORSIZE),
1108 SECTORSIZE,
1109 &FileOffset,
1110 NULL);
1111 if (!NT_SUCCESS(Status))
1112 {
1113 }
1114 NtClose(FileHandle);
1115
1116 /* Free the new boot sector */
1117 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1118
1119 return Status;
1120 }
1121
1122
1123 NTSTATUS
1124 InstallMbrBootCodeToDisk(
1125 PWSTR SrcPath,
1126 PWSTR RootPath)
1127 {
1128 OBJECT_ATTRIBUTES ObjectAttributes;
1129 IO_STATUS_BLOCK IoStatusBlock;
1130 UNICODE_STRING Name;
1131 HANDLE FileHandle;
1132 NTSTATUS Status;
1133 PPARTITION_SECTOR OrigBootSector;
1134 PPARTITION_SECTOR NewBootSector;
1135
1136 /* Allocate buffer for original bootsector */
1137 OrigBootSector = (PPARTITION_SECTOR)RtlAllocateHeap(ProcessHeap,
1138 0,
1139 sizeof(PARTITION_SECTOR));
1140 if (OrigBootSector == NULL)
1141 return STATUS_INSUFFICIENT_RESOURCES;
1142
1143 /* Read current boot sector into buffer */
1144 RtlInitUnicodeString(&Name,
1145 RootPath);
1146
1147 InitializeObjectAttributes(&ObjectAttributes,
1148 &Name,
1149 OBJ_CASE_INSENSITIVE,
1150 NULL,
1151 NULL);
1152
1153 Status = NtOpenFile(&FileHandle,
1154 GENERIC_READ | SYNCHRONIZE,
1155 &ObjectAttributes,
1156 &IoStatusBlock,
1157 0,
1158 FILE_SYNCHRONOUS_IO_NONALERT);
1159 if (!NT_SUCCESS(Status))
1160 {
1161 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1162 return Status;
1163 }
1164
1165 Status = NtReadFile(FileHandle,
1166 NULL,
1167 NULL,
1168 NULL,
1169 &IoStatusBlock,
1170 OrigBootSector,
1171 SECTORSIZE,
1172 NULL,
1173 NULL);
1174 NtClose(FileHandle);
1175 if (!NT_SUCCESS(Status))
1176 {
1177 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1178 return Status;
1179 }
1180
1181
1182 /* Allocate buffer for new bootsector */
1183 NewBootSector = (PPARTITION_SECTOR)RtlAllocateHeap(ProcessHeap,
1184 0,
1185 sizeof(PARTITION_SECTOR));
1186 if (NewBootSector == NULL)
1187 {
1188 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1189 return STATUS_INSUFFICIENT_RESOURCES;
1190 }
1191
1192 /* Read new bootsector from SrcPath */
1193 RtlInitUnicodeString(&Name, SrcPath);
1194
1195 InitializeObjectAttributes(&ObjectAttributes,
1196 &Name,
1197 OBJ_CASE_INSENSITIVE,
1198 NULL,
1199 NULL);
1200
1201 Status = NtOpenFile(&FileHandle,
1202 GENERIC_READ | SYNCHRONIZE,
1203 &ObjectAttributes,
1204 &IoStatusBlock,
1205 0,
1206 FILE_SYNCHRONOUS_IO_NONALERT);
1207 if (!NT_SUCCESS(Status))
1208 {
1209 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1210 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1211 return Status;
1212 }
1213
1214 Status = NtReadFile(FileHandle,
1215 NULL,
1216 NULL,
1217 NULL,
1218 &IoStatusBlock,
1219 NewBootSector,
1220 sizeof(PARTITION_SECTOR),
1221 NULL,
1222 NULL);
1223 NtClose(FileHandle);
1224 if (!NT_SUCCESS(Status))
1225 {
1226 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1227 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1228 return Status;
1229 }
1230
1231 /* Copy partition table from old MBR to new */
1232 RtlCopyMemory (&NewBootSector->Signature,
1233 &OrigBootSector->Signature,
1234 sizeof(PARTITION_SECTOR) - offsetof(PARTITION_SECTOR, Signature) /* Length of partition table */);
1235
1236 /* Free the original boot sector */
1237 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1238
1239 /* Write new bootsector to RootPath */
1240 RtlInitUnicodeString(&Name, RootPath);
1241
1242 InitializeObjectAttributes(&ObjectAttributes,
1243 &Name,
1244 0,
1245 NULL,
1246 NULL);
1247
1248 Status = NtOpenFile(&FileHandle,
1249 GENERIC_WRITE | SYNCHRONIZE,
1250 &ObjectAttributes,
1251 &IoStatusBlock,
1252 0,
1253 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY);
1254 if (!NT_SUCCESS(Status))
1255 {
1256 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1257 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1258 return Status;
1259 }
1260
1261 Status = NtWriteFile(FileHandle,
1262 NULL,
1263 NULL,
1264 NULL,
1265 &IoStatusBlock,
1266 NewBootSector,
1267 SECTORSIZE,
1268 NULL,
1269 NULL);
1270 NtClose(FileHandle);
1271
1272 /* Free the new boot sector */
1273 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1274
1275 return Status;
1276 }
1277
1278 NTSTATUS
1279 InstallFat12BootCodeToFloppy(PWSTR SrcPath,
1280 PWSTR RootPath)
1281 {
1282 OBJECT_ATTRIBUTES ObjectAttributes;
1283 IO_STATUS_BLOCK IoStatusBlock;
1284 UNICODE_STRING Name;
1285 HANDLE FileHandle;
1286 NTSTATUS Status;
1287 PFAT_BOOTSECTOR OrigBootSector;
1288 PFAT_BOOTSECTOR NewBootSector;
1289
1290 /* Allocate buffer for original bootsector */
1291 OrigBootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
1292 if (OrigBootSector == NULL)
1293 return STATUS_INSUFFICIENT_RESOURCES;
1294
1295 /* Read current boot sector into buffer */
1296 RtlInitUnicodeString(&Name, RootPath);
1297
1298 InitializeObjectAttributes(&ObjectAttributes,
1299 &Name,
1300 OBJ_CASE_INSENSITIVE,
1301 NULL,
1302 NULL);
1303
1304 Status = NtOpenFile(&FileHandle,
1305 GENERIC_READ | SYNCHRONIZE,
1306 &ObjectAttributes,
1307 &IoStatusBlock,
1308 0,
1309 FILE_SYNCHRONOUS_IO_NONALERT);
1310 if (!NT_SUCCESS(Status))
1311 {
1312 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1313 return Status;
1314 }
1315
1316 Status = NtReadFile(FileHandle,
1317 NULL,
1318 NULL,
1319 NULL,
1320 &IoStatusBlock,
1321 OrigBootSector,
1322 SECTORSIZE,
1323 NULL,
1324 NULL);
1325 NtClose(FileHandle);
1326 if (!NT_SUCCESS(Status))
1327 {
1328 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1329 return Status;
1330 }
1331
1332
1333 /* Allocate buffer for new bootsector */
1334 NewBootSector = RtlAllocateHeap(ProcessHeap,
1335 0,
1336 SECTORSIZE);
1337 if (NewBootSector == NULL)
1338 {
1339 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1340 return STATUS_INSUFFICIENT_RESOURCES;
1341 }
1342
1343 /* Read new bootsector from SrcPath */
1344 RtlInitUnicodeString(&Name, SrcPath);
1345
1346 InitializeObjectAttributes(&ObjectAttributes,
1347 &Name,
1348 OBJ_CASE_INSENSITIVE,
1349 NULL,
1350 NULL);
1351
1352 Status = NtOpenFile(&FileHandle,
1353 GENERIC_READ | SYNCHRONIZE,
1354 &ObjectAttributes,
1355 &IoStatusBlock,
1356 0,
1357 FILE_SYNCHRONOUS_IO_NONALERT);
1358 if (!NT_SUCCESS(Status))
1359 {
1360 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1361 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1362 return Status;
1363 }
1364
1365 Status = NtReadFile(FileHandle,
1366 NULL,
1367 NULL,
1368 NULL,
1369 &IoStatusBlock,
1370 NewBootSector,
1371 SECTORSIZE,
1372 NULL,
1373 NULL);
1374 NtClose(FileHandle);
1375 if (!NT_SUCCESS(Status))
1376 {
1377 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1378 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1379 return Status;
1380 }
1381
1382 /* Adjust bootsector (copy a part of the FAT16 BPB) */
1383 memcpy(&NewBootSector->OemName,
1384 &OrigBootSector->OemName,
1385 FIELD_OFFSET(FAT_BOOTSECTOR, BootCodeAndData) -
1386 FIELD_OFFSET(FAT_BOOTSECTOR, OemName));
1387
1388 /* Free the original boot sector */
1389 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1390
1391 /* Write new bootsector to RootPath */
1392 RtlInitUnicodeString(&Name, RootPath);
1393
1394 InitializeObjectAttributes(&ObjectAttributes,
1395 &Name,
1396 0,
1397 NULL,
1398 NULL);
1399
1400 Status = NtOpenFile(&FileHandle,
1401 GENERIC_WRITE | SYNCHRONIZE,
1402 &ObjectAttributes,
1403 &IoStatusBlock,
1404 0,
1405 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY);
1406 if (!NT_SUCCESS(Status))
1407 {
1408 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1409 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1410 return Status;
1411 }
1412
1413 #if 0
1414 FilePosition.QuadPart = 0;
1415 #endif
1416 Status = NtWriteFile(FileHandle,
1417 NULL,
1418 NULL,
1419 NULL,
1420 &IoStatusBlock,
1421 NewBootSector,
1422 SECTORSIZE,
1423 NULL,
1424 NULL);
1425 NtClose(FileHandle);
1426
1427 /* Free the new boot sector */
1428 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1429
1430 return Status;
1431 }
1432
1433
1434 NTSTATUS
1435 InstallFat16BootCodeToDisk(
1436 PWSTR SrcPath,
1437 PWSTR RootPath)
1438 {
1439 OBJECT_ATTRIBUTES ObjectAttributes;
1440 IO_STATUS_BLOCK IoStatusBlock;
1441 UNICODE_STRING Name;
1442 HANDLE FileHandle;
1443 NTSTATUS Status;
1444 PFAT_BOOTSECTOR OrigBootSector;
1445 PFAT_BOOTSECTOR NewBootSector;
1446 PARTITION_INFORMATION *PartInfo;
1447
1448 /* Allocate buffer for original bootsector */
1449 OrigBootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
1450 if (OrigBootSector == NULL)
1451 return STATUS_INSUFFICIENT_RESOURCES;
1452
1453 /* Read current boot sector into buffer */
1454 RtlInitUnicodeString(&Name, RootPath);
1455
1456 InitializeObjectAttributes(&ObjectAttributes,
1457 &Name,
1458 OBJ_CASE_INSENSITIVE,
1459 NULL,
1460 NULL);
1461
1462 Status = NtOpenFile(&FileHandle,
1463 GENERIC_READ | SYNCHRONIZE,
1464 &ObjectAttributes,
1465 &IoStatusBlock,
1466 0,
1467 FILE_SYNCHRONOUS_IO_NONALERT);
1468 if (!NT_SUCCESS(Status))
1469 {
1470 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1471 return Status;
1472 }
1473
1474 Status = NtReadFile(FileHandle,
1475 NULL,
1476 NULL,
1477 NULL,
1478 &IoStatusBlock,
1479 OrigBootSector,
1480 SECTORSIZE,
1481 NULL,
1482 NULL);
1483 NtClose(FileHandle);
1484 if (!NT_SUCCESS(Status))
1485 {
1486 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1487 return Status;
1488 }
1489
1490
1491 /* Allocate buffer for new bootsector */
1492 NewBootSector = RtlAllocateHeap(ProcessHeap,
1493 0,
1494 SECTORSIZE);
1495 if (NewBootSector == NULL)
1496 {
1497 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1498 return STATUS_INSUFFICIENT_RESOURCES;
1499 }
1500
1501 /* Read new bootsector from SrcPath */
1502 RtlInitUnicodeString(&Name, SrcPath);
1503
1504 InitializeObjectAttributes(&ObjectAttributes,
1505 &Name,
1506 OBJ_CASE_INSENSITIVE,
1507 NULL,
1508 NULL);
1509
1510 Status = NtOpenFile(&FileHandle,
1511 GENERIC_READ | SYNCHRONIZE,
1512 &ObjectAttributes,
1513 &IoStatusBlock,
1514 0,
1515 FILE_SYNCHRONOUS_IO_NONALERT);
1516 if (!NT_SUCCESS(Status))
1517 {
1518 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1519 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1520 return Status;
1521 }
1522
1523 Status = NtReadFile(FileHandle,
1524 NULL,
1525 NULL,
1526 NULL,
1527 &IoStatusBlock,
1528 NewBootSector,
1529 SECTORSIZE,
1530 NULL,
1531 NULL);
1532 NtClose(FileHandle);
1533 if (!NT_SUCCESS(Status))
1534 {
1535 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1536 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1537 return Status;
1538 }
1539
1540 /* Adjust bootsector (copy a part of the FAT16 BPB) */
1541 memcpy(&NewBootSector->OemName,
1542 &OrigBootSector->OemName,
1543 FIELD_OFFSET(FAT_BOOTSECTOR, BootCodeAndData) -
1544 FIELD_OFFSET(FAT_BOOTSECTOR, OemName));
1545
1546 PartInfo = &PartitionList->CurrentPartition->PartInfo[PartitionList->CurrentPartitionNumber];
1547 NewBootSector->HiddenSectors = PartInfo->HiddenSectors;
1548
1549 /* Free the original boot sector */
1550 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1551
1552 /* Write new bootsector to RootPath */
1553 RtlInitUnicodeString(&Name, RootPath);
1554
1555 InitializeObjectAttributes(&ObjectAttributes,
1556 &Name,
1557 0,
1558 NULL,
1559 NULL);
1560
1561 Status = NtOpenFile(&FileHandle,
1562 GENERIC_WRITE | SYNCHRONIZE,
1563 &ObjectAttributes,
1564 &IoStatusBlock,
1565 0,
1566 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY);
1567 if (!NT_SUCCESS(Status))
1568 {
1569 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1570 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1571 return Status;
1572 }
1573
1574 #if 0
1575 FilePosition.QuadPart = 0;
1576 #endif
1577 Status = NtWriteFile(FileHandle,
1578 NULL,
1579 NULL,
1580 NULL,
1581 &IoStatusBlock,
1582 NewBootSector,
1583 SECTORSIZE,
1584 NULL,
1585 NULL);
1586 NtClose(FileHandle);
1587
1588 /* Free the new boot sector */
1589 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1590
1591 return Status;
1592 }
1593
1594
1595 NTSTATUS
1596 InstallFat32BootCodeToDisk(
1597 PWSTR SrcPath,
1598 PWSTR RootPath)
1599 {
1600 OBJECT_ATTRIBUTES ObjectAttributes;
1601 IO_STATUS_BLOCK IoStatusBlock;
1602 UNICODE_STRING Name;
1603 HANDLE FileHandle;
1604 NTSTATUS Status;
1605 PFAT32_BOOTSECTOR OrigBootSector;
1606 PFAT32_BOOTSECTOR NewBootSector;
1607 LARGE_INTEGER FileOffset;
1608 USHORT BackupBootSector;
1609 PARTITION_INFORMATION *PartInfo;
1610
1611 /* Allocate buffer for original bootsector */
1612 OrigBootSector = RtlAllocateHeap(ProcessHeap, 0, SECTORSIZE);
1613 if (OrigBootSector == NULL)
1614 return STATUS_INSUFFICIENT_RESOURCES;
1615
1616 /* Read current boot sector into buffer */
1617 RtlInitUnicodeString(&Name, RootPath);
1618
1619 InitializeObjectAttributes(&ObjectAttributes,
1620 &Name,
1621 OBJ_CASE_INSENSITIVE,
1622 NULL,
1623 NULL);
1624
1625 Status = NtOpenFile(&FileHandle,
1626 GENERIC_READ | SYNCHRONIZE,
1627 &ObjectAttributes,
1628 &IoStatusBlock,
1629 0,
1630 FILE_SYNCHRONOUS_IO_NONALERT);
1631 if (!NT_SUCCESS(Status))
1632 {
1633 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1634 return Status;
1635 }
1636
1637 Status = NtReadFile(FileHandle,
1638 NULL,
1639 NULL,
1640 NULL,
1641 &IoStatusBlock,
1642 OrigBootSector,
1643 SECTORSIZE,
1644 NULL,
1645 NULL);
1646 NtClose(FileHandle);
1647 if (!NT_SUCCESS(Status))
1648 {
1649 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1650 return Status;
1651 }
1652
1653
1654 /* Allocate buffer for new bootsector (2 sectors) */
1655 NewBootSector = RtlAllocateHeap(ProcessHeap, 0, 2 * SECTORSIZE);
1656 if (NewBootSector == NULL)
1657 {
1658 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1659 return STATUS_INSUFFICIENT_RESOURCES;
1660 }
1661
1662 /* Read new bootsector from SrcPath */
1663 RtlInitUnicodeString(&Name, SrcPath);
1664
1665 InitializeObjectAttributes(&ObjectAttributes,
1666 &Name,
1667 OBJ_CASE_INSENSITIVE,
1668 NULL,
1669 NULL);
1670
1671 Status = NtOpenFile(&FileHandle,
1672 GENERIC_READ | SYNCHRONIZE,
1673 &ObjectAttributes,
1674 &IoStatusBlock,
1675 0,
1676 FILE_SYNCHRONOUS_IO_NONALERT);
1677 if (!NT_SUCCESS(Status))
1678 {
1679 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1680 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1681 return Status;
1682 }
1683
1684 Status = NtReadFile(FileHandle,
1685 NULL,
1686 NULL,
1687 NULL,
1688 &IoStatusBlock,
1689 NewBootSector,
1690 2 * SECTORSIZE,
1691 NULL,
1692 NULL);
1693 NtClose(FileHandle);
1694 if (!NT_SUCCESS(Status))
1695 {
1696 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1697 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1698 return Status;
1699 }
1700
1701 /* Adjust bootsector (copy a part of the FAT32 BPB) */
1702 memcpy(&NewBootSector->OemName,
1703 &OrigBootSector->OemName,
1704 FIELD_OFFSET(FAT32_BOOTSECTOR, BootCodeAndData) -
1705 FIELD_OFFSET(FAT32_BOOTSECTOR, OemName));
1706
1707 PartInfo = &PartitionList->CurrentPartition->PartInfo[PartitionList->CurrentPartitionNumber];
1708 NewBootSector->HiddenSectors = PartInfo->HiddenSectors;
1709
1710 /* Get the location of the backup boot sector */
1711 BackupBootSector = OrigBootSector->BackupBootSector;
1712
1713 /* Free the original boot sector */
1714 RtlFreeHeap(ProcessHeap, 0, OrigBootSector);
1715
1716 /* Write the first sector of the new bootcode to DstPath */
1717 RtlInitUnicodeString(&Name, RootPath);
1718
1719 InitializeObjectAttributes(&ObjectAttributes,
1720 &Name,
1721 0,
1722 NULL,
1723 NULL);
1724
1725 Status = NtOpenFile(&FileHandle,
1726 GENERIC_WRITE | SYNCHRONIZE,
1727 &ObjectAttributes,
1728 &IoStatusBlock,
1729 0,
1730 FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY);
1731 if (!NT_SUCCESS(Status))
1732 {
1733 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1734 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1735 return Status;
1736 }
1737
1738 /* Write sector 0 */
1739 FileOffset.QuadPart = 0ULL;
1740 Status = NtWriteFile(FileHandle,
1741 NULL,
1742 NULL,
1743 NULL,
1744 &IoStatusBlock,
1745 NewBootSector,
1746 SECTORSIZE,
1747 &FileOffset,
1748 NULL);
1749 if (!NT_SUCCESS(Status))
1750 {
1751 DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
1752 NtClose(FileHandle);
1753 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1754 return Status;
1755 }
1756
1757 /* Write backup boot sector */
1758 if ((BackupBootSector != 0x0000) && (BackupBootSector != 0xFFFF))
1759 {
1760 FileOffset.QuadPart = (ULONGLONG)((ULONG)BackupBootSector * SECTORSIZE);
1761 Status = NtWriteFile(FileHandle,
1762 NULL,
1763 NULL,
1764 NULL,
1765 &IoStatusBlock,
1766 NewBootSector,
1767 SECTORSIZE,
1768 &FileOffset,
1769 NULL);
1770 if (!NT_SUCCESS(Status))
1771 {
1772 DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
1773 NtClose(FileHandle);
1774 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1775 return Status;
1776 }
1777 }
1778
1779 /* Write sector 14 */
1780 FileOffset.QuadPart = 14 * SECTORSIZE;
1781 Status = NtWriteFile(FileHandle,
1782 NULL,
1783 NULL,
1784 NULL,
1785 &IoStatusBlock,
1786 ((PUCHAR)NewBootSector + SECTORSIZE),
1787 SECTORSIZE,
1788 &FileOffset,
1789 NULL);
1790 if (!NT_SUCCESS(Status))
1791 {
1792 DPRINT1("NtWriteFile() failed (Status %lx)\n", Status);
1793 }
1794 NtClose(FileHandle);
1795
1796 /* Free the new boot sector */
1797 RtlFreeHeap(ProcessHeap, 0, NewBootSector);
1798
1799 return Status;
1800 }
1801
1802
1803 static
1804 NTSTATUS
1805 UnprotectBootIni(
1806 PWSTR FileName,
1807 PULONG Attributes)
1808 {
1809 UNICODE_STRING Name;
1810 OBJECT_ATTRIBUTES ObjectAttributes;
1811 IO_STATUS_BLOCK IoStatusBlock;
1812 FILE_BASIC_INFORMATION FileInfo;
1813 HANDLE FileHandle;
1814 NTSTATUS Status;
1815
1816 RtlInitUnicodeString(&Name, FileName);
1817
1818 InitializeObjectAttributes(&ObjectAttributes,
1819 &Name,
1820 OBJ_CASE_INSENSITIVE,
1821 NULL,
1822 NULL);
1823
1824 Status = NtOpenFile(&FileHandle,
1825 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
1826 &ObjectAttributes,
1827 &IoStatusBlock,
1828 0,
1829 FILE_SYNCHRONOUS_IO_NONALERT);
1830 if (Status == STATUS_NO_SUCH_FILE)
1831 {
1832 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1833 *Attributes = 0;
1834 return STATUS_SUCCESS;
1835 }
1836 if (!NT_SUCCESS(Status))
1837 {
1838 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1839 return Status;
1840 }
1841
1842 Status = NtQueryInformationFile(FileHandle,
1843 &IoStatusBlock,
1844 &FileInfo,
1845 sizeof(FILE_BASIC_INFORMATION),
1846 FileBasicInformation);
1847 if (!NT_SUCCESS(Status))
1848 {
1849 DPRINT1("NtQueryInformationFile() failed (Status %lx)\n", Status);
1850 NtClose(FileHandle);
1851 return Status;
1852 }
1853
1854 *Attributes = FileInfo.FileAttributes;
1855
1856 /* Delete attributes SYSTEM, HIDDEN and READONLY */
1857 FileInfo.FileAttributes = FileInfo.FileAttributes &
1858 ~(FILE_ATTRIBUTE_SYSTEM |
1859 FILE_ATTRIBUTE_HIDDEN |
1860 FILE_ATTRIBUTE_READONLY);
1861
1862 Status = NtSetInformationFile(FileHandle,
1863 &IoStatusBlock,
1864 &FileInfo,
1865 sizeof(FILE_BASIC_INFORMATION),
1866 FileBasicInformation);
1867 if (!NT_SUCCESS(Status))
1868 {
1869 DPRINT1("NtSetInformationFile() failed (Status %lx)\n", Status);
1870 }
1871
1872 NtClose(FileHandle);
1873 return Status;
1874 }
1875
1876
1877 static
1878 NTSTATUS
1879 ProtectBootIni(
1880 PWSTR FileName,
1881 ULONG Attributes)
1882 {
1883 UNICODE_STRING Name;
1884 OBJECT_ATTRIBUTES ObjectAttributes;
1885 IO_STATUS_BLOCK IoStatusBlock;
1886 FILE_BASIC_INFORMATION FileInfo;
1887 HANDLE FileHandle;
1888 NTSTATUS Status;
1889
1890 RtlInitUnicodeString(&Name, FileName);
1891
1892 InitializeObjectAttributes(&ObjectAttributes,
1893 &Name,
1894 OBJ_CASE_INSENSITIVE,
1895 NULL,
1896 NULL);
1897
1898 Status = NtOpenFile(&FileHandle,
1899 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
1900 &ObjectAttributes,
1901 &IoStatusBlock,
1902 0,
1903 FILE_SYNCHRONOUS_IO_NONALERT);
1904 if (!NT_SUCCESS(Status))
1905 {
1906 DPRINT1("NtOpenFile() failed (Status %lx)\n", Status);
1907 return Status;
1908 }
1909
1910 Status = NtQueryInformationFile(FileHandle,
1911 &IoStatusBlock,
1912 &FileInfo,
1913 sizeof(FILE_BASIC_INFORMATION),
1914 FileBasicInformation);
1915 if (!NT_SUCCESS(Status))
1916 {
1917 DPRINT1("NtQueryInformationFile() failed (Status %lx)\n", Status);
1918 NtClose(FileHandle);
1919 return Status;
1920 }
1921
1922 FileInfo.FileAttributes = FileInfo.FileAttributes | Attributes;
1923
1924 Status = NtSetInformationFile(FileHandle,
1925 &IoStatusBlock,
1926 &FileInfo,
1927 sizeof(FILE_BASIC_INFORMATION),
1928 FileBasicInformation);
1929 if (!NT_SUCCESS(Status))
1930 {
1931 DPRINT1("NtSetInformationFile() failed (Status %lx)\n", Status);
1932 }
1933
1934 NtClose(FileHandle);
1935 return Status;
1936 }
1937
1938
1939 NTSTATUS
1940 UpdateBootIni(
1941 PWSTR BootIniPath,
1942 PWSTR EntryName,
1943 PWSTR EntryValue)
1944 {
1945 UNICODE_STRING Name;
1946 PINICACHE Cache = NULL;
1947 PINICACHESECTION Section = NULL;
1948 NTSTATUS Status;
1949 ULONG FileAttribute;
1950 PWCHAR OldValue = NULL;
1951
1952 RtlInitUnicodeString(&Name, BootIniPath);
1953
1954 Status = IniCacheLoad(&Cache, &Name, FALSE);
1955 if (!NT_SUCCESS(Status))
1956 {
1957 return Status;
1958 }
1959
1960 Section = IniCacheGetSection(Cache,
1961 L"operating systems");
1962 if (Section == NULL)
1963 {
1964 IniCacheDestroy(Cache);
1965 return STATUS_UNSUCCESSFUL;
1966 }
1967
1968 /* Check - maybe record already exists */
1969 Status = IniCacheGetKey(Section, EntryName, &OldValue);
1970
1971 /* If either key was not found, or contains something else - add new one */
1972 if (!NT_SUCCESS(Status) || wcscmp(OldValue, EntryValue))
1973 {
1974 IniCacheInsertKey(Section,
1975 NULL,
1976 INSERT_LAST,
1977 EntryName,
1978 EntryValue);
1979 }
1980
1981 Status = UnprotectBootIni(BootIniPath,
1982 &FileAttribute);
1983 if (!NT_SUCCESS(Status))
1984 {
1985 IniCacheDestroy(Cache);
1986 return Status;
1987 }
1988
1989 Status = IniCacheSave(Cache, BootIniPath);
1990 if (!NT_SUCCESS(Status))
1991 {
1992 IniCacheDestroy(Cache);
1993 return Status;
1994 }
1995
1996 FileAttribute |= (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_READONLY);
1997 Status = ProtectBootIni(BootIniPath, FileAttribute);
1998
1999 IniCacheDestroy(Cache);
2000
2001 return Status;
2002 }
2003
2004 BOOLEAN
2005 CheckInstallFatBootcodeToPartition(
2006 PUNICODE_STRING SystemRootPath)
2007 {
2008 #ifdef __REACTOS__
2009 if (DoesFileExist(SystemRootPath->Buffer, L"ntldr") ||
2010 DoesFileExist(SystemRootPath->Buffer, L"boot.ini"))
2011 {
2012 return TRUE;
2013 }
2014 else if (DoesFileExist(SystemRootPath->Buffer, L"io.sys") ||
2015 DoesFileExist(SystemRootPath->Buffer, L"msdos.sys"))
2016 {
2017 return TRUE;
2018 }
2019 #endif
2020
2021 return FALSE;
2022 }
2023
2024
2025 NTSTATUS
2026 InstallFatBootcodeToPartition(
2027 PUNICODE_STRING SystemRootPath,
2028 PUNICODE_STRING SourceRootPath,
2029 PUNICODE_STRING DestinationArcPath,
2030 UCHAR PartitionType)
2031 {
2032 #ifdef __REACTOS__
2033 WCHAR SrcPath[MAX_PATH];
2034 WCHAR DstPath[MAX_PATH];
2035 NTSTATUS Status;
2036
2037 /* FAT or FAT32 partition */
2038 DPRINT("System path: '%wZ'\n", SystemRootPath);
2039
2040 if (DoesFileExist(SystemRootPath->Buffer, L"ntldr") == TRUE ||
2041 DoesFileExist(SystemRootPath->Buffer, L"boot.ini") == TRUE)
2042 {
2043 /* Search root directory for 'ntldr' and 'boot.ini'. */
2044 DPRINT("Found Microsoft Windows NT/2000/XP boot loader\n");
2045
2046 /* Copy FreeLoader to the boot partition */
2047 wcscpy(SrcPath, SourceRootPath->Buffer);
2048 wcscat(SrcPath, L"\\loader\\freeldr.sys");
2049 wcscpy(DstPath, SystemRootPath->Buffer);
2050 wcscat(DstPath, L"\\freeldr.sys");
2051
2052 DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
2053 Status = SetupCopyFile(SrcPath, DstPath);
2054 if (!NT_SUCCESS(Status))
2055 {
2056 DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
2057 return Status;
2058 }
2059
2060 /* Create or update freeldr.ini */
2061 if (DoesFileExist(SystemRootPath->Buffer, L"freeldr.ini") == FALSE)
2062 {
2063 /* Create new 'freeldr.ini' */
2064 DPRINT1("Create new 'freeldr.ini'\n");
2065 wcscpy(DstPath, SystemRootPath->Buffer);
2066 wcscat(DstPath, L"\\freeldr.ini");
2067
2068 Status = CreateFreeLoaderIniForReactos(DstPath,
2069 DestinationArcPath->Buffer);
2070 if (!NT_SUCCESS(Status))
2071 {
2072 DPRINT1("CreateFreeLoaderIniForReactos() failed (Status %lx)\n", Status);
2073 return Status;
2074 }
2075
2076 /* Install new bootcode */
2077 if (PartitionType == PARTITION_FAT32 ||
2078 PartitionType == PARTITION_FAT32_XINT13)
2079 {
2080 /* Install FAT32 bootcode */
2081 wcscpy(SrcPath, SourceRootPath->Buffer);
2082 wcscat(SrcPath, L"\\loader\\fat32.bin");
2083 wcscpy(DstPath, SystemRootPath->Buffer);
2084 wcscat(DstPath, L"\\bootsect.ros");
2085
2086 DPRINT1("Install FAT32 bootcode: %S ==> %S\n", SrcPath, DstPath);
2087 Status = InstallFat32BootCodeToFile(SrcPath,
2088 DstPath,
2089 SystemRootPath->Buffer);
2090 if (!NT_SUCCESS(Status))
2091 {
2092 DPRINT1("InstallFat32BootCodeToFile() failed (Status %lx)\n", Status);
2093 return Status;
2094 }
2095 }
2096 else
2097 {
2098 /* Install FAT16 bootcode */
2099 wcscpy(SrcPath, SourceRootPath->Buffer);
2100 wcscat(SrcPath, L"\\loader\\fat.bin");
2101 wcscpy(DstPath, SystemRootPath->Buffer);
2102 wcscat(DstPath, L"\\bootsect.ros");
2103
2104 DPRINT1("Install FAT bootcode: %S ==> %S\n", SrcPath, DstPath);
2105 Status = InstallFat16BootCodeToFile(SrcPath,
2106 DstPath,
2107 SystemRootPath->Buffer);
2108 if (!NT_SUCCESS(Status))
2109 {
2110 DPRINT1("InstallFat16BootCodeToFile() failed (Status %lx)\n", Status);
2111 return Status;
2112 }
2113 }
2114 }
2115 else
2116 {
2117 /* Update existing 'freeldr.ini' */
2118 DPRINT1("Update existing 'freeldr.ini'\n");
2119 wcscpy(DstPath, SystemRootPath->Buffer);
2120 wcscat(DstPath, L"\\freeldr.ini");
2121
2122 Status = UpdateFreeLoaderIni(DstPath,
2123 DestinationArcPath->Buffer);
2124 if (!NT_SUCCESS(Status))
2125 {
2126 DPRINT1("UpdateFreeLoaderIni() failed (Status %lx)\n", Status);
2127 return Status;
2128 }
2129 }
2130
2131 /* Update 'boot.ini' */
2132 wcscpy(DstPath, SystemRootPath->Buffer);
2133 wcscat(DstPath, L"\\boot.ini");
2134
2135 DPRINT1("Update 'boot.ini': %S\n", DstPath);
2136 Status = UpdateBootIni(DstPath,
2137 L"C:\\bootsect.ros",
2138 L"\"ReactOS\"");
2139 if (!NT_SUCCESS(Status))
2140 {
2141 DPRINT1("UpdateBootIni() failed (Status %lx)\n", Status);
2142 return Status;
2143 }
2144 }
2145 else if (DoesFileExist(SystemRootPath->Buffer, L"io.sys") == TRUE ||
2146 DoesFileExist(SystemRootPath->Buffer, L"msdos.sys") == TRUE)
2147 {
2148 /* Search for root directory for 'io.sys' and 'msdos.sys'. */
2149 DPRINT1("Found Microsoft DOS or Windows 9x boot loader\n");
2150
2151 /* Copy FreeLoader to the boot partition */
2152 wcscpy(SrcPath, SourceRootPath->Buffer);
2153 wcscat(SrcPath, L"\\loader\\freeldr.sys");
2154 wcscpy(DstPath, SystemRootPath->Buffer);
2155 wcscat(DstPath, L"\\freeldr.sys");
2156
2157 DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
2158 Status = SetupCopyFile(SrcPath, DstPath);
2159 if (!NT_SUCCESS(Status))
2160 {
2161 DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
2162 return Status;
2163 }
2164
2165 /* Create or update 'freeldr.ini' */
2166 if (DoesFileExist(SystemRootPath->Buffer, L"freeldr.ini") == FALSE)
2167 {
2168 /* Create new 'freeldr.ini' */
2169 DPRINT1("Create new 'freeldr.ini'\n");
2170 wcscpy(DstPath, SystemRootPath->Buffer);
2171 wcscat(DstPath, L"\\freeldr.ini");
2172
2173 Status = CreateFreeLoaderIniForDos(DstPath,
2174 DestinationArcPath->Buffer);
2175 if (!NT_SUCCESS(Status))
2176 {
2177 DPRINT1("CreateFreeLoaderIniForDos() failed (Status %lx)\n", Status);
2178 return Status;
2179 }
2180
2181 /* Save current bootsector as 'BOOTSECT.DOS' */
2182 wcscpy(SrcPath, SystemRootPath->Buffer);
2183 wcscpy(DstPath, SystemRootPath->Buffer);
2184 wcscat(DstPath, L"\\bootsect.dos");
2185
2186 DPRINT1("Save bootsector: %S ==> %S\n", SrcPath, DstPath);
2187 Status = SaveCurrentBootSector(SrcPath,
2188 DstPath);
2189 if (!NT_SUCCESS(Status))
2190 {
2191 DPRINT1("SaveCurrentBootSector() failed (Status %lx)\n", Status);
2192 return Status;
2193 }
2194
2195 /* Install new bootsector */
2196 if (PartitionType == PARTITION_FAT32 ||
2197 PartitionType == PARTITION_FAT32_XINT13)
2198 {
2199 wcscpy(SrcPath, SourceRootPath->Buffer);
2200 wcscat(SrcPath, L"\\loader\\fat32.bin");
2201
2202 DPRINT1("Install FAT32 bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
2203 Status = InstallFat32BootCodeToDisk(SrcPath,
2204 SystemRootPath->Buffer);
2205 if (!NT_SUCCESS(Status))
2206 {
2207 DPRINT1("InstallFat32BootCodeToDisk() failed (Status %lx)\n", Status);
2208 return Status;
2209 }
2210 }
2211 else
2212 {
2213 wcscpy(SrcPath, SourceRootPath->Buffer);
2214 wcscat(SrcPath, L"\\loader\\fat.bin");
2215
2216 DPRINT1("Install FAT bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
2217 Status = InstallFat16BootCodeToDisk(SrcPath,
2218 SystemRootPath->Buffer);
2219 if (!NT_SUCCESS(Status))
2220 {
2221 DPRINT1("InstallFat16BootCodeToDisk() failed (Status %lx)\n", Status);
2222 return Status;
2223 }
2224 }
2225 }
2226 else
2227 {
2228 /* Update existing 'freeldr.ini' */
2229 wcscpy(DstPath, SystemRootPath->Buffer);
2230 wcscat(DstPath, L"\\freeldr.ini");
2231
2232 Status = UpdateFreeLoaderIni(DstPath, DestinationArcPath->Buffer);
2233 if (!NT_SUCCESS(Status))
2234 {
2235 DPRINT1("UpdateFreeLoaderIni() failed (Status %lx)\n", Status);
2236 return Status;
2237 }
2238 }
2239 }
2240 else
2241 {
2242 /* No or unknown boot loader */
2243 DPRINT1("No or unknown boot loader found\n");
2244
2245 /* Copy FreeLoader to the boot partition */
2246 wcscpy(SrcPath, SourceRootPath->Buffer);
2247 wcscat(SrcPath, L"\\loader\\freeldr.sys");
2248 wcscpy(DstPath, SystemRootPath->Buffer);
2249 wcscat(DstPath, L"\\freeldr.sys");
2250
2251 DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
2252 Status = SetupCopyFile(SrcPath, DstPath);
2253 if (!NT_SUCCESS(Status))
2254 {
2255 DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
2256 return Status;
2257 }
2258
2259 /* Create or update 'freeldr.ini' */
2260 if (DoesFileExist(SystemRootPath->Buffer, L"freeldr.ini") == FALSE)
2261 {
2262 /* Create new freeldr.ini */
2263 wcscpy(DstPath, SystemRootPath->Buffer);
2264 wcscat(DstPath, L"\\freeldr.ini");
2265
2266 DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
2267 Status = CreateFreeLoaderIniForReactos(DstPath,
2268 DestinationArcPath->Buffer);
2269 if (!NT_SUCCESS(Status))
2270 {
2271 DPRINT1("CreateFreeLoaderIniForReactos() failed (Status %lx)\n", Status);
2272 return Status;
2273 }
2274
2275 /* Save current bootsector as 'BOOTSECT.OLD' */
2276 wcscpy(SrcPath, SystemRootPath->Buffer);
2277 wcscpy(DstPath, SystemRootPath->Buffer);
2278 wcscat(DstPath, L"\\bootsect.old");
2279
2280 DPRINT("Save bootsector: %S ==> %S\n", SrcPath, DstPath);
2281 Status = SaveCurrentBootSector(SrcPath,
2282 DstPath);
2283 if (!NT_SUCCESS(Status))
2284 {
2285 DPRINT1("SaveCurrentBootSector() failed (Status %lx)\n", Status);
2286 return Status;
2287 }
2288
2289 /* Install new bootsector */
2290 if ((PartitionType == PARTITION_FAT32) ||
2291 (PartitionType == PARTITION_FAT32_XINT13))
2292 {
2293 wcscpy(SrcPath, SourceRootPath->Buffer);
2294 wcscat(SrcPath, L"\\loader\\fat32.bin");
2295
2296 DPRINT("Install FAT32 bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
2297 Status = InstallFat32BootCodeToDisk(SrcPath,
2298 SystemRootPath->Buffer);
2299 if (!NT_SUCCESS(Status))
2300 {
2301 DPRINT1("InstallFat32BootCodeToDisk() failed (Status %lx)\n", Status);
2302 return Status;
2303 }
2304 }
2305 else
2306 {
2307 wcscpy(SrcPath, SourceRootPath->Buffer);
2308 wcscat(SrcPath, L"\\loader\\fat.bin");
2309
2310 DPRINT("Install FAT bootcode: %S ==> %S\n", SrcPath, SystemRootPath->Buffer);
2311 Status = InstallFat16BootCodeToDisk(SrcPath,
2312 SystemRootPath->Buffer);
2313 if (!NT_SUCCESS(Status))
2314 {
2315 DPRINT1("InstallFat16BootCodeToDisk() failed (Status %lx)\n", Status);
2316 return Status;
2317 }
2318 }
2319 }
2320 else
2321 {
2322 /* Update existing 'freeldr.ini' */
2323 wcscpy(DstPath, SystemRootPath->Buffer);
2324 wcscat(DstPath, L"\\freeldr.ini");
2325
2326 Status = UpdateFreeLoaderIni(DstPath,
2327 DestinationArcPath->Buffer);
2328 if (!NT_SUCCESS(Status))
2329 {
2330 DPRINT1("UpdateFreeLoaderIni() failed (Status %lx)\n", Status);
2331 return Status;
2332 }
2333 }
2334 }
2335
2336 return STATUS_SUCCESS;
2337 #else
2338 return STATUS_NOT_IMPLEMENTED;
2339 #endif
2340 }
2341
2342 NTSTATUS
2343 InstallVBRToPartition(
2344 PUNICODE_STRING SystemRootPath,
2345 PUNICODE_STRING SourceRootPath,
2346 PUNICODE_STRING DestinationArcPath,
2347 UCHAR PartitionType)
2348 {
2349 if ((PartitionType == PARTITION_FAT_12) ||
2350 (PartitionType == PARTITION_FAT_16) ||
2351 (PartitionType == PARTITION_HUGE) ||
2352 (PartitionType == PARTITION_XINT13) ||
2353 (PartitionType == PARTITION_FAT32) ||
2354 (PartitionType == PARTITION_FAT32_XINT13))
2355 {
2356 return InstallFatBootcodeToPartition(SystemRootPath,
2357 SourceRootPath,
2358 DestinationArcPath,
2359 PartitionType);
2360 }
2361
2362 return STATUS_UNSUCCESSFUL;
2363 }
2364
2365
2366 NTSTATUS
2367 InstallFatBootcodeToFloppy(
2368 PUNICODE_STRING SourceRootPath,
2369 PUNICODE_STRING DestinationArcPath)
2370 {
2371 #ifdef __REACTOS__
2372 UNICODE_STRING FloppyDevice = RTL_CONSTANT_STRING(L"\\Device\\Floppy0");
2373 WCHAR SrcPath[MAX_PATH];
2374 WCHAR DstPath[MAX_PATH];
2375 NTSTATUS Status;
2376
2377 /* Format the floppy first */
2378 Status = VfatFormat(&FloppyDevice,
2379 FMIFS_FLOPPY,
2380 NULL,
2381 TRUE,
2382 0,
2383 NULL);
2384 if (!NT_SUCCESS(Status))
2385 {
2386 DPRINT1("VfatFormat() failed (Status %lx)\n", Status);
2387 return Status;
2388 }
2389
2390 /* Copy FreeLoader to the boot partition */
2391 wcscpy(SrcPath, SourceRootPath->Buffer);
2392 wcscat(SrcPath, L"\\loader\\freeldr.sys");
2393
2394 wcscpy(DstPath, L"\\Device\\Floppy0\\freeldr.sys");
2395
2396 DPRINT("Copy: %S ==> %S\n", SrcPath, DstPath);
2397 Status = SetupCopyFile(SrcPath, DstPath);
2398 if (!NT_SUCCESS(Status))
2399 {
2400 DPRINT1("SetupCopyFile() failed (Status %lx)\n", Status);
2401 return Status;
2402 }
2403
2404 /* Create new 'freeldr.ini' */
2405 wcscpy(DstPath, L"\\Device\\Floppy0\\freeldr.ini");
2406
2407 DPRINT("Create new 'freeldr.ini'\n");
2408 Status = CreateFreeLoaderIniForReactos(DstPath, DestinationArcPath->Buffer);
2409 if (!NT_SUCCESS(Status))
2410 {
2411 DPRINT1("CreateFreeLoaderIniForReactos() failed (Status %lx)\n", Status);
2412 return Status;
2413 }
2414
2415 /* Install FAT12/16 boosector */
2416 wcscpy(SrcPath, SourceRootPath->Buffer);
2417 wcscat(SrcPath, L"\\loader\\fat.bin");
2418
2419 wcscpy(DstPath, L"\\Device\\Floppy0");
2420
2421 DPRINT("Install FAT bootcode: %S ==> %S\n", SrcPath, DstPath);
2422 Status = InstallFat12BootCodeToFloppy(SrcPath, DstPath);
2423 if (!NT_SUCCESS(Status))
2424 {
2425 DPRINT1("InstallFat16BootCodeToDisk() failed (Status %lx)\n", Status);
2426 return Status;
2427 }
2428
2429 return STATUS_SUCCESS;
2430 #else
2431 return STATUS_NOT_IMPLEMENTED;
2432 #endif
2433 }
2434
2435 /* EOF */