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