ReactOS 0.4.15-dev-8231-g29a56f3
custom.c
Go to the documentation of this file.
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/* GLOBALS ********************************************************************/
25
26#if defined(_M_IX86) || defined(_M_AMD64)
27static const PCSTR BootSectorFilePrompt =
28 "Enter the boot sector file path.\n"
29 "Leave blank for booting a disk or partition.\n"
30 "\n"
31 "Examples:\n"
32 "\\BOOTSECT.DOS\n"
33 "/boot/bootsect.dos";
34static const PCSTR LinuxKernelPrompt =
35 "Enter the Linux kernel image path.\n"
36 "\n"
37 "Examples:\n"
38 "/vmlinuz\n"
39 "/boot/vmlinuz-2.4.18";
40static const PCSTR LinuxInitrdPrompt =
41 "Enter the initrd image path.\n"
42 "Leave blank for no initial ramdisk.\n"
43 "\n"
44 "Examples:\n"
45 "/initrd.gz\n"
46 "/boot/root.img.gz";
47static const PCSTR LinuxCommandLinePrompt =
48 "Enter the Linux kernel command line.\n"
49 "\n"
50 "Examples:\n"
51 "root=/dev/hda1\n"
52 "root=/dev/fd0 read-only\n"
53 "root=/dev/sdb1 init=/sbin/init";
54#endif /* _M_IX86 || _M_AMD64 */
55
56static const PCSTR BootDrivePrompt =
57 "Enter the boot drive.\n"
58 "\n"
59 "Examples:\n"
60 "fd0 - first floppy drive\n"
61 "hd0 - first hard drive\n"
62 "hd1 - second hard drive\n"
63 "cd0 - first CD-ROM drive.\n"
64 "\n"
65 "BIOS drive numbers may also be used:\n"
66 "0 - first floppy drive\n"
67 "0x80 - first hard drive\n"
68 "0x81 - second hard drive";
70 "Enter the boot partition.\n";
71 // "\n"
72 // "Enter 0 for the active (bootable) partition.";
73 /* NOTE: "Active"/bootable partition is a per-platform concept,
74 * and may not really exist. In addition, partition(0) in ARC
75 * means the whole disk (in non-partitioned access).
76 * Commit f2854a864 (r17736) and CORE-156 are thus inaccurate
77 * in this regard. */
78
79static const PCSTR ARCPathPrompt =
80 "Enter the boot ARC path.\n"
81 "\n"
82 "Examples:\n"
83 "multi(0)disk(0)rdisk(0)partition(1)\n"
84 "multi(0)disk(0)fdisk(0)";
85
87 "Enter the path to your ReactOS system directory.\n"
88 "\n"
89 "Examples:\n"
90 "\\REACTOS\n"
91 "\\ROS";
93 "Enter the load options you want passed to the kernel.\n"
94 "\n"
95 "Examples:\n"
96 "/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200\n"
97 "/FASTDETECT /SOS /NOGUIBOOT\n"
98 "/BASEVIDEO /MAXMEM=64\n"
99 "/KERNEL=NTKRNLMP.EXE /HAL=HALMPS.DLL";
101 "Enter additional load options you want passed to the ReactOS Setup.\n"
102 "These options will supplement those obtained from the TXTSETUP.SIF\n"
103 "file, unless you also specify the /SIFOPTIONSOVERRIDE option switch.\n"
104 "\n"
105 "Example:\n"
106 "/DEBUG /DEBUGPORT=COM1 /BAUDRATE=115200 /NOGUIBOOT";
107
109 "Press ENTER to boot your custom boot setup.";
110
111/* FUNCTIONS ******************************************************************/
112
113#ifdef HAS_OPTION_MENU_CUSTOM_BOOT
114
116{
117 PCSTR CustomBootMenuList[] = {
118#if defined(_M_IX86) || defined(_M_AMD64)
119 "Boot Sector (Disk/Partition/File)",
120 "Linux",
121#endif
122 "ReactOS",
123 "ReactOS Setup"
124 };
125 ULONG SelectedMenuItem;
126 OperatingSystemItem OperatingSystem;
127
128 if (!UiDisplayMenu("Please choose a boot method:", NULL,
129 FALSE,
130 CustomBootMenuList,
131 RTL_NUMBER_OF(CustomBootMenuList),
132 0, -1,
133 &SelectedMenuItem,
134 TRUE,
135 NULL, NULL))
136 {
137 /* The user pressed ESC */
138 return;
139 }
140
141 /* Initialize a new custom OS entry */
142 OperatingSystem.SectionId = 0;
143 switch (SelectedMenuItem)
144 {
145#if defined(_M_IX86) || defined(_M_AMD64)
146 case 0: // Boot Sector (Disk/Partition/File)
147 EditCustomBootSector(&OperatingSystem);
148 break;
149 case 1: // Linux
150 EditCustomBootLinux(&OperatingSystem);
151 break;
152 case 2: // ReactOS
153 EditCustomBootReactOS(&OperatingSystem, FALSE);
154 break;
155 case 3: // ReactOS Setup
156 EditCustomBootReactOS(&OperatingSystem, TRUE);
157 break;
158#else
159 case 0: // ReactOS
160 EditCustomBootReactOS(&OperatingSystem, FALSE);
161 break;
162 case 1: // ReactOS Setup
163 EditCustomBootReactOS(&OperatingSystem, TRUE);
164 break;
165#endif /* _M_IX86 || _M_AMD64 */
166 }
167
168 /* And boot it */
169 if (OperatingSystem.SectionId != 0)
170 {
172 LoadOperatingSystem(&OperatingSystem);
173 }
174}
175
176#endif // HAS_OPTION_MENU_CUSTOM_BOOT
177
178#if defined(_M_IX86) || defined(_M_AMD64)
179
180VOID
181EditCustomBootSector(
182 _Inout_ OperatingSystemItem* OperatingSystem)
183{
184 TIMEINFO* TimeInfo;
185 ULONG_PTR SectionId = OperatingSystem->SectionId;
186 CHAR SectionName[100];
187 /* This construct is a trick for saving some stack space */
188 union
189 {
190 struct
191 {
192 CHAR Guard1;
193 CHAR Drive[20];
194 CHAR Partition[20];
195 CHAR Guard2;
196 };
197 CHAR ArcPath[200];
198 } BootStrings;
199 CHAR BootSectorFile[200];
200
201 RtlZeroMemory(SectionName, sizeof(SectionName));
202 RtlZeroMemory(&BootStrings, sizeof(BootStrings));
203 RtlZeroMemory(BootSectorFile, sizeof(BootSectorFile));
204
205 if (SectionId != 0)
206 {
207 /* Load the settings */
208
209 /*
210 * Check whether we have a "BootPath" value (takes precedence
211 * over both "BootDrive" and "BootPartition").
212 */
213 *BootStrings.ArcPath = ANSI_NULL;
214 IniReadSettingByName(SectionId, "BootPath", BootStrings.ArcPath, sizeof(BootStrings.ArcPath));
215 if (!*BootStrings.ArcPath)
216 {
217 /* We don't, retrieve the boot drive and partition values instead */
218 IniReadSettingByName(SectionId, "BootDrive", BootStrings.Drive, sizeof(BootStrings.Drive));
219 IniReadSettingByName(SectionId, "BootPartition", BootStrings.Partition, sizeof(BootStrings.Partition));
220 }
221
222 /* Always load the file name; it will only be handled later if a partition has been specified */
223 IniReadSettingByName(SectionId, "BootSectorFile", BootSectorFile, sizeof(BootSectorFile));
224 }
225
226 if (!*BootStrings.ArcPath)
227 {
228 if (!UiEditBox(BootDrivePrompt, BootStrings.Drive, sizeof(BootStrings.Drive)))
229 return;
230
231 if (*BootStrings.Drive)
232 {
233 if (!UiEditBox(BootPartitionPrompt, BootStrings.Partition, sizeof(BootStrings.Partition)))
234 return;
235 }
236 }
237 if (!*BootStrings.Drive)
238 {
239 if (!UiEditBox(ARCPathPrompt, BootStrings.ArcPath, sizeof(BootStrings.ArcPath)))
240 return;
241 }
242
243 /* Edit the file name only if a partition has been specified */
244 if ((!*BootStrings.ArcPath && atoi(BootStrings.Partition) != 0) ||
245 (*BootStrings.ArcPath && !strstr(BootStrings.ArcPath, ")partition()") &&
246 !strstr(BootStrings.ArcPath, ")partition(0)")))
247 {
248 if (!UiEditBox(BootSectorFilePrompt, BootSectorFile, sizeof(BootSectorFile)))
249 return;
250 }
251
252
253 /* Modify the settings values and return if we were in edit mode */
254 if (SectionId != 0)
255 {
256 /* Modify the BootPath if we have one */
257 if (*BootStrings.ArcPath)
258 {
259 IniModifySettingValue(SectionId, "BootPath", BootStrings.ArcPath);
260 }
261 else if (*BootStrings.Drive)
262 {
263 /* Otherwise, modify the BootDrive and BootPartition */
264 IniModifySettingValue(SectionId, "BootDrive", BootStrings.Drive);
265 IniModifySettingValue(SectionId, "BootPartition", BootStrings.Partition);
266 }
267 else
268 {
269 /*
270 * Otherwise, reset all values: BootSectorFile
271 * will be relative to the default system partition.
272 */
273 IniModifySettingValue(SectionId, "BootPath", "");
274 IniModifySettingValue(SectionId, "BootDrive", "");
275 IniModifySettingValue(SectionId, "BootPartition", "");
276 }
277
278 /* Always write back the file name */
279 IniModifySettingValue(SectionId, "BootSectorFile", BootSectorFile);
280 return;
281 }
282
283 /* Generate a unique section name */
284 TimeInfo = ArcGetTime();
285 RtlStringCbPrintfA(SectionName, sizeof(SectionName),
286 "CustomBootSector%u%u%u%u%u%u",
287 TimeInfo->Year, TimeInfo->Day, TimeInfo->Month,
288 TimeInfo->Hour, TimeInfo->Minute, TimeInfo->Second);
289
290 /* Add the section */
291 if (!IniAddSection(SectionName, &SectionId))
292 return;
293
294 /* Add the BootType */
295 if (!IniAddSettingValueToSection(SectionId, "BootType", "BootSector"))
296 return;
297
298 /* Add the BootPath if we have one */
299 if (*BootStrings.ArcPath)
300 {
301 if (!IniAddSettingValueToSection(SectionId, "BootPath", BootStrings.ArcPath))
302 return;
303 }
304 else if (*BootStrings.Drive)
305 {
306 /* Otherwise, add the BootDrive and BootPartition */
307 if (!IniAddSettingValueToSection(SectionId, "BootDrive", BootStrings.Drive))
308 return;
309
310 if (!IniAddSettingValueToSection(SectionId, "BootPartition", BootStrings.Partition))
311 return;
312 }
313
314 /* Add the BootSectorFile if any */
315 if (*BootSectorFile)
316 {
317 if (!IniAddSettingValueToSection(SectionId, "BootSectorFile", BootSectorFile))
318 return;
319 }
320
321 OperatingSystem->SectionId = SectionId;
322 OperatingSystem->LoadIdentifier = NULL;
323}
324
325VOID
326EditCustomBootLinux(
327 IN OUT OperatingSystemItem* OperatingSystem)
328{
329 TIMEINFO* TimeInfo;
330 ULONG_PTR SectionId = OperatingSystem->SectionId;
331 CHAR SectionName[100];
332 /* This construct is a trick for saving some stack space */
333 union
334 {
335 struct
336 {
337 CHAR Guard1;
338 CHAR Drive[20];
339 CHAR Partition[20];
340 CHAR Guard2;
341 };
342 CHAR ArcPath[200];
343 } BootStrings;
344 CHAR LinuxKernelString[200];
345 CHAR LinuxInitrdString[200];
346 CHAR LinuxCommandLineString[200];
347
348 RtlZeroMemory(SectionName, sizeof(SectionName));
349 RtlZeroMemory(&BootStrings, sizeof(BootStrings));
350 RtlZeroMemory(LinuxKernelString, sizeof(LinuxKernelString));
351 RtlZeroMemory(LinuxInitrdString, sizeof(LinuxInitrdString));
352 RtlZeroMemory(LinuxCommandLineString, sizeof(LinuxCommandLineString));
353
354 if (SectionId != 0)
355 {
356 /* Load the settings */
357
358 /*
359 * Check whether we have a "BootPath" value (takes precedence
360 * over both "BootDrive" and "BootPartition").
361 */
362 *BootStrings.ArcPath = ANSI_NULL;
363 IniReadSettingByName(SectionId, "BootPath", BootStrings.ArcPath, sizeof(BootStrings.ArcPath));
364 if (!*BootStrings.ArcPath)
365 {
366 /* We don't, retrieve the boot drive and partition values instead */
367 IniReadSettingByName(SectionId, "BootDrive", BootStrings.Drive, sizeof(BootStrings.Drive));
368 IniReadSettingByName(SectionId, "BootPartition", BootStrings.Partition, sizeof(BootStrings.Partition));
369 }
370
371 IniReadSettingByName(SectionId, "Kernel", LinuxKernelString, sizeof(LinuxKernelString));
372 IniReadSettingByName(SectionId, "Initrd", LinuxInitrdString, sizeof(LinuxInitrdString));
373 IniReadSettingByName(SectionId, "CommandLine", LinuxCommandLineString, sizeof(LinuxCommandLineString));
374 }
375
376 if (!*BootStrings.ArcPath)
377 {
378 if (!UiEditBox(BootDrivePrompt, BootStrings.Drive, sizeof(BootStrings.Drive)))
379 return;
380
381 if (*BootStrings.Drive)
382 {
383 if (!UiEditBox(BootPartitionPrompt, BootStrings.Partition, sizeof(BootStrings.Partition)))
384 return;
385 }
386 }
387 if (!*BootStrings.Drive)
388 {
389 if (!UiEditBox(ARCPathPrompt, BootStrings.ArcPath, sizeof(BootStrings.ArcPath)))
390 return;
391 }
392
393 if (!UiEditBox(LinuxKernelPrompt, LinuxKernelString, sizeof(LinuxKernelString)))
394 return;
395
396 if (!UiEditBox(LinuxInitrdPrompt, LinuxInitrdString, sizeof(LinuxInitrdString)))
397 return;
398
399 if (!UiEditBox(LinuxCommandLinePrompt, LinuxCommandLineString, sizeof(LinuxCommandLineString)))
400 return;
401
402 /* Modify the settings values and return if we were in edit mode */
403 if (SectionId != 0)
404 {
405 /* Modify the BootPath if we have one */
406 if (*BootStrings.ArcPath)
407 {
408 IniModifySettingValue(SectionId, "BootPath", BootStrings.ArcPath);
409 }
410 else if (*BootStrings.Drive)
411 {
412 /* Otherwise, modify the BootDrive and BootPartition */
413 IniModifySettingValue(SectionId, "BootDrive", BootStrings.Drive);
414 IniModifySettingValue(SectionId, "BootPartition", BootStrings.Partition);
415 }
416 else
417 {
418 /*
419 * Otherwise, reset all values: the files will
420 * be relative to the default system partition.
421 */
422 IniModifySettingValue(SectionId, "BootPath", "");
423 IniModifySettingValue(SectionId, "BootDrive", "");
424 IniModifySettingValue(SectionId, "BootPartition", "");
425 }
426
427 IniModifySettingValue(SectionId, "Kernel", LinuxKernelString);
428 IniModifySettingValue(SectionId, "Initrd", LinuxInitrdString);
429 IniModifySettingValue(SectionId, "CommandLine", LinuxCommandLineString);
430 return;
431 }
432
433 /* Generate a unique section name */
434 TimeInfo = ArcGetTime();
435 RtlStringCbPrintfA(SectionName, sizeof(SectionName),
436 "CustomLinux%u%u%u%u%u%u",
437 TimeInfo->Year, TimeInfo->Day, TimeInfo->Month,
438 TimeInfo->Hour, TimeInfo->Minute, TimeInfo->Second);
439
440 /* Add the section */
441 if (!IniAddSection(SectionName, &SectionId))
442 return;
443
444 /* Add the BootType */
445 if (!IniAddSettingValueToSection(SectionId, "BootType", "Linux"))
446 return;
447
448 /* Add the BootPath if we have one */
449 if (*BootStrings.ArcPath)
450 {
451 if (!IniAddSettingValueToSection(SectionId, "BootPath", BootStrings.ArcPath))
452 return;
453 }
454 else if (*BootStrings.Drive)
455 {
456 /* Otherwise, add the BootDrive and BootPartition */
457 if (!IniAddSettingValueToSection(SectionId, "BootDrive", BootStrings.Drive))
458 return;
459
460 if (!IniAddSettingValueToSection(SectionId, "BootPartition", BootStrings.Partition))
461 return;
462 }
463
464 /* Add the Kernel */
465 if (!IniAddSettingValueToSection(SectionId, "Kernel", LinuxKernelString))
466 return;
467
468 /* Add the Initrd */
469 if (*LinuxInitrdString)
470 {
471 if (!IniAddSettingValueToSection(SectionId, "Initrd", LinuxInitrdString))
472 return;
473 }
474
475 /* Add the CommandLine */
476 if (!IniAddSettingValueToSection(SectionId, "CommandLine", LinuxCommandLineString))
477 return;
478
479 OperatingSystem->SectionId = SectionId;
480 OperatingSystem->LoadIdentifier = "Custom Linux Setup";
481}
482
483#endif /* _M_IX86 || _M_AMD64 */
484
485VOID
487 IN OUT OperatingSystemItem* OperatingSystem,
488 IN BOOLEAN IsSetup)
489{
490 TIMEINFO* TimeInfo;
491 ULONG_PTR SectionId = OperatingSystem->SectionId;
492 CHAR SectionName[100];
493 CHAR BootDriveString[20];
494 CHAR BootPartitionString[20];
495 CHAR ReactOSSystemPath[200];
496 CHAR ReactOSARCPath[200];
497 CHAR ReactOSOptions[200];
498
499 RtlZeroMemory(SectionName, sizeof(SectionName));
500 RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
501 RtlZeroMemory(BootPartitionString, sizeof(BootPartitionString));
502 RtlZeroMemory(ReactOSSystemPath, sizeof(ReactOSSystemPath));
503 RtlZeroMemory(ReactOSARCPath, sizeof(ReactOSARCPath));
504 RtlZeroMemory(ReactOSOptions, sizeof(ReactOSOptions));
505
506 if (SectionId != 0)
507 {
508 /* Load the settings */
509 IniReadSettingByName(SectionId, "SystemPath", ReactOSARCPath, sizeof(ReactOSARCPath));
510 IniReadSettingByName(SectionId, "Options", ReactOSOptions, sizeof(ReactOSOptions));
511 }
512
513 if (SectionId == 0)
514 {
515 if (!UiEditBox(BootDrivePrompt, BootDriveString, sizeof(BootDriveString)))
516 return;
517
518 if (!UiEditBox(BootPartitionPrompt, BootPartitionString, sizeof(BootPartitionString)))
519 return;
520
521 if (!UiEditBox(ReactOSSystemPathPrompt, ReactOSSystemPath, sizeof(ReactOSSystemPath)))
522 return;
523 }
524 else
525 {
526 if (!UiEditBox(ReactOSSystemPathPrompt, ReactOSARCPath, sizeof(ReactOSARCPath)))
527 return;
528 }
529
530 if (!UiEditBox(IsSetup ? ReactOSSetupOptionsPrompt : ReactOSOptionsPrompt, ReactOSOptions, sizeof(ReactOSOptions)))
531 return;
532
533 /* Modify the settings values and return if we were in edit mode */
534 if (SectionId != 0)
535 {
536 IniModifySettingValue(SectionId, "SystemPath", ReactOSARCPath);
537 IniModifySettingValue(SectionId, "Options", ReactOSOptions);
538 return;
539 }
540
541 /* Generate a unique section name */
542 TimeInfo = ArcGetTime();
543 RtlStringCbPrintfA(SectionName, sizeof(SectionName),
544 "CustomReactOS%u%u%u%u%u%u",
545 TimeInfo->Year, TimeInfo->Day, TimeInfo->Month,
546 TimeInfo->Hour, TimeInfo->Minute, TimeInfo->Second);
547
548 /* Add the section */
549 if (!IniAddSection(SectionName, &SectionId))
550 return;
551
552 /* Add the BootType */
553 if (!IniAddSettingValueToSection(SectionId, "BootType", IsSetup ? "ReactOSSetup" : "Windows2003"))
554 return;
555
556 /* Construct the ReactOS ARC system path */
557 ConstructArcPath(ReactOSARCPath, ReactOSSystemPath,
558 DriveMapGetBiosDriveNumber(BootDriveString),
559 atoi(BootPartitionString));
560
561 /* Add the system path */
562 if (!IniAddSettingValueToSection(SectionId, "SystemPath", ReactOSARCPath))
563 return;
564
565 /* Add the CommandLine */
566 if (!IniAddSettingValueToSection(SectionId, "Options", ReactOSOptions))
567 return;
568
569 OperatingSystem->SectionId = SectionId;
570 OperatingSystem->LoadIdentifier = NULL;
571}
572
573#ifdef HAS_OPTION_MENU_REBOOT
574
576{
577 UiMessageBox("The system will now reboot.");
578 Reboot();
579}
580
581#endif // HAS_OPTION_MENU_REBOOT
unsigned char BOOLEAN
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
TIMEINFO * ArcGetTime(VOID)
Definition: arcemul.c:27
PWCHAR Drive
Definition: chkdsk.c:73
@ Reboot
Definition: bl.h:891
VOID ConstructArcPath(PCHAR ArcPath, PCHAR SystemFolder, UCHAR Disk, ULONG Partition)
Definition: arcname.c:175
static const PCSTR BootPartitionPrompt
Definition: custom.c:69
VOID EditCustomBootReactOS(IN OUT OperatingSystemItem *OperatingSystem, IN BOOLEAN IsSetup)
Definition: custom.c:486
static const PCSTR ARCPathPrompt
Definition: custom.c:79
static const PCSTR ReactOSSetupOptionsPrompt
Definition: custom.c:100
static const PCSTR ReactOSSystemPathPrompt
Definition: custom.c:86
static const PCSTR BootDrivePrompt
Definition: custom.c:56
static const PCSTR CustomBootPrompt
Definition: custom.c:108
static const PCSTR ReactOSOptionsPrompt
Definition: custom.c:92
#define DriveMapGetBiosDriveNumber(DeviceName)
Definition: hardware.h:35
BOOLEAN UiEditBox(PCSTR MessageText, PCHAR EditTextBuffer, ULONG Length)
Definition: ui.c:634
BOOLEAN UiDisplayMenu(IN PCSTR MenuHeader, IN PCSTR MenuFooter OPTIONAL, IN BOOLEAN ShowBootOptions, IN PCSTR MenuItemList[], IN ULONG MenuItemCount, IN ULONG DefaultMenuItem, IN LONG MenuTimeOut, OUT PULONG SelectedMenuItem, IN BOOLEAN CanEscape, IN UiMenuKeyPressFilterCallback KeyPressFilter OPTIONAL, IN PVOID Context OPTIONAL)
Definition: ui.c:605
VOID UiMessageBox(_In_ PCSTR Format,...)
Definition: ui.c:359
VOID OptionMenuCustomBoot(VOID)
VOID OptionMenuReboot(VOID)
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
VOID LoadOperatingSystem(_In_ OperatingSystemItem *OperatingSystem)
Definition: bootmgr.c:282
_Check_return_ int __cdecl atoi(_In_z_ const char *_Str)
PINI_SECTION IniAddSection(_In_ PINICACHE Cache, _In_ PCWSTR Name)
Definition: inicache.c:838
BOOLEAN IniAddSettingValueToSection(ULONG_PTR SectionId, PCSTR SettingName, PCSTR SettingValue)
Definition: inifile.c:255
BOOLEAN IniModifySettingValue(ULONG_PTR SectionId, PCSTR SettingName, PCSTR SettingValue)
Definition: inifile.c:296
BOOLEAN IniReadSettingByName(ULONG_PTR SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize)
Definition: inifile.c:149
#define _Inout_
Definition: ms_sal.h:378
#define ANSI_NULL
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
Definition: fw.h:10
USHORT Month
Definition: fw.h:12
USHORT Day
Definition: fw.h:13
USHORT Minute
Definition: fw.h:15
USHORT Hour
Definition: fw.h:14
USHORT Second
Definition: fw.h:16
USHORT Year
Definition: fw.h:11
ULONG_PTR SectionId
Definition: oslist.h:26
const char * PCSTR
Definition: typedefs.h:52
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
char CHAR
Definition: xmlstorage.h:175