inffile.c File Reference

#include <freeldr.h>
#include "inffile.h"

Include dependency graph for inffile.c:

Go to the source code of this file.

Classes
struct	_INFCACHEFIELD
struct	_INFCACHELINE
struct	_INFCACHESECTION
struct	_INFCACHE
struct	parser

Macros
#define	CONTROL_Z   '\x1a'
#define	MAX_SECTION_NAME_LEN   255
#define	MAX_FIELD_LEN   511 /* larger fields get silently truncated */
#define	MAX_STRING_LEN   (MAX_INF_STRING_LENGTH+1)
#define	TAG_INF_KEY   'KfnI'
#define	TAG_INF_FIELD   'ffnI'
#define	TAG_INF_LINE   'LfnI'
#define	TAG_INF_SECTION   'SfnI'
#define	TAG_INF_CACHE   'CfnI'
#define	TAG_INF_FILE   'FfnI'

Typedefs
typedef struct _INFCACHEFIELD	INFCACHEFIELD
typedef struct _INFCACHEFIELD *	PINFCACHEFIELD
typedef struct _INFCACHELINE	INFCACHELINE
typedef struct _INFCACHELINE *	PINFCACHELINE
typedef struct _INFCACHESECTION	INFCACHESECTION
typedef struct _INFCACHESECTION *	PINFCACHESECTION
typedef struct _INFCACHE	INFCACHE
typedef struct _INFCACHE *	PINFCACHE
typedef const CHAR *(*	parser_state_func) (struct parser *parser, const CHAR *pos)

Enumerations
enum	parser_state {   HEADER, PARSE_WIN31_LINE, LINE_START, KEY_NAME,   DELETE_KEY, DEFAULT_VALUE_NAME, QUOTED_VALUE_NAME, DATA_START,   DELETE_VALUE, DATA_TYPE, STRING_DATA, DWORD_DATA,   HEX_DATA, EOL_BACKSLASH, HEX_MULTILINE, UNKNOWN_DATA,   SET_VALUE, NB_PARSER_STATES, LINE_START, SECTION_NAME,   KEY_NAME, VALUE_NAME, EOL_BACKSLASH, QUOTES,   LEADING_SPACES, TRAILING_SPACES, COMMENT, NB_PARSER_STATES,   LINE_START, SECTION_NAME, KEY_NAME, VALUE_NAME,   EOL_BACKSLASH, QUOTES, LEADING_SPACES, TRAILING_SPACES,   COMMENT, NB_PARSER_STATES, LINE_START, SECTION_NAME,   KEY_NAME, VALUE_NAME, EOL_BACKSLASH, QUOTES,   LEADING_SPACES, TRAILING_SPACES, COMMENT, NB_PARSER_STATES }

Functions
static const CHAR *	line_start_state (struct parser *parser, const CHAR *pos)
static const CHAR *	section_name_state (struct parser *parser, const CHAR *pos)
static const CHAR *	key_name_state (struct parser *parser, const CHAR *pos)
static const CHAR *	value_name_state (struct parser *parser, const CHAR *pos)
static const CHAR *	eol_backslash_state (struct parser *parser, const CHAR *pos)
static const CHAR *	quotes_state (struct parser *parser, const CHAR *pos)
static const CHAR *	leading_spaces_state (struct parser *parser, const CHAR *pos)
static const CHAR *	trailing_spaces_state (struct parser *parser, const CHAR *pos)
static const CHAR *	comment_state (struct parser *parser, const CHAR *pos)
static PINFCACHELINE	InfpCacheFreeLine (PINFCACHELINE Line)
static PINFCACHESECTION	InfpCacheFreeSection (PINFCACHESECTION Section)
static PINFCACHESECTION	InfpCacheFindSection (PINFCACHE Cache, PCSTR Name)
static PINFCACHESECTION	InfpCacheAddSection (PINFCACHE Cache, PCHAR Name)
static PINFCACHELINE	InfpCacheAddLine (PINFCACHESECTION Section)
static PVOID	InfpAddKeyToLine (PINFCACHELINE Line, PCHAR Key)
static PVOID	InfpAddFieldToLine (PINFCACHELINE Line, PCHAR Data)
static PINFCACHELINE	InfpCacheFindKeyLine (PINFCACHESECTION Section, PCSTR Key)
static __inline void	push_state (struct parser *parser, enum parser_state state)
static __inline void	pop_state (struct parser *parser)
static __inline enum parser_state	set_state (struct parser *parser, enum parser_state state)
static __inline int	is_eof (struct parser *parser, const CHAR *ptr)
static __inline int	is_eol (struct parser *parser, const CHAR *ptr)
static int	push_token (struct parser *parser, const CHAR *pos)
static PVOID	add_section_from_token (struct parser *parser)
static struct field *	add_field_from_token (struct parser *parser, int is_key)
static VOID	close_current_line (struct parser *parser)
static BOOLEAN	InfpParseBuffer (PINFCACHE file, PCCHAR buffer, PCCHAR end, PULONG error_line)
BOOLEAN	InfOpenFile (PHINF InfHandle, PCSTR FileName, PULONG ErrorLine)
VOID	InfCloseFile (HINF InfHandle)
BOOLEAN	InfFindFirstLine (HINF InfHandle, PCSTR Section, PCSTR Key, PINFCONTEXT Context)
BOOLEAN	InfFindNextLine (PINFCONTEXT ContextIn, PINFCONTEXT ContextOut)
BOOLEAN	InfFindFirstMatchLine (PINFCONTEXT ContextIn, PCHAR Key, PINFCONTEXT ContextOut)
BOOLEAN	InfFindNextMatchLine (PINFCONTEXT ContextIn, PCHAR Key, PINFCONTEXT ContextOut)
LONG	InfGetLineCount (HINF InfHandle, PCHAR Section)
LONG	InfGetFieldCount (PINFCONTEXT Context)
BOOLEAN	InfGetBinaryField (PINFCONTEXT Context, ULONG FieldIndex, PUCHAR ReturnBuffer, ULONG ReturnBufferSize, PULONG RequiredSize)
BOOLEAN	InfGetIntField (PINFCONTEXT Context, ULONG FieldIndex, PLONG IntegerValue)
BOOLEAN	InfGetMultiSzField (PINFCONTEXT Context, ULONG FieldIndex, PCHAR ReturnBuffer, ULONG ReturnBufferSize, PULONG RequiredSize)
BOOLEAN	InfGetStringField (PINFCONTEXT Context, ULONG FieldIndex, PCHAR ReturnBuffer, ULONG ReturnBufferSize, PULONG RequiredSize)
BOOLEAN	InfGetData (PINFCONTEXT Context, PCHAR *Key, PCHAR *Data)
BOOLEAN	InfGetDataField (PINFCONTEXT Context, ULONG FieldIndex, PCSTR *Data)

Variables
static const parser_state_func	parser_funcs [NB_PARSER_STATES]

Macro Definition Documentation

CONTROL_Z

#define CONTROL_Z   '\x1a'

Definition at line 14 of file inffile.c.

MAX_FIELD_LEN

#define MAX_FIELD_LEN   511 /* larger fields get silently truncated */

Definition at line 16 of file inffile.c.

MAX_SECTION_NAME_LEN

#define MAX_SECTION_NAME_LEN   255

Definition at line 15 of file inffile.c.

MAX_STRING_LEN

#define MAX_STRING_LEN   (MAX_INF_STRING_LENGTH+1)

Definition at line 18 of file inffile.c.

TAG_INF_CACHE

#define TAG_INF_CACHE   'CfnI'

Definition at line 24 of file inffile.c.

TAG_INF_FIELD

#define TAG_INF_FIELD   'ffnI'

Definition at line 21 of file inffile.c.

TAG_INF_FILE

#define TAG_INF_FILE   'FfnI'

Definition at line 25 of file inffile.c.

TAG_INF_KEY

#define TAG_INF_KEY   'KfnI'

Definition at line 20 of file inffile.c.

TAG_INF_LINE

#define TAG_INF_LINE   'LfnI'

Definition at line 22 of file inffile.c.

TAG_INF_SECTION

#define TAG_INF_SECTION   'SfnI'

Definition at line 23 of file inffile.c.

Typedef Documentation

INFCACHE

typedef struct _INFCACHE INFCACHE

INFCACHEFIELD

typedef struct _INFCACHEFIELD INFCACHEFIELD

INFCACHELINE

typedef struct _INFCACHELINE INFCACHELINE

INFCACHESECTION

typedef struct _INFCACHESECTION INFCACHESECTION

parser_state_func

typedef const CHAR*(* parser_state_func) (struct parser *parser, const CHAR *pos)

Definition at line 102 of file inffile.c.

PINFCACHE

typedef struct _INFCACHE * PINFCACHE

PINFCACHEFIELD

typedef struct _INFCACHEFIELD * PINFCACHEFIELD

PINFCACHELINE

typedef struct _INFCACHELINE * PINFCACHELINE

PINFCACHESECTION

typedef struct _INFCACHESECTION * PINFCACHESECTION

Enumeration Type Documentation

parser_state

enum parser_state

Enumerator
HEADER
PARSE_WIN31_LINE
LINE_START
KEY_NAME
DELETE_KEY
DEFAULT_VALUE_NAME
QUOTED_VALUE_NAME
DATA_START
DELETE_VALUE
DATA_TYPE
STRING_DATA
DWORD_DATA
HEX_DATA
EOL_BACKSLASH
HEX_MULTILINE
UNKNOWN_DATA
SET_VALUE
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES
LINE_START
SECTION_NAME
KEY_NAME
VALUE_NAME
EOL_BACKSLASH
QUOTES
LEADING_SPACES
TRAILING_SPACES
COMMENT
NB_PARSER_STATES

Definition at line 71 of file inffile.c.

{
    LINE_START,      /* at beginning of a line */
    SECTION_NAME,    /* parsing a section name */
    KEY_NAME,        /* parsing a key name */
    VALUE_NAME,      /* parsing a value name */
    EOL_BACKSLASH,   /* backslash at end of line */
    QUOTES,          /* inside quotes */
    LEADING_SPACES,  /* leading spaces */
    TRAILING_SPACES, /* trailing spaces */
    COMMENT,         /* inside a comment */
    NB_PARSER_STATES
};

Function Documentation

add_field_from_token()

static struct field* add_field_from_token ( struct parser *  parser, int  is_key  )

static

Definition at line 490 of file inffile.c.

{
    PVOID field;

    if (!parser->line)  /* need to start a new line */
    {
        if (parser->cur_section == NULL)  /* got a line before the first section */
        {
            parser->error = STATUS_WRONG_INF_STYLE;
            return NULL;
        }

        parser->line = InfpCacheAddLine(parser->cur_section);
        if (parser->line == NULL)
            goto error;
    }
    else
    {
//      assert(!is_key);
    }

    if (is_key)
    {
        field = InfpAddKeyToLine(parser->line, parser->token);
    }
    else
    {
        field = InfpAddFieldToLine(parser->line, parser->token);
    }

    if (field != NULL)
    {
        parser->token_len = 0;
        return field;
    }

error:
    parser->error = FALSE;
    return NULL;
}

Referenced by key_name_state(), and value_name_state().

add_section_from_token()

static PVOID add_section_from_token ( struct parser *  parser )

static

Definition at line 458 of file inffile.c.

{
    PINFCACHESECTION Section;

    if (parser->token_len > MAX_SECTION_NAME_LEN)
    {
        parser->error = FALSE;
        return NULL;
    }

    Section = InfpCacheFindSection(parser->file, parser->token);
    if (Section == NULL)
    {
        /* need to create a new one */
        Section = InfpCacheAddSection(parser->file, parser->token);
        if (Section == NULL)
        {
            parser->error = FALSE;
            return NULL;
        }
    }

    parser->token_len = 0;
    parser->cur_section = Section;

    return (PVOID)Section;
}

Referenced by section_name_state().

close_current_line()

static VOID close_current_line ( struct parser *  parser )

static

Definition at line 537 of file inffile.c.

{
    parser->line = NULL;
}

Referenced by line_start_state().

comment_state()

static const CHAR * comment_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 862 of file inffile.c.

{
    const CHAR *p = pos;

    while (!is_eol(parser, p))
        p++;
    pop_state(parser);
    return p;
}

eol_backslash_state()

static const CHAR * eol_backslash_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 733 of file inffile.c.

{
    const CHAR *p;

    for (p = pos; !is_eof(parser, p); p++)
    {
        switch(*p)
        {
        case '\r':
            continue;

        case '\n':
            parser->line_pos++;
            parser->start = p + 1;
            set_state(parser, LEADING_SPACES);
            return p + 1;

        case '\\':
            continue;

        case ';':
            push_state(parser, EOL_BACKSLASH);
            set_state(parser, COMMENT);
            return p + 1;

        default:
            if (isspace((unsigned char)*p))
                continue;
            push_token(parser, p);
            pop_state(parser);
            return p;
        }
    }
    parser->start = p;
    pop_state(parser);

    return p;
}

InfCloseFile()

VOID InfCloseFile

(

HINF

InfHandle

)

Definition at line 1028 of file inffile.c.

{
    PINFCACHE Cache;

    Cache = (PINFCACHE)InfHandle;

    if (Cache == NULL)
    {
        return;
    }

    while (Cache->FirstSection != NULL)
    {
        Cache->FirstSection = InfpCacheFreeSection(Cache->FirstSection);
    }
    Cache->LastSection = NULL;

    FrLdrTempFree(Cache, TAG_INF_CACHE);
}

InfFindFirstLine()

BOOLEAN InfFindFirstLine	(	HINF	InfHandle,
		PCSTR	Section,
		PCSTR	Key,
		PINFCONTEXT	Context
	)

Definition at line 1050 of file inffile.c.

{
    PINFCACHE Cache;
    PINFCACHESECTION CacheSection;
    PINFCACHELINE CacheLine;

    if ((InfHandle == NULL) || (Section == NULL) || (Context == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    Cache = (PINFCACHE)InfHandle;

    /* Iterate through list of sections */
    CacheSection = Cache->FirstSection;
    while (CacheSection != NULL)
    {
//      DPRINT("Comparing '%s' and '%s'\n", CacheSection->Name, Section);

        /* Are the section names the same? */
        if (_stricmp(CacheSection->Name, Section) == 0)
        {
            if (Key != NULL)
            {
                CacheLine = InfpCacheFindKeyLine(CacheSection, Key);
            }
            else
            {
                CacheLine = CacheSection->FirstLine;
            }

            if (CacheLine == NULL)
                return FALSE;

            Context->Inf = (PVOID)Cache;
            Context->Section = (PVOID)CacheSection;
            Context->Line = (PVOID)CacheLine;

            return TRUE;
        }

        /* Get the next section */
        CacheSection = CacheSection->Next;
    }

//  DPRINT("Section not found\n");

    return FALSE;
}

Referenced by LoadReactOSSetup(), SetupFindFirstLineW(), SetupLdrInitErrataInf(), SetupLdrLoadNlsData(), and SetupLdrScanBootDrivers().

InfFindFirstMatchLine()

BOOLEAN InfFindFirstMatchLine	(	PINFCONTEXT	ContextIn,
		PCHAR	Key,
		PINFCONTEXT	ContextOut
	)

Definition at line 1135 of file inffile.c.

{
    PINFCACHELINE CacheLine;

    if ((ContextIn == NULL) || (ContextOut == NULL) || (Key == NULL) || (*Key == 0))
        return FALSE;

    if (ContextIn->Inf == NULL || ContextIn->Section == NULL)
        return FALSE;

    CacheLine = ((PINFCACHESECTION)(ContextIn->Section))->FirstLine;
    while (CacheLine != NULL)
    {
        if ((CacheLine->Key != NULL) && (_stricmp(CacheLine->Key, Key) == 0))
        {

            if (ContextIn != ContextOut)
            {
                ContextOut->Inf = ContextIn->Inf;
                ContextOut->Section = ContextIn->Section;
            }
            ContextOut->Line = (PVOID)CacheLine;

            return TRUE;
        }

        CacheLine = CacheLine->Next;
    }

    return FALSE;
}

InfFindNextLine()

BOOLEAN InfFindNextLine	(	PINFCONTEXT	ContextIn,
		PINFCONTEXT	ContextOut
	)

Definition at line 1107 of file inffile.c.

{
    PINFCACHELINE CacheLine;

    if ((ContextIn == NULL) || (ContextOut == NULL))
        return FALSE;

    if (ContextIn->Line == NULL)
        return FALSE;

    CacheLine = (PINFCACHELINE)ContextIn->Line;
    if (CacheLine->Next == NULL)
        return FALSE;

    if (ContextIn != ContextOut)
    {
        ContextOut->Inf = ContextIn->Inf;
        ContextOut->Section = ContextIn->Section;
    }
    ContextOut->Line = (PVOID)(CacheLine->Next);

    return TRUE;
}

InfFindNextMatchLine()

BOOLEAN InfFindNextMatchLine	(	PINFCONTEXT	ContextIn,
		PCHAR	Key,
		PINFCONTEXT	ContextOut
	)

Definition at line 1172 of file inffile.c.

{
    PINFCACHELINE CacheLine;

    if ((ContextIn == NULL) || (ContextOut == NULL) || (Key == NULL) || (*Key == 0))
        return FALSE;

    if ((ContextIn->Inf == NULL) || (ContextIn->Section == NULL) || (ContextIn->Line == NULL))
        return FALSE;

    CacheLine = (PINFCACHELINE)ContextIn->Line;
    while (CacheLine != NULL)
    {
        if ((CacheLine->Key != NULL) && (_stricmp(CacheLine->Key, Key) == 0))
        {

            if (ContextIn != ContextOut)
            {
                ContextOut->Inf = ContextIn->Inf;
                ContextOut->Section = ContextIn->Section;
            }
            ContextOut->Line = (PVOID)CacheLine;

            return TRUE;
        }

        CacheLine = CacheLine->Next;
    }

    return FALSE;
}

InfGetBinaryField()

BOOLEAN InfGetBinaryField	(	PINFCONTEXT	Context,
		ULONG	FieldIndex,
		PUCHAR	ReturnBuffer,
		ULONG	ReturnBufferSize,
		PULONG	RequiredSize
	)

Definition at line 1260 of file inffile.c.

{
    PINFCACHELINE CacheLine;
    PINFCACHEFIELD CacheField;
    ULONG Index;
    ULONG Size;
    PUCHAR Ptr;

    if ((Context == NULL) || (Context->Line == NULL) || (FieldIndex == 0))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    if (RequiredSize != NULL)
        *RequiredSize = 0;

    CacheLine = (PINFCACHELINE)Context->Line;

    if (FieldIndex > CacheLine->FieldCount)
        return FALSE;

    CacheField = CacheLine->FirstField;
    for (Index = 1; Index < FieldIndex; Index++)
        CacheField = CacheField->Next;

    Size = CacheLine->FieldCount - FieldIndex + 1;

    if (RequiredSize != NULL)
        *RequiredSize = Size;

    if (ReturnBuffer != NULL)
    {
        if (ReturnBufferSize < Size)
            return FALSE;

        /* Copy binary data */
        Ptr = ReturnBuffer;
        while (CacheField != NULL)
        {
            *Ptr = (UCHAR)atoi(CacheField->Data); //strtoul(CacheField->Data, NULL, 16);

            Ptr++;
            CacheField = CacheField->Next;
        }
    }

    return TRUE;
}

InfGetData()

BOOLEAN InfGetData	(	PINFCONTEXT	Context,
		PCHAR *	Key,
		PCHAR *	Data
	)

Definition at line 1491 of file inffile.c.

{
    PINFCACHELINE CacheKey;

    if ((Context == NULL) || (Context->Line == NULL) || (Data == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    CacheKey = (PINFCACHELINE)Context->Line;
    if (Key != NULL)
        *Key = CacheKey->Key;

    *Data = (CacheKey->FirstField == NULL) ? NULL : CacheKey->FirstField->Data;

    return TRUE;
}

InfGetDataField()

BOOLEAN InfGetDataField	(	PINFCONTEXT	Context,
		ULONG	FieldIndex,
		PCSTR *	Data
	)

Definition at line 1515 of file inffile.c.

{
    PINFCACHELINE CacheLine;
    PINFCACHEFIELD CacheField;
    ULONG Index;

    if ((Context == NULL) || (Context->Line == NULL) || (Data == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    CacheLine = (PINFCACHELINE)Context->Line;

    if (FieldIndex > CacheLine->FieldCount)
        return FALSE;

    if (FieldIndex == 0)
    {
        *Data = CacheLine->Key;
    }
    else
    {
        CacheField = CacheLine->FirstField;
        for (Index = 1; Index < FieldIndex; Index++)
            CacheField = CacheField->Next;

        *Data = CacheField->Data;
    }

    return TRUE;
}

InfGetFieldCount()

LONG InfGetFieldCount

(

PINFCONTEXT

Context

)

Definition at line 1250 of file inffile.c.

{
    if ((Context == NULL) || (Context->Line == NULL))
        return 0;

    return ((PINFCACHELINE)Context->Line)->FieldCount;
}

InfGetIntField()

BOOLEAN InfGetIntField	(	PINFCONTEXT	Context,
		ULONG	FieldIndex,
		PLONG	IntegerValue
	)

Definition at line 1317 of file inffile.c.

{
    PINFCACHELINE CacheLine;
    PINFCACHEFIELD CacheField;
    ULONG Index;
    PCHAR Ptr;

    if ((Context == NULL) || (Context->Line == NULL) || (IntegerValue == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    CacheLine = (PINFCACHELINE)Context->Line;

    if (FieldIndex > CacheLine->FieldCount)
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    if (FieldIndex == 0)
    {
        Ptr = CacheLine->Key;
    }
    else
    {
        CacheField = CacheLine->FirstField;
        for (Index = 1; Index < FieldIndex; Index++)
            CacheField = CacheField->Next;

        Ptr = CacheField->Data;
    }

    *IntegerValue = atoi(Ptr); //strtol(Ptr, NULL, 0);

    return TRUE;
}

InfGetLineCount()

LONG InfGetLineCount	(	HINF	InfHandle,
		PCHAR	Section
	)

Definition at line 1209 of file inffile.c.

{
    PINFCACHE Cache;
    PINFCACHESECTION CacheSection;

    if ((InfHandle == NULL) || (Section == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return -1;
    }

    Cache = (PINFCACHE)InfHandle;

    /* Iterate through list of sections */
    CacheSection = Cache->FirstSection;
    while (CacheSection != NULL)
    {
//      DPRINT("Comparing '%s' and '%s'\n", CacheSection->Name, Section);

        /* Are the section names the same? */
        if (_stricmp(CacheSection->Name, Section) == 0)
        {
            return CacheSection->LineCount;
        }

        /* Get the next section */
        CacheSection = CacheSection->Next;
    }

//  DPRINT("Section not found\n");

    return -1;
}

InfGetMultiSzField()

BOOLEAN InfGetMultiSzField	(	PINFCONTEXT	Context,
		ULONG	FieldIndex,
		PCHAR	ReturnBuffer,
		ULONG	ReturnBufferSize,
		PULONG	RequiredSize
	)

Definition at line 1361 of file inffile.c.

{
    PINFCACHELINE CacheLine;
    PINFCACHEFIELD CacheField;
    PINFCACHEFIELD FieldPtr;
    ULONG Index;
    SIZE_T Size;
    PCHAR Ptr;

    if ((Context == NULL) || (Context->Line == NULL) || (FieldIndex == 0))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    if (RequiredSize != NULL)
        *RequiredSize = 0;

    CacheLine = (PINFCACHELINE)Context->Line;

    if (FieldIndex > CacheLine->FieldCount)
        return FALSE;

    CacheField = CacheLine->FirstField;
    for (Index = 1; Index < FieldIndex; Index++)
        CacheField = CacheField->Next;

    /* Calculate the required buffer size */
    FieldPtr = CacheField;
    Size = 0;
    while (FieldPtr != NULL)
    {
        Size += (strlen(FieldPtr->Data) + 1);
        FieldPtr = FieldPtr->Next;
    }
    Size++;

    if (RequiredSize != NULL)
        *RequiredSize = (ULONG)Size;

    if (ReturnBuffer != NULL)
    {
        if (ReturnBufferSize < Size)
            return FALSE;

        /* Copy multi-sz string */
        Ptr = ReturnBuffer;
        FieldPtr = CacheField;
        while (FieldPtr != NULL)
        {
            Size = strlen(FieldPtr->Data) + 1;

            strcpy(Ptr, FieldPtr->Data);

            Ptr = Ptr + Size;
            FieldPtr = FieldPtr->Next;
        }
        *Ptr = 0;
    }

    return TRUE;
}

InfGetStringField()

BOOLEAN InfGetStringField	(	PINFCONTEXT	Context,
		ULONG	FieldIndex,
		PCHAR	ReturnBuffer,
		ULONG	ReturnBufferSize,
		PULONG	RequiredSize
	)

Definition at line 1431 of file inffile.c.

{
    PINFCACHELINE CacheLine;
    PINFCACHEFIELD CacheField;
    ULONG Index;
    PCHAR Ptr;
    SIZE_T Size;

    if ((Context == NULL) || (Context->Line == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return FALSE;
    }

    if (RequiredSize != NULL)
        *RequiredSize = 0;

    CacheLine = (PINFCACHELINE)Context->Line;

    if (FieldIndex > CacheLine->FieldCount)
        return FALSE;

    if (FieldIndex == 0)
    {
        Ptr = CacheLine->Key;
    }
    else
    {
        CacheField = CacheLine->FirstField;
        for (Index = 1; Index < FieldIndex; Index++)
            CacheField = CacheField->Next;

        Ptr = CacheField->Data;
    }

    Size = strlen(Ptr) + 1;

    if (RequiredSize != NULL)
        *RequiredSize = (ULONG)Size;

    if (ReturnBuffer != NULL)
    {
        if (ReturnBufferSize < Size)
            return FALSE;

        strcpy(ReturnBuffer, Ptr);
    }

    return TRUE;
}

InfOpenFile()

BOOLEAN InfOpenFile	(	PHINF	InfHandle,
		PCSTR	FileName,
		PULONG	ErrorLine
	)

Definition at line 918 of file inffile.c.

{
    FILEINFORMATION Information;
    ULONG FileId;
    PCHAR FileBuffer;
    ULONG FileSize, Count;
    PINFCACHE Cache;
    BOOLEAN Success;
    ARC_STATUS Status;

    *InfHandle = NULL;
    *ErrorLine = (ULONG) - 1;

    //
    // Open the .inf file
    //
    Status = ArcOpen((PSTR)FileName, OpenReadOnly, &FileId);
    if (Status != ESUCCESS)
    {
        return FALSE;
    }

    //
    // Query file size
    //
    Status = ArcGetFileInformation(FileId, &Information);
    if ((Status != ESUCCESS) || (Information.EndingAddress.HighPart != 0))
    {
        ArcClose(FileId);
        return FALSE;
    }
    FileSize = Information.EndingAddress.LowPart;

    //
    // Allocate buffer to cache the file
    //
    FileBuffer = FrLdrTempAlloc(FileSize + 1, TAG_INF_FILE);
    if (!FileBuffer)
    {
        ArcClose(FileId);
        return FALSE;
    }

    //
    // Read file into memory
    //
    Status = ArcRead(FileId, FileBuffer, FileSize, &Count);
    if ((Status != ESUCCESS) || (Count != FileSize))
    {
        ArcClose(FileId);
        FrLdrTempFree(FileBuffer, TAG_INF_FILE);
        return FALSE;
    }

    //
    // We don't need the file anymore. Close it
    //
    ArcClose(FileId);

    //
    // Append string terminator
    //
    FileBuffer[FileSize] = 0;

    //
    // Allocate infcache header
    //
    Cache = (PINFCACHE)FrLdrTempAlloc(sizeof(INFCACHE), TAG_INF_CACHE);
    if (!Cache)
    {
        FrLdrTempFree(FileBuffer, TAG_INF_FILE);
        return FALSE;
    }

    //
    // Initialize inicache header
    //
    RtlZeroMemory(Cache, sizeof(INFCACHE));

    //
    // Parse the inf buffer
    //
    Success = InfpParseBuffer(Cache,
                              FileBuffer,
                              FileBuffer + FileSize,
                              ErrorLine);
    if (!Success)
    {
        FrLdrTempFree(Cache, TAG_INF_CACHE);
        Cache = NULL;
    }

    //
    // Free file buffer, as it has been parsed
    //
    FrLdrTempFree(FileBuffer, TAG_INF_FILE);

    //
    // Return .inf parsed contents
    //
    *InfHandle = (HINF)Cache;

    return Success;
}

Referenced by LoadReactOSSetup(), and SetupOpenInfFileExW().

InfpAddFieldToLine()

static PVOID InfpAddFieldToLine ( PINFCACHELINE  Line, PCHAR  Data  )

static

Definition at line 331 of file inffile.c.

{
    PINFCACHEFIELD Field;
    SIZE_T Size;

    Size = sizeof(INFCACHEFIELD) + strlen(Data);
    Field = (PINFCACHEFIELD)FrLdrTempAlloc(Size, TAG_INF_FIELD);
    if (Field == NULL)
    {
        return NULL;
    }
    memset(Field, 0, Size);

    strcpy(Field->Data, Data);

    /* Append key */
    if (Line->FirstField == NULL)
    {
        Line->FirstField = Field;
        Line->LastField = Field;
    }
    else
    {
        Line->LastField->Next = Field;
        Field->Prev = Line->LastField;
        Line->LastField = Field;
    }
    Line->FieldCount++;

    return (PVOID)Field;
}

Referenced by add_field_from_token(), and InfpAddField().

InfpAddKeyToLine()

static PVOID InfpAddKeyToLine ( PINFCACHELINE  Line, PCHAR  Key  )

static

Definition at line 309 of file inffile.c.

{
    if (Line == NULL)
        return NULL;

    if (Line->Key != NULL)
        return NULL;

    Line->Key = FrLdrTempAlloc(strlen(Key) + 1, TAG_INF_KEY);
    if (Line->Key == NULL)
        return NULL;

    strcpy(Line->Key, Key);

    return (PVOID)Line->Key;
}

Referenced by add_field_from_token(), and InfpAddLineWithKey().

InfpCacheAddLine()

static PINFCACHELINE InfpCacheAddLine ( PINFCACHESECTION  Section )

static

Definition at line 271 of file inffile.c.

{
    PINFCACHELINE Line;

    if (Section == NULL)
    {
//      DPRINT("Invalid parameter\n");
        return NULL;
    }

    Line = (PINFCACHELINE)FrLdrTempAlloc(sizeof(INFCACHELINE), TAG_INF_LINE);
    if (Line == NULL)
    {
//      DPRINT("RtlAllocateHeap() failed\n");
        return NULL;
    }
    memset(Line, 0, sizeof(INFCACHELINE));

    /* Append line */
    if (Section->FirstLine == NULL)
    {
        Section->FirstLine = Line;
        Section->LastLine = Line;
    }
    else
    {
        Section->LastLine->Next = Line;
        Line->Prev = Section->LastLine;
        Section->LastLine = Line;
    }
    Section->LineCount++;

    return Line;
}

Referenced by add_field_from_token().

InfpCacheAddSection()

static PINFCACHESECTION InfpCacheAddSection ( PINFCACHE  Cache, PCHAR  Name  )

static

Definition at line 226 of file inffile.c.

{
    PINFCACHESECTION Section = NULL;
    SIZE_T Size;

    if ((Cache == NULL) || (Name == NULL))
    {
//      DPRINT("Invalid parameter\n");
        return NULL;
    }

    /* Allocate and initialize the new section */
    Size = sizeof(INFCACHESECTION) + strlen(Name);
    Section = (PINFCACHESECTION)FrLdrTempAlloc(Size, TAG_INF_SECTION);
    if (Section == NULL)
    {
//      DPRINT("RtlAllocateHeap() failed\n");
        return NULL;
    }
    memset(Section, 0, Size);

    /* Copy section name */
    strcpy(Section->Name, Name);

    /* Append section */
    if (Cache->FirstSection == NULL)
    {
        Cache->FirstSection = Section;
        Cache->LastSection = Section;
    }
    else
    {
        Cache->LastSection->Next = Section;
        Section->Prev = Cache->LastSection;
        Cache->LastSection = Section;
    }

    return Section;
}

Referenced by add_section_from_token().

InfpCacheFindKeyLine()

static PINFCACHELINE InfpCacheFindKeyLine ( PINFCACHESECTION  Section, PCSTR  Key  )

static

Definition at line 368 of file inffile.c.

{
    PINFCACHELINE Line;

    Line = Section->FirstLine;
    while (Line != NULL)
    {
        if ((Line->Key != NULL) && (_stricmp(Line->Key, Key) == 0))
        {
            return Line;
        }

        Line = Line->Next;
    }

    return NULL;
}

Referenced by InfFindFirstLine().

InfpCacheFindSection()

static PINFCACHESECTION InfpCacheFindSection ( PINFCACHE  Cache, PCSTR  Name  )

static

Definition at line 196 of file inffile.c.

{
    PINFCACHESECTION Section = NULL;

    if (Cache == NULL || Name == NULL)
    {
        return NULL;
    }

    /* iterate through list of sections */
    Section = Cache->FirstSection;
    while (Section != NULL)
    {
        if (_stricmp(Section->Name, Name) == 0)
        {
            return Section;
        }

        /* get the next section*/
        Section = Section->Next;
    }

    return NULL;
}

Referenced by add_section_from_token(), and InfpParseBuffer().

InfpCacheFreeLine()

static PINFCACHELINE InfpCacheFreeLine ( PINFCACHELINE  Line )

static

Definition at line 135 of file inffile.c.

{
    PINFCACHELINE Next;
    PINFCACHEFIELD Field;

    if (Line == NULL)
    {
        return NULL;
    }

    Next = Line->Next;
    if (Line->Key != NULL)
    {
        FrLdrTempFree(Line->Key, TAG_INF_KEY);
        Line->Key = NULL;
    }

    /* Remove data fields */
    while (Line->FirstField != NULL)
    {
        Field = Line->FirstField->Next;
        FrLdrTempFree(Line->FirstField, TAG_INF_FIELD);
        Line->FirstField = Field;
    }
    Line->LastField = NULL;

    FrLdrTempFree(Line, TAG_INF_LINE);

    return Next;
}

Referenced by InfpCacheFreeSection().

InfpCacheFreeSection()

static PINFCACHESECTION InfpCacheFreeSection ( PINFCACHESECTION  Section )

static

Definition at line 170 of file inffile.c.

{
    PINFCACHESECTION Next;

    if (Section == NULL)
    {
        return NULL;
    }

    /* Release all keys */
    Next = Section->Next;
    while (Section->FirstLine != NULL)
    {
        Section->FirstLine = InfpCacheFreeLine(Section->FirstLine);
    }
    Section->LastLine = NULL;

    FrLdrTempFree(Section, TAG_INF_SECTION);

    return Next;
}

Referenced by InfCloseFile().

InfpParseBuffer()

static BOOLEAN InfpParseBuffer ( PINFCACHE  file, PCCHAR  buffer, PCCHAR  end, PULONG  error_line  )

static

Definition at line 878 of file inffile.c.

{
    struct parser parser;
    const CHAR* pos = buffer;

    parser.start       = buffer;
    parser.end         = end;
    parser.file        = file;
    parser.line        = NULL;
    parser.state       = LINE_START;
    parser.stack_pos   = 0;
    parser.cur_section = NULL;
    parser.line_pos    = 1;
    parser.error       = TRUE;
    parser.token_len   = 0;

    /* parser main loop */
    while (pos)
        pos = (parser_funcs[parser.state])(&parser, pos);

    if (parser.error)
    {
        if (error_line)
            *error_line = parser.line_pos;
        return parser.error;
    }

    /* find the [strings] section */
    file->StringsSection = InfpCacheFindSection(file, "Strings");

    return TRUE;
}

Referenced by InfHostOpenBufferedFile(), InfHostOpenFile(), InfOpenBufferedFile(), and InfOpenFile().

is_eof()

static __inline int is_eof ( struct parser *  parser, const CHAR *  ptr  )

static

Definition at line 415 of file inffile.c.

{
    return (ptr >= parser->end || *ptr == CONTROL_Z);
}

Referenced by eol_backslash_state(), and line_start_state().

is_eol()

static __inline int is_eol ( struct parser *  parser, const CHAR *  ptr  )

static

Definition at line 422 of file inffile.c.

{
    return ((ptr >= parser->end) ||
            (*ptr == CONTROL_Z) ||
            (*ptr == '\n') ||
            ((*ptr == '\r') && (*(ptr + 1) == '\n')));
}

Referenced by comment_state(), key_name_state(), leading_spaces_state(), ME_FindPixelPos(), quotes_state(), section_name_state(), trailing_spaces_state(), and value_name_state().

key_name_state()

static const CHAR * key_name_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 618 of file inffile.c.

{
    const CHAR *p, *token_end = parser->start;

    for (p = pos; !is_eol(parser, p); p++)
    {
        if (*p == ',') break;
        switch(*p)
        {

        case '=':
            push_token(parser, token_end);
            if (!add_field_from_token(parser, 1)) return NULL;
            parser->start = p + 1;
            push_state(parser, VALUE_NAME);
            set_state(parser, LEADING_SPACES);
            return p + 1;
        case ';':
            push_token(parser, token_end);
            if (!add_field_from_token(parser, 0)) return NULL;
            push_state(parser, LINE_START);
            set_state(parser, COMMENT);
            return p + 1;
        case '"':
            push_token(parser, token_end);
            parser->start = p + 1;
            push_state(parser, KEY_NAME);
            set_state(parser, QUOTES);
            return p + 1;
        case '\\':
            push_token(parser, token_end);
            parser->start = p;
            push_state(parser, KEY_NAME);
            set_state(parser, EOL_BACKSLASH);
            return p;
        default:
            if (!isspace((unsigned char)*p)) token_end = p + 1;
            else
            {
                push_token(parser, p);
                push_state(parser, KEY_NAME);
                set_state(parser, TRAILING_SPACES);
                return p;
            }
            break;
        }
    }
    push_token(parser, token_end);
    set_state(parser, VALUE_NAME);
    return p;
}

leading_spaces_state()

static const CHAR * leading_spaces_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 812 of file inffile.c.

{
    const CHAR *p;

    for (p = pos; !is_eol(parser, p); p++)
    {
        if (*p == '\\')
        {
            parser->start = p;
            set_state(parser, EOL_BACKSLASH);
            return p;
        }
        if (!isspace((unsigned char)*p))
            break;
    }
    parser->start = p;
    pop_state(parser);
    return p;
}

line_start_state()

static const CHAR * line_start_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 546 of file inffile.c.

{
    const CHAR *p;

    for (p = pos; !is_eof(parser, p); p++)
    {
        switch(*p)
        {
        case '\r':
            continue;

        case '\n':
            parser->line_pos++;
            close_current_line(parser);
            break;

        case ';':
            push_state(parser, LINE_START);
            set_state(parser, COMMENT);
            return p + 1;

        case '[':
            parser->start = p + 1;
            set_state(parser, SECTION_NAME);
            return p + 1;

        default:
            if (!isspace((unsigned char)*p))
            {
                parser->start = p;
                set_state(parser, KEY_NAME);
                return p;
            }
            break;
        }
    }
    close_current_line(parser);
    return NULL;
}

pop_state()

static __inline void pop_state ( struct parser *  parser )

static

Definition at line 398 of file inffile.c.

{
//  assert( parser->stack_pos );
    parser->state = parser->stack[--parser->stack_pos];
}

Referenced by comment_state(), eol_backslash_state(), leading_spaces_state(), quotes_state(), and trailing_spaces_state().

push_state()

static __inline void push_state ( struct parser *  parser, enum parser_state  state  )

static

Definition at line 390 of file inffile.c.

{
//  assert(parser->stack_pos < sizeof(parser->stack)/sizeof(parser->stack[0]));
    parser->stack[parser->stack_pos++] = state;
}

Referenced by eol_backslash_state(), key_name_state(), line_start_state(), section_name_state(), and value_name_state().

push_token()

static int push_token ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 434 of file inffile.c.

{
    SIZE_T len = pos - parser->start;
    const CHAR *src = parser->start;
    CHAR *dst = parser->token + parser->token_len;

    if (len > MAX_FIELD_LEN - parser->token_len)
        len = MAX_FIELD_LEN - parser->token_len;

    parser->token_len += (ULONG)len;
    for ( ; len > 0; len--, dst++, src++)
        *dst = *src ? (CHAR)*src : L' ';
    *dst = 0;
    parser->start = pos;

    return 0;
}

Referenced by eol_backslash_state(), key_name_state(), quotes_state(), section_name_state(), and value_name_state().

quotes_state()

static const CHAR * quotes_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 778 of file inffile.c.

{
    const CHAR *p, *token_end = parser->start;

    for (p = pos; !is_eol(parser, p); p++)
    {
        if (*p == '"')
        {
            if (p + 1 < parser->end && p[1] == '"') /* double quotes */
            {
                push_token(parser, p + 1);
                parser->start = token_end = p + 2;
                p++;
            }
            else  /* end of quotes */
            {
                push_token(parser, p);
                parser->start = p + 1;
                pop_state(parser);
                return p + 1;
            }
        }
    }
    push_token(parser, p);
    pop_state(parser);
    return p;
}

section_name_state()

static const CHAR * section_name_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 592 of file inffile.c.

{
    const CHAR *p;

    for (p = pos; !is_eol(parser, p); p++)
    {
        if (*p == ']')
        {
            push_token(parser, p);
            if (add_section_from_token(parser) == NULL)
                return NULL;
            push_state(parser, LINE_START);
            set_state(parser, COMMENT);  /* ignore everything else on the line */
            return p + 1;
        }
    }
    parser->error = STATUS_BAD_SECTION_NAME_LINE; /* unfinished section name */
    return NULL;
}

set_state()

static __inline enum parser_state set_state ( struct parser *  parser, enum parser_state  state  )

static

Definition at line 406 of file inffile.c.

{
    enum parser_state ret = parser->state;
    parser->state = state;
    return ret;
}

Referenced by eol_backslash_state(), key_name_state(), leading_spaces_state(), line_start_state(), section_name_state(), trailing_spaces_state(), and value_name_state().

trailing_spaces_state()

static const CHAR * trailing_spaces_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 838 of file inffile.c.

{
    const CHAR *p;

    for (p = pos; !is_eol(parser, p); p++)
    {
        if (*p == '\\')
        {
            set_state(parser, EOL_BACKSLASH);
            return p;
        }
        if (!isspace((unsigned char)*p))
            break;
    }
    pop_state(parser);
    return p;
}

value_name_state()

static const CHAR * value_name_state ( struct parser *  parser, const CHAR *  pos  )

static

Definition at line 676 of file inffile.c.

{
    const CHAR *p, *token_end = parser->start;

    for (p = pos; !is_eol(parser, p); p++)
    {
        switch(*p)
        {
        case ';':
            push_token(parser, token_end);
            if (!add_field_from_token(parser, 0)) return NULL;
            push_state(parser, LINE_START);
            set_state(parser, COMMENT);
            return p + 1;
        case ',':
            push_token(parser, token_end);
            if (!add_field_from_token(parser, 0)) return NULL;
            parser->start = p + 1;
            push_state(parser, VALUE_NAME);
            set_state(parser, LEADING_SPACES);
            return p + 1;
        case '"':
            push_token(parser, token_end);
            parser->start = p + 1;
            push_state(parser, VALUE_NAME);
            set_state(parser, QUOTES);
            return p + 1;
        case '\\':
            push_token(parser, token_end);
            parser->start = p;
            push_state(parser, VALUE_NAME);
            set_state(parser, EOL_BACKSLASH);
            return p;
        default:
            if (!isspace((unsigned char)*p)) token_end = p + 1;
            else
            {
                push_token(parser, p);
                push_state(parser, VALUE_NAME);
                set_state(parser, TRAILING_SPACES);
                return p;
            }
            break;
        }
    }
    push_token(parser, token_end);
    if (!add_field_from_token(parser, 0)) return NULL;
    set_state(parser, LINE_START);
    return p;
}

Variable Documentation

parser_funcs

const parser_state_func parser_funcs[NB_PARSER_STATES]

static

Initial value:

=
{
    line_start_state,      
    section_name_state,    
    key_name_state,        
    value_name_state,      
    eol_backslash_state,   
    quotes_state,          
    leading_spaces_state,  
    trailing_spaces_state, 
    comment_state          
}

Definition at line 117 of file inffile.c.

Referenced by InfpParseBuffer().