inicache.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_KEYWORD
struct	_INI_SECTION
struct	_INICACHE
struct	_PINICACHEITERATOR

Typedefs
typedef struct _INI_KEYWORD	INI_KEYWORD
typedef struct _INI_KEYWORD *	PINI_KEYWORD
typedef struct _INI_SECTION	INI_SECTION
typedef struct _INI_SECTION *	PINI_SECTION
typedef struct _INICACHE	INICACHE
typedef struct _INICACHE *	PINICACHE
typedef struct _PINICACHEITERATOR	INICACHEITERATOR
typedef struct _PINICACHEITERATOR *	PINICACHEITERATOR

Enumerations
enum	INSERTION_TYPE { INSERT_FIRST , INSERT_BEFORE , INSERT_AFTER , INSERT_LAST }

Functions
NTSTATUS	IniCacheLoadFromMemory (PINICACHE *Cache, PCHAR FileBuffer, ULONG FileLength, BOOLEAN String)
NTSTATUS	IniCacheLoadByHandle (PINICACHE *Cache, HANDLE FileHandle, BOOLEAN String)
NTSTATUS	IniCacheLoad (PINICACHE *Cache, PWCHAR FileName, BOOLEAN String)
VOID	IniCacheDestroy (_In_ PINICACHE Cache)
PINI_SECTION	IniGetSection (_In_ PINICACHE Cache, _In_ PCWSTR Name)
PINI_KEYWORD	IniGetKey (_In_ PINI_SECTION Section, _In_ PCWSTR KeyName, _Out_ PCWSTR *KeyData)
PINICACHEITERATOR	IniFindFirstValue (_In_ PINI_SECTION Section, _Out_ PCWSTR *KeyName, _Out_ PCWSTR *KeyData)
BOOLEAN	IniFindNextValue (_In_ PINICACHEITERATOR Iterator, _Out_ PCWSTR *KeyName, _Out_ PCWSTR *KeyData)
VOID	IniFindClose (_In_ PINICACHEITERATOR Iterator)
PINI_SECTION	IniAddSection (_In_ PINICACHE Cache, _In_ PCWSTR Name)
VOID	IniRemoveSection (_In_ PINI_SECTION Section)
PINI_KEYWORD	IniInsertKey (_In_ PINI_SECTION Section, _In_ PINI_KEYWORD AnchorKey, _In_ INSERTION_TYPE InsertionType, _In_ PCWSTR Name, _In_ PCWSTR Data)
PINI_KEYWORD	IniAddKey (_In_ PINI_SECTION Section, _In_ PCWSTR Name, _In_ PCWSTR Data)
VOID	IniRemoveKeyByName (_In_ PINI_SECTION Section, _In_ PCWSTR KeyName)
VOID	IniRemoveKey (_In_ PINI_SECTION Section, _In_ PINI_KEYWORD Key)
PINICACHE	IniCacheCreate (VOID)
NTSTATUS	IniCacheSaveByHandle (PINICACHE Cache, HANDLE FileHandle)
NTSTATUS	IniCacheSave (PINICACHE Cache, PWCHAR FileName)

Typedef Documentation

INI_KEYWORD

typedef struct _INI_KEYWORD INI_KEYWORD

INI_SECTION

typedef struct _INI_SECTION INI_SECTION

INICACHE

typedef struct _INICACHE INICACHE

INICACHEITERATOR

typedef struct _PINICACHEITERATOR INICACHEITERATOR

PINI_KEYWORD

typedef struct _INI_KEYWORD * PINI_KEYWORD

PINI_SECTION

typedef struct _INI_SECTION * PINI_SECTION

PINICACHE

typedef struct _INICACHE * PINICACHE

PINICACHEITERATOR

typedef struct _PINICACHEITERATOR * PINICACHEITERATOR

Enumeration Type Documentation

INSERTION_TYPE

enum INSERTION_TYPE

Enumerator
INSERT_FIRST
INSERT_BEFORE
INSERT_AFTER
INSERT_LAST

Definition at line 35 of file inicache.h.

{
    INSERT_FIRST,
    INSERT_BEFORE,
    INSERT_AFTER,
    INSERT_LAST
} INSERTION_TYPE;

Function Documentation

IniAddKey()

PINI_KEYWORD IniAddKey	(	_In_ PINI_SECTION	Section,
		_In_ PCWSTR	Name,
		_In_ PCWSTR	Data
	)

Definition at line 883 of file inicache.c.

{
    return IniInsertKey(Section, NULL, INSERT_LAST, Name, Data);
}

Referenced by AddBootStoreEntry(), CreateCommonFreeLdrSections(), CreateNTOSEntry(), FreeLdrMigrateBootDrivePart(), InstallSetupInfFile(), and SetBootStoreOptions().

IniAddSection()

PINI_SECTION IniAddSection	(	_In_ PINICACHE	Cache,
		_In_ PCWSTR	Name
	)

Definition at line 838 of file inicache.c.

{
    if (!Cache || !Name || !*Name)
    {
        DPRINT("Invalid parameter\n");
        return NULL;
    }
    return IniCacheAddSectionAorW(Cache, Name, wcslen(Name), TRUE);
}

Referenced by CreateCommonFreeLdrSections(), CreateNTOSEntry(), EditCustomBootReactOS(), InitOperatingSystemList(), InstallSetupInfFile(), and OpenIniBootLoaderStore().

IniCacheCreate()

PINICACHE IniCacheCreate

(

VOID

)

Definition at line 919 of file inicache.c.

{
    PINICACHE Cache;
 
    /* Allocate inicache header */
    Cache = (PINICACHE)RtlAllocateHeap(ProcessHeap,
                                       HEAP_ZERO_MEMORY,
                                       sizeof(INICACHE));
    if (!Cache)
    {
        DPRINT("RtlAllocateHeap() failed\n");
        return NULL;
    }
    InitializeListHead(&Cache->SectionList);
 
    return Cache;
}

Referenced by IniCacheLoadFromMemory(), InstallSetupInfFile(), and OpenIniBootLoaderStore().

IniCacheDestroy()

VOID IniCacheDestroy

(

_In_ PINICACHE

Cache

)

Definition at line 699 of file inicache.c.

{
    if (!Cache)
        return;
 
    while (!IsListEmpty(&Cache->SectionList))
    {
        PLIST_ENTRY Entry = RemoveHeadList(&Cache->SectionList);
        PINI_SECTION Section = CONTAINING_RECORD(Entry, INI_SECTION, ListEntry);
        IniCacheFreeSection(Section);
    }
 
    RtlFreeHeap(ProcessHeap, 0, Cache);
}

Referenced by CloseIniBootLoaderStore(), and InstallSetupInfFile().

IniCacheLoad()

NTSTATUS IniCacheLoad	(	PINICACHE *	Cache,
		PWCHAR	FileName,
		BOOLEAN	String
	)

Definition at line 655 of file inicache.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE FileHandle;
 
    *Cache = NULL;
 
    /* Open the INI file */
    RtlInitUnicodeString(&Name, FileName);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtOpenFile(&FileHandle,
                        FILE_GENERIC_READ | SYNCHRONIZE,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ,
                        FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("NtOpenFile() failed (Status %lx)\n", Status);
        return Status;
    }
 
    DPRINT("NtOpenFile() successful\n");
 
    Status = IniCacheLoadByHandle(Cache, FileHandle, String);
 
    /* Close the INI file */
    NtClose(FileHandle);
    return Status;
}

Referenced by InstallSetupInfFile().

IniCacheLoadByHandle()

NTSTATUS IniCacheLoadByHandle	(	PINICACHE *	Cache,
		HANDLE	FileHandle,
		BOOLEAN	String
	)

Definition at line 581 of file inicache.c.

{
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatusBlock;
    FILE_STANDARD_INFORMATION FileInfo;
    PCHAR FileBuffer;
    ULONG FileLength;
    LARGE_INTEGER FileOffset;
 
    *Cache = NULL;
 
    /* Query file size */
    Status = NtQueryInformationFile(FileHandle,
                                    &IoStatusBlock,
                                    &FileInfo,
                                    sizeof(FILE_STANDARD_INFORMATION),
                                    FileStandardInformation);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("NtQueryInformationFile() failed (Status %lx)\n", Status);
        return Status;
    }
 
    FileLength = FileInfo.EndOfFile.u.LowPart;
 
    DPRINT("File size: %lu\n", FileLength);
 
    /* Allocate file buffer with NULL-terminator */
    FileBuffer = (PCHAR)RtlAllocateHeap(ProcessHeap,
                                        0,
                                        FileLength + 1);
    if (FileBuffer == NULL)
    {
        DPRINT1("RtlAllocateHeap() failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Read file */
    FileOffset.QuadPart = 0ULL;
    Status = NtReadFile(FileHandle,
                        NULL,
                        NULL,
                        NULL,
                        &IoStatusBlock,
                        FileBuffer,
                        FileLength,
                        &FileOffset,
                        NULL);
 
    /* Append NULL-terminator */
    FileBuffer[FileLength] = 0;
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("NtReadFile() failed (Status %lx)\n", Status);
        goto Quit;
    }
 
    Status = IniCacheLoadFromMemory(Cache, FileBuffer, FileLength, String);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IniCacheLoadFromMemory() failed (Status %lx)\n", Status);
    }
 
Quit:
    /* Free the file buffer, and return */
    RtlFreeHeap(ProcessHeap, 0, FileBuffer);
    return Status;
}

Referenced by IniCacheLoad(), and OpenIniBootLoaderStore().

IniCacheLoadFromMemory()

NTSTATUS IniCacheLoadFromMemory	(	PINICACHE *	Cache,
		PCHAR	FileBuffer,
		ULONG	FileLength,
		BOOLEAN	String
	)

Definition at line 487 of file inicache.c.

{
    PCHAR Ptr;
 
    PINI_SECTION Section;
    PINI_KEYWORD Key;
 
    PCHAR SectionName;
    ULONG SectionNameSize;
 
    PCHAR KeyName;
    ULONG KeyNameSize;
 
    PCHAR KeyValue;
    ULONG KeyValueSize;
 
    /* Allocate inicache header */
    *Cache = IniCacheCreate();
    if (!*Cache)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Parse ini file */
    Section = NULL;
    Ptr = FileBuffer;
    while (Ptr != NULL && *Ptr != 0)
    {
        Ptr = IniCacheSkipWhitespace(Ptr);
        if (Ptr == NULL)
            continue;
 
        if (*Ptr == '[')
        {
            Section = NULL;
            Ptr++;
 
            Ptr = IniCacheGetSectionName(Ptr,
                                         &SectionName,
                                         &SectionNameSize);
 
            DPRINT("[%.*s]\n", SectionNameSize, SectionName);
 
            Section = IniCacheAddSectionAorW(*Cache,
                                             SectionName,
                                             SectionNameSize,
                                             FALSE);
            if (Section == NULL)
            {
                DPRINT("IniCacheAddSectionAorW() failed\n");
                Ptr = IniCacheSkipToNextSection(Ptr);
                continue;
            }
        }
        else
        {
            if (Section == NULL)
            {
                Ptr = IniCacheSkipToNextSection(Ptr);
                continue;
            }
 
            Ptr = IniCacheGetKeyName(Ptr,
                                     &KeyName,
                                     &KeyNameSize);
 
            Ptr = IniCacheGetKeyValue(Ptr,
                                      &KeyValue,
                                      &KeyValueSize,
                                      String);
 
            DPRINT("'%.*s' = '%.*s'\n", KeyNameSize, KeyName, KeyValueSize, KeyValue);
 
            Key = IniCacheAddKeyAorW(Section,
                                     NULL,
                                     INSERT_LAST,
                                     KeyName,
                                     KeyNameSize,
                                     KeyValue,
                                     KeyValueSize,
                                     FALSE);
            if (Key == NULL)
            {
                DPRINT("IniCacheAddKeyAorW() failed\n");
            }
        }
    }
 
    return STATUS_SUCCESS;
}

Referenced by IniCacheLoadByHandle(), and OpenIniBootLoaderStore().

IniCacheSave()

NTSTATUS IniCacheSave	(	PINICACHE	Cache,
		PWCHAR	FileName
	)

Definition at line 1038 of file inicache.c.

{
    NTSTATUS Status;
    UNICODE_STRING Name;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    HANDLE FileHandle;
 
    /* Create the INI file */
    RtlInitUnicodeString(&Name, FileName);
 
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = NtCreateFile(&FileHandle,
                          FILE_GENERIC_WRITE | SYNCHRONIZE,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          FILE_ATTRIBUTE_NORMAL,
                          0,
                          FILE_SUPERSEDE,
                          FILE_SYNCHRONOUS_IO_NONALERT | FILE_SEQUENTIAL_ONLY | FILE_NON_DIRECTORY_FILE,
                          NULL,
                          0);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("NtCreateFile() failed (Status %lx)\n", Status);
        return Status;
    }
 
    Status = IniCacheSaveByHandle(Cache, FileHandle);
 
    /* Close the INI file */
    NtClose(FileHandle);
    return Status;
}

Referenced by InstallSetupInfFile().

IniCacheSaveByHandle()

NTSTATUS IniCacheSaveByHandle	(	PINICACHE	Cache,
		HANDLE	FileHandle
	)

Definition at line 938 of file inicache.c.

{
    NTSTATUS Status;
    PLIST_ENTRY Entry1, Entry2;
    PINI_SECTION Section;
    PINI_KEYWORD Key;
    ULONG BufferSize;
    PCHAR Buffer;
    PCHAR Ptr;
    ULONG Len;
    IO_STATUS_BLOCK IoStatusBlock;
    LARGE_INTEGER Offset;
 
    /* Calculate required buffer size */
    BufferSize = 0;
    Entry1 = Cache->SectionList.Flink;
    while (Entry1 != &Cache->SectionList)
    {
        Section = CONTAINING_RECORD(Entry1, INI_SECTION, ListEntry);
        BufferSize += (Section->Name ? wcslen(Section->Name) : 0)
                       + 4; /* "[]\r\n" */
 
        Entry2 = Section->KeyList.Flink;
        while (Entry2 != &Section->KeyList)
        {
            Key = CONTAINING_RECORD(Entry2, INI_KEYWORD, ListEntry);
            BufferSize += wcslen(Key->Name)
                          + (Key->Data ? wcslen(Key->Data) : 0)
                          + 3; /* "=\r\n" */
            Entry2 = Entry2->Flink;
        }
 
        Entry1 = Entry1->Flink;
        if (Entry1 != &Cache->SectionList)
            BufferSize += 2; /* Extra "\r\n" at end of each section */
    }
 
    DPRINT("BufferSize: %lu\n", BufferSize);
 
    /* Allocate file buffer with NULL-terminator */
    Buffer = (PCHAR)RtlAllocateHeap(ProcessHeap,
                                    HEAP_ZERO_MEMORY,
                                    BufferSize + 1);
    if (Buffer == NULL)
    {
        DPRINT1("RtlAllocateHeap() failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Fill file buffer */
    Ptr = Buffer;
    Entry1 = Cache->SectionList.Flink;
    while (Entry1 != &Cache->SectionList)
    {
        Section = CONTAINING_RECORD(Entry1, INI_SECTION, ListEntry);
        Len = sprintf(Ptr, "[%S]\r\n", Section->Name);
        Ptr += Len;
 
        Entry2 = Section->KeyList.Flink;
        while (Entry2 != &Section->KeyList)
        {
            Key = CONTAINING_RECORD(Entry2, INI_KEYWORD, ListEntry);
            Len = sprintf(Ptr, "%S=%S\r\n", Key->Name, Key->Data);
            Ptr += Len;
            Entry2 = Entry2->Flink;
        }
 
        Entry1 = Entry1->Flink;
        if (Entry1 != &Cache->SectionList)
        {
            Len = sprintf(Ptr, "\r\n");
            Ptr += Len;
        }
    }
 
    /* Write to the INI file */
    Offset.QuadPart = 0LL;
    Status = NtWriteFile(FileHandle,
                         NULL,
                         NULL,
                         NULL,
                         &IoStatusBlock,
                         Buffer,
                         BufferSize,
                         &Offset,
                         NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("NtWriteFile() failed (Status %lx)\n", Status);
        RtlFreeHeap(ProcessHeap, 0, Buffer);
        return Status;
    }
 
    RtlFreeHeap(ProcessHeap, 0, Buffer);
    return STATUS_SUCCESS;
}

Referenced by CloseIniBootLoaderStore(), and IniCacheSave().

IniFindClose()

VOID IniFindClose

(

_In_ PINICACHEITERATOR

Iterator

)

Definition at line 828 of file inicache.c.

{
    if (!Iterator)
        return;
    RtlFreeHeap(ProcessHeap, 0, Iterator);
}

Referenced by FreeLdrEnumerateBootEntries(), FreeLdrMigrateBootDrivePart(), and NtLdrEnumerateBootEntries().

IniFindFirstValue()

PINICACHEITERATOR IniFindFirstValue	(	_In_ PINI_SECTION	Section,
		_Out_ PCWSTR *	KeyName,
		_Out_ PCWSTR *	KeyData
	)

Definition at line 756 of file inicache.c.

{
    PINICACHEITERATOR Iterator;
    PLIST_ENTRY Entry;
    PINI_KEYWORD Key;
 
    if (!Section || !KeyName || !KeyData)
    {
        DPRINT("Invalid parameter\n");
        return NULL;
    }
 
    Entry = Section->KeyList.Flink;
    if (Entry == &Section->KeyList)
    {
        DPRINT("Invalid parameter\n");
        return NULL;
    }
    Key = CONTAINING_RECORD(Entry, INI_KEYWORD, ListEntry);
 
    Iterator = (PINICACHEITERATOR)RtlAllocateHeap(ProcessHeap,
                                                  0,
                                                  sizeof(INICACHEITERATOR));
    if (!Iterator)
    {
        DPRINT("RtlAllocateHeap() failed\n");
        return NULL;
    }
    Iterator->Section = Section;
    Iterator->Key = Key;
 
    *KeyName = Key->Name;
    *KeyData = Key->Data;
 
    return Iterator;
}

Referenced by FreeLdrEnumerateBootEntries(), FreeLdrMigrateBootDrivePart(), and NtLdrEnumerateBootEntries().

IniFindNextValue()

BOOLEAN IniFindNextValue	(	_In_ PINICACHEITERATOR	Iterator,
		_Out_ PCWSTR *	KeyName,
		_Out_ PCWSTR *	KeyData
	)

Definition at line 797 of file inicache.c.

{
    PLIST_ENTRY Entry;
    PINI_KEYWORD Key;
 
    if (!Iterator || !KeyName || !KeyData)
    {
        DPRINT("Invalid parameter\n");
        return FALSE;
    }
 
    Entry = Iterator->Key->ListEntry.Flink;
    if (Entry == &Iterator->Section->KeyList)
    {
        DPRINT("No more entries\n");
        return FALSE;
    }
    Key = CONTAINING_RECORD(Entry, INI_KEYWORD, ListEntry);
 
    Iterator->Key = Key;
 
    *KeyName = Key->Name;
    *KeyData = Key->Data;
 
    return TRUE;
}

Referenced by FreeLdrEnumerateBootEntries(), FreeLdrMigrateBootDrivePart(), and NtLdrEnumerateBootEntries().

IniGetKey()

PINI_KEYWORD IniGetKey	(	_In_ PINI_SECTION	Section,
		_In_ PCWSTR	KeyName,
		_Out_ PCWSTR *	KeyData
	)

Definition at line 730 of file inicache.c.

{
    PINI_KEYWORD Key;
 
    if (!Section || !KeyName || !KeyData)
    {
        DPRINT("Invalid parameter\n");
        return NULL;
    }
 
    *KeyData = NULL;
 
    Key = IniCacheFindKey(Section, KeyName);
    if (!Key)
        return NULL;
 
    *KeyData = Key->Data;
 
    return Key;
}

Referenced by FreeLdrEnumerateBootEntries(), FreeLdrMigrateBootDrivePart(), FreeLdrMigrateBootDrivePartWorker(), and QueryBootStoreOptions().

IniGetSection()

PINI_SECTION IniGetSection	(	_In_ PINICACHE	Cache,
		_In_ PCWSTR	Name
	)

Definition at line 717 of file inicache.c.

{
    if (!Cache || !Name)
    {
        DPRINT("Invalid parameter\n");
        return NULL;
    }
    return IniCacheFindSection(Cache, Name);
}

Referenced by FreeLdrEnumerateBootEntries(), FreeLdrMigrateBootDrivePart(), and OpenIniBootLoaderStore().

IniInsertKey()

PINI_KEYWORD IniInsertKey	(	_In_ PINI_SECTION	Section,
		_In_ PINI_KEYWORD	AnchorKey,
		_In_ INSERTION_TYPE	InsertionType,
		_In_ PCWSTR	Name,
		_In_ PCWSTR	Data
	)

Definition at line 863 of file inicache.c.

{
    if (!Section || !Name || !*Name || !Data || !*Data)
    {
        DPRINT("Invalid parameter\n");
        return NULL;
    }
    return IniCacheAddKeyAorW(Section,
                              AnchorKey, InsertionType,
                              Name, wcslen(Name),
                              Data, wcslen(Data),
                              TRUE);
}

Referenced by FreeLdrMigrateBootDrivePartWorker(), and IniAddKey().

IniRemoveKey()

VOID IniRemoveKey	(	_In_ PINI_SECTION	Section,
		_In_ PINI_KEYWORD	Key
	)

Definition at line 905 of file inicache.c.

{
    UNREFERENCED_PARAMETER(Section);
    if (!Key)
    {
        DPRINT("Invalid parameter\n");
        return;
    }
    IniCacheFreeKey(Key);
}

IniRemoveKeyByName()

VOID IniRemoveKeyByName	(	_In_ PINI_SECTION	Section,
		_In_ PCWSTR	KeyName
	)

Definition at line 892 of file inicache.c.

{
    PINI_KEYWORD Key;
    UNREFERENCED_PARAMETER(Section);
 
    Key = IniCacheFindKey(Section, KeyName);
    if (Key)
        IniCacheFreeKey(Key);
}

Referenced by FreeLdrMigrateBootDrivePartWorker().

IniRemoveSection()

VOID IniRemoveSection

(

_In_ PINI_SECTION

Section

)

Definition at line 851 of file inicache.c.

{
    if (!Section)
    {
        DPRINT("Invalid parameter\n");
        return;
    }
    IniCacheFreeSection(Section);
}