setupldr.c File Reference

#include <freeldr.h>
#include <ndk/ldrtypes.h>
#include <arc/setupblk.h>
#include "winldr.h"
#include "inffile.h"
#include "ntldropts.h"
#include <debug.h>

Include dependency graph for setupldr.c:

Go to the source code of this file.

Macros
#define	TAG_BOOT_OPTIONS   'pOtB'

Functions
	DBG_DEFAULT_CHANNEL (WINDOWS)
VOID	AllocateAndInitLPB (IN USHORT VersionToBoot, OUT PLOADER_PARAMETER_BLOCK *OutLoaderBlock)
static VOID	SetupLdrLoadNlsData (_Inout_ PLOADER_PARAMETER_BLOCK LoaderBlock, _In_ HINF InfHandle, _In_ PCSTR SearchPath)
static BOOLEAN	SetupLdrInitErrataInf (IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock, IN HINF InfHandle, IN PCSTR SystemRoot)
static VOID	SetupLdrScanBootDrivers (_Inout_ PLIST_ENTRY BootDriverListHead, _In_ HINF InfHandle, _In_ PCSTR SearchPath)
VOID	NtLdrUpdateLoadOptions (IN OUT PSTR LoadOptions, IN ULONG BufferSize, IN BOOLEAN Append, IN PCSTR OptionsToAdd[] OPTIONAL, IN PCSTR OptionsToRemove[] OPTIONAL)
VOID	NtLdrGetHigherPriorityOptions (IN PCSTR BootOptions, OUT PSTR *ExtraOptions, OUT PSTR *HigherPriorityOptions)
ARC_STATUS	LoadReactOSSetup (IN ULONG Argc, IN PCHAR Argv[], IN PCHAR Envp[])

Variables
struct {
PCSTR   Options
PCSTR   ExtraOptions
PCSTR   HigherPriorOptions
}	HighPriorOptionsMap []

Macro Definition Documentation

TAG_BOOT_OPTIONS

#define TAG_BOOT_OPTIONS   'pOtB'

Definition at line 379 of file setupldr.c.

Function Documentation

AllocateAndInitLPB()

VOID AllocateAndInitLPB	(	IN USHORT	VersionToBoot,
		OUT PLOADER_PARAMETER_BLOCK *	OutLoaderBlock
	)

Definition at line 77 of file winldr.c.

{
    PLOADER_PARAMETER_BLOCK LoaderBlock;
    PLOADER_PARAMETER_EXTENSION Extension;
 
    /* Allocate and zero-init the Loader Parameter Block */
    WinLdrSystemBlock = MmAllocateMemoryWithType(sizeof(LOADER_SYSTEM_BLOCK),
                                                 LoaderSystemBlock);
    if (WinLdrSystemBlock == NULL)
    {
        UiMessageBox("Failed to allocate memory for system block!");
        return;
    }
 
    RtlZeroMemory(WinLdrSystemBlock, sizeof(LOADER_SYSTEM_BLOCK));
 
    LoaderBlock = &WinLdrSystemBlock->LoaderBlock;
    LoaderBlock->NlsData = &WinLdrSystemBlock->NlsDataBlock;
 
    /* Initialize the Loader Block Extension */
    Extension = &WinLdrSystemBlock->Extension;
    LoaderBlock->Extension = Extension;
    Extension->Size = sizeof(LOADER_PARAMETER_EXTENSION);
    Extension->MajorVersion = (VersionToBoot & 0xFF00) >> 8;
    Extension->MinorVersion = (VersionToBoot & 0xFF);
 
    /* Init three critical lists, used right away */
    InitializeListHead(&LoaderBlock->LoadOrderListHead);
    InitializeListHead(&LoaderBlock->MemoryDescriptorListHead);
    InitializeListHead(&LoaderBlock->BootDriverListHead);
 
    *OutLoaderBlock = LoaderBlock;
}

Referenced by LoadAndBootWindows(), and LoadReactOSSetup().

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

WINDOWS

)

LoadReactOSSetup()

ARC_STATUS LoadReactOSSetup	(	IN ULONG	Argc,
		IN PCHAR	Argv[],
		IN PCHAR	Envp[]
	)

Definition at line 492 of file setupldr.c.

{
    ARC_STATUS Status;
    PCSTR ArgValue;
    PCSTR SystemPartition;
    PCSTR SystemPath;
    PSTR FileName;
    ULONG FileNameLength;
    BOOLEAN BootFromFloppy;
    BOOLEAN Success;
    HINF InfHandle;
    INFCONTEXT InfContext;
    ULONG i, ErrorLine;
    PLOADER_PARAMETER_BLOCK LoaderBlock;
    PSETUP_LOADER_BLOCK SetupBlock;
    CHAR BootPath[MAX_PATH];
    CHAR FilePath[MAX_PATH];
    CHAR UserBootOptions[256];
    PCSTR BootOptions;
 
    static PCSTR SourcePaths[] =
    {
        "", /* Only for floppy boot */
#if defined(_M_IX86)
        "I386\\",
#elif defined(_M_MPPC)
        "PPC\\",
#elif defined(_M_MRX000)
        "MIPS\\",
#endif
        "reactos\\",
        NULL
    };
 
    /* Retrieve the (mandatory) boot type */
    ArgValue = GetArgumentValue(Argc, Argv, "BootType");
    if (!ArgValue || !*ArgValue)
    {
        ERR("No 'BootType' value, aborting!\n");
        return EINVAL;
    }
    if (_stricmp(ArgValue, "ReactOSSetup") != 0)
    {
        ERR("Unknown 'BootType' value '%s', aborting!\n", ArgValue);
        return EINVAL;
    }
 
    /* Retrieve the (mandatory) system partition */
    SystemPartition = GetArgumentValue(Argc, Argv, "SystemPartition");
    if (!SystemPartition || !*SystemPartition)
    {
        ERR("No 'SystemPartition' specified, aborting!\n");
        return EINVAL;
    }
 
    /* Let the user know we started loading */
    UiDrawBackdrop(UiGetScreenHeight());
    UiDrawStatusText("Setup is loading...");
    UiDrawProgressBarCenter("Loading ReactOS Setup...");
 
    /* Retrieve the system path */
    *BootPath = ANSI_NULL;
    ArgValue = GetArgumentValue(Argc, Argv, "SystemPath");
    if (ArgValue)
    {
        RtlStringCbCopyA(BootPath, sizeof(BootPath), ArgValue);
    }
    else
    {
        /*
         * IMPROVE: I don't want to use the SystemPartition here as a
         * default choice because I can do it after (see few lines below).
         * Instead I reset BootPath here so that we can build the full path
         * using the general code from below.
         */
        // RtlStringCbCopyA(BootPath, sizeof(BootPath), SystemPartition);
        *BootPath = ANSI_NULL;
    }
 
    /*
     * Check whether BootPath is a full path
     * and if not, create a full boot path.
     *
     * See FsOpenFile for the technique used.
     */
    if (strrchr(BootPath, ')') == NULL)
    {
        /* Temporarily save the boot path */
        RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
 
        /* This is not a full path: prepend the SystemPartition */
        RtlStringCbCopyA(BootPath, sizeof(BootPath), SystemPartition);
 
        /* Append a path separator if needed */
        if (*FilePath != '\\' && *FilePath != '/')
            RtlStringCbCatA(BootPath, sizeof(BootPath), "\\");
 
        /* Append the remaining path */
        RtlStringCbCatA(BootPath, sizeof(BootPath), FilePath);
    }
 
    /* Append a path separator if needed */
    if (!*BootPath || BootPath[strlen(BootPath) - 1] != '\\')
        RtlStringCbCatA(BootPath, sizeof(BootPath), "\\");
 
    TRACE("BootPath: '%s'\n", BootPath);
 
    /*
     * Retrieve the boot options. Any options present here will supplement or
     * override those that will be specified in TXTSETUP.SIF's OsLoadOptions.
     */
    BootOptions = GetArgumentValue(Argc, Argv, "Options");
    if (!BootOptions)
        BootOptions = "";
 
    TRACE("BootOptions: '%s'\n", BootOptions);
 
    /* Check if a RAM disk file was given */
    FileName = (PSTR)NtLdrGetOptionEx(BootOptions, "RDPATH=", &FileNameLength);
    if (FileName && (FileNameLength >= 7))
    {
        /* Load the RAM disk */
        Status = RamDiskInitialize(FALSE, BootOptions, SystemPartition);
        if (Status != ESUCCESS)
        {
            FileName += 7; FileNameLength -= 7;
            UiMessageBox("Failed to load RAM disk file '%.*s'",
                         FileNameLength, FileName);
            return Status;
        }
    }
 
    /* Check if we booted from floppy */
    BootFromFloppy = strstr(BootPath, "fdisk") != NULL;
 
    /* Open 'txtsetup.sif' from any of the source paths */
    FileName = BootPath + strlen(BootPath);
    for (i = BootFromFloppy ? 0 : 1; ; i++)
    {
        SystemPath = SourcePaths[i];
        if (!SystemPath)
        {
            UiMessageBox("Failed to open txtsetup.sif");
            return ENOENT;
        }
        FileNameLength = (ULONG)(sizeof(BootPath) - (FileName - BootPath)*sizeof(CHAR));
        RtlStringCbCopyA(FileName, FileNameLength, SystemPath);
        RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
        RtlStringCbCatA(FilePath, sizeof(FilePath), "txtsetup.sif");
        if (InfOpenFile(&InfHandle, FilePath, &ErrorLine))
        {
            break;
        }
    }
 
    TRACE("BootPath: '%s', SystemPath: '%s'\n", BootPath, SystemPath);
 
    // UseLocalSif = NtLdrGetOption(BootOptions, "USELOCALSIF");
 
    if (NtLdrGetOption(BootOptions, "SIFOPTIONSOVERRIDE"))
    {
        PCSTR OptionsToRemove[2] = {"SIFOPTIONSOVERRIDE", NULL};
 
        /* Do not use any load options from TXTSETUP.SIF, but
         * use instead those passed from the command line. */
        RtlStringCbCopyA(UserBootOptions, sizeof(UserBootOptions), BootOptions);
 
        /* Remove the private switch from the options */
        NtLdrUpdateLoadOptions(UserBootOptions,
                               sizeof(UserBootOptions),
                               FALSE,
                               NULL,
                               OptionsToRemove);
 
        BootOptions = UserBootOptions;
    }
    else // if (!*BootOptions || NtLdrGetOption(BootOptions, "SIFOPTIONSADD"))
    {
        PCSTR LoadOptions = NULL;
        PCSTR DbgLoadOptions = NULL;
        PSTR ExtraOptions, HigherPriorityOptions;
        PSTR OptionsToAdd[3];
        PSTR OptionsToRemove[4];
 
        /* Load the options from TXTSETUP.SIF */
        if (InfFindFirstLine(InfHandle, "SetupData", "OsLoadOptions", &InfContext))
        {
            if (!InfGetDataField(&InfContext, 1, &LoadOptions))
                WARN("Failed to get load options\n");
        }
 
#if !DBG
        /* Non-debug mode: get the debug load options only if /DEBUG was specified
         * in the Argv command-line options (was e.g. added to the options when
         * the user selected "Debugging Mode" in the advanced boot menu). */
        if (NtLdrGetOption(BootOptions, "DEBUG") ||
            NtLdrGetOption(BootOptions, "DEBUG="))
        {
#else
        /* Debug mode: always get the debug load options */
#endif
        if (InfFindFirstLine(InfHandle, "SetupData", "SetupDebugOptions", &InfContext))
        {
            if (!InfGetDataField(&InfContext, 1, &DbgLoadOptions))
                WARN("Failed to get debug load options\n");
        }
        /* If none was found, default to enabling debugging */
        if (!DbgLoadOptions)
            DbgLoadOptions = "/DEBUG";
#if !DBG
        }
#endif
 
        /* Initialize the load options with those from TXTSETUP.SIF */
        *UserBootOptions = ANSI_NULL;
        if (LoadOptions && *LoadOptions)
            RtlStringCbCopyA(UserBootOptions, sizeof(UserBootOptions), LoadOptions);
 
        /* Merge the debug load options if any */
        if (DbgLoadOptions)
        {
            RtlZeroMemory(OptionsToAdd, sizeof(OptionsToAdd));
            RtlZeroMemory(OptionsToRemove, sizeof(OptionsToRemove));
 
            /*
             * Retrieve any option patterns that we should remove from the
             * SIF load options because they are of higher precedence than
             * those specified in the debug load options to be added.
             * Also always remove NODEBUG (even if the debug load options
             * do not contain explicitly the DEBUG option), since we want
             * to have debugging enabled if possible.
             */
            OptionsToRemove[0] = "/NODEBUG";
            NtLdrGetHigherPriorityOptions(DbgLoadOptions,
                                          &ExtraOptions,
                                          &HigherPriorityOptions);
            OptionsToAdd[1] = (ExtraOptions ? ExtraOptions : "");
            OptionsToRemove[1] = (HigherPriorityOptions ? HigherPriorityOptions : "");
 
            /*
             * Prepend the debug load options, so that in case it contains
             * redundant options with respect to the SIF load options, the
             * former can take precedence over the latter.
             */
            OptionsToAdd[0] = (PSTR)DbgLoadOptions;
            OptionsToRemove[2] = (PSTR)DbgLoadOptions;
            NtLdrUpdateLoadOptions(UserBootOptions,
                                   sizeof(UserBootOptions),
                                   FALSE,
                                   (PCSTR*)OptionsToAdd,
                                   (PCSTR*)OptionsToRemove);
 
            if (ExtraOptions)
                FrLdrHeapFree(ExtraOptions, TAG_BOOT_OPTIONS);
            if (HigherPriorityOptions)
                FrLdrHeapFree(HigherPriorityOptions, TAG_BOOT_OPTIONS);
        }
 
        RtlZeroMemory(OptionsToAdd, sizeof(OptionsToAdd));
        RtlZeroMemory(OptionsToRemove, sizeof(OptionsToRemove));
 
        /*
         * Retrieve any option patterns that we should remove from the
         * SIF load options because they are of higher precedence than
         * those specified in the options to be added.
         */
        NtLdrGetHigherPriorityOptions(BootOptions,
                                      &ExtraOptions,
                                      &HigherPriorityOptions);
        OptionsToAdd[1] = (ExtraOptions ? ExtraOptions : "");
        OptionsToRemove[0] = (HigherPriorityOptions ? HigherPriorityOptions : "");
 
        /* Finally, prepend the user-specified options that
         * take precedence over those from TXTSETUP.SIF. */
        OptionsToAdd[0] = (PSTR)BootOptions;
        OptionsToRemove[1] = (PSTR)BootOptions;
        NtLdrUpdateLoadOptions(UserBootOptions,
                               sizeof(UserBootOptions),
                               FALSE,
                               (PCSTR*)OptionsToAdd,
                               (PCSTR*)OptionsToRemove);
 
        if (ExtraOptions)
            FrLdrHeapFree(ExtraOptions, TAG_BOOT_OPTIONS);
        if (HigherPriorityOptions)
            FrLdrHeapFree(HigherPriorityOptions, TAG_BOOT_OPTIONS);
 
        BootOptions = UserBootOptions;
    }
 
    TRACE("BootOptions: '%s'\n", BootOptions);
 
    /* Handle the SOS option */
    SosEnabled = !!NtLdrGetOption(BootOptions, "SOS");
    if (SosEnabled)
        UiResetForSOS();
 
    /* Allocate and minimally-initialize the Loader Parameter Block */
    AllocateAndInitLPB(_WIN32_WINNT_WS03, &LoaderBlock);
 
    /* Allocate and initialize the setup loader block */
    SetupBlock = &WinLdrSystemBlock->SetupBlock;
    LoaderBlock->SetupLdrBlock = SetupBlock;
 
    /* Set textmode setup flag */
    SetupBlock->Flags = SETUPLDR_TEXT_MODE;
 
    /* Load the "setupreg.hiv" setup system hive */
    UiUpdateProgressBar(15, "Loading setup system hive...");
    Success = WinLdrInitSystemHive(LoaderBlock, BootPath, TRUE);
    TRACE("Setup SYSTEM hive %s\n", (Success ? "loaded" : "not loaded"));
    /* Bail out if failure */
    if (!Success)
        return ENOEXEC;
 
    /* Load NLS data, they are in the System32 directory of the installation medium */
    RtlStringCbCopyA(FilePath, sizeof(FilePath), BootPath);
    RtlStringCbCatA(FilePath, sizeof(FilePath), "system32\\");
    SetupLdrLoadNlsData(LoaderBlock, InfHandle, FilePath);
 
    /* Load the Firmware Errata file from the installation medium */
    Success = SetupLdrInitErrataInf(LoaderBlock, InfHandle, BootPath);
    TRACE("Firmware Errata file %s\n", (Success ? "loaded" : "not loaded"));
    /* Not necessarily fatal if not found - carry on going */
 
    // UiDrawStatusText("Press F6 if you need to install a 3rd-party SCSI or RAID driver...");
 
    /* Get a list of boot drivers */
    SetupLdrScanBootDrivers(&LoaderBlock->BootDriverListHead, InfHandle, BootPath);
 
    /* Close the inf file */
    InfCloseFile(InfHandle);
 
    UiDrawStatusText("The Setup program is starting...");
 
    /* Finish loading */
    return LoadAndBootWindowsCommon(_WIN32_WINNT_WS03,
                                    LoaderBlock,
                                    BootOptions,
                                    BootPath);
}

NtLdrGetHigherPriorityOptions()

VOID NtLdrGetHigherPriorityOptions	(	IN PCSTR	BootOptions,
		OUT PSTR *	ExtraOptions,
		OUT PSTR *	HigherPriorityOptions
	)

Definition at line 382 of file setupldr.c.

{
    ULONG i;
    PCSTR NextOptions, NextOpt;
    ULONG NextOptLength;
    SIZE_T ExtraOptsSize = 0;
    SIZE_T HighPriorOptsSize = 0;
 
    /* Masks specifying the presence (TRUE) or absence (FALSE) of the options */
    BOOLEAN Masks[RTL_NUMBER_OF(HighPriorOptionsMap)];
 
    /* Just return if we cannot return anything */
    if (!ExtraOptions && !HigherPriorityOptions)
        return;
 
    if (ExtraOptions)
        *ExtraOptions = NULL;
    if (HigherPriorityOptions)
        *HigherPriorityOptions = NULL;
 
    /* Just return if no initial options were given */
    if (!BootOptions || !*BootOptions)
        return;
 
    /* Determine the presence of the colliding options, and the
     * maximum necessary sizes for the pointers to be allocated. */
    RtlZeroMemory(Masks, sizeof(Masks));
    for (i = 0; i < RTL_NUMBER_OF(HighPriorOptionsMap); ++i)
    {
        /* Loop over the given options to search for */
        NextOptions = HighPriorOptionsMap[i].Options;
        while ((NextOpt = NtLdrGetNextOption(&NextOptions, &NextOptLength)))
        {
            /* If any of these options are present... */
            if (NtLdrGetOptionExN(BootOptions, NextOpt, NextOptLength, NULL))
            {
                /* ... set the mask, retrieve the sizes and stop looking for these options */
                Masks[i] = TRUE;
                if (ExtraOptions && HighPriorOptionsMap[i].ExtraOptions)
                {
                    ExtraOptsSize += strlen(HighPriorOptionsMap[i].ExtraOptions) * sizeof(CHAR);
                }
                if (HigherPriorityOptions && HighPriorOptionsMap[i].HigherPriorOptions)
                {
                    HighPriorOptsSize += strlen(HighPriorOptionsMap[i].HigherPriorOptions) * sizeof(CHAR);
                }
                break;
            }
        }
    }
    /* Count the NULL-terminator */
    if (ExtraOptions)
        ExtraOptsSize += sizeof(ANSI_NULL);
    if (HigherPriorityOptions)
        HighPriorOptsSize += sizeof(ANSI_NULL);
 
    /* Allocate the string pointers */
    if (ExtraOptions)
    {
        *ExtraOptions = FrLdrHeapAlloc(ExtraOptsSize, TAG_BOOT_OPTIONS);
        if (!*ExtraOptions)
            return;
    }
    if (HigherPriorityOptions)
    {
        *HigherPriorityOptions = FrLdrHeapAlloc(HighPriorOptsSize, TAG_BOOT_OPTIONS);
        if (!*HigherPriorityOptions)
        {
            if (ExtraOptions)
            {
                FrLdrHeapFree(*ExtraOptions, TAG_BOOT_OPTIONS);
                *ExtraOptions = NULL;
            }
            return;
        }
    }
 
    /* Initialize the strings */
    if (ExtraOptions)
        *(*ExtraOptions) = '\0';
    if (HigherPriorityOptions)
        *(*HigherPriorityOptions) = '\0';
 
    /* Go through the masks that determine the options to check */
    for (i = 0; i < RTL_NUMBER_OF(HighPriorOptionsMap); ++i)
    {
        if (Masks[i])
        {
            /* Retrieve the strings */
            if (ExtraOptions && HighPriorOptionsMap[i].ExtraOptions)
            {
                RtlStringCbCatA(*ExtraOptions,
                                ExtraOptsSize,
                                HighPriorOptionsMap[i].ExtraOptions);
            }
            if (HigherPriorityOptions && HighPriorOptionsMap[i].HigherPriorOptions)
            {
                RtlStringCbCatA(*HigherPriorityOptions,
                                HighPriorOptsSize,
                                HighPriorOptionsMap[i].HigherPriorOptions);
            }
        }
    }
}

Referenced by LoadReactOSSetup().

NtLdrUpdateLoadOptions()

VOID NtLdrUpdateLoadOptions	(	IN OUT PSTR	LoadOptions,
		IN ULONG	BufferSize,
		IN BOOLEAN	Append,
		IN PCSTR OptionsToAdd[]	OPTIONAL,
		IN PCSTR OptionsToRemove[]	OPTIONAL
	)

Definition at line 258 of file setupldr.c.

{
    PCSTR NextOptions, NextOpt;
    PSTR Options, Option;
    ULONG NextOptLength;
    ULONG OptionLength;
 
    if (!LoadOptions || (BufferSize == 0))
        return;
    // ASSERT(strlen(LoadOptions) + 1 <= BufferSize);
 
    /* Loop over the options to remove */
    for (; OptionsToRemove && *OptionsToRemove; ++OptionsToRemove)
    {
        NextOptions = *OptionsToRemove;
        while ((NextOpt = NtLdrGetNextOption(&NextOptions, &NextOptLength)))
        {
            /* Scan the load options */
            Options = LoadOptions;
            while ((Option = (PSTR)NtLdrGetNextOption((PCSTR*)&Options, &OptionLength)))
            {
                /*
                 * Check whether the option to find exactly matches the current
                 * load option, or is a prefix thereof if this is an option with
                 * appended data.
                 */
                if ((OptionLength >= NextOptLength) &&
                    (_strnicmp(Option, NextOpt, NextOptLength) == 0))
                {
                    if ((OptionLength == NextOptLength) ||
                        (NextOpt[NextOptLength-1] == '=') ||
                        (NextOpt[NextOptLength-1] == ':'))
                    {
                        /* Eat any skipped option or whitespace separators */
                        while ((Option > LoadOptions) &&
                               (Option[-1] == '/' ||
                                Option[-1] == ' ' ||
                                Option[-1] == '\t'))
                        {
                            --Option;
                        }
 
                        /* If the option was not preceded by a whitespace
                         * separator, insert one and advance the pointer. */
                        if ((Option > LoadOptions) &&
                            (Option[-1] != ' ') &&
                            (Option[-1] != '\t') &&
                            (*Options != '\0') /* &&
                            ** Not necessary since NtLdrGetNextOption() **
                            ** stripped any leading separators.         **
                            (*Options != ' ') &&
                            (*Options != '\t') */)
                        {
                            *Option++ = ' ';
                        }
 
                        /* Move the remaining options back, erasing the current one */
                        ASSERT(Option <= Options);
                        RtlMoveMemory(Option,
                                      Options,
                                      (strlen(Options) + 1) * sizeof(CHAR));
 
                        /* Reset the iterator */
                        Options = Option;
                    }
                }
            }
        }
    }
 
    /* Now loop over the options to add */
    for (; OptionsToAdd && *OptionsToAdd; ++OptionsToAdd)
    {
        NtLdrAddOptions(LoadOptions,
                        BufferSize,
                        Append,
                        *OptionsToAdd);
    }
}

Referenced by LoadReactOSSetup().

SetupLdrInitErrataInf()

static BOOLEAN SetupLdrInitErrataInf ( IN OUT PLOADER_PARAMETER_BLOCK  LoaderBlock, IN HINF  InfHandle, IN PCSTR  SystemRoot  )

static

Definition at line 108 of file setupldr.c.

{
    INFCONTEXT InfContext;
    PCSTR FileName;
    ULONG FileSize;
    PVOID PhysicalBase;
    CHAR ErrataFilePath[MAX_PATH];
 
    /* Retrieve the INF file name value */
    if (!InfFindFirstLine(InfHandle, "BiosInfo", "InfName", &InfContext))
    {
        WARN("Failed to find 'BiosInfo/InfName'\n");
        return FALSE;
    }
    if (!InfGetDataField(&InfContext, 1, &FileName))
    {
        WARN("Failed to read 'InfName' value\n");
        return FALSE;
    }
 
    RtlStringCbCopyA(ErrataFilePath, sizeof(ErrataFilePath), SystemRoot);
    RtlStringCbCatA(ErrataFilePath, sizeof(ErrataFilePath), FileName);
 
    /* Load the INF file */
    PhysicalBase = WinLdrLoadModule(ErrataFilePath, &FileSize, LoaderRegistryData);
    if (!PhysicalBase)
    {
        WARN("Could not load '%s'\n", ErrataFilePath);
        return FALSE;
    }
 
    LoaderBlock->Extension->EmInfFileImage = PaToVa(PhysicalBase);
    LoaderBlock->Extension->EmInfFileSize  = FileSize;
 
    return TRUE;
}

Referenced by LoadReactOSSetup().

SetupLdrLoadNlsData()

static VOID SetupLdrLoadNlsData ( _Inout_ PLOADER_PARAMETER_BLOCK  LoaderBlock, _In_ HINF  InfHandle, _In_ PCSTR  SearchPath  )

static

Definition at line 36 of file setupldr.c.

{
    BOOLEAN Success;
    INFCONTEXT InfContext;
    PCSTR AnsiData;
    UNICODE_STRING AnsiFileName = {0};
    UNICODE_STRING OemFileName = {0};
    UNICODE_STRING LangFileName = {0}; // CaseTable
    UNICODE_STRING OemHalFileName = {0};
 
    /* Get ANSI codepage file */
    if (!InfFindFirstLine(InfHandle, "NLS", "AnsiCodepage", &InfContext) ||
        !InfGetDataField(&InfContext, 1, &AnsiData) ||
        !RtlCreateUnicodeStringFromAsciiz(&AnsiFileName, AnsiData))
    {
        ERR("Failed to find or get 'NLS/AnsiCodepage'\n");
        return;
    }
 
    /* Get OEM codepage file */
    if (!InfFindFirstLine(InfHandle, "NLS", "OemCodepage", &InfContext) ||
        !InfGetDataField(&InfContext, 1, &AnsiData) ||
        !RtlCreateUnicodeStringFromAsciiz(&OemFileName, AnsiData))
    {
        ERR("Failed to find or get 'NLS/OemCodepage'\n");
        goto Quit;
    }
 
    /* Get the Unicode case table file */
    if (!InfFindFirstLine(InfHandle, "NLS", "UnicodeCasetable", &InfContext) ||
        !InfGetDataField(&InfContext, 1, &AnsiData) ||
        !RtlCreateUnicodeStringFromAsciiz(&LangFileName, AnsiData))
    {
        ERR("Failed to find or get 'NLS/UnicodeCasetable'\n");
        goto Quit;
    }
 
    /* Get OEM HAL font file */
    if (!InfFindFirstLine(InfHandle, "NLS", "OemHalFont", &InfContext) ||
        !InfGetData(&InfContext, NULL, &AnsiData) ||
        !RtlCreateUnicodeStringFromAsciiz(&OemHalFileName, AnsiData))
    {
        WARN("Failed to find or get 'NLS/OemHalFont'\n");
        /* Ignore, this is an optional file */
        RtlInitEmptyUnicodeString(&OemHalFileName, NULL, 0);
    }
 
    TRACE("NLS data: '%wZ' '%wZ' '%wZ' '%wZ'\n",
          &AnsiFileName, &OemFileName, &LangFileName, &OemHalFileName);
 
    /* Load NLS data */
    Success = WinLdrLoadNLSData(LoaderBlock,
                                SearchPath,
                                &AnsiFileName,
                                &OemFileName,
                                &LangFileName,
                                &OemHalFileName);
    TRACE("NLS data loading %s\n", Success ? "successful" : "failed");
    (VOID)Success;
 
Quit:
    RtlFreeUnicodeString(&OemHalFileName);
    RtlFreeUnicodeString(&LangFileName);
    RtlFreeUnicodeString(&OemFileName);
    RtlFreeUnicodeString(&AnsiFileName);
}

Referenced by LoadReactOSSetup().

SetupLdrScanBootDrivers()

static VOID SetupLdrScanBootDrivers ( _Inout_ PLIST_ENTRY  BootDriverListHead, _In_ HINF  InfHandle, _In_ PCSTR  SearchPath  )

static

Definition at line 149 of file setupldr.c.

{
    INFCONTEXT InfContext, dirContext;
    PCSTR Media, DriverName, dirIndex, ImagePath;
    BOOLEAN Success;
    UINT8 Pass;
    WCHAR ImagePathW[MAX_PATH];
    WCHAR DriverNameW[256];
 
    UNREFERENCED_PARAMETER(SearchPath);
 
    /* Open the INF section, first the optional platform-specific one,
     * then the generic section */
    for (Pass = 0; Pass <= 1; ++Pass)
    {
    PCSTR pFilesSection[] = {"SourceDisksFiles." INF_ARCH, "SourceDisksFiles"};
 
    if (!InfFindFirstLine(InfHandle, pFilesSection[Pass], NULL, &InfContext))
        continue;
 
    /* Load all listed boot drivers */
    do
    {
        if (InfGetDataField(&InfContext, 7, &Media) &&
            InfGetDataField(&InfContext, 0, &DriverName) &&
            InfGetDataField(&InfContext, 13, &dirIndex))
        {
            if ((strcmp(Media, "x") == 0) && // HACK: ReactOS-specific
                InfFindFirstLine(InfHandle, "Directories", dirIndex, &dirContext) &&
                InfGetDataField(&dirContext, 1, &ImagePath))
            {
                /* Prepare image path */
                RtlStringCbPrintfW(ImagePathW, sizeof(ImagePathW),
                                   L"%S\\%S", ImagePath, DriverName);
 
                /* Convert name to Unicode and remove .sys extension */
                RtlStringCbPrintfW(DriverNameW, sizeof(DriverNameW),
                                   L"%S", DriverName);
                DriverNameW[wcslen(DriverNameW) - 4] = UNICODE_NULL;
 
                /* Add it to the list */
                Success = WinLdrAddDriverToList(BootDriverListHead,
                                                FALSE,
                                                DriverNameW,
                                                ImagePathW,
                                                NULL,
                                                SERVICE_ERROR_NORMAL,
                                                -1);
                if (!Success)
                {
                    ERR("Could not add boot driver '%s'\n", DriverName);
                    /* Ignore and continue adding other drivers */
                }
            }
        }
    } while (InfFindNextLine(&InfContext, &InfContext));
    } // for (Pass...)
 
    /* Finally, add the boot filesystem driver to the list */
    if (BootFileSystem)
    {
        TRACE("Adding filesystem driver %S\n", BootFileSystem);
        Success = WinLdrAddDriverToList(BootDriverListHead,
                                        FALSE,
                                        BootFileSystem,
                                        NULL,
                                        L"Boot File System",
                                        SERVICE_ERROR_CRITICAL,
                                        -1);
        if (!Success)
            ERR("Failed to add filesystem driver %S\n", BootFileSystem);
    }
    else
    {
        TRACE("No required filesystem driver\n");
    }
}

Referenced by LoadReactOSSetup().

Variable Documentation

ExtraOptions

PCSTR ExtraOptions

Definition at line 353 of file setupldr.c.

Referenced by BlGetBootOptionDevice(), LoadReactOSSetup(), and NtLdrGetHigherPriorityOptions().

HigherPriorOptions

PCSTR HigherPriorOptions

Definition at line 354 of file setupldr.c.

Referenced by NtLdrGetHigherPriorityOptions().

const struct { ... } HighPriorOptionsMap[]

Initial value:

=
{
    
    {"/DEBUG/DEBUG=", NULL, "/NODEBUG"},
 
    
    {"/DEBUGPORT=SCREEN", NULL, "/NOGUIBOOT"},
 
    
    {"/HAL=/KERNEL=", NULL, "/DETECTHAL"},
 
    
    {"/PAE", NULL, "/NOPAE"},
 
    
    {"/EXECUTE", "/NOEXECUTE=ALWAYSOFF", "/NOEXECUTE/NOEXECUTE="},
    
    {"/NOEXECUTE/NOEXECUTE=", NULL, "/NOEXECUTE/NOEXECUTE="},
 
    
    {"/SAFEBOOT/SAFEBOOT:", NULL, "/SAFEBOOT/SAFEBOOT:"},
}

Referenced by NtLdrGetHigherPriorityOptions().

Options

PCSTR Options

Definition at line 352 of file setupldr.c.

Referenced by NtLdrUpdateLoadOptions().