1971 lines
44 KiB
C
1971 lines
44 KiB
C
/*++
|
|
|
|
Copyright (c) 1991 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
alinf.c
|
|
|
|
Abstract:
|
|
|
|
This module implements functions to access the parsed INF.
|
|
|
|
Author:
|
|
|
|
Sunil Pai (sunilp) 13-Nov-1991
|
|
|
|
Revision History:
|
|
|
|
Calin Negreanu (calinn) 03-Sep-1998 - Major parser rewrite to work with a swap file
|
|
|
|
--*/
|
|
|
|
#include "winnt.h"
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <dos.h>
|
|
#include <stdio.h>
|
|
#include <io.h>
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
|
|
|
|
#define MAX_BUFFER_SIZE 0x1680 //7D00
|
|
#define SWAP_SIGNATURE 0xAABBCCDD
|
|
#define SWAP_SIGN_SIZE 4
|
|
|
|
#define NULL_HANDLE 0
|
|
#define MAX_PATH 256
|
|
|
|
//
|
|
// typedefs exported
|
|
//
|
|
|
|
typedef unsigned *PUNSIGNED;
|
|
typedef PVOID SECTION_HANDLE;
|
|
typedef unsigned long LINE_HANDLE;
|
|
typedef unsigned long VALUE_HANDLE;
|
|
|
|
typedef struct _SWAP_VALUE {
|
|
unsigned ValueSize;
|
|
VALUE_HANDLE NextValue;
|
|
char ValueName[];
|
|
} SWAP_VALUE, *PSWAP_VALUE;
|
|
|
|
typedef struct _SWAP_LINE {
|
|
unsigned LineSize;
|
|
LINE_HANDLE NextLine;
|
|
VALUE_HANDLE FirstValue;
|
|
VALUE_HANDLE LastValue;
|
|
char LineName[];
|
|
} SWAP_LINE, *PSWAP_LINE;
|
|
|
|
typedef struct _SWAP_SECTION {
|
|
unsigned SectionSize;
|
|
SECTION_HANDLE NextSection;
|
|
LINE_HANDLE FirstLine;
|
|
LINE_HANDLE LastLine;
|
|
char SectionName[];
|
|
} SWAP_SECTION, *PSWAP_SECTION;
|
|
|
|
typedef struct _SWAP_INF {
|
|
SECTION_HANDLE CurrentSection;
|
|
SECTION_HANDLE FirstSection;
|
|
SECTION_HANDLE LastSection;
|
|
int SwapFileHandle;
|
|
unsigned long BufferSize;
|
|
BOOLEAN BufferDirty;
|
|
PCHAR Buffer;
|
|
unsigned long BufferStart;
|
|
unsigned long BufferEnd;
|
|
SECTION_HANDLE LastSectionHandle;
|
|
unsigned LastLineIndex;
|
|
LINE_HANDLE LastLineHandle;
|
|
unsigned LastValueIndex;
|
|
VALUE_HANDLE LastValueHandle;
|
|
char SwapFile[];
|
|
} SWAP_INF, *PSWAP_INF;
|
|
|
|
char *CommonStrings[] =
|
|
{ (char *)("d1")
|
|
};
|
|
|
|
//
|
|
// DEFINES USED FOR THE PARSER INTERNALLY
|
|
//
|
|
//
|
|
// typedefs used
|
|
//
|
|
|
|
typedef enum _tokentype {
|
|
TOK_EOF,
|
|
TOK_EOL,
|
|
TOK_LBRACE,
|
|
TOK_RBRACE,
|
|
TOK_STRING,
|
|
TOK_EQUAL,
|
|
TOK_COMMA,
|
|
TOK_ERRPARSE,
|
|
TOK_ERRNOMEM
|
|
} TOKENTYPE, *PTOKENTTYPE;
|
|
|
|
|
|
typedef struct _token {
|
|
TOKENTYPE Type;
|
|
PCHAR pValue;
|
|
} TOKEN, *PTOKEN;
|
|
|
|
|
|
//
|
|
// Routine defines
|
|
//
|
|
|
|
PSWAP_SECTION
|
|
GetSectionPtr (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE SectionHandle
|
|
);
|
|
|
|
PSWAP_LINE
|
|
GetLinePtr (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE LineHandle
|
|
);
|
|
|
|
PSWAP_VALUE
|
|
GetValuePtr (
|
|
IN PSWAP_INF InfHandle,
|
|
IN VALUE_HANDLE ValueHandle
|
|
);
|
|
|
|
|
|
SECTION_HANDLE
|
|
GetNextSection (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE SectionHandle
|
|
);
|
|
|
|
LINE_HANDLE
|
|
GetNextLine (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE LineHandle
|
|
);
|
|
|
|
VALUE_HANDLE
|
|
GetNextValue (
|
|
IN PSWAP_INF InfHandle,
|
|
IN VALUE_HANDLE ValueHandle
|
|
);
|
|
|
|
|
|
SECTION_HANDLE
|
|
AddSection (
|
|
IN PSWAP_INF InfHandle,
|
|
IN PCHAR SectionName
|
|
);
|
|
|
|
LINE_HANDLE
|
|
AddLine (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN PCHAR LineName
|
|
);
|
|
|
|
VALUE_HANDLE
|
|
AddValue (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE Line,
|
|
IN PCHAR ValueName
|
|
);
|
|
|
|
|
|
SECTION_HANDLE
|
|
StoreNewSection (
|
|
IN PSWAP_INF InfHandle,
|
|
IN PSWAP_SECTION Section
|
|
);
|
|
|
|
LINE_HANDLE
|
|
StoreNewLine (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN PSWAP_LINE Line
|
|
);
|
|
|
|
VALUE_HANDLE
|
|
StoreNewValue (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE Line,
|
|
IN PSWAP_VALUE Value
|
|
);
|
|
|
|
|
|
BOOLEAN
|
|
LoadBuffer (
|
|
IN PSWAP_INF InfHandle,
|
|
IN unsigned long Offset
|
|
);
|
|
|
|
TOKEN
|
|
GetToken (
|
|
IN FILE *File
|
|
);
|
|
|
|
BOOLEAN
|
|
ParseInfBuffer (
|
|
IN PSWAP_INF InfHandle,
|
|
IN FILE *File,
|
|
IN OUT unsigned *LineNumber
|
|
);
|
|
|
|
|
|
//
|
|
// Internal Routine declarations for searching in the INF structures
|
|
//
|
|
|
|
|
|
VALUE_HANDLE
|
|
SearchValueInLineByIndex (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE Line,
|
|
IN unsigned ValueIndex
|
|
);
|
|
|
|
LINE_HANDLE
|
|
SearchLineInSectionByName (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN PCHAR LineName
|
|
);
|
|
|
|
LINE_HANDLE
|
|
SearchLineInSectionByIndex (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN unsigned LineIndex
|
|
);
|
|
|
|
SECTION_HANDLE
|
|
SearchSectionByName (
|
|
IN PSWAP_INF InfHandle,
|
|
IN PCHAR SectionName
|
|
);
|
|
|
|
|
|
//
|
|
// ROUTINE DEFINITIONS
|
|
//
|
|
|
|
static unsigned g_Sequencer = 0;
|
|
|
|
//
|
|
// returns a handle to use for further inf parsing
|
|
//
|
|
|
|
int
|
|
DnInitINFBuffer (
|
|
IN FILE *InfFileHandle,
|
|
OUT PVOID *pINFHandle,
|
|
OUT unsigned *LineNumber
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
char SwapFilePath[MAX_PATH];
|
|
PSWAP_INF InfHandle = NULL;
|
|
int Status;
|
|
unsigned long SwapSign;
|
|
|
|
*LineNumber = 0;
|
|
|
|
//
|
|
// Prepare the swap file path
|
|
//
|
|
sprintf (SwapFilePath, "%c:\\INF%03u.SWP", DngSwapDriveLetter, g_Sequencer++);
|
|
|
|
//
|
|
// Allocate and populate the SWAP_INF structure
|
|
//
|
|
InfHandle = MALLOC(sizeof(SWAP_INF) + strlen (SwapFilePath) + 1, TRUE);
|
|
InfHandle->CurrentSection = NULL;
|
|
InfHandle->FirstSection = NULL;
|
|
InfHandle->LastSection = NULL;
|
|
InfHandle->SwapFileHandle = -1;
|
|
InfHandle->BufferSize = 0;
|
|
InfHandle->BufferDirty = FALSE;
|
|
InfHandle->Buffer = NULL;
|
|
InfHandle->BufferStart = 0;
|
|
InfHandle->BufferEnd = 0;
|
|
InfHandle->LastSectionHandle = NULL_HANDLE;
|
|
InfHandle->LastLineIndex = 0xffff;
|
|
InfHandle->LastLineHandle = NULL_HANDLE;
|
|
InfHandle->LastValueIndex = 0xffff;
|
|
InfHandle->LastValueHandle = NULL_HANDLE;
|
|
strcpy (InfHandle->SwapFile, SwapFilePath);
|
|
|
|
//
|
|
// Prepare the swap file
|
|
//
|
|
InfHandle->SwapFileHandle = open (InfHandle->SwapFile, O_BINARY|O_CREAT|O_TRUNC|O_RDWR, S_IREAD|S_IWRITE);
|
|
if (InfHandle->SwapFileHandle == -1) {
|
|
FREE (InfHandle);
|
|
Status = errno;
|
|
}
|
|
else {
|
|
//
|
|
// write down signature
|
|
//
|
|
SwapSign = SWAP_SIGNATURE;
|
|
write (InfHandle->SwapFileHandle, &SwapSign, SWAP_SIGN_SIZE);
|
|
|
|
//
|
|
// Prepare the buffer
|
|
//
|
|
InfHandle->BufferSize = MAX_BUFFER_SIZE;
|
|
InfHandle->Buffer = MALLOC (MAX_BUFFER_SIZE, TRUE);
|
|
InfHandle->BufferStart = SWAP_SIGN_SIZE;
|
|
InfHandle->BufferEnd = SWAP_SIGN_SIZE;
|
|
|
|
//
|
|
// Parse the file
|
|
//
|
|
if (!ParseInfBuffer (InfHandle, InfFileHandle, LineNumber)) {
|
|
//
|
|
// Free SWAP_INF structure
|
|
//
|
|
DnFreeINFBuffer (InfHandle);
|
|
*pINFHandle = NULL;
|
|
Status = EBADF;
|
|
} else {
|
|
*pINFHandle = InfHandle;
|
|
Status = EZERO;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Clean up and return
|
|
//
|
|
return(Status);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// frees an INF Buffer
|
|
//
|
|
int
|
|
DnFreeINFBuffer (
|
|
IN PVOID INFHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
|
|
--*/
|
|
|
|
{
|
|
PSWAP_INF pINF;
|
|
PSWAP_SECTION Section;
|
|
SECTION_HANDLE SectionHandle;
|
|
|
|
//
|
|
// Valid INF Handle?
|
|
//
|
|
|
|
if (INFHandle == (PVOID)NULL) {
|
|
return EZERO;
|
|
}
|
|
|
|
//
|
|
// cast the buffer into an INF structure
|
|
//
|
|
|
|
pINF = (PSWAP_INF)INFHandle;
|
|
|
|
//
|
|
// Close and delete the swap file
|
|
//
|
|
close (pINF->SwapFileHandle);
|
|
remove (pINF->SwapFile);
|
|
|
|
//
|
|
// free temporary buffer
|
|
//
|
|
FREE (pINF->Buffer);
|
|
|
|
//
|
|
// Free section list
|
|
//
|
|
SectionHandle = pINF->FirstSection;
|
|
|
|
while (SectionHandle) {
|
|
Section = GetSectionPtr (pINF, SectionHandle);
|
|
SectionHandle = Section->NextSection;
|
|
FREE (Section);
|
|
}
|
|
|
|
//
|
|
// free the inf structure too
|
|
//
|
|
FREE(pINF);
|
|
|
|
return( EZERO );
|
|
}
|
|
|
|
|
|
SECTION_HANDLE
|
|
AddSection (
|
|
IN PSWAP_INF InfHandle,
|
|
IN PCHAR SectionName
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
PSWAP_SECTION Section;
|
|
unsigned SectionSize;
|
|
|
|
//
|
|
// Let's walk through the section structures to make sure that this section does
|
|
// not exist.
|
|
//
|
|
SectionHandle = InfHandle->FirstSection;
|
|
while (SectionHandle) {
|
|
|
|
Section = GetSectionPtr (InfHandle, SectionHandle);
|
|
if (stricmp (Section->SectionName, SectionName) == 0) {
|
|
break;
|
|
}
|
|
SectionHandle = GetNextSection (InfHandle, SectionHandle);
|
|
}
|
|
if (!SectionHandle) {
|
|
//
|
|
// Allocate the section structure
|
|
//
|
|
SectionSize = sizeof(SWAP_SECTION) + (SectionName?strlen (SectionName):0) + 1;
|
|
Section = MALLOC (SectionSize, TRUE);
|
|
Section->SectionSize = SectionSize;
|
|
Section->NextSection = NULL;
|
|
Section->FirstLine = NULL_HANDLE;
|
|
Section->LastLine = NULL_HANDLE;
|
|
if (SectionName) {
|
|
strcpy (Section->SectionName, SectionName);
|
|
}
|
|
else {
|
|
Section->SectionName[0] = 0;
|
|
}
|
|
|
|
//
|
|
// Store the newly created section
|
|
//
|
|
SectionHandle = StoreNewSection (InfHandle, Section);
|
|
}
|
|
return SectionHandle;
|
|
}
|
|
|
|
|
|
LINE_HANDLE
|
|
AddLine (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN PCHAR LineName
|
|
)
|
|
{
|
|
LINE_HANDLE LineHandle;
|
|
PSWAP_LINE Line;
|
|
unsigned LineSize;
|
|
|
|
//
|
|
// Allocate the line structure
|
|
//
|
|
LineSize = sizeof(SWAP_LINE) + (LineName?strlen (LineName):0) + 1;
|
|
Line = MALLOC (LineSize, TRUE);
|
|
Line->LineSize = LineSize;
|
|
Line->NextLine = NULL_HANDLE;
|
|
Line->FirstValue = NULL_HANDLE;
|
|
Line->LastValue = NULL_HANDLE;
|
|
if (LineName) {
|
|
strcpy (Line->LineName, LineName);
|
|
}
|
|
else {
|
|
Line->LineName[0] = 0;
|
|
}
|
|
|
|
//
|
|
// Store the newly created line
|
|
//
|
|
LineHandle = StoreNewLine (InfHandle, Section, Line);
|
|
FREE (Line);
|
|
return LineHandle;
|
|
}
|
|
|
|
|
|
VALUE_HANDLE
|
|
AddValue (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE Line,
|
|
IN PCHAR ValueName
|
|
)
|
|
{
|
|
VALUE_HANDLE ValueHandle;
|
|
PSWAP_VALUE Value;
|
|
unsigned ValueSize;
|
|
|
|
//
|
|
// Allocate the value structure
|
|
//
|
|
ValueSize = sizeof(SWAP_VALUE) + (ValueName?strlen (ValueName):0) + 1;
|
|
Value = MALLOC (ValueSize, TRUE);
|
|
Value->ValueSize = ValueSize;
|
|
Value->NextValue = NULL_HANDLE;
|
|
if (ValueName) {
|
|
strcpy (Value->ValueName, ValueName);
|
|
}
|
|
else {
|
|
Value->ValueName[0] = 0;
|
|
}
|
|
|
|
//
|
|
// Store the newly created line
|
|
//
|
|
ValueHandle = StoreNewValue (InfHandle, Line, Value);
|
|
FREE (Value);
|
|
return ValueHandle;
|
|
}
|
|
|
|
|
|
PSWAP_SECTION
|
|
GetSectionPtr (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE SectionHandle
|
|
)
|
|
{
|
|
return (PSWAP_SECTION) SectionHandle;
|
|
}
|
|
|
|
|
|
PSWAP_LINE
|
|
GetLinePtr (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE LineHandle
|
|
)
|
|
{
|
|
//
|
|
// Verify if the buffer contains the requested line (at least the size of LineSize)
|
|
//
|
|
if ((InfHandle->BufferStart > LineHandle) ||
|
|
(InfHandle->BufferEnd < (LineHandle + sizeof (unsigned))) ||
|
|
(InfHandle->BufferEnd < (LineHandle + *((PUNSIGNED)(InfHandle->Buffer+LineHandle-InfHandle->BufferStart))))
|
|
) {
|
|
LoadBuffer (InfHandle, LineHandle);
|
|
}
|
|
return (PSWAP_LINE) (InfHandle->Buffer+LineHandle-InfHandle->BufferStart);
|
|
}
|
|
|
|
|
|
PSWAP_VALUE
|
|
GetValuePtr (
|
|
IN PSWAP_INF InfHandle,
|
|
IN VALUE_HANDLE ValueHandle
|
|
)
|
|
{
|
|
//
|
|
// Verify if the buffer contains the requested value (at least the size of ValueSize)
|
|
//
|
|
if ((InfHandle->BufferStart > ValueHandle) ||
|
|
(InfHandle->BufferEnd < (ValueHandle + sizeof (unsigned))) ||
|
|
(InfHandle->BufferEnd < (ValueHandle + *((PUNSIGNED)(InfHandle->Buffer+ValueHandle-InfHandle->BufferStart))))
|
|
) {
|
|
LoadBuffer (InfHandle, ValueHandle);
|
|
}
|
|
return (PSWAP_VALUE) (InfHandle->Buffer+ValueHandle-InfHandle->BufferStart);
|
|
}
|
|
|
|
|
|
SECTION_HANDLE
|
|
GetNextSection (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE SectionHandle
|
|
)
|
|
{
|
|
PSWAP_SECTION Section;
|
|
|
|
Section = GetSectionPtr (InfHandle, SectionHandle);
|
|
return Section->NextSection;
|
|
}
|
|
|
|
|
|
LINE_HANDLE
|
|
GetNextLine (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE LineHandle
|
|
)
|
|
{
|
|
PSWAP_LINE Line;
|
|
|
|
Line = GetLinePtr (InfHandle, LineHandle);
|
|
return Line->NextLine;
|
|
}
|
|
|
|
|
|
VALUE_HANDLE
|
|
GetNextValue (
|
|
IN PSWAP_INF InfHandle,
|
|
IN VALUE_HANDLE ValueHandle
|
|
)
|
|
{
|
|
PSWAP_VALUE Value;
|
|
|
|
Value = GetValuePtr (InfHandle, ValueHandle);
|
|
return Value->NextValue;
|
|
}
|
|
|
|
|
|
SECTION_HANDLE
|
|
StoreNewSection (
|
|
IN PSWAP_INF InfHandle,
|
|
IN PSWAP_SECTION Section
|
|
)
|
|
{
|
|
PSWAP_SECTION LastSectionPtr;
|
|
|
|
if (!InfHandle->FirstSection) {
|
|
InfHandle->FirstSection = (SECTION_HANDLE) Section;
|
|
InfHandle->LastSection = (SECTION_HANDLE) Section;
|
|
}
|
|
else {
|
|
LastSectionPtr = GetSectionPtr (InfHandle, InfHandle->LastSection);
|
|
LastSectionPtr->NextSection = (SECTION_HANDLE) Section;
|
|
InfHandle->LastSection = (SECTION_HANDLE) Section;
|
|
}
|
|
return (SECTION_HANDLE) Section;
|
|
}
|
|
|
|
|
|
LINE_HANDLE
|
|
StoreNewLine (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN PSWAP_LINE Line
|
|
)
|
|
{
|
|
PSWAP_SECTION SectionPtr;
|
|
LINE_HANDLE LineHandle;
|
|
PSWAP_LINE LastLinePtr;
|
|
|
|
//
|
|
// Let's store data in the swap file
|
|
//
|
|
if ((InfHandle->BufferSize-InfHandle->BufferEnd+InfHandle->BufferStart) < Line->LineSize) {
|
|
LoadBuffer (InfHandle, 0);
|
|
}
|
|
memcpy (InfHandle->Buffer+InfHandle->BufferEnd-InfHandle->BufferStart, Line, Line->LineSize);
|
|
InfHandle->BufferDirty = TRUE;
|
|
LineHandle = InfHandle->BufferEnd;
|
|
InfHandle->BufferEnd += Line->LineSize;
|
|
|
|
SectionPtr = GetSectionPtr (InfHandle, Section);
|
|
if (!SectionPtr->LastLine) {
|
|
SectionPtr->FirstLine = LineHandle;
|
|
SectionPtr->LastLine = LineHandle;
|
|
}
|
|
else {
|
|
LastLinePtr = GetLinePtr (InfHandle, SectionPtr->LastLine);
|
|
LastLinePtr->NextLine = LineHandle;
|
|
InfHandle->BufferDirty = TRUE;
|
|
SectionPtr = GetSectionPtr (InfHandle, Section);
|
|
SectionPtr->LastLine = LineHandle;
|
|
}
|
|
return LineHandle;
|
|
}
|
|
|
|
|
|
VALUE_HANDLE
|
|
StoreNewValue (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE Line,
|
|
IN PSWAP_VALUE Value
|
|
)
|
|
{
|
|
PSWAP_LINE LinePtr;
|
|
VALUE_HANDLE ValueHandle;
|
|
PSWAP_VALUE LastValuePtr;
|
|
|
|
//
|
|
// Let's store data in the swap file
|
|
//
|
|
if ((InfHandle->BufferSize-InfHandle->BufferEnd+InfHandle->BufferStart) < Value->ValueSize) {
|
|
LoadBuffer (InfHandle, 0);
|
|
}
|
|
memcpy (InfHandle->Buffer+InfHandle->BufferEnd-InfHandle->BufferStart, Value, Value->ValueSize);
|
|
InfHandle->BufferDirty = TRUE;
|
|
ValueHandle = InfHandle->BufferEnd;
|
|
InfHandle->BufferEnd += Value->ValueSize;
|
|
|
|
LinePtr = GetLinePtr (InfHandle, Line);
|
|
if (!LinePtr->LastValue) {
|
|
LinePtr->FirstValue = ValueHandle;
|
|
LinePtr->LastValue = ValueHandle;
|
|
InfHandle->BufferDirty = TRUE;
|
|
}
|
|
else {
|
|
LastValuePtr = GetValuePtr (InfHandle, LinePtr->LastValue);
|
|
LastValuePtr->NextValue = ValueHandle;
|
|
InfHandle->BufferDirty = TRUE;
|
|
LinePtr = GetLinePtr (InfHandle, Line);
|
|
LinePtr->LastValue = ValueHandle;
|
|
InfHandle->BufferDirty = TRUE;
|
|
}
|
|
return ValueHandle;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
LoadBuffer (
|
|
IN PSWAP_INF InfHandle,
|
|
IN unsigned long Offset
|
|
)
|
|
{
|
|
//
|
|
// See if we need to write the buffer to disk (e.g. is dirty)
|
|
//
|
|
if (InfHandle->BufferDirty) {
|
|
lseek (InfHandle->SwapFileHandle, InfHandle->BufferStart, SEEK_SET);
|
|
write (InfHandle->SwapFileHandle, InfHandle->Buffer, (unsigned int) (InfHandle->BufferEnd-InfHandle->BufferStart));
|
|
}
|
|
if (!Offset) {
|
|
Offset = lseek (InfHandle->SwapFileHandle, 0, SEEK_END);
|
|
}
|
|
InfHandle->BufferStart = lseek (InfHandle->SwapFileHandle, Offset, SEEK_SET);
|
|
InfHandle->BufferEnd = InfHandle->BufferStart + read (InfHandle->SwapFileHandle, InfHandle->Buffer, MAX_BUFFER_SIZE);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
SECTION_HANDLE
|
|
SearchSectionByName (
|
|
IN PSWAP_INF InfHandle,
|
|
IN PCHAR SectionName
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
PSWAP_SECTION Section;
|
|
|
|
SectionHandle = InfHandle->FirstSection;
|
|
while (SectionHandle) {
|
|
|
|
Section = GetSectionPtr (InfHandle, SectionHandle);
|
|
if (stricmp (Section->SectionName, SectionName?SectionName:"") == 0) {
|
|
break;
|
|
}
|
|
SectionHandle = GetNextSection (InfHandle, SectionHandle);
|
|
}
|
|
if (SectionHandle != InfHandle->LastSectionHandle) {
|
|
InfHandle->LastSectionHandle = SectionHandle;
|
|
InfHandle->LastLineIndex = 0xffff;
|
|
InfHandle->LastLineHandle = NULL_HANDLE;
|
|
InfHandle->LastValueIndex = 0xffff;
|
|
InfHandle->LastValueHandle = NULL_HANDLE;
|
|
}
|
|
return SectionHandle;
|
|
}
|
|
|
|
|
|
LINE_HANDLE
|
|
SearchLineInSectionByName (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN PCHAR LineName
|
|
)
|
|
{
|
|
PSWAP_SECTION SectionPtr;
|
|
LINE_HANDLE LineHandle;
|
|
PSWAP_LINE Line;
|
|
unsigned index;
|
|
|
|
if (!Section) {
|
|
return NULL_HANDLE;
|
|
}
|
|
|
|
SectionPtr = GetSectionPtr (InfHandle, Section);
|
|
LineHandle = SectionPtr->FirstLine;
|
|
index = 0;
|
|
while (LineHandle) {
|
|
|
|
Line = GetLinePtr (InfHandle, LineHandle);
|
|
if (stricmp (Line->LineName, LineName?LineName:"") == 0) {
|
|
break;
|
|
}
|
|
index ++;
|
|
LineHandle = GetNextLine (InfHandle, LineHandle);
|
|
}
|
|
if (LineHandle != InfHandle->LastLineHandle) {
|
|
InfHandle->LastLineIndex = index;
|
|
InfHandle->LastLineHandle = LineHandle;
|
|
InfHandle->LastValueIndex = 0xffff;
|
|
InfHandle->LastValueHandle = NULL_HANDLE;
|
|
}
|
|
return LineHandle;
|
|
}
|
|
|
|
|
|
LINE_HANDLE
|
|
SearchLineInSectionByIndex (
|
|
IN PSWAP_INF InfHandle,
|
|
IN SECTION_HANDLE Section,
|
|
IN unsigned LineIndex
|
|
)
|
|
{
|
|
PSWAP_SECTION SectionPtr;
|
|
LINE_HANDLE LineHandle;
|
|
unsigned index;
|
|
|
|
if (!Section) {
|
|
return NULL_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Optimize access
|
|
//
|
|
if ((InfHandle->LastSectionHandle == Section) &&
|
|
(InfHandle->LastLineIndex <= LineIndex)
|
|
) {
|
|
LineHandle = InfHandle->LastLineHandle;
|
|
index = InfHandle->LastLineIndex;
|
|
}
|
|
else {
|
|
SectionPtr = GetSectionPtr (InfHandle, Section);
|
|
LineHandle = SectionPtr->FirstLine;
|
|
index = 0;
|
|
}
|
|
while (LineHandle) {
|
|
|
|
if (index == LineIndex) {
|
|
break;
|
|
}
|
|
index ++;
|
|
LineHandle = GetNextLine (InfHandle, LineHandle);
|
|
}
|
|
if (LineHandle != InfHandle->LastLineHandle) {
|
|
InfHandle->LastLineIndex = LineIndex;
|
|
InfHandle->LastLineHandle = LineHandle;
|
|
InfHandle->LastValueIndex = 0xffff;
|
|
InfHandle->LastValueHandle = NULL_HANDLE;
|
|
}
|
|
return LineHandle;
|
|
}
|
|
|
|
|
|
VALUE_HANDLE
|
|
SearchValueInLineByIndex (
|
|
IN PSWAP_INF InfHandle,
|
|
IN LINE_HANDLE Line,
|
|
IN unsigned ValueIndex
|
|
)
|
|
{
|
|
PSWAP_LINE LinePtr;
|
|
VALUE_HANDLE ValueHandle;
|
|
unsigned index;
|
|
|
|
if (!Line) {
|
|
return NULL_HANDLE;
|
|
}
|
|
|
|
//
|
|
// Optimize access
|
|
//
|
|
if ((InfHandle->LastLineHandle == Line) &&
|
|
(InfHandle->LastValueIndex <= ValueIndex)
|
|
) {
|
|
ValueHandle = InfHandle->LastValueHandle;
|
|
index = InfHandle->LastValueIndex;
|
|
}
|
|
else {
|
|
LinePtr = GetLinePtr (InfHandle, Line);
|
|
ValueHandle = LinePtr->FirstValue;
|
|
index = 0;
|
|
}
|
|
while (ValueHandle) {
|
|
|
|
if (index == ValueIndex) {
|
|
break;
|
|
}
|
|
index ++;
|
|
ValueHandle = GetNextValue (InfHandle, ValueHandle);
|
|
}
|
|
InfHandle->LastValueIndex = ValueIndex;
|
|
InfHandle->LastValueHandle = ValueHandle;
|
|
return ValueHandle;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Globals used by the token parser
|
|
//
|
|
|
|
// string terminators are the whitespace characters (isspace: space, tab,
|
|
// linefeed, formfeed, vertical tab, carriage return) or the chars given below
|
|
|
|
CHAR StringTerminators[] = {'[', ']', '=', ',', '\"', ' ', '\t',
|
|
'\n','\f','\v','\r','\032', 0};
|
|
|
|
//
|
|
// quoted string terminators allow some of the regular terminators to
|
|
// appear as characters
|
|
|
|
CHAR QStringTerminators[] = {'\"', '\n','\f','\v', '\r','\032', 0};
|
|
|
|
|
|
//
|
|
// Main parser routine
|
|
//
|
|
|
|
BOOLEAN
|
|
ParseInfBuffer (
|
|
IN PSWAP_INF InfHandle,
|
|
IN FILE *File,
|
|
IN OUT unsigned *LineNumber
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given a character buffer containing the INF file, this routine parses
|
|
the INF into an internal form with Section records, Line records and
|
|
Value records.
|
|
|
|
Arguments:
|
|
|
|
InfHandle - PSWAP_INF structure used to create INF structures
|
|
|
|
File - supplies open, rewound CRT handle to file.
|
|
|
|
LineNumber - In case of error, this variable will contain the line
|
|
in the file that contains a syntax error.
|
|
|
|
Return Value:
|
|
|
|
TRUE - the INF file was parsed successfully
|
|
FALSE - otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR pchSectionName, pchValue;
|
|
unsigned State, InfLine;
|
|
TOKEN Token;
|
|
BOOLEAN Done;
|
|
BOOLEAN Error;
|
|
int ErrorCode;
|
|
|
|
SECTION_HANDLE LastSection = NULL;
|
|
LINE_HANDLE LastLine = NULL_HANDLE;
|
|
|
|
*LineNumber = 0;
|
|
|
|
//
|
|
// Set initial state
|
|
//
|
|
State = 1;
|
|
InfLine = 1;
|
|
Done = FALSE;
|
|
Error = FALSE;
|
|
|
|
//
|
|
// Enter token processing loop
|
|
//
|
|
|
|
while (!Done) {
|
|
|
|
Token = GetToken(File);
|
|
|
|
switch (State) {
|
|
//
|
|
// STATE1: Start of file, this state remains till first
|
|
// section is found
|
|
// Valid Tokens: TOK_EOL, TOK_EOF, TOK_LBRACE
|
|
case 1:
|
|
switch (Token.Type) {
|
|
case TOK_EOL:
|
|
break;
|
|
case TOK_EOF:
|
|
Done = TRUE;
|
|
break;
|
|
case TOK_LBRACE:
|
|
State = 2;
|
|
break;
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// STATE 2: Section LBRACE has been received, expecting STRING
|
|
//
|
|
// Valid Tokens: TOK_STRING
|
|
//
|
|
case 2:
|
|
switch (Token.Type) {
|
|
case TOK_STRING:
|
|
State = 3;
|
|
pchSectionName = Token.pValue;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
|
|
}
|
|
break;
|
|
|
|
//
|
|
// STATE 3: Section Name received, expecting RBRACE
|
|
//
|
|
// Valid Tokens: TOK_RBRACE
|
|
//
|
|
case 3:
|
|
switch (Token.Type) {
|
|
case TOK_RBRACE:
|
|
State = 4;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
//
|
|
// STATE 4: Section Definition Complete, expecting EOL
|
|
//
|
|
// Valid Tokens: TOK_EOL, TOK_EOF
|
|
//
|
|
case 4:
|
|
switch (Token.Type) {
|
|
case TOK_EOL:
|
|
LastSection = AddSection (InfHandle, pchSectionName);
|
|
FREE (pchSectionName);
|
|
pchSectionName = NULL;
|
|
State = 5;
|
|
break;
|
|
|
|
case TOK_EOF:
|
|
LastSection = AddSection (InfHandle, pchSectionName);
|
|
FREE (pchSectionName);
|
|
pchSectionName = NULL;
|
|
Done = TRUE;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// STATE 5: Expecting Section Lines
|
|
//
|
|
// Valid Tokens: TOK_EOL, TOK_EOF, TOK_STRING, TOK_LBRACE
|
|
//
|
|
case 5:
|
|
switch (Token.Type) {
|
|
case TOK_EOL:
|
|
break;
|
|
case TOK_EOF:
|
|
Done = TRUE;
|
|
break;
|
|
case TOK_STRING:
|
|
pchValue = Token.pValue;
|
|
State = 6;
|
|
break;
|
|
case TOK_LBRACE:
|
|
State = 2;
|
|
break;
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// STATE 6: String returned, not sure whether it is key or value
|
|
//
|
|
// Valid Tokens: TOK_EOL, TOK_EOF, TOK_COMMA, TOK_EQUAL
|
|
//
|
|
case 6:
|
|
switch (Token.Type) {
|
|
case TOK_EOL:
|
|
LastLine = AddLine (InfHandle, LastSection, NULL);
|
|
AddValue (InfHandle, LastLine, pchValue);
|
|
FREE (pchValue);
|
|
pchValue = NULL;
|
|
State = 5;
|
|
break;
|
|
|
|
case TOK_EOF:
|
|
LastLine = AddLine (InfHandle, LastSection, NULL);
|
|
AddValue (InfHandle, LastLine, pchValue);
|
|
FREE (pchValue);
|
|
pchValue = NULL;
|
|
Done = TRUE;
|
|
break;
|
|
|
|
case TOK_COMMA:
|
|
LastLine = AddLine (InfHandle, LastSection, NULL);
|
|
AddValue (InfHandle, LastLine, pchValue);
|
|
FREE (pchValue);
|
|
pchValue = NULL;
|
|
State = 7;
|
|
break;
|
|
|
|
case TOK_EQUAL:
|
|
LastLine = AddLine (InfHandle, LastSection, pchValue);
|
|
FREE (pchValue);
|
|
pchValue = NULL;
|
|
State = 8;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//
|
|
// STATE 7: Comma received, Expecting another string
|
|
//
|
|
// Valid Tokens: TOK_STRING
|
|
//
|
|
case 7:
|
|
switch (Token.Type) {
|
|
case TOK_STRING:
|
|
AddValue (InfHandle, LastLine, Token.pValue);
|
|
State = 9;
|
|
break;
|
|
case TOK_COMMA:
|
|
AddValue (InfHandle, LastLine, NULL);
|
|
State = 7;
|
|
break;
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
//
|
|
// STATE 8: Equal received, Expecting another string
|
|
//
|
|
// Valid Tokens: TOK_STRING
|
|
//
|
|
case 8:
|
|
switch (Token.Type) {
|
|
case TOK_STRING:
|
|
AddValue (InfHandle, LastLine, Token.pValue);
|
|
State = 9;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
//
|
|
// STATE 9: String received after equal, value string
|
|
//
|
|
// Valid Tokens: TOK_EOL, TOK_EOF, TOK_COMMA
|
|
//
|
|
case 9:
|
|
switch (Token.Type) {
|
|
case TOK_EOL:
|
|
State = 5;
|
|
break;
|
|
|
|
case TOK_EOF:
|
|
Done = TRUE;
|
|
break;
|
|
|
|
case TOK_COMMA:
|
|
State = 7;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
//
|
|
// STATE 10: Value string definitely received
|
|
//
|
|
// Valid Tokens: TOK_EOL, TOK_EOF, TOK_COMMA
|
|
//
|
|
case 10:
|
|
switch (Token.Type) {
|
|
case TOK_EOL:
|
|
State =5;
|
|
break;
|
|
|
|
case TOK_EOF:
|
|
Done = TRUE;
|
|
break;
|
|
|
|
case TOK_COMMA:
|
|
State = 7;
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
Error = Done = TRUE;
|
|
ErrorCode = EINVAL;
|
|
break;
|
|
|
|
} // end switch(State)
|
|
|
|
|
|
if (Error) {
|
|
switch (ErrorCode) {
|
|
case ENOMEM:
|
|
DnFatalError(&DnsOutOfMemory);
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
|
|
//
|
|
// Keep track of line numbers so that we can display Errors
|
|
//
|
|
|
|
if (Token.Type == TOK_EOL)
|
|
InfLine++;
|
|
}
|
|
|
|
} // End while
|
|
|
|
if (Error) {
|
|
*LineNumber = InfLine;
|
|
}
|
|
|
|
return (BOOLEAN) (!Error);
|
|
}
|
|
|
|
|
|
|
|
BOOLEAN
|
|
TokenMatch (
|
|
IN OUT char **p,
|
|
IN char *line
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function tries to match to string pointed to be line against
|
|
a set of commonly used stirngs. If we hit, we'll assign p to
|
|
point to the matched string.
|
|
|
|
Arguments:
|
|
|
|
p - Supplies a char pointer that we'll assign if we find a match.
|
|
|
|
line - Supplies the address of the string we're trying to match.
|
|
|
|
Return Value:
|
|
|
|
TRUE - we found a match and have assigned p
|
|
|
|
FALSE - we found no match and made no assignment to p
|
|
|
|
--*/
|
|
|
|
{
|
|
int i;
|
|
|
|
if( (p == NULL) || (line == NULL) ) {
|
|
return( FALSE );
|
|
}
|
|
|
|
for( i = 0; i < sizeof(CommonStrings)/sizeof(char *); i++ ) {
|
|
if( !strcmp( line, CommonStrings[i] ) ) {
|
|
//
|
|
// Hit...
|
|
//
|
|
*p = (char *)CommonStrings[i];
|
|
return( TRUE );
|
|
}
|
|
}
|
|
return( FALSE );
|
|
}
|
|
|
|
TOKEN
|
|
GetToken(
|
|
IN FILE *File
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function returns the Next token from the configuration stream.
|
|
|
|
Arguments:
|
|
|
|
Stream - Supplies the address of the configuration stream. Returns
|
|
the address of where to start looking for tokens within the
|
|
stream.
|
|
|
|
MaxStream - Supplies the address of the last character in the stream.
|
|
|
|
|
|
Return Value:
|
|
|
|
TOKEN - Returns the next token
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
int i;
|
|
unsigned Length;
|
|
TOKEN Token;
|
|
#define _MAXLINE 1024
|
|
static char line[_MAXLINE+1];
|
|
char *p;
|
|
|
|
//
|
|
// Skip whitespace (except for eol)
|
|
//
|
|
while(((i = fgetc(File)) != EOF) && (i != '\n') && (isspace(i) || (i == 26))) {
|
|
;
|
|
}
|
|
|
|
//
|
|
// Check for comments and remove them
|
|
//
|
|
if((i != EOF) && ((i == '#') || (i == ';'))) {
|
|
while(((i = fgetc(File)) != EOF) && (i != '\n')) {
|
|
;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check to see if EOF has been reached, set the token to the right
|
|
// value
|
|
//
|
|
if(i == EOF) {
|
|
Token.Type = TOK_EOF;
|
|
Token.pValue = NULL;
|
|
return(Token);
|
|
}
|
|
|
|
switch(i) {
|
|
|
|
case '[' :
|
|
Token.Type = TOK_LBRACE;
|
|
Token.pValue = NULL;
|
|
break;
|
|
|
|
case ']' :
|
|
Token.Type = TOK_RBRACE;
|
|
Token.pValue = NULL;
|
|
break;
|
|
|
|
case '=' :
|
|
Token.Type = TOK_EQUAL;
|
|
Token.pValue = NULL;
|
|
break;
|
|
|
|
case ',' :
|
|
Token.Type = TOK_COMMA;
|
|
Token.pValue = NULL;
|
|
break;
|
|
|
|
case '\n' :
|
|
Token.Type = TOK_EOL;
|
|
Token.pValue = NULL;
|
|
break;
|
|
|
|
case '\"':
|
|
|
|
//
|
|
// determine quoted string
|
|
//
|
|
Length = 0;
|
|
while(((i = fgetc(File)) != EOF) && !strchr(QStringTerminators,i)) {
|
|
if(Length < _MAXLINE) {
|
|
line[Length++] = (char)i;
|
|
}
|
|
}
|
|
|
|
if((i == EOF) || (i != '\"')) {
|
|
Token.Type = TOK_ERRPARSE;
|
|
Token.pValue = NULL;
|
|
} else {
|
|
line[Length] = 0;
|
|
p = MALLOC(Length+1,TRUE);
|
|
strcpy(p,line);
|
|
Token.Type = TOK_STRING;
|
|
Token.pValue = p;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
//
|
|
// determine regular string
|
|
//
|
|
line[0] = (char)i;
|
|
Length = 1;
|
|
while(((i = fgetc(File)) != EOF) && !strchr(StringTerminators,i)) {
|
|
if(Length < _MAXLINE) {
|
|
line[Length++] = (char)i;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Put back the char that terminated the string.
|
|
//
|
|
if(i != EOF) {
|
|
ungetc(i,File);
|
|
}
|
|
|
|
line[Length] = 0;
|
|
|
|
//
|
|
// See if we can use one of the common strings.
|
|
//
|
|
if( !TokenMatch ( &p, line ) ) {
|
|
//
|
|
// Nope.
|
|
//
|
|
p = MALLOC(Length+1,TRUE);
|
|
strcpy(p,line);
|
|
}
|
|
else {
|
|
char *p1;
|
|
p1 = MALLOC (strlen(p)+1, TRUE);
|
|
strcpy (p1, p);
|
|
p = p1;
|
|
}
|
|
Token.Type = TOK_STRING;
|
|
Token.pValue = p;
|
|
break;
|
|
}
|
|
|
|
return(Token);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DnSearchINFSection (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName
|
|
)
|
|
{
|
|
return (BOOLEAN) (SearchSectionByName ((PSWAP_INF)INFHandle, SectionName) != NULL_HANDLE);
|
|
}
|
|
|
|
|
|
PCHAR
|
|
DnGetSectionLineIndex (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName,
|
|
IN unsigned LineIndex,
|
|
IN unsigned ValueIndex
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
LINE_HANDLE LineHandle;
|
|
VALUE_HANDLE ValueHandle;
|
|
PSWAP_VALUE Value;
|
|
PCHAR result;
|
|
|
|
SectionHandle = SearchSectionByName ((PSWAP_INF)INFHandle, SectionName);
|
|
|
|
if (!SectionHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
LineHandle = SearchLineInSectionByIndex ((PSWAP_INF)INFHandle, SectionHandle, LineIndex);
|
|
|
|
if (!LineHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
ValueHandle = SearchValueInLineByIndex ((PSWAP_INF)INFHandle, LineHandle, ValueIndex);
|
|
|
|
if (!ValueHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
Value = GetValuePtr ((PSWAP_INF)INFHandle, ValueHandle);
|
|
|
|
result = MALLOC (Value->ValueSize - sizeof(SWAP_VALUE), TRUE);
|
|
|
|
strcpy (result, Value->ValueName);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DnGetSectionKeyExists (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR Key
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
|
|
SectionHandle = SearchSectionByName ((PSWAP_INF)INFHandle, SectionName);
|
|
|
|
if (!SectionHandle) {
|
|
return FALSE;
|
|
}
|
|
|
|
return (BOOLEAN) (SearchLineInSectionByName ((PSWAP_INF)INFHandle, SectionHandle, Key) != NULL_HANDLE);
|
|
}
|
|
|
|
BOOLEAN
|
|
DnGetSectionEntryExists (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR Entry
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
LINE_HANDLE LineHandle;
|
|
PSWAP_SECTION SectionPtr=NULL;
|
|
PSWAP_LINE LinePtr=NULL;
|
|
PSWAP_VALUE ValuePtr=NULL;
|
|
PCHAR pEntryName;
|
|
|
|
SectionHandle = SearchSectionByName ((PSWAP_INF)INFHandle, SectionName);
|
|
|
|
if (!SectionHandle) {
|
|
return FALSE;
|
|
}
|
|
|
|
//_LOG(("Found [%s]\n", SectionName));
|
|
|
|
SectionPtr = GetSectionPtr((PSWAP_INF)INFHandle, SectionHandle);
|
|
|
|
LineHandle = SectionPtr->FirstLine;
|
|
|
|
while( LineHandle ){
|
|
|
|
LinePtr = GetLinePtr((PSWAP_INF)INFHandle, LineHandle);
|
|
|
|
pEntryName = NULL;
|
|
|
|
if( LinePtr->LineName[0] != 0){
|
|
pEntryName = LinePtr->LineName;
|
|
// _LOG(("Found Line %s\n", pEntryName));
|
|
}else{
|
|
ValuePtr = GetValuePtr((PSWAP_INF)INFHandle, LinePtr->FirstValue);
|
|
if (ValuePtr && (ValuePtr->ValueName[0] != 0)) {
|
|
pEntryName = ValuePtr->ValueName;
|
|
}else
|
|
pEntryName = NULL;
|
|
|
|
}
|
|
//_LOG(("Found Entry %s\n", pEntryName));
|
|
|
|
if( pEntryName && !stricmp( pEntryName, Entry )){
|
|
return TRUE;
|
|
}
|
|
|
|
LineHandle = GetNextLine((PSWAP_INF)INFHandle, LineHandle);
|
|
|
|
|
|
|
|
}// while
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
PCHAR
|
|
DnGetSectionKeyIndex (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR Key,
|
|
IN unsigned ValueIndex
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
LINE_HANDLE LineHandle;
|
|
VALUE_HANDLE ValueHandle;
|
|
PSWAP_VALUE Value;
|
|
PCHAR result;
|
|
|
|
SectionHandle = SearchSectionByName ((PSWAP_INF)INFHandle, SectionName);
|
|
|
|
if (!SectionHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
LineHandle = SearchLineInSectionByName ((PSWAP_INF)INFHandle, SectionHandle, Key);
|
|
|
|
if (!LineHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
ValueHandle = SearchValueInLineByIndex ((PSWAP_INF)INFHandle, LineHandle, ValueIndex);
|
|
|
|
if (!ValueHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
Value = GetValuePtr ((PSWAP_INF)INFHandle, ValueHandle);
|
|
|
|
result = MALLOC (Value->ValueSize - sizeof(SWAP_VALUE), TRUE);
|
|
|
|
strcpy (result, Value->ValueName);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
PCHAR
|
|
DnGetKeyName (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName,
|
|
IN unsigned LineIndex
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
LINE_HANDLE LineHandle;
|
|
PSWAP_LINE Line;
|
|
PCHAR result;
|
|
|
|
SectionHandle = SearchSectionByName ((PSWAP_INF)INFHandle, SectionName);
|
|
|
|
if (!SectionHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
LineHandle = SearchLineInSectionByIndex ((PSWAP_INF)INFHandle, SectionHandle, LineIndex);
|
|
|
|
if (!LineHandle) {
|
|
return NULL;
|
|
}
|
|
|
|
Line = GetLinePtr ((PSWAP_INF)INFHandle, LineHandle);
|
|
|
|
result = MALLOC (Line->LineSize - sizeof(SWAP_LINE), TRUE);
|
|
|
|
strcpy (result, Line->LineName);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
PVOID
|
|
DnNewSetupTextFile (
|
|
VOID
|
|
)
|
|
{
|
|
char SwapFilePath[MAX_PATH];
|
|
PSWAP_INF InfHandle = NULL;
|
|
unsigned long SwapSign;
|
|
|
|
//
|
|
// Prepare the swap file path
|
|
//
|
|
sprintf (SwapFilePath, "%c:\\INF%03u.SWP", DngSwapDriveLetter, g_Sequencer++);
|
|
|
|
//
|
|
// Allocate and populate the SWAP_INF structure
|
|
//
|
|
InfHandle = MALLOC(sizeof(SWAP_INF) + strlen (SwapFilePath) + 1, TRUE);
|
|
InfHandle->CurrentSection = NULL;
|
|
InfHandle->FirstSection = NULL;
|
|
InfHandle->LastSection = NULL;
|
|
InfHandle->SwapFileHandle = -1;
|
|
InfHandle->BufferSize = 0;
|
|
InfHandle->BufferDirty = FALSE;
|
|
InfHandle->Buffer = NULL;
|
|
InfHandle->BufferStart = 0;
|
|
InfHandle->BufferEnd = 0;
|
|
InfHandle->LastSectionHandle = NULL_HANDLE;
|
|
InfHandle->LastLineIndex = 0xffff;
|
|
InfHandle->LastLineHandle = NULL_HANDLE;
|
|
InfHandle->LastValueIndex = 0xffff;
|
|
InfHandle->LastValueHandle = NULL_HANDLE;
|
|
strcpy (InfHandle->SwapFile, SwapFilePath);
|
|
|
|
//
|
|
// Prepare the swap file
|
|
//
|
|
InfHandle->SwapFileHandle = open (InfHandle->SwapFile, O_BINARY|O_CREAT|O_TRUNC|O_RDWR, S_IREAD|S_IWRITE);
|
|
if (InfHandle->SwapFileHandle == -1) {
|
|
FREE (InfHandle);
|
|
return NULL;
|
|
}
|
|
else {
|
|
//
|
|
// write down signature
|
|
//
|
|
SwapSign = SWAP_SIGNATURE;
|
|
write (InfHandle->SwapFileHandle, &SwapSign, SWAP_SIGN_SIZE);
|
|
|
|
//
|
|
// Prepare the buffer
|
|
//
|
|
InfHandle->BufferSize = MAX_BUFFER_SIZE;
|
|
InfHandle->Buffer = MALLOC (MAX_BUFFER_SIZE, TRUE);
|
|
InfHandle->BufferStart = SWAP_SIGN_SIZE;
|
|
InfHandle->BufferEnd = SWAP_SIGN_SIZE;
|
|
return InfHandle;
|
|
}
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DnWriteSetupTextFile (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR FileName
|
|
)
|
|
{
|
|
struct find_t FindData;
|
|
FILE *Handle;
|
|
PSWAP_INF pInf;
|
|
SECTION_HANDLE Section;
|
|
PSWAP_SECTION SectionPtr;
|
|
LINE_HANDLE Line;
|
|
PSWAP_LINE LinePtr;
|
|
VALUE_HANDLE Value;
|
|
PSWAP_VALUE ValuePtr;
|
|
|
|
//
|
|
// See if the file exists and see if it is in read-only mode
|
|
//
|
|
if(!_dos_findfirst(FileName,_A_HIDDEN|_A_SUBDIR|_A_SYSTEM|_A_RDONLY,&FindData)) {
|
|
|
|
//
|
|
// The File Exists -- Perform some simple checks
|
|
//
|
|
if (FindData.attrib & _A_RDONLY) {
|
|
|
|
//
|
|
// Make it writeable
|
|
//
|
|
_dos_setfileattr(FileName,_A_NORMAL);
|
|
|
|
}
|
|
|
|
if (FindData.attrib & _A_SUBDIR) {
|
|
|
|
//
|
|
// This isn't a valid file that we can work with..
|
|
//
|
|
return FALSE;
|
|
|
|
}
|
|
}
|
|
//
|
|
// Obtain a handle to the file in write-only mode
|
|
//
|
|
Handle = fopen(FileName, "w+");
|
|
if (Handle == NULL) {
|
|
|
|
//
|
|
// We could not open the file
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
pInf = (PSWAP_INF) INFHandle;
|
|
if (pInf == NULL) {
|
|
|
|
//
|
|
// There isn't anything in the file.
|
|
// That isn't an error since we can empty
|
|
// the file if we so desire, but this is a
|
|
// strange way todo that. However...
|
|
//
|
|
fclose(Handle);
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// NOTE - This can't handle > 64k buffers. Which may or may not be
|
|
// important
|
|
//
|
|
Section = pInf->FirstSection;
|
|
while (Section) {
|
|
SectionPtr = GetSectionPtr (pInf, Section);
|
|
|
|
fprintf (Handle, "[%s]\n", SectionPtr->SectionName);
|
|
|
|
Line = SectionPtr->FirstLine;
|
|
while (Line) {
|
|
LinePtr = GetLinePtr (pInf, Line);
|
|
|
|
if ((LinePtr->LineName) && (LinePtr->LineName[0])) {
|
|
if (strchr (LinePtr->LineName, ' ') == NULL) {
|
|
fprintf (Handle, "%s = ", LinePtr->LineName);
|
|
} else {
|
|
fprintf (Handle, "\"%s\" = ", LinePtr->LineName);
|
|
}
|
|
}
|
|
|
|
Value = LinePtr->FirstValue;
|
|
while (Value) {
|
|
ValuePtr = GetValuePtr (pInf, Value);
|
|
|
|
fprintf (Handle,"\"%s\"", ValuePtr->ValueName);
|
|
|
|
Value = GetNextValue (pInf, Value);
|
|
if (Value) {
|
|
fprintf (Handle, ",");
|
|
}
|
|
}
|
|
Line = GetNextLine (pInf, Line);
|
|
fprintf (Handle,"\n");
|
|
}
|
|
Section = GetNextSection (pInf, Section);
|
|
}
|
|
|
|
//
|
|
// Flush and Close the file
|
|
//
|
|
fflush(Handle);
|
|
fclose(Handle);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
DnAddLineToSection (
|
|
IN PVOID INFHandle,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR KeyName,
|
|
IN PCHAR Values[],
|
|
IN ULONG ValueCount
|
|
)
|
|
{
|
|
SECTION_HANDLE SectionHandle;
|
|
LINE_HANDLE LineHandle;
|
|
VALUE_HANDLE ValueHandle;
|
|
ULONG v;
|
|
|
|
SectionHandle = AddSection ((PSWAP_INF)INFHandle, SectionName);
|
|
LineHandle = AddLine ((PSWAP_INF)INFHandle, SectionHandle, KeyName);
|
|
|
|
for (v = 0; v<ValueCount; v++) {
|
|
|
|
ValueHandle = AddValue ((PSWAP_INF)INFHandle, LineHandle, Values[v]);
|
|
}
|
|
}
|
|
|
|
|
|
PCHAR
|
|
DnGetSectionName (
|
|
IN PVOID INFHandle
|
|
)
|
|
{
|
|
PSWAP_INF pInf;
|
|
PSWAP_SECTION Section;
|
|
PCHAR result;
|
|
|
|
pInf = (PSWAP_INF)INFHandle;
|
|
if (!pInf->CurrentSection) {
|
|
pInf->CurrentSection = pInf->FirstSection;
|
|
}
|
|
else {
|
|
pInf->CurrentSection = GetNextSection (pInf, pInf->CurrentSection);
|
|
}
|
|
if (!pInf->CurrentSection) {
|
|
return NULL;
|
|
}
|
|
Section = GetSectionPtr (pInf, pInf->CurrentSection);
|
|
|
|
result = MALLOC (Section->SectionSize - sizeof(SWAP_SECTION), TRUE);
|
|
|
|
strcpy (result, Section->SectionName);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
VOID
|
|
DnCopySetupTextSection (
|
|
IN PVOID FromInf,
|
|
IN PVOID ToInf,
|
|
IN PCHAR SectionName
|
|
)
|
|
{
|
|
PSWAP_INF SourceInf;
|
|
PSWAP_INF DestInf;
|
|
SECTION_HANDLE SourceSection;
|
|
SECTION_HANDLE DestSection;
|
|
PSWAP_SECTION SectionPtr;
|
|
LINE_HANDLE SourceLine;
|
|
LINE_HANDLE DestLine;
|
|
PSWAP_LINE LinePtr;
|
|
VALUE_HANDLE SourceValue;
|
|
VALUE_HANDLE DestValue;
|
|
PSWAP_VALUE ValuePtr;
|
|
|
|
SourceInf = (PSWAP_INF)FromInf;
|
|
DestInf = (PSWAP_INF)ToInf;
|
|
|
|
SourceSection = SearchSectionByName (FromInf, SectionName);
|
|
if (SourceSection) {
|
|
SectionPtr = GetSectionPtr (SourceInf, SourceSection);
|
|
DestSection = AddSection (DestInf, SectionPtr->SectionName);
|
|
if (DestSection) {
|
|
SourceLine = SectionPtr->FirstLine;
|
|
while (SourceLine) {
|
|
LinePtr = GetLinePtr (SourceInf, SourceLine);
|
|
DestLine = AddLine (DestInf, DestSection, LinePtr->LineName);
|
|
SourceValue = LinePtr->FirstValue;
|
|
while (SourceValue) {
|
|
ValuePtr = GetValuePtr (SourceInf, SourceValue);
|
|
DestValue = AddValue (DestInf, DestLine, ValuePtr->ValueName);
|
|
SourceValue = GetNextValue (SourceInf, SourceValue);
|
|
}
|
|
SourceLine = GetNextLine (SourceInf, SourceLine);
|
|
}
|
|
}
|
|
}
|
|
}
|