[FREELDR] Limit the usage of DiskStopFloppyMotor() in hardware/platform-specific...
[reactos.git] / boot / freeldr / freeldr / bootmgr.c
1 /*
2 * FreeLoader
3 * Copyright (C) 1998-2003 Brian Palmer <brianp@sginet.com>
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 along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 /* INCLUDES *******************************************************************/
21
22 #include <freeldr.h>
23
24 #include <debug.h>
25 DBG_DEFAULT_CHANNEL(INIFILE);
26
27 /* GLOBALS ********************************************************************/
28
29 typedef
30 VOID
31 (*EDIT_OS_ENTRY_PROC)(
32 IN OUT OperatingSystemItem* OperatingSystem);
33
34 static VOID
35 EditCustomBootReactOSSetup(
36 IN OUT OperatingSystemItem* OperatingSystem)
37 {
38 EditCustomBootReactOS(OperatingSystem, TRUE);
39 }
40
41 static VOID
42 EditCustomBootNTOS(
43 IN OUT OperatingSystemItem* OperatingSystem)
44 {
45 EditCustomBootReactOS(OperatingSystem, FALSE);
46 }
47
48 static const struct
49 {
50 PCSTR BootType;
51 EDIT_OS_ENTRY_PROC EditOsEntry;
52 ARC_ENTRY_POINT OsLoader;
53 } OSLoadingMethods[] =
54 {
55 {"ReactOSSetup", EditCustomBootReactOSSetup, LoadReactOSSetup},
56
57 #ifdef _M_IX86
58 {"Drive" , EditCustomBootDisk , LoadAndBootDrive },
59 {"Partition" , EditCustomBootPartition , LoadAndBootPartition },
60 {"BootSector" , EditCustomBootSectorFile, LoadAndBootBootSector},
61
62 {"Linux" , EditCustomBootLinux, LoadAndBootLinux },
63 {"WindowsNT40" , EditCustomBootNTOS , LoadAndBootWindows},
64 #endif
65 {"Windows" , EditCustomBootNTOS , LoadAndBootWindows},
66 {"Windows2003" , EditCustomBootNTOS , LoadAndBootWindows},
67 };
68
69 /* FUNCTIONS ******************************************************************/
70
71 /*
72 * This function converts the list of key=value options in the given operating
73 * system section into an ARC-compatible argument vector, providing in addition
74 * the extra mandatory Software Loading Environment Variables, following the
75 * ARC specification.
76 */
77 PCHAR*
78 BuildArgvForOsLoader(
79 IN PCSTR LoadIdentifier,
80 IN ULONG_PTR SectionId,
81 OUT PULONG pArgc)
82 {
83 SIZE_T Size;
84 ULONG Count;
85 ULONG i;
86 ULONG Argc;
87 PCHAR* Argv;
88 PCHAR* Args;
89 PCHAR SettingName, SettingValue;
90
91 *pArgc = 0;
92
93 ASSERT(SectionId != 0);
94
95 /* Validate the LoadIdentifier (to make tests simpler later) */
96 if (LoadIdentifier && !*LoadIdentifier)
97 LoadIdentifier = NULL;
98
99 /* Count the number of operating systems in the section */
100 Count = IniGetNumSectionItems(SectionId);
101
102 /*
103 * The argument vector contains the program name, the SystemPartition,
104 * the LoadIdentifier (optional), and the items in the OS section.
105 */
106 Argc = 2 + (LoadIdentifier ? 1 : 0) + Count;
107
108 /* Calculate the total size needed for the string buffer of the argument vector */
109 Size = 0;
110 /* i == 0: Program name */
111 /* i == 1: SystemPartition : from where FreeLdr has been started */
112 Size += (strlen("SystemPartition=") + strlen(FrldrBootPath) + 1) * sizeof(CHAR);
113 /* i == 2: LoadIdentifier : ASCII string that may be used to associate an identifier with a set of load parameters */
114 if (LoadIdentifier)
115 {
116 Size += (strlen("LoadIdentifier=") + strlen(LoadIdentifier) + 1) * sizeof(CHAR);
117 }
118 for (i = 0; i < Count; ++i)
119 {
120 Size += IniGetSectionSettingNameSize(SectionId, i); // Counts also the NULL-terminator, that we transform into the '=' sign separator.
121 Size += IniGetSectionSettingValueSize(SectionId, i); // Counts also the NULL-terminator.
122 }
123 Size += sizeof(ANSI_NULL); // Final NULL-terminator.
124
125 /* Allocate memory to hold the argument vector: pointers and string buffer */
126 Argv = FrLdrHeapAlloc(Argc * sizeof(PCHAR) + Size, TAG_STRING);
127 if (!Argv)
128 return NULL;
129
130 /* Initialize the argument vector: loop through the section and copy the key=value options */
131 SettingName = (PCHAR)((ULONG_PTR)Argv + (Argc * sizeof(PCHAR)));
132 Args = Argv;
133 /* i == 0: Program name */
134 *Args++ = NULL;
135 /* i == 1: SystemPartition */
136 {
137 strcpy(SettingName, "SystemPartition=");
138 strcat(SettingName, FrldrBootPath);
139
140 *Args++ = SettingName;
141 SettingName += (strlen(SettingName) + 1);
142 }
143 /* i == 2: LoadIdentifier */
144 if (LoadIdentifier)
145 {
146 strcpy(SettingName, "LoadIdentifier=");
147 strcat(SettingName, LoadIdentifier);
148
149 *Args++ = SettingName;
150 SettingName += (strlen(SettingName) + 1);
151 }
152 for (i = 0; i < Count; ++i)
153 {
154 Size = IniGetSectionSettingNameSize(SectionId, i);
155 SettingValue = SettingName + Size;
156 IniReadSettingByNumber(SectionId, i,
157 SettingName, Size,
158 SettingValue, IniGetSectionSettingValueSize(SectionId, i));
159 SettingName[Size - 1] = '=';
160
161 *Args++ = SettingName;
162 SettingName += (strlen(SettingName) + 1);
163 }
164
165 #if DBG
166 /* Dump the argument vector for debugging */
167 for (i = 0; i < Argc; ++i)
168 {
169 TRACE("Argv[%lu]: '%s'\n", i, Argv[i]);
170 }
171 #endif
172
173 *pArgc = Argc;
174 return Argv;
175 }
176
177 VOID LoadOperatingSystem(IN OperatingSystemItem* OperatingSystem)
178 {
179 ULONG_PTR SectionId = OperatingSystem->SectionId;
180 ULONG i;
181 ULONG Argc;
182 PCHAR* Argv;
183 CHAR BootType[80];
184
185 /* The operating system section has been opened by InitOperatingSystemList() */
186 ASSERT(SectionId != 0);
187
188 /* Try to read the boot type */
189 *BootType = ANSI_NULL;
190 IniReadSettingByName(SectionId, "BootType", BootType, sizeof(BootType));
191
192 /* We must have the "BootType" value (it has been possibly added by InitOperatingSystemList()) */
193 ASSERT(*BootType);
194
195 #ifdef _M_IX86
196 /* Install the drive mapper according to this section drive mappings */
197 DriveMapMapDrivesInSection(SectionId);
198 #endif
199
200 /* Loop through the OS loading method table and find a suitable OS to boot */
201 for (i = 0; i < sizeof(OSLoadingMethods) / sizeof(OSLoadingMethods[0]); ++i)
202 {
203 if (_stricmp(BootType, OSLoadingMethods[i].BootType) == 0)
204 {
205 Argv = BuildArgvForOsLoader(OperatingSystem->LoadIdentifier, SectionId, &Argc);
206 if (Argv)
207 {
208 OSLoadingMethods[i].OsLoader(Argc, Argv, NULL);
209 FrLdrHeapFree(Argv, TAG_STRING);
210 }
211 return;
212 }
213 }
214 }
215
216 #ifdef HAS_OPTION_MENU_EDIT_CMDLINE
217
218 VOID EditOperatingSystemEntry(IN OperatingSystemItem* OperatingSystem)
219 {
220 ULONG_PTR SectionId = OperatingSystem->SectionId;
221 ULONG i;
222 CHAR BootType[80];
223
224 /* The operating system section has been opened by InitOperatingSystemList() */
225 ASSERT(SectionId != 0);
226
227 /* Try to read the boot type */
228 *BootType = ANSI_NULL;
229 IniReadSettingByName(SectionId, "BootType", BootType, sizeof(BootType));
230
231 /* We must have the "BootType" value (it has been possibly added by InitOperatingSystemList()) */
232 ASSERT(*BootType);
233
234 /* Loop through the OS loading method table and find a suitable OS entry editor */
235 for (i = 0; i < sizeof(OSLoadingMethods) / sizeof(OSLoadingMethods[0]); ++i)
236 {
237 if (_stricmp(BootType, OSLoadingMethods[i].BootType) == 0)
238 {
239 OSLoadingMethods[i].EditOsEntry(OperatingSystem);
240 return;
241 }
242 }
243 }
244
245 #endif // HAS_OPTION_MENU_EDIT_CMDLINE
246
247 static LONG
248 GetTimeOut(
249 IN ULONG_PTR FrLdrSectionId)
250 {
251 LONG TimeOut = -1;
252 CHAR TimeOutText[20];
253
254 TimeOut = CmdLineGetTimeOut();
255 if (TimeOut >= 0)
256 return TimeOut;
257
258 TimeOut = -1;
259
260 if ((FrLdrSectionId != 0) &&
261 IniReadSettingByName(FrLdrSectionId, "TimeOut", TimeOutText, sizeof(TimeOutText)))
262 {
263 TimeOut = atoi(TimeOutText);
264 }
265
266 return TimeOut;
267 }
268
269 BOOLEAN
270 MainBootMenuKeyPressFilter(
271 IN ULONG KeyPress,
272 IN ULONG SelectedMenuItem,
273 IN PVOID Context OPTIONAL)
274 {
275 switch (KeyPress)
276 {
277 case KEY_F8:
278 DoOptionsMenu(&((OperatingSystemItem*)Context)[SelectedMenuItem]);
279 return TRUE;
280
281 #ifdef HAS_OPTION_MENU_EDIT_CMDLINE
282 case KEY_F10:
283 EditOperatingSystemEntry(&((OperatingSystemItem*)Context)[SelectedMenuItem]);
284 return TRUE;
285 #endif
286
287 default:
288 /* We didn't handle the key */
289 return FALSE;
290 }
291 }
292
293 VOID RunLoader(VOID)
294 {
295 ULONG_PTR SectionId;
296 LONG TimeOut;
297 ULONG OperatingSystemCount;
298 OperatingSystemItem* OperatingSystemList;
299 PCSTR* OperatingSystemDisplayNames;
300 ULONG DefaultOperatingSystem;
301 ULONG SelectedOperatingSystem;
302 ULONG i;
303
304 if (!MachInitializeBootDevices())
305 {
306 UiMessageBoxCritical("Error when detecting hardware.");
307 return;
308 }
309
310 #ifdef _M_IX86
311 /* Load additional SCSI driver (if any) */
312 if (LoadBootDeviceDriver() != ESUCCESS)
313 {
314 UiMessageBoxCritical("Unable to load additional boot device drivers.");
315 }
316 #endif
317
318 if (!IniFileInitialize())
319 {
320 UiMessageBoxCritical("Error initializing .ini file.");
321 return;
322 }
323
324 /* Open the [FreeLoader] section */
325 if (!IniOpenSection("FreeLoader", &SectionId))
326 {
327 UiMessageBoxCritical("Section [FreeLoader] not found in freeldr.ini.");
328 return;
329 }
330
331 /* Debugger main initialization */
332 DebugInit(SectionId);
333
334 /* Retrieve the default timeout */
335 TimeOut = GetTimeOut(SectionId);
336
337 /* UI main initialization */
338 if (!UiInitialize(TRUE))
339 {
340 UiMessageBoxCritical("Unable to initialize UI.");
341 return;
342 }
343
344 OperatingSystemList = InitOperatingSystemList(SectionId,
345 &OperatingSystemCount,
346 &DefaultOperatingSystem);
347 if (!OperatingSystemList)
348 {
349 UiMessageBox("Unable to read operating systems section in freeldr.ini.\nPress ENTER to reboot.");
350 goto Reboot;
351 }
352 if (OperatingSystemCount == 0)
353 {
354 UiMessageBox("There were no operating systems listed in freeldr.ini.\nPress ENTER to reboot.");
355 goto Reboot;
356 }
357
358 /* Create list of display names */
359 OperatingSystemDisplayNames = FrLdrTempAlloc(sizeof(PCSTR) * OperatingSystemCount, 'mNSO');
360 if (!OperatingSystemDisplayNames)
361 goto Reboot;
362
363 for (i = 0; i < OperatingSystemCount; i++)
364 {
365 OperatingSystemDisplayNames[i] = OperatingSystemList[i].LoadIdentifier;
366 }
367
368 /* Find all the message box settings and run them */
369 UiShowMessageBoxesInSection(SectionId);
370
371 for (;;)
372 {
373 /* Redraw the backdrop */
374 UiDrawBackdrop();
375
376 /* Show the operating system list menu */
377 if (!UiDisplayMenu("Please select the operating system to start:",
378 "For troubleshooting and advanced startup options for "
379 "ReactOS, press F8.",
380 TRUE,
381 OperatingSystemDisplayNames,
382 OperatingSystemCount,
383 DefaultOperatingSystem,
384 TimeOut,
385 &SelectedOperatingSystem,
386 FALSE,
387 MainBootMenuKeyPressFilter,
388 OperatingSystemList))
389 {
390 UiMessageBox("Press ENTER to reboot.");
391 goto Reboot;
392 }
393
394 TimeOut = -1;
395
396 /* Load the chosen operating system */
397 LoadOperatingSystem(&OperatingSystemList[SelectedOperatingSystem]);
398 }
399
400 Reboot:
401 UiUnInitialize("Rebooting...");
402 IniCleanup();
403 return;
404 }