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 (PCSTR IniFileData, ULONG IniFileSize)
ULONG	IniGetNextLineSize (PCSTR IniFileData, ULONG IniFileSize, ULONG CurrentOffset)
ULONG	IniGetNextLine (PCSTR IniFileData, ULONG IniFileSize, PCHAR Buffer, ULONG BufferSize, ULONG CurrentOffset)
BOOLEAN	IniIsLineEmpty (PCSTR TextLine, ULONG TextLength)
BOOLEAN	IniIsCommentLine (PCSTR TextLine, ULONG TextLength)
BOOLEAN	IniIsSectionName (PCSTR TextLine, ULONG TextLength)
ULONG	IniGetSectionNameSize (PCSTR SectionNameLine, ULONG LineLength)
VOID	IniExtractSectionName (PSTR SectionName, PCSTR SectionNameLine, ULONG LineLength)
BOOLEAN	IniIsSetting (PCSTR TextLine, ULONG TextLength)
ULONG	IniGetSettingNameSize (PCSTR SettingNameLine, ULONG LineLength)
ULONG	IniGetSettingValueSize (PCSTR SettingValueLine, ULONG LineLength)
VOID	IniExtractSettingName (PSTR SettingName, PCSTR SettingNameLine, ULONG LineLength)
VOID	IniExtractSettingValue (PSTR SettingValue, PCSTR 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)
BOOLEAN	IniModifySettingValue (ULONG_PTR SectionId, PCSTR SettingName, PCSTR SettingValue)
VOID	IniCleanup (VOID)
PLIST_ENTRY	IniGetFileSectionListHead (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 187 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;
}

IniAddSettingValueToSection()

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

Definition at line 260 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 EditCustomBootReactOS(), IniModifySettingValue(), and InitOperatingSystemList().

IniCleanup()

VOID IniCleanup

(

VOID

)

Definition at line 243 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(), and RunLoader().

IniExtractSectionName()

VOID IniExtractSectionName	(	PSTR	SectionName,
		PCSTR	SectionNameLine,
		ULONG	LineLength
	)

Definition at line 315 of file parse.c.

{
    ULONG Idx, DestIdx;
 
    // Find the opening bracket (skipping whitespace)
    for (Idx = 0; Idx < LineLength; ++Idx)
    {
        if ((SectionNameLine[Idx] == ' ') || (SectionNameLine[Idx] == '\t'))
            continue;
 
        //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;
 
        // Copy the character
        SectionName[DestIdx] = SectionNameLine[Idx];
        ++DestIdx;
    }
 
    // Terminate the string
    SectionName[DestIdx] = '\0';
}

Referenced by IniParseFile().

IniExtractSettingName()

VOID IniExtractSettingName	(	PSTR	SettingName,
		PCSTR	SettingNameLine,
		ULONG	LineLength
	)

Definition at line 423 of file parse.c.

{
    ULONG Idx, DestIdx;
 
    // Skip whitespace
    for (Idx = 0; Idx < LineLength; ++Idx)
    {
        if ((SettingNameLine[Idx] == ' ') || (SettingNameLine[Idx] == '\t'))
            continue;
        break;
    }
 
    // Get the characters up until the '=' equals sign or EOL
    for (DestIdx = 0; Idx < LineLength; ++Idx)
    {
        if ((SettingNameLine[Idx] == '=') || (SettingNameLine[Idx] == '\0'))
        {
            // Before ending, trim any trailing whitespace
            for (; DestIdx > 0; --DestIdx)
            {
                if ((SettingName[DestIdx-1] == ' ') || (SettingName[DestIdx-1] == '\t'))
                    continue;
                break;
            }
            break;
        }
 
        // Copy the character
        SettingName[DestIdx] = SettingNameLine[Idx];
        ++DestIdx;
    }
 
    // Terminate the string
    SettingName[DestIdx] = '\0';
}

Referenced by IniParseFile().

IniExtractSettingValue()

VOID IniExtractSettingValue	(	PSTR	SettingValue,
		PCSTR	SettingValueLine,
		ULONG	LineLength
	)

Definition at line 459 of file parse.c.

{
    ULONG Idx, DestIdx;
 
    // Skip whitespace
    for (Idx = 0; Idx < LineLength; ++Idx)
    {
        if ((SettingValueLine[Idx] == ' ') || (SettingValueLine[Idx] == '\t'))
            continue;
        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;
 
        // Copy the character
        SettingValue[DestIdx] = SettingValueLine[Idx];
        ++DestIdx;
    }
 
    // Terminate the string
    SettingValue[DestIdx] = '\0';
}

Referenced by IniParseFile().

IniFileInitialize()

BOOLEAN IniFileInitialize

(

VOID

)

Definition at line 25 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");
 
    /* Try to open freeldr.ini */
    Status = FsOpenFile("freeldr.ini", FrLdrBootPath, OpenReadOnly, &FileId);
    if (Status != ESUCCESS)
    {
        ERR("Error while opening freeldr.ini, Status: %d\n", Status);
 
        /* Try to open boot.ini */
        Status = FsOpenFile("boot.ini", FrLdrBootPath, OpenReadOnly, &FileId);
        if (Status != ESUCCESS)
        {
            ERR("Error while opening boot.ini, Status: %d\n", Status);
            UiMessageBoxCritical("Error opening freeldr.ini/boot.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.");
        ArcClose(FileId);
        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;
    }
 
    /* Load freeldr.ini from the disk */
    Status = ArcRead(FileId, FreeLoaderIniFileData, FreeLoaderIniFileSize, &Count);
    if (Status != ESUCCESS || Count != FreeLoaderIniFileSize)
    {
        ERR("Error while reading freeldr.ini, Status: %d\n", Status);
        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().

IniGetFileSectionListHead()

PLIST_ENTRY IniGetFileSectionListHead

(

VOID

)

Definition at line 25 of file inifile.c.

{
    return &IniFileSectionListHead;
}

Referenced by LoadSettings().

IniGetNextLine()

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

Definition at line 202 of file parse.c.

{
    ULONG Idx;
 
    // Loop through grabbing chars until we hit the end
    // of the file or we encounter a newline character
    for (Idx = 0; (CurrentOffset < IniFileSize); ++CurrentOffset)
    {
        // If we haven't exceeded our buffer size yet
        // then store another character
        if (Idx < (BufferSize - 1))
            Buffer[Idx++] = IniFileData[CurrentOffset];
 
        // Check for newline character
        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';
 
    return CurrentOffset;
}

Referenced by IniParseFile().

IniGetNextLineSize()

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

Definition at line 181 of file parse.c.

{
    ULONG LineCharCount = 0;
 
    // Loop through counting chars until we hit the end
    // of the file or we encounter a newline character
    for (; (CurrentOffset < IniFileSize); ++CurrentOffset)
    {
        // Increment the line character count
        ++LineCharCount;
 
        // Check for newline character
        if (IniFileData[CurrentOffset] == '\n')
            break;
    }
    // Count the NUL-terminator
    ++LineCharCount;
 
    return LineCharCount;
}

Referenced by IniParseFile().

IniGetNumSectionItems()

ULONG IniGetNumSectionItems

(

ULONG_PTR

SectionId

)

Definition at line 60 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 BuildArgvForOsLoader(), InitOperatingSystemList(), and UiShowMessageBoxesInSection().

IniGetSectionNameSize()

ULONG IniGetSectionNameSize	(	PCSTR	SectionNameLine,
		ULONG	LineLength
	)

Definition at line 286 of file parse.c.

{
    ULONG Idx, NameSize;
 
    // Find the opening bracket (skipping whitespace)
    for (Idx = 0; Idx < LineLength; ++Idx)
    {
        if ((SectionNameLine[Idx] == ' ') || (SectionNameLine[Idx] == '\t'))
            continue;
 
        //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;
        ++NameSize;
    }
    // Count the NUL-terminator
    ++NameSize;
 
    return NameSize;
}

Referenced by IniParseFile().

IniGetSectionSettingNameSize()

ULONG IniGetSectionSettingNameSize	(	ULONG_PTR	SectionId,
		ULONG	SettingIndex
	)

Definition at line 95 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);
}

Referenced by BuildArgvForOsLoader().

IniGetSectionSettingValueSize()

ULONG IniGetSectionSettingValueSize	(	ULONG_PTR	SectionId,
		ULONG	SettingIndex
	)

Definition at line 108 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 BuildArgvForOsLoader(), and UiShowMessageBoxesInSection().

IniGetSettingNameSize()

ULONG IniGetSettingNameSize	(	PCSTR	SettingNameLine,
		ULONG	LineLength
	)

Definition at line 359 of file parse.c.

{
    ULONG Idx, NameSize;
 
    // Skip whitespace
    for (Idx = 0; Idx < LineLength; ++Idx)
    {
        if ((SettingNameLine[Idx] == ' ') || (SettingNameLine[Idx] == '\t'))
            continue;
        break;
    }
 
    // Count the characters up until the '=' equals sign or EOL
    for (NameSize = 0; Idx < LineLength; ++Idx)
    {
        if ((SettingNameLine[Idx] == '=') || (SettingNameLine[Idx] == '\0'))
            break;
        ++NameSize;
    }
    // Count the NUL-terminator
    ++NameSize;
 
    return NameSize;
}

Referenced by IniParseFile().

IniGetSettingValueSize()

ULONG IniGetSettingValueSize	(	PCSTR	SettingValueLine,
		ULONG	LineLength
	)

Definition at line 384 of file parse.c.

{
    ULONG Idx, ValueSize;
 
    // Skip whitespace
    for (Idx = 0; Idx < LineLength; ++Idx)
    {
        if ((SettingValueLine[Idx] == ' ') || (SettingValueLine[Idx] == '\t'))
            continue;
        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;
        ++ValueSize;
    }
    // Count the NUL-terminator
    ++ValueSize;
 
    return ValueSize;
}

Referenced by IniParseFile().

IniIsCommentLine()

BOOLEAN IniIsCommentLine	(	PCSTR	TextLine,
		ULONG	TextLength
	)

Definition at line 250 of file parse.c.

{
    ULONG Idx;
 
    // Check the first character (skipping whitespace)
    // and make sure that it is a comment character
    for (Idx = 0; Idx < TextLength; ++Idx)
    {
        if ((TextLine[Idx] == ' ') || (TextLine[Idx] == '\t'))
            continue;
 
        if (TextLine[Idx] == INI_FILE_COMMENT_CHAR)
            return TRUE;
        break;
    }
    return FALSE;
}

Referenced by IniParseFile().

IniIsLineEmpty()

BOOLEAN IniIsLineEmpty	(	PCSTR	TextLine,
		ULONG	TextLength
	)

Definition at line 233 of file parse.c.

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

Referenced by IniParseFile().

IniIsSectionName()

BOOLEAN IniIsSectionName	(	PCSTR	TextLine,
		ULONG	TextLength
	)

Definition at line 268 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 ((TextLine[Idx] == ' ') || (TextLine[Idx] == '\t'))
            continue;
 
        if (TextLine[Idx] == '[')
            return TRUE;
        break;
    }
    return FALSE;
}

Referenced by IniParseFile().

IniIsSetting()

BOOLEAN IniIsSetting	(	PCSTR	TextLine,
		ULONG	TextLength
	)

Definition at line 346 of file parse.c.

{
    ULONG Idx;
 
    // Just check for an '=' equals sign
    for (Idx = 0; Idx < TextLength; ++Idx)
    {
        if (TextLine[Idx] == '=')
            return TRUE;
    }
    return FALSE;
}

Referenced by IniParseFile().

IniModifySettingValue()

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

Definition at line 301 of file inifile.c.

{
    PINI_SECTION Section = (PINI_SECTION)SectionId;
    PLIST_ENTRY Entry;
    PINI_SECTION_ITEM SectionItem;
    PCHAR NewItemValue;
 
    // Loop through each section item and find the one we want
    for (Entry = Section->SectionItemList.Flink;
         Entry != &Section->SectionItemList;
         Entry = Entry->Flink)
    {
        SectionItem = CONTAINING_RECORD(Entry, INI_SECTION_ITEM, ListEntry);
 
        // Check to see if this is the setting we want
        if (_stricmp(SectionItem->ItemName, SettingName) == 0)
        {
            break;
        }
        // Nope, keep going
    }
    // If the section item does not exist, create it
    if (Entry == &Section->SectionItemList)
    {
        return IniAddSettingValueToSection(SectionId, SettingName, SettingValue);
    }
 
    // Reallocate the new setting value buffer
    NewItemValue = FrLdrTempAlloc(strlen(SettingValue) + 1, TAG_INI_VALUE);
    if (!NewItemValue)
    {
        // We failed, bail out
        return FALSE;
    }
    FrLdrTempFree(SectionItem->ItemValue, TAG_INI_VALUE);
    SectionItem->ItemValue = NewItemValue;
 
    strcpy(SectionItem->ItemValue, SettingValue);
 
    return TRUE;
}

Referenced by EditCustomBootReactOS(), GetOSLoadingMethod(), and InitOperatingSystemList().

IniOpenSection()

BOOLEAN IniOpenSection	(	PCSTR	SectionName,
		ULONG_PTR *	SectionId
	)

Definition at line 30 of file inifile.c.

{
    PLIST_ENTRY Entry;
    PINI_SECTION Section;
 
    TRACE("IniOpenSection() SectionName = %s\n", SectionName);
 
    // Loop through each section and find the one we want
    for (Entry = IniFileSectionListHead.Flink;
         Entry != &IniFileSectionListHead;
         Entry = Entry->Flink)
    {
        Section = CONTAINING_RECORD(Entry, INI_SECTION, ListEntry);
 
        // 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;
        }
    }
 
    TRACE("IniOpenSection() Section not found.\n");
 
    return FALSE;
}

Referenced by InitOperatingSystemList(), LoadSettings(), and UiInitialize().

IniParseFile()

BOOLEAN IniParseFile	(	PCSTR	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)
            {
                ERR("Error: freeldr.ini:%lu: Setting '%s' found outside of a [section].\n", CurrentLineNumber, IniFileLine);
 
                // Skip it
                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 154 of file inifile.c.

{
    PINI_SECTION Section = (PINI_SECTION)SectionId;
    PLIST_ENTRY Entry;
    PINI_SECTION_ITEM SectionItem;
 
    TRACE("IniReadSettingByName() SectionId = 0x%x\n", SectionId);
 
    // Loop through each section item and find the one we want
    for (Entry = Section->SectionItemList.Flink;
         Entry != &Section->SectionItemList;
         Entry = Entry->Flink)
    {
        SectionItem = CONTAINING_RECORD(Entry, INI_SECTION_ITEM, ListEntry);
 
        // Check to see if this is the setting we 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;
        }
    }
 
    WARN("IniReadSettingByName() Setting \'%s\' not found.\n", SettingName);
 
    return FALSE;
}

Referenced by EditCustomBootReactOS(), GetOSLoadingMethod(), InitOperatingSystemList(), LoadSettings(), and UiInitialize().

IniReadSettingByNumber()

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

Definition at line 121 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 BuildArgvForOsLoader(), InitOperatingSystemList(), and UiShowMessageBoxesInSection().

Variable Documentation

IniFileSectionCount

ULONG IniFileSectionCount

extern

Definition at line 27 of file parse.c.

Referenced by IniAddSection(), and IniParseFile().

IniFileSectionInitialized

BOOLEAN IniFileSectionInitialized

extern

Definition at line 26 of file parse.c.

Referenced by IniParseFile().

IniFileSectionListHead

LIST_ENTRY IniFileSectionListHead

extern

Definition at line 25 of file parse.c.

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

IniFileSettingCount

ULONG IniFileSettingCount

extern

Definition at line 28 of file parse.c.

Referenced by IniParseFile().