inifile.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	INI_SECTION_ITEM
struct	INI_SECTION

Macros
#define	INI_FILE_COMMENT_CHAR   ';'
#define	TAG_INI_FILE   'FinI'
#define	TAG_INI_SECTION   'SinI'
#define	TAG_INI_SECTION_ITEM   'IinI'
#define	TAG_INI_NAME   'NinI'
#define	TAG_INI_VALUE   'VinI'

Typedefs
typedef struct INI_SECTION_ITEM *	PINI_SECTION_ITEM
typedef struct INI_SECTION *	PINI_SECTION

Functions
BOOLEAN	IniParseFile (PCHAR IniFileData, ULONG IniFileSize)
ULONG	IniGetNextLineSize (PCHAR IniFileData, ULONG IniFileSize, ULONG CurrentOffset)
ULONG	IniGetNextLine (PCHAR IniFileData, ULONG IniFileSize, PCHAR Buffer, ULONG BufferSize, ULONG CurrentOffset)
BOOLEAN	IniIsLineEmpty (PCHAR LineOfText, ULONG TextLength)
BOOLEAN	IniIsCommentLine (PCHAR LineOfText, ULONG TextLength)
BOOLEAN	IniIsSectionName (PCHAR LineOfText, ULONG TextLength)
ULONG	IniGetSectionNameSize (PCHAR SectionNameLine, ULONG LineLength)
VOID	IniExtractSectionName (PCHAR SectionName, PCHAR SectionNameLine, ULONG LineLength)
BOOLEAN	IniIsSetting (PCHAR LineOfText, ULONG TextLength)
ULONG	IniGetSettingNameSize (PCHAR SettingNameLine, ULONG LineLength)
ULONG	IniGetSettingValueSize (PCHAR SettingValueLine, ULONG LineLength)
VOID	IniExtractSettingName (PCHAR SettingName, PCHAR SettingNameLine, ULONG LineLength)
VOID	IniExtractSettingValue (PCHAR SettingValue, PCHAR SettingValueLine, ULONG LineLength)
BOOLEAN	IniFileInitialize (VOID)
BOOLEAN	IniOpenSection (PCSTR SectionName, ULONG_PTR *SectionId)
ULONG	IniGetNumSectionItems (ULONG_PTR SectionId)
ULONG	IniGetSectionSettingNameSize (ULONG_PTR SectionId, ULONG SettingIndex)
ULONG	IniGetSectionSettingValueSize (ULONG_PTR SectionId, ULONG SettingIndex)
BOOLEAN	IniReadSettingByNumber (ULONG_PTR SectionId, ULONG SettingNumber, PCHAR SettingName, ULONG NameSize, PCHAR SettingValue, ULONG ValueSize)
BOOLEAN	IniReadSettingByName (ULONG_PTR SectionId, PCSTR SettingName, PCHAR Buffer, ULONG BufferSize)
BOOLEAN	IniAddSection (PCSTR SectionName, ULONG_PTR *SectionId)
BOOLEAN	IniAddSettingValueToSection (ULONG_PTR SectionId, PCSTR SettingName, PCSTR SettingValue)
VOID	IniCleanup (VOID)

Variables
LIST_ENTRY	IniFileSectionListHead
BOOLEAN	IniFileSectionInitialized
ULONG	IniFileSectionCount
ULONG	IniFileSettingCount

Macro Definition Documentation

INI_FILE_COMMENT_CHAR

#define INI_FILE_COMMENT_CHAR   ';'

Definition at line 22 of file inifile.h.

TAG_INI_FILE

#define TAG_INI_FILE   'FinI'

Definition at line 24 of file inifile.h.

TAG_INI_NAME

#define TAG_INI_NAME   'NinI'

Definition at line 27 of file inifile.h.

TAG_INI_SECTION

#define TAG_INI_SECTION   'SinI'

Definition at line 25 of file inifile.h.

TAG_INI_SECTION_ITEM

#define TAG_INI_SECTION_ITEM   'IinI'

Definition at line 26 of file inifile.h.

TAG_INI_VALUE

#define TAG_INI_VALUE   'VinI'

Definition at line 28 of file inifile.h.

Typedef Documentation

PINI_SECTION

typedef struct INI_SECTION * PINI_SECTION

PINI_SECTION_ITEM

typedef struct INI_SECTION_ITEM * PINI_SECTION_ITEM

Function Documentation

IniAddSection()

BOOLEAN IniAddSection	(	PCSTR	SectionName,
		ULONG_PTR *	SectionId
	)

Definition at line 179 of file inifile.c.

{
    PINI_SECTION    Section;

    // Allocate a new section structure
    Section = FrLdrTempAlloc(sizeof(INI_SECTION), TAG_INI_SECTION);
    if (!Section)
    {
        return FALSE;
    }

    RtlZeroMemory(Section, sizeof(INI_SECTION));

    // Allocate the section name buffer
    Section->SectionName = FrLdrTempAlloc(strlen(SectionName) + sizeof(CHAR), TAG_INI_NAME);
    if (!Section->SectionName)
    {
        FrLdrTempFree(Section, TAG_INI_SECTION);
        return FALSE;
    }

    // Get the section name
    strcpy(Section->SectionName, SectionName);
    InitializeListHead(&Section->SectionItemList);

    // Add it to the section list head
    IniFileSectionCount++;
    InsertHeadList(&IniFileSectionListHead, &Section->ListEntry);

    *SectionId = (ULONG_PTR)Section;

    return TRUE;
}

Referenced by OptionMenuCustomBootReactOS().

IniAddSettingValueToSection()

BOOLEAN IniAddSettingValueToSection	(	ULONG_PTR	SectionId,
		PCSTR	SettingName,
		PCSTR	SettingValue
	)

Definition at line 252 of file inifile.c.

{
    PINI_SECTION        Section = (PINI_SECTION)SectionId;
    PINI_SECTION_ITEM    SectionItem;

    // Allocate a new item structure
    SectionItem = FrLdrTempAlloc(sizeof(INI_SECTION_ITEM), TAG_INI_SECTION_ITEM);
    if (!SectionItem)
    {
        return FALSE;
    }

    RtlZeroMemory(SectionItem, sizeof(INI_SECTION_ITEM));

    // Allocate the setting name buffer
    SectionItem->ItemName = FrLdrTempAlloc(strlen(SettingName) + 1, TAG_INI_NAME);
    if (!SectionItem->ItemName)
    {
        FrLdrTempFree(SectionItem, TAG_INI_SECTION_ITEM);
        return FALSE;
    }

    // Allocate the setting value buffer
    SectionItem->ItemValue = FrLdrTempAlloc(strlen(SettingValue) + 1, TAG_INI_VALUE);
    if (!SectionItem->ItemValue)
    {
        FrLdrTempFree(SectionItem->ItemName, TAG_INI_NAME);
        FrLdrTempFree(SectionItem, TAG_INI_SECTION_ITEM);
        return FALSE;
    }

    strcpy(SectionItem->ItemName, SettingName);
    strcpy(SectionItem->ItemValue, SettingValue);

    // Add it to the current section
    Section->SectionItemCount++;
    InsertTailList(&Section->SectionItemList, &SectionItem->ListEntry);

    return TRUE;
}

Referenced by OptionMenuCustomBootReactOS().

IniCleanup()

VOID IniCleanup

(

VOID

)

Definition at line 235 of file inifile.c.

{
    PLIST_ENTRY ListEntry;
    PINI_SECTION Section;

    // Loop while there are sections
    while (!IsListEmpty(&IniFileSectionListHead))
    {
        // Remove the section
        ListEntry = RemoveHeadList(&IniFileSectionListHead);
        Section = CONTAINING_RECORD(ListEntry, INI_SECTION, ListEntry);

        // Free it
        IniFreeSection(Section);
    }
}

Referenced by LoadAndBootWindowsCommon().

IniExtractSectionName()

VOID IniExtractSectionName	(	PCHAR	SectionName,
		PCHAR	SectionNameLine,
		ULONG	LineLength
	)

Definition at line 360 of file parse.c.

{
    ULONG        Idx;
    ULONG        DestIdx;

    // Find the opening bracket (skipping whitespace)
    for (Idx=0; Idx<LineLength; Idx++)
    {
        if ((SectionNameLine[Idx] == ' ') ||
            (SectionNameLine[Idx] == '\t'))
        {
            continue;
        }
        else //if (SectionNameLine[Idx] == '[')
        {
            break;
        }
    }

    // Skip past the opening bracket
    Idx++;

    // Count the characters up until the closing bracket or EOL
    for (DestIdx=0; Idx<LineLength; Idx++)
    {
        if ((SectionNameLine[Idx] == ']') ||
            (SectionNameLine[Idx] == '\0'))
        {
            break;
        }

        // Grab a character and increment DestIdx
        SectionName[DestIdx] = SectionNameLine[Idx];
        DestIdx++;
    }

    // Terminate the string
    SectionName[DestIdx] = '\0';
}

Referenced by IniParseFile().

IniExtractSettingName()

VOID IniExtractSettingName	(	PCHAR	SettingName,
		PCHAR	SettingNameLine,
		ULONG	LineLength
	)

Definition at line 507 of file parse.c.

{
    ULONG        Idx;
    ULONG        DestIdx;

    // Skip whitespace
    for (Idx=0; Idx<LineLength; Idx++)
    {
        if ((SettingNameLine[Idx] == ' ') ||
            (SettingNameLine[Idx] == '\t'))
        {
            continue;
        }
        else
        {
            break;
        }
    }

    // Get the characters up until the '=' equals sign or EOL
    for (DestIdx=0; Idx<LineLength; Idx++)
    {
        if ((SettingNameLine[Idx] == '=') ||
            (SettingNameLine[Idx] == '\0'))
        {
            break;
        }

        // Grab a character and increment DestIdx
        SettingName[DestIdx] = SettingNameLine[Idx];
        DestIdx++;
    }

    // Terminate the string
    SettingName[DestIdx] = '\0';
}

Referenced by IniParseFile().

IniExtractSettingValue()

VOID IniExtractSettingValue	(	PCHAR	SettingValue,
		PCHAR	SettingValueLine,
		ULONG	LineLength
	)

Definition at line 544 of file parse.c.

{
    ULONG        Idx;
    ULONG        DestIdx;

    // Skip whitespace
    for (Idx=0; Idx<LineLength; Idx++)
    {
        if ((SettingValueLine[Idx] == ' ') ||
            (SettingValueLine[Idx] == '\t'))
        {
            continue;
        }
        else
        {
            break;
        }
    }

    // Skip the characters up until the '=' equals sign or EOL
    for (; Idx<LineLength; Idx++)
    {
        if (SettingValueLine[Idx] == '=')
        {
            Idx++;
            break;
        }

        // If we hit EOL then obviously the value size is zero
        if (SettingValueLine[Idx] == '\0')
        {
            SettingValue[0] = '\0';
            return;
        }
    }

    // Get the characters up until the EOL
    for (DestIdx=0; Idx<LineLength; Idx++)
    {
        if (SettingValueLine[Idx] == '\0')
        {
            break;
        }

        // Grab a character and increment DestIdx
        SettingValue[DestIdx] = SettingValueLine[Idx];
        DestIdx++;
    }

    // Terminate the string
    SettingValue[DestIdx] = '\0';
}

Referenced by IniParseFile().

IniFileInitialize()

BOOLEAN IniFileInitialize

(

VOID

)

Definition at line 38 of file ini_init.c.

{
    FILEINFORMATION FileInformation;
    ULONG FileId; // File handle for freeldr.ini
    PCHAR FreeLoaderIniFileData;
    ULONG FreeLoaderIniFileSize, Count;
    ARC_STATUS Status;
    BOOLEAN Success;
    TRACE("IniFileInitialize()\n");

    //
    // Open freeldr.ini
    //
    Status = IniOpenIniFile(&FileId);
    if (Status != ESUCCESS)
    {
        UiMessageBoxCritical("Error opening freeldr.ini or file not found.\nYou need to re-install FreeLoader.");
        return FALSE;
    }

    //
    // Get the file size
    //
    Status = ArcGetFileInformation(FileId, &FileInformation);
    if (Status != ESUCCESS || FileInformation.EndingAddress.HighPart != 0)
    {
        UiMessageBoxCritical("Error while getting informations about freeldr.ini.\nYou need to re-install FreeLoader.");
        return FALSE;
    }
    FreeLoaderIniFileSize = FileInformation.EndingAddress.LowPart;

    //
    // Allocate memory to cache the whole freeldr.ini
    //
    FreeLoaderIniFileData = FrLdrTempAlloc(FreeLoaderIniFileSize, TAG_INI_FILE);
    if (!FreeLoaderIniFileData)
    {
        UiMessageBoxCritical("Out of memory while loading freeldr.ini.");
        ArcClose(FileId);
        return FALSE;
    }

    //
    // Read freeldr.ini off the disk
    //
    Status = ArcRead(FileId, FreeLoaderIniFileData, FreeLoaderIniFileSize, &Count);
    if (Status != ESUCCESS || Count != FreeLoaderIniFileSize)
    {
        UiMessageBoxCritical("Error while reading freeldr.ini.");
        ArcClose(FileId);
        FrLdrTempFree(FreeLoaderIniFileData, TAG_INI_FILE);
        return FALSE;
    }

    //
    // Parse the .ini file data
    //
    Success = IniParseFile(FreeLoaderIniFileData, FreeLoaderIniFileSize);

    //
    // Do some cleanup, and return
    //
    ArcClose(FileId);
    FrLdrTempFree(FreeLoaderIniFileData, TAG_INI_FILE);

    return Success;
}

Referenced by RunLoader().

IniGetNextLine()

ULONG IniGetNextLine	(	PCHAR	IniFileData,
		ULONG	IniFileSize,
		PCHAR	Buffer,
		ULONG	BufferSize,
		ULONG	CurrentOffset
	)

Definition at line 210 of file parse.c.

{
    ULONG        Idx;

    // Loop through grabbing chars until we hit the end of the
    // file or we encounter a new line char
    for (Idx=0; (CurrentOffset < IniFileSize); CurrentOffset++)
    {
        // If we haven't exceeded our buffer size yet
        // then store another char
        if (Idx < (BufferSize - 1))
        {
            Buffer[Idx++] = IniFileData[CurrentOffset];
        }

        // Check for new line char
        if (IniFileData[CurrentOffset] == '\n')
        {
            CurrentOffset++;
            break;
        }
    }

    // Terminate the string
    Buffer[Idx] = '\0';

    // Get rid of newline & linefeed characters (if any)
    while(Idx && (Buffer[--Idx] == '\n' || Buffer[Idx] == '\r'))
        Buffer[Idx] = '\0';

    // Send back new offset
    return CurrentOffset;
}

Referenced by IniParseFile().

IniGetNextLineSize()

ULONG IniGetNextLineSize	(	PCHAR	IniFileData,
		ULONG	IniFileSize,
		ULONG	CurrentOffset
	)

Definition at line 185 of file parse.c.

{
    ULONG        LineCharCount = 0;

    // Loop through counting chars until we hit the end of the
    // file or we encounter a new line char
    for (; (CurrentOffset < IniFileSize); CurrentOffset++)
    {
        // Increment the line character count
        LineCharCount++;

        // Check for new line char
        if (IniFileData[CurrentOffset] == '\n')
        {
            break;
        }
    }

    // Add one for the NULL-terminator
    LineCharCount++;

    // Send back line character count
    return LineCharCount;
}

Referenced by IniParseFile().

IniGetNumSectionItems()

ULONG IniGetNumSectionItems

(

ULONG_PTR

SectionId

)

Definition at line 54 of file inifile.c.

{
    PINI_SECTION    Section = (PINI_SECTION)SectionId;

    TRACE("IniGetNumSectionItems() SectionId = 0x%x\n", SectionId);
    TRACE("IniGetNumSectionItems() Item count = %d\n", Section->SectionItemCount);

    return Section->SectionItemCount;
}

Referenced by DriveMapMapDrivesInSection(), InitOperatingSystemList(), and UiShowMessageBoxesInSection().

IniGetSectionNameSize()

ULONG IniGetSectionNameSize	(	PCHAR	SectionNameLine,
		ULONG	LineLength
	)

Definition at line 319 of file parse.c.

{
    ULONG        Idx;
    ULONG        NameSize;

    // Find the opening bracket (skipping whitespace)
    for (Idx=0; Idx<LineLength; Idx++)
    {
        if ((SectionNameLine[Idx] == ' ') ||
            (SectionNameLine[Idx] == '\t'))
        {
            continue;
        }
        else //if (SectionNameLine[Idx] == '[')
        {
            break;
        }
    }

    // Skip past the opening bracket
    Idx++;

    // Count the characters up until the closing bracket or EOL
    for (NameSize=0; Idx<LineLength; Idx++)
    {
        if ((SectionNameLine[Idx] == ']') ||
            (SectionNameLine[Idx] == '\0'))
        {
            break;
        }

        // Increment the count
        NameSize++;
    }

    // Add one for the NULL-terminator
    NameSize++;

    return NameSize;
}

Referenced by IniParseFile().

IniGetSectionSettingNameSize()

ULONG IniGetSectionSettingNameSize	(	ULONG_PTR	SectionId,
		ULONG	SettingIndex
	)

Definition at line 88 of file inifile.c.

{
    PINI_SECTION_ITEM    SectionItem;

    // Retrieve requested setting
    SectionItem = IniGetSettingByNumber(SectionId, SettingIndex);
    if (!SectionItem)
        return 0;

    // Return the size of the string plus 1 for the null-terminator
    return (ULONG)(strlen(SectionItem->ItemName) + 1);
}

IniGetSectionSettingValueSize()

ULONG IniGetSectionSettingValueSize	(	ULONG_PTR	SectionId,
		ULONG	SettingIndex
	)

Definition at line 101 of file inifile.c.

{
    PINI_SECTION_ITEM    SectionItem;

    // Retrieve requested setting
    SectionItem = IniGetSettingByNumber(SectionId, SettingIndex);
    if (!SectionItem)
        return 0;

    // Return the size of the string plus 1 for the null-terminator
    return (ULONG)(strlen(SectionItem->ItemValue) + 1);
}

Referenced by UiShowMessageBoxesInSection().

IniGetSettingNameSize()

ULONG IniGetSettingNameSize	(	PCHAR	SettingNameLine,
		ULONG	LineLength
	)

Definition at line 416 of file parse.c.

{
    ULONG        Idx;
    ULONG        NameSize;

    // Skip whitespace
    for (Idx=0; Idx<LineLength; Idx++)
    {
        if ((SettingNameLine[Idx] == ' ') ||
            (SettingNameLine[Idx] == '\t'))
        {
            continue;
        }
        else
        {
            break;
        }
    }

    // Count the characters up until the '=' equals sign or EOL
    for (NameSize=0; Idx<LineLength; Idx++)
    {
        if ((SettingNameLine[Idx] == '=') ||
            (SettingNameLine[Idx] == '\0'))
        {
            break;
        }

        // Increment the count
        NameSize++;
    }

    // Add one for the NULL-terminator
    NameSize++;

    return NameSize;
}

Referenced by IniParseFile().

IniGetSettingValueSize()

ULONG IniGetSettingValueSize	(	PCHAR	SettingValueLine,
		ULONG	LineLength
	)

Definition at line 454 of file parse.c.

{
    ULONG        Idx;
    ULONG        ValueSize;

    // Skip whitespace
    for (Idx=0; Idx<LineLength; Idx++)
    {
        if ((SettingValueLine[Idx] == ' ') ||
            (SettingValueLine[Idx] == '\t'))
        {
            continue;
        }
        else
        {
            break;
        }
    }

    // Skip the characters up until the '=' equals sign or EOL
    for (; Idx<LineLength; Idx++)
    {
        if (SettingValueLine[Idx] == '=')
        {
            Idx++;
            break;
        }

        // If we hit EOL then obviously the value size is zero
        if (SettingValueLine[Idx] == '\0')
        {
            return 0;
        }
    }

    // Count the characters up until the EOL
    for (ValueSize=0; Idx<LineLength; Idx++)
    {
        if (SettingValueLine[Idx] == '\0')
        {
            break;
        }

        // Increment the count
        ValueSize++;
    }

    // Add one for the NULL-terminator
    ValueSize++;

    return ValueSize;
}

Referenced by IniParseFile().

IniIsCommentLine()

BOOLEAN IniIsCommentLine	(	PCHAR	LineOfText,
		ULONG	TextLength
	)

Definition at line 267 of file parse.c.

{
    ULONG        Idx;

    // Check the first character (skipping whitespace)
    // and make sure that it is an opening bracket
    for (Idx=0; Idx<TextLength; Idx++)
    {
        if ((LineOfText[Idx] == ' ') ||
            (LineOfText[Idx] == '\t'))
        {
            continue;
        }
        else if (LineOfText[Idx] == INI_FILE_COMMENT_CHAR)
        {
            return TRUE;
        }
        else
        {
            break;
        }
    }

    return FALSE;
}

Referenced by IniParseFile().

IniIsLineEmpty()

BOOLEAN IniIsLineEmpty	(	PCHAR	LineOfText,
		ULONG	TextLength
	)

Definition at line 244 of file parse.c.

{
    ULONG        Idx;

    // Check for text (skipping whitespace)
    for (Idx=0; Idx<TextLength; Idx++)
    {
        if ((LineOfText[Idx] == ' ') ||
            (LineOfText[Idx] == '\t') ||
            (LineOfText[Idx] == '\n') ||
            (LineOfText[Idx] == '\r'))
        {
            continue;
        }
        else
        {
            return FALSE;
        }
    }

    return TRUE;
}

Referenced by IniParseFile().

IniIsSectionName()

BOOLEAN IniIsSectionName	(	PCHAR	LineOfText,
		ULONG	TextLength
	)

Definition at line 293 of file parse.c.

{
    ULONG        Idx;

    // Check the first character (skipping whitespace)
    // and make sure that it is an opening bracket
    for (Idx=0; Idx<TextLength; Idx++)
    {
        if ((LineOfText[Idx] == ' ') ||
            (LineOfText[Idx] == '\t'))
        {
            continue;
        }
        else if (LineOfText[Idx] == '[')
        {
            return TRUE;
        }
        else
        {
            break;
        }
    }

    return FALSE;
}

Referenced by IniParseFile().

IniIsSetting()

BOOLEAN IniIsSetting	(	PCHAR	LineOfText,
		ULONG	TextLength
	)

Definition at line 400 of file parse.c.

{
    ULONG        Idx;

    // Basically just check for an '=' equals sign
    for (Idx=0; Idx<TextLength; Idx++)
    {
        if (LineOfText[Idx] == '=')
        {
            return TRUE;
        }
    }

    return FALSE;
}

Referenced by IniParseFile().

IniOpenSection()

BOOLEAN IniOpenSection	(	PCSTR	SectionName,
		ULONG_PTR *	SectionId
	)

Definition at line 25 of file inifile.c.

{
    PINI_SECTION    Section;

    TRACE("IniOpenSection() SectionName = %s\n", SectionName);

    // Loop through each section and find the one they want
    Section = CONTAINING_RECORD(IniFileSectionListHead.Flink, INI_SECTION, ListEntry);
    while (&Section->ListEntry != &IniFileSectionListHead)
    {
        // Compare against the section name
        if (_stricmp(SectionName, Section->SectionName) == 0)
        {
            // We found it
            if (SectionId)
                *SectionId = (ULONG_PTR)Section;
            TRACE("IniOpenSection() Found it! SectionId = 0x%x\n", SectionId);
            return TRUE;
        }

        // Get the next section in the list
        Section = CONTAINING_RECORD(Section->ListEntry.Flink, INI_SECTION, ListEntry);
    }

    TRACE("IniOpenSection() Section not found.\n");

    return FALSE;
}

Referenced by DriveMapMapDrivesInSection(), GetDefaultOperatingSystem(), GetTimeOut(), InitOperatingSystemList(), LoadAndBootWindows(), LoadOperatingSystem(), LoadReactOSSetup(), RunLoader(), UiInitialize(), and UiShowMessageBoxesInSection().

IniParseFile()

BOOLEAN IniParseFile	(	PCHAR	IniFileData,
		ULONG	IniFileSize
	)

Definition at line 31 of file parse.c.

{
    ULONG                    CurrentOffset;
    ULONG                    CurrentLineNumber;
    PCHAR                IniFileLine;
    ULONG                    IniFileLineSize;
    ULONG                    LineLength;
    PINI_SECTION        CurrentSection = NULL;
    PINI_SECTION_ITEM    CurrentItem = NULL;

    TRACE("IniParseFile() IniFileSize: %d\n", IniFileSize);

    if (!IniFileSectionInitialized)
    {
        InitializeListHead(&IniFileSectionListHead);
        IniFileSectionInitialized = TRUE;
    }

    // Start with an 80-byte buffer
    IniFileLineSize = 80;
    IniFileLine = FrLdrTempAlloc(IniFileLineSize, TAG_INI_FILE);
    if (!IniFileLine)
    {
        return FALSE;
    }

    // Loop through each line and parse it
    CurrentLineNumber = 0;
    CurrentOffset = 0;
    while (CurrentOffset < IniFileSize)
    {
        // First check the line size and increase our buffer if necessary
        if (IniFileLineSize < IniGetNextLineSize(IniFileData, IniFileSize, CurrentOffset))
        {
            IniFileLineSize = IniGetNextLineSize(IniFileData, IniFileSize, CurrentOffset);
            FrLdrTempFree(IniFileLine, TAG_INI_FILE);
            IniFileLine = FrLdrTempAlloc(IniFileLineSize, TAG_INI_FILE);
            if (!IniFileLine)
            {
                return FALSE;
            }
        }

        // Get the line of data
        CurrentOffset = IniGetNextLine(IniFileData, IniFileSize, IniFileLine, IniFileLineSize, CurrentOffset);
        LineLength = (ULONG)strlen(IniFileLine);

        // If it is a blank line or a comment then skip it
        if (IniIsLineEmpty(IniFileLine, LineLength) || IniIsCommentLine(IniFileLine, LineLength))
        {
            CurrentLineNumber++;
            continue;
        }

        // Check if it is a new section
        if (IniIsSectionName(IniFileLine, LineLength))
        {
            // Allocate a new section structure
            CurrentSection = FrLdrTempAlloc(sizeof(INI_SECTION), TAG_INI_SECTION);
            if (!CurrentSection)
            {
                FrLdrTempFree(IniFileLine, TAG_INI_FILE);
                return FALSE;
            }

            RtlZeroMemory(CurrentSection, sizeof(INI_SECTION));

            // Allocate the section name buffer
            CurrentSection->SectionName = FrLdrTempAlloc(IniGetSectionNameSize(IniFileLine, LineLength), TAG_INI_NAME);
            if (!CurrentSection->SectionName)
            {
                FrLdrTempFree(CurrentSection, TAG_INI_FILE);
                FrLdrTempFree(IniFileLine, TAG_INI_FILE);
                return FALSE;
            }

            // Get the section name
            IniExtractSectionName(CurrentSection->SectionName, IniFileLine, LineLength);
            InitializeListHead(&CurrentSection->SectionItemList);

            // Add it to the section list head
            IniFileSectionCount++;
            InsertTailList(&IniFileSectionListHead, &CurrentSection->ListEntry);

            CurrentLineNumber++;
            continue;
        }

        // Check if it is a setting
        if (IniIsSetting(IniFileLine, LineLength))
        {
            // First check to make sure we're inside a [section]
            if (CurrentSection == NULL)
            {
                printf("Error: freeldr.ini:%lu: Setting '%s' found outside of a [section].\n", CurrentLineNumber, IniFileLine);
                printf("Press any key to continue...\n");
                MachConsGetCh();
                CurrentLineNumber++;
                continue;
            }

            // Allocate a new item structure
            CurrentItem = FrLdrTempAlloc(sizeof(INI_SECTION_ITEM), TAG_INI_SECTION_ITEM);
            if (!CurrentItem)
            {
                FrLdrTempFree(IniFileLine, TAG_INI_FILE);
                return FALSE;
            }

            RtlZeroMemory(CurrentItem, sizeof(INI_SECTION_ITEM));

            // Allocate the setting name buffer
            CurrentItem->ItemName = FrLdrTempAlloc(IniGetSettingNameSize(IniFileLine, LineLength), TAG_INI_NAME);
            if (!CurrentItem->ItemName)
            {
                FrLdrTempFree(CurrentItem, TAG_INI_SECTION_ITEM);
                FrLdrTempFree(IniFileLine, TAG_INI_FILE);
                return FALSE;
            }

            // Allocate the setting value buffer
            CurrentItem->ItemValue = FrLdrTempAlloc(IniGetSettingValueSize(IniFileLine, LineLength), TAG_INI_VALUE);
            if (!CurrentItem->ItemValue)
            {
                FrLdrTempFree(CurrentItem->ItemName, TAG_INI_NAME);
                FrLdrTempFree(CurrentItem, TAG_INI_SECTION_ITEM);
                FrLdrTempFree(IniFileLine, TAG_INI_FILE);
                return FALSE;
            }

            // Get the section name
            IniExtractSettingName(CurrentItem->ItemName, IniFileLine, LineLength);
            IniExtractSettingValue(CurrentItem->ItemValue, IniFileLine, LineLength);

            // Add it to the current section
            IniFileSettingCount++;
            CurrentSection->SectionItemCount++;
            InsertTailList(&CurrentSection->SectionItemList, &CurrentItem->ListEntry);

            CurrentLineNumber++;
            continue;
        }

        CurrentLineNumber++;
    }

    FrLdrTempFree(IniFileLine, TAG_INI_FILE);

    TRACE("Parsed %d sections and %d settings.\n", IniFileSectionCount, IniFileSettingCount);
    TRACE("IniParseFile() done.\n");

    return TRUE;
}

Referenced by IniFileInitialize().

IniReadSettingByName()

BOOLEAN IniReadSettingByName	(	ULONG_PTR	SectionId,
		PCSTR	SettingName,
		PCHAR	Buffer,
		ULONG	BufferSize
	)

Definition at line 147 of file inifile.c.

{
    PINI_SECTION        Section = (PINI_SECTION)SectionId;
    PINI_SECTION_ITEM    SectionItem;

    TRACE("IniReadSettingByName() SectionId = 0x%x\n", SectionId);

    // Loop through each section item and find the one they want
    SectionItem = CONTAINING_RECORD(Section->SectionItemList.Flink, INI_SECTION_ITEM, ListEntry);
    while (&SectionItem->ListEntry != &Section->SectionItemList)
    {
        // Check to see if this is the setting they want
        if (_stricmp(SettingName, SectionItem->ItemName) == 0)
        {
            TRACE("IniReadSettingByName() Setting \'%s\' found.\n", SettingName);
            TRACE("IniReadSettingByName() Setting value = %s\n", SectionItem->ItemValue);

            strncpy(Buffer, SectionItem->ItemValue, BufferSize - 1);
            Buffer[BufferSize - 1] = '\0';

            return TRUE;
        }

        // Get the next section item in the list
        SectionItem = CONTAINING_RECORD(SectionItem->ListEntry.Flink, INI_SECTION_ITEM, ListEntry);
    }

    WARN("IniReadSettingByName() Setting \'%s\' not found.\n", SettingName);

    return FALSE;
}

Referenced by GetDefaultOperatingSystem(), GetTimeOut(), LoadAndBootWindows(), LoadOperatingSystem(), LoadReactOSSetup(), and UiInitialize().

IniReadSettingByNumber()

BOOLEAN IniReadSettingByNumber	(	ULONG_PTR	SectionId,
		ULONG	SettingNumber,
		PCHAR	SettingName,
		ULONG	NameSize,
		PCHAR	SettingValue,
		ULONG	ValueSize
	)

Definition at line 114 of file inifile.c.

{
    PINI_SECTION_ITEM    SectionItem;
    TRACE(".001 NameSize = %d ValueSize = %d\n", NameSize, ValueSize);

    TRACE("IniReadSettingByNumber() SectionId = 0x%x\n", SectionId);

    // Retrieve requested setting
    SectionItem = IniGetSettingByNumber(SectionId, SettingNumber);
    if (!SectionItem)
    {
        TRACE("IniReadSettingByNumber() Setting number %d not found.\n", SettingNumber);
        return FALSE;
    }

    TRACE("IniReadSettingByNumber() Setting number %d found.\n", SettingNumber);
    TRACE("IniReadSettingByNumber() Setting name = %s\n", SectionItem->ItemName);
    TRACE("IniReadSettingByNumber() Setting value = %s\n", SectionItem->ItemValue);

    TRACE("1 NameSize = %d ValueSize = %d\n", NameSize, ValueSize);
    TRACE("2 NameSize = %d ValueSize = %d\n", NameSize, ValueSize);
    strncpy(SettingName, SectionItem->ItemName, NameSize - 1);
    SettingName[NameSize - 1] = '\0';
    TRACE("3 NameSize = %d ValueSize = %d\n", NameSize, ValueSize);
    strncpy(SettingValue, SectionItem->ItemValue, ValueSize - 1);
    SettingValue[ValueSize - 1] = '\0';
    TRACE("4 NameSize = %d ValueSize = %d\n", NameSize, ValueSize);
    DbgDumpBuffer(DPRINT_INIFILE, SettingName, NameSize);
    DbgDumpBuffer(DPRINT_INIFILE, SettingValue, ValueSize);

    return TRUE;
}

Referenced by DriveMapMapDrivesInSection(), InitOperatingSystemList(), and UiShowMessageBoxesInSection().

Variable Documentation

IniFileSectionCount

ULONG IniFileSectionCount

Definition at line 27 of file parse.c.

Referenced by IniAddSection(), and IniParseFile().

IniFileSectionInitialized

BOOLEAN IniFileSectionInitialized

Definition at line 26 of file parse.c.

Referenced by IniParseFile().

IniFileSectionListHead

LIST_ENTRY IniFileSectionListHead

Definition at line 25 of file parse.c.

Referenced by IniAddSection(), IniCleanup(), IniOpenSection(), and IniParseFile().

IniFileSettingCount

ULONG IniFileSettingCount

Definition at line 28 of file parse.c.

Referenced by IniParseFile().