windows-server-2003/inetcore/setup/ieak5/parser/admparse.cpp

#include <w95wraps.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include "shlwapi.h"
#include "parse.h"
#include "..\ieakutil\ieakutil.h"

#define NCATEGORY        0
#define NPOLICY          1
#define NPART            2
#define NACTIONLIST      3

TCHAR *pKeyNames[29] = { TEXT("CLASS"), TEXT("CATEGORY"), TEXT("KEYNAME"), TEXT("POLICY"), TEXT("VALUENAME"),
    TEXT("ACTIONLISTON"), TEXT("ACTIONLISTOFF"), TEXT("PART"), TEXT("END"), TEXT("ITEMLIST"), TEXT("NAME"),
    TEXT("MAXLEN"), TEXT("DEFAULT"), TEXT("ACTIONLIST"), TEXT("SUGGESTIONS"), TEXT("MIN"), TEXT("MAX"), TEXT("VALUEON"),
    TEXT("VALUEOFF"), TEXT("VALUE"), TEXT("DEFCHECKED"), TEXT("SPIN"), TEXT("#if"), TEXT("#endif"), TEXT("VERSION"),
    TEXT("<"), TEXT("<="), TEXT(">"), TEXT(">=") };

TCHAR *pPartTypes[8] = { TEXT("EDITTEXT"), TEXT("DROPDOWNLIST"), TEXT("NUMERIC"), TEXT("CHECKBOX"),
    TEXT("LISTBOX"), TEXT("TEXT"), TEXT("COMBOBOX"), TEXT("POLICY") };

BOOL ReadAdmFile(LPADMFILE, LPCTSTR);
void FreeAdmMemory(LPADMFILE);
int g_nLine = 1;

#define MAX_NUMERIC     32767
#define MAX_EDITTEXTLEN 512
#define ALLOCATE        100
#define REALLOCATE      101

//-------------------------------------------------------------------------
//  F I L E  E X I S T S
//
//  Checks to see if a file exists and returns true if it does
//-------------------------------------------------------------------------
BOOL FileExists( LPCTSTR pcszFile )
{
    return (GetFileAttributes( pcszFile ) != -1 );
}

void FreeActionList(LPACTIONLIST pActionList, int nActions)
{
    if (pActionList == NULL)
        return;
    
    for(int nActionListIndex = 0; nActionListIndex < nActions; nActionListIndex++)
    {
        if(pActionList[nActionListIndex].szName != NULL)
            LocalFree(pActionList[nActionListIndex].szName);

        if(pActionList[nActionListIndex].szValue != NULL)
            LocalFree(pActionList[nActionListIndex].szValue);
    
        for(int nValueIndex = 0; nValueIndex < pActionList[nActionListIndex].nValues; nValueIndex++)
        {
            if(pActionList[nActionListIndex].value[nValueIndex].szKeyname != NULL)
                LocalFree(pActionList[nActionListIndex].value[nValueIndex].szKeyname);
            if(pActionList[nActionListIndex].value[nValueIndex].szValueName != NULL)
                LocalFree(pActionList[nActionListIndex].value[nValueIndex].szValueName);
            if(pActionList[nActionListIndex].value[nValueIndex].szValue != NULL)
                LocalFree(pActionList[nActionListIndex].value[nValueIndex].szValue);
            if(pActionList[nActionListIndex].value[nValueIndex].szValueOn != NULL)
                LocalFree(pActionList[nActionListIndex].value[nValueIndex].szValueOn);
            if(pActionList[nActionListIndex].value[nValueIndex].szValueOff != NULL)
                LocalFree(pActionList[nActionListIndex].value[nValueIndex].szValueOff);
        }

        if (pActionList[nActionListIndex].value != NULL)
            HeapFree(GetProcessHeap(), 0, pActionList[nActionListIndex].value);
    }
}

//--------------------------------------------------------------------------
//  F R E E  A D M  M E M O R Y     Exported Function
//
//  Releases memory allocated by ReadAdmFile
//--------------------------------------------------------------------------
void FreeAdmMemory( LPADMFILE pAdmFile )
{
    if (pAdmFile == NULL)
        return;

    for(int nPartIndex = 0; nPartIndex < pAdmFile->nParts; nPartIndex++ )
    {
        if(pAdmFile->pParts[nPartIndex].szName != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].szName);
        if(pAdmFile->pParts[nPartIndex].szCategory != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].szCategory);
        if(pAdmFile->pParts[nPartIndex].szDefaultValue != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].szDefaultValue);

        if(pAdmFile->pParts[nPartIndex].value.szKeyname != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].value.szKeyname);
        if(pAdmFile->pParts[nPartIndex].value.szValueName != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].value.szValueName);
        if(pAdmFile->pParts[nPartIndex].value.szValue != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].value.szValue);
        if(pAdmFile->pParts[nPartIndex].value.szValueOn != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].value.szValueOn);
        if(pAdmFile->pParts[nPartIndex].value.szValueOff != NULL)
            LocalFree(pAdmFile->pParts[nPartIndex].value.szValueOff);

        FreeActionList(pAdmFile->pParts[nPartIndex].actionlist, pAdmFile->pParts[nPartIndex].nActions);
        if (pAdmFile->pParts[nPartIndex].actionlist != NULL)
            HeapFree(GetProcessHeap(), 0, pAdmFile->pParts[nPartIndex].actionlist);

        for(int nSuggestionIndex = 0; nSuggestionIndex < pAdmFile->pParts[nPartIndex].nSuggestions; nSuggestionIndex++)
        {
            if(pAdmFile->pParts[nPartIndex].suggestions[nSuggestionIndex].szText != NULL)
                LocalFree(pAdmFile->pParts[nPartIndex].suggestions[nSuggestionIndex].szText);
        }
        if (pAdmFile->pParts[nPartIndex].suggestions != NULL)
            HeapFree(GetProcessHeap(), 0, pAdmFile->pParts[nPartIndex].suggestions);
    }
    
    if(pAdmFile->pParts != NULL)
    {
        HeapFree(GetProcessHeap(), 0, pAdmFile->pParts);
        pAdmFile->pParts = NULL;
    }

    pAdmFile->nParts = 0;
    *pAdmFile->szFilename = TEXT('\0');
}

void FreePartData( LPVOID* pPartData, int nParts )
{
    LPPARTDATA pData = NULL;

    if (pData == NULL)
        return;

    pData = (LPPARTDATA)*pPartData;

    for(int nPartIndex = 0; nPartIndex < nParts; nPartIndex++ )
    {
        if(pData != NULL && pData[nPartIndex].value.szValue != NULL)
            LocalFree(pData[nPartIndex].value.szValue);

        FreeActionList(pData[nPartIndex].actionlist, pData[nPartIndex].nActions);
        if (pData[nPartIndex].actionlist != NULL)
            HeapFree(GetProcessHeap(), 0, pData[nPartIndex].actionlist);
    }
    
    HeapFree(GetProcessHeap(), 0, pData);
    pData = NULL;
}

//--------------------------------------------------------------------------
//  R E A D  K E Y  W O R D
//
//  Reads the next word in the string pData and copyies it into szKeyWord
//  Returns a pointer to the next character after the word
//--------------------------------------------------------------------------
TCHAR *ReadKeyword( TCHAR *pData, TCHAR *szKeyWord, int cchLength )
{
    int i;
    int nIndex;

    memset( szKeyWord, 0, cchLength*sizeof(TCHAR) );

    // remove whitespace
    i = StrSpn( pData, TEXT(" \n\t\x0d\x0a") );
    if(i)
    {
        for(nIndex = 0; nIndex < i; nIndex++)
        {
            if(*(pData + nIndex) == TEXT('\x0a'))
                g_nLine++;
        }
    }
    pData += i;

    i = StrCSpn( pData, TEXT(" \n\t\x0d\x0a") );

    if( i > cchLength )       // make sure we dont overrun our buffer
        i = cchLength - 1;

    StrCpyN( szKeyWord, pData, i+1 );

    pData += i;
    return pData;
}

//--------------------------------------------------------------------------
//  G E T  E O F
//
//  Returns the number of bytes in pFile
//--------------------------------------------------------------------------
//int GetEof( FILE *pFile )
//{
//    int i = 0;
//    char cByte;
//
//    while( !feof( pFile ))
//    {
//        fread( &cByte, 1, 1, pFile );
//        i++;
//    }
//    rewind( pFile );
//    return i;
//}

//--------------------------------------------------------------------------
//  G E T  K E Y  N A M E
//
//  Compares szKeyName to an array of available keynames and returns an
//  index into that array
//--------------------------------------------------------------------------
int GetKeyName( TCHAR *szKeyName )
{
    int i;
    for( i = 0; i < ARRAYSIZE( pKeyNames ); i++ )
    {
        if( StrCmpI( szKeyName, pKeyNames[i] ) == 0 )
            return i;
    }
    return KEY_ERROR;
}

//--------------------------------------------------------------------------
//  G E T  P A R T  N A M E
//
//  compares szParyType to an array of available part types and return an
//  index into that array
//--------------------------------------------------------------------------
int GetPartName( TCHAR *szPartType )
{
    int i;
    for( i = 0; i < ARRAYSIZE( pPartTypes ); i++ )
    {
        if( StrCmp( szPartType, pPartTypes[i] ) == 0 )
            return i;
    }
    return PART_ERROR;
}

//--------------------------------------------------------------------------
//  C H E C K  S T R I N G S
//
//  Checks to see if szString is localizable and replaces it if it is
//--------------------------------------------------------------------------
void CheckStrings( TCHAR *szString, LPCTSTR pcszFileName )
{
    TCHAR szTemp[1024];

    if( StrCmpN( szString, TEXT("!!"), 2 ) == 0 )
    {
        szString += 2; //incrememt pointer

        GetPrivateProfileString( TEXT("strings"), szString, TEXT(""), szTemp,
            ARRAYSIZE( szTemp ), pcszFileName );

        szString -= 2; //decrement pointer

        if( *szTemp )
        {
            StrCpy( szString, szTemp );
        }
    }
}

//--------------------------------------------------------------------------
//  G E T  Q U O T E D  T E X T
//
//  Checks to see if the current word is quoted and copies the entire
//  series of quoted words into szKeyWord
//--------------------------------------------------------------------------
TCHAR *GetQuotedText( TCHAR *pData, TCHAR *szKeyWord, int nLength )
{
    int i;

    pData -= lstrlen( szKeyWord );

    // if we are not quoted, return the current pointer
    if( pData[0] != TEXT('\"') )
    {
        pData += lstrlen( szKeyWord );
        return pData;
    }

    // skip over first quote
    pData++;

    // search for another quote or a newline character
    i = StrCSpn( pData, TEXT("\"\n") );
    memset( szKeyWord, 0, nLength );
    StrCpyN( szKeyWord, pData, i+1 );
    pData += i;
    return ++pData;
}

//--------------------------------------------------------------------------
//  R E A D  V A L U E
//
//  
//--------------------------------------------------------------------------
TCHAR *ReadValue( TCHAR *pCurrent, LPVALUE value, int nValue, LPCTSTR pcszFileName )
{
    TCHAR szKeyWord[1024];

    pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
    if( StrCmp( szKeyWord, TEXT("VALUE") ) == 0 )
    {
        pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
        if(value[nValue].szValue != NULL)
            LocalFree(value[nValue].szValue);
        value[nValue].szValue = NULL;
        if( StrCmp( szKeyWord, TEXT("NUMERIC") ) == 0 )
        {
            pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
            value[nValue].dwValue = StrToInt( szKeyWord );
            value[nValue].fNumeric = TRUE;
        }
        else
        {
            if( StrCmp( szKeyWord, TEXT("TEXT") ) == 0 )
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));

            if (pCurrent && (*pCurrent != TEXT('\0')))
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
            CheckStrings( szKeyWord, pcszFileName );
            value[nValue].szValue = StrDup(szKeyWord);
        }
    }

    return pCurrent;
}

BOOL AllocateActions(LPACTIONLIST* actionlist, int nAllocate, int nAllocType)
{
    LPVOID lpTemp = NULL;
    
    if(nAllocType == ALLOCATE)
    {
        *actionlist = (LPACTIONLIST) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACTIONLIST) * nAllocate);
        if(*actionlist == NULL)
            return FALSE;
    }
    else
    {
        lpTemp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *actionlist, sizeof(ACTIONLIST) * nAllocate);
        if(lpTemp == NULL)
            return FALSE;
        *actionlist = (LPACTIONLIST) lpTemp;
    }
    return TRUE;
}

BOOL AllocateValues(LPVALUE* values, int nAllocate, int nAllocType)
{
    LPVOID lpTemp = NULL;

    if(nAllocType == ALLOCATE)
    {
        *values = (LPVALUE) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VALUE) * nAllocate);
        if(*values == NULL)
            return FALSE;
    }
    else
    {
        lpTemp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *values, sizeof(VALUE) * nAllocate);
        if(lpTemp == NULL)
            return FALSE;
        *values = (LPVALUE) lpTemp;
    }
    return TRUE;
}

BOOL AllocateSuggestions(LPSUGGESTIONS* suggestions, int nAllocate, int nAllocType)
{
    LPVOID lpTemp = NULL;

    if(nAllocType == ALLOCATE)
    {
        *suggestions = (LPSUGGESTIONS) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SUGGESTIONS) * nAllocate);
        if(*suggestions == NULL)
            return FALSE;
    }
    else
    {
        lpTemp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *suggestions, sizeof(SUGGESTIONS) * nAllocate);
        if(lpTemp == NULL)
            return FALSE;
        *suggestions = (LPSUGGESTIONS) lpTemp;
    }
    return TRUE;
}

//--------------------------------------------------------------------------
//  R E A D  A D M  F I L E         Exported Function
//
//  Parses a global policy template into an array of PARTs.
//--------------------------------------------------------------------------
BOOL ReadAdmFile( LPADMFILE admfile, LPCTSTR pcszFileName)
{
    HANDLE hFile;
    TCHAR *pData;
    TCHAR *pCurrent;
    TCHAR szKeyWord[1024];
    int nFileSize;
    int nParts = 0;
    int nValues = 0;
    int nSuggestions = 0;
    LPPART part = NULL;
    LPVALUE value = NULL;
    LPSUGGESTIONS suggestions = NULL;
    HGLOBAL hFileMem;
    int nPartsAlloc = 100;
    int nValuesAlloc = 0;
    int nSuggestionsAlloc = 0;

    HKEY hkCurrentClass = HKEY_CURRENT_USER;
    TCHAR szCurrentCategory[1024];
    BOOL fInPart = FALSE, fInPolicy = FALSE, fInCategory = FALSE;
    BOOL fInActionList = FALSE;
    TCHAR szRegKey[4][1024];
    TCHAR szValueName[1024];
    BOOL bContinue = TRUE;

    int nActionsAlloc = 0;
    int nActions = 0;
    LPACTIONLIST actionlist = NULL;
    LPVOID lpTemp = NULL;
    int nPolicyPart = -1;
    int nKeyValue = 0;
    TCHAR szValueOn[1024];
    TCHAR szValueOff[1024];
    int nValueOn = 1;
    int nValueOff = 0;
    BOOL fInItemList = FALSE;
    int nActionListType = -1;
    BOOL fSkip = FALSE;

    if( !FileExists( pcszFileName ))
    {
        SetLastError( ERROR_FILE_NOT_FOUND );
        return FALSE;
    }

    // allocate memory
    part = (LPPART) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PART) * nPartsAlloc);

    // set up pointers and structures
    admfile->pParts = part;
    admfile->nParts = 0;

    if(part == NULL)
    {
        FreeAdmMemory( admfile );
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
    }

    memset( szRegKey, 0, sizeof( szRegKey ));

    hFile = CreateFile( pcszFileName, GENERIC_READ, FILE_SHARE_READ,
        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL );
    if( hFile == INVALID_HANDLE_VALUE )
    {
        FreeAdmMemory( admfile );
        return FALSE;
    }

    nFileSize = GetFileSize( hFile, NULL );

    hFileMem = LocalAlloc( LPTR, (nFileSize + 1)*sizeof(TCHAR));

    if( hFileMem == NULL )
    {
        CloseHandle( hFile );
        FreeAdmMemory( admfile );
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
        return FALSE;
    }

    pData = (LPTSTR) hFileMem;

    // read all of the data available

    ReadStringFromFile( hFile, pData, (DWORD) nFileSize);
    CloseHandle( hFile );

    // set the current pointer to the beginning of the data
    pCurrent = pData;
    g_nLine = 1;

    // main loop
    do
    {
        pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
        if( pCurrent >= pData + nFileSize )
            break;
        
        nKeyValue = GetKeyName(szKeyWord);

        if (nKeyValue != KEY_ENDIF && fSkip == TRUE)
            continue;
        
        switch((nKeyValue))
        {
        case KEY_CLASS:
            pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
            if( StrCmp( szKeyWord, TEXT("MACHINE") ) == 0 )
                hkCurrentClass = HKEY_LOCAL_MACHINE;
            if( StrCmp( szKeyWord, TEXT("USER") ) == 0 )
                hkCurrentClass = HKEY_CURRENT_USER;
            break;

        case KEY_CATEGORY:
            fInCategory = TRUE;
            pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
            pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
            CheckStrings( szKeyWord, pcszFileName );
            StrCpy( szCurrentCategory, szKeyWord );
            // patch for displaying the icon
            part[nParts].hkClass = hkCurrentClass;
            if(part[nParts].szCategory != NULL)
                LocalFree(part[nParts].szCategory);
            part[nParts].szCategory = NULL;
            part[nParts].szCategory = StrDup(szCurrentCategory);
            part[nParts].nType = PART_ERROR;
            break;

        case KEY_END:
            pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
            switch( GetKeyName( szKeyWord ))
            {
            case KEY_PART:
                if(fInPart)
                {
                    if(part[nParts].nType != PART_TEXT && part[nParts].nType != PART_ERROR)
                    {
                        if(part[nParts].value.szKeyname != NULL)
                            LocalFree(part[nParts].value.szKeyname);
                        part[nParts].value.szKeyname = NULL;
                        if( ISNONNULL( szRegKey[NPART] ))
                        {
                            part[nParts].value.szKeyname = StrDup(szRegKey[NPART]);
                            memset( szRegKey[NPART], 0, sizeof( szRegKey[NPART] ));
                        }
                        else if( ISNONNULL( szRegKey[NPOLICY] ))
                            part[nParts].value.szKeyname = StrDup(szRegKey[NPOLICY]);

                        else if( ISNONNULL( szRegKey[NCATEGORY] ))
                            part[nParts].value.szKeyname = StrDup(szRegKey[NCATEGORY]);

                        if(part[nParts].value.szValueName != NULL)
                            LocalFree(part[nParts].value.szValueName);
                        part[nParts].value.szValueName = NULL;
                        part[nParts].value.szValueName = StrDup(szValueName);

                        // using szDefaultValue variable as the storage for holding the policy key for
                        // part as a listbox only
                        if((lstrlen(szRegKey[NPOLICY]) || lstrlen(szRegKey[NCATEGORY])) && part[nParts].nType == PART_LISTBOX)
                        {
                            if(part[nParts].szDefaultValue != NULL)
                                LocalFree(part[nParts].szDefaultValue);
                            part[nParts].szDefaultValue = NULL;
                            if(ISNONNULL(szRegKey[NPOLICY]))
                                part[nParts].szDefaultValue = StrDup(szRegKey[NPOLICY]);
                            else
                                part[nParts].szDefaultValue = StrDup(szRegKey[NCATEGORY]);
                        }
                    }

                    if(nActions)
                    {
                        if(!AllocateActions(&actionlist, nActions, REALLOCATE))
                            bContinue = FALSE;
                        else
                            part[nParts].actionlist = &actionlist[0];
                    }
                    if(nSuggestions)
                    {
                        if(!AllocateSuggestions(&suggestions, nSuggestions, REALLOCATE))
                            bContinue = FALSE;
                        else
                            part[nParts].suggestions = &suggestions[0];
                    }
                
                    nParts++;
                    if(nParts >= nPartsAlloc)
                    {
                        nPartsAlloc += 50;
                        lpTemp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, part, sizeof(PART) * nPartsAlloc);
                        if(lpTemp == NULL)
                            bContinue = FALSE;
                        else
                            part = (LPPART) lpTemp;
                    }
                    memset(szRegKey[NACTIONLIST], 0, sizeof( szRegKey[NACTIONLIST]));
                    fInPart = FALSE;
                }
                break;

            case KEY_POLICY:
                if(fInPolicy)
                {
                    if(part[nPolicyPart].fRequired == TRUE)
                    {
                        if(part[nPolicyPart].value.szKeyname != NULL)
                            LocalFree(part[nPolicyPart].value.szKeyname);
                        part[nPolicyPart].value.szKeyname = NULL;

                        if( ISNONNULL( szRegKey[NPOLICY] ))
                            part[nPolicyPart].value.szKeyname = StrDup(szRegKey[NPOLICY]);
                        else if( ISNONNULL( szRegKey[NCATEGORY] ))
                            part[nPolicyPart].value.szKeyname = StrDup(szRegKey[NCATEGORY]);

                        if(part[nPolicyPart].value.szValueName != NULL)
                            LocalFree(part[nPolicyPart].value.szValueName);
                        part[nPolicyPart].value.szValueName = NULL;
                        part[nPolicyPart].value.szValueName = StrDup(szValueName);

                        part[nPolicyPart].value.nValueOn = nValueOn;
                        part[nPolicyPart].value.nValueOff = nValueOff;
                        if(*szValueOn != TEXT('\0'))
                        {
                            if(part[nPolicyPart].value.szValueOn != NULL)
                                LocalFree(part[nPolicyPart].value.szValueOn);
                            part[nPolicyPart].value.szValueOn = NULL;
                            part[nPolicyPart].value.szValueOn = StrDup(szValueOn);
                        }
                        if(*szValueOff != TEXT('\0'))
                        {
                            if(part[nPolicyPart].value.szValueOff != NULL)
                                LocalFree(part[nPolicyPart].value.szValueOff);
                            part[nPolicyPart].value.szValueOff = NULL;
                            part[nPolicyPart].value.szValueOff = StrDup(szValueOff);
                        }
                    }

                    memset(szRegKey[NACTIONLIST], 0, sizeof(szRegKey[NACTIONLIST]));
                    memset( szRegKey[NPART], 0, sizeof( szRegKey[NPART] ));
                    memset( szRegKey[NPOLICY], 0, sizeof( szRegKey[NPOLICY] ));
                    nPolicyPart = -1;
                    fInPolicy = FALSE;
                }
                break;

            case KEY_CATEGORY:
                if(fInCategory)
                {
                    memset(szRegKey[NACTIONLIST], 0, sizeof(szRegKey[NACTIONLIST]));
                    memset( szRegKey[NPART], 0, sizeof( szRegKey[NPART] ));
                    memset( szRegKey[NPOLICY], 0, sizeof( szRegKey[NPOLICY] ));
                    memset( szRegKey[NCATEGORY], 0, sizeof( szRegKey[NCATEGORY] ));
                    fInCategory = FALSE;
                }
                break;

            case KEY_ACTIONLIST:
            case KEY_ACTIONLISTOFF:
            case KEY_ACTIONLISTON:
                if(fInActionList)
                {
                    if(nValues)
                    {
                        if(!AllocateValues(&value, nValues, REALLOCATE))
                            bContinue = FALSE;
                        else
                        {
                            part[nParts].actionlist[part[nParts].nActions - 1].value = &value[0];
                            nValuesAlloc = nValues;
                        }
                    }
                    memset(szRegKey[NACTIONLIST], 0, sizeof(szRegKey[NACTIONLIST]));
                    fInActionList = FALSE;
                }
                break;

            case KEY_ITEMLIST:
                fInItemList = FALSE;
            }
            break;
        
        case KEY_ACTIONLISTON:
        case KEY_ACTIONLISTOFF:
            if (part[nParts].nType == PART_CHECKBOX)
            {
                fInActionList = TRUE;
                nActionListType = (nKeyValue == KEY_ACTIONLISTOFF) ? 0 : 1;

                if(part[nParts].nActions == 0)
                {
                    nActionsAlloc = 1;
                    if(!AllocateActions(&actionlist, nActionsAlloc, ALLOCATE))
                        bContinue = FALSE;
                    else
                        part[nParts].actionlist = &actionlist[0];

                    part[nParts].nActions++;
                    nActions++;
                    nValues = 0;
                    nValuesAlloc = 0;
                    value = NULL;
                }
            }
            break;

        case KEY_ACTIONLIST:
            if (fInItemList)
                fInActionList = TRUE;
            break;

        case KEY_ITEMLIST:
            if (fInPart)
                fInItemList = TRUE;
            break;

        case KEY_MAXLEN:
            if(part[nParts].nType == PART_EDITTEXT)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                part[nParts].nMax = StrToInt( szKeyWord );
                if (part[nParts].nMax > MAX_EDITTEXTLEN)
                    part[nParts].nMax = MAX_EDITTEXTLEN;
            }
            break;

        case KEY_MIN:
            if(part[nParts].nType == PART_NUMERIC)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                part[nParts].nMin = StrToInt( szKeyWord );
            }
            break;

        case KEY_MAX:
            if(part[nParts].nType == PART_NUMERIC)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                part[nParts].nMax = StrToInt( szKeyWord );
            }
            break;

        case KEY_SPIN:
            if(part[nParts].nType == PART_NUMERIC)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                part[nParts].nSpin = StrToInt( szKeyWord );
            }
            break;

        case KEY_DEFCHECKED:
            if(part[nParts].nType == PART_CHECKBOX)
                part[nParts].nDefault = 1;
            else if(!fInPart && fInPolicy)
                part[nParts - 1].nDefault = 1;
            break;
        
        case KEY_DEFAULT:
            if( part[nParts].nType == PART_NUMERIC)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                part[nParts].nDefault = StrToInt( szKeyWord );
            }
            else if( part[nParts].nType == PART_EDITTEXT || part[nParts].nType == PART_COMBOBOX)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                CheckStrings( szKeyWord, pcszFileName );
                if(part[nParts].szDefaultValue != NULL)
                    LocalFree(part[nParts].szDefaultValue);
                part[nParts].szDefaultValue = NULL;
                part[nParts].szDefaultValue = StrDup(szKeyWord);
            }
            else if(part[nParts].nType == PART_DROPDOWNLIST)
            {
                if(part[nParts].szDefaultValue != NULL)
                    LocalFree(part[nParts].szDefaultValue);
                part[nParts].szDefaultValue = NULL;
                if(part[nParts].nActions != 0 && part[nParts].actionlist[part[nParts].nActions - 1].szName != NULL)
                    part[nParts].szDefaultValue = StrDup(part[nParts].actionlist[part[nParts].nActions - 1].szName);
            }
            break;

        case KEY_PART:
            if(fInPolicy)
            {
                fInPart = TRUE;
                // read the name of the part
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                CheckStrings( szKeyWord, pcszFileName );
                if(part[nParts].szName != NULL)
                    LocalFree(part[nParts].szName);
                part[nParts].szName = NULL;
                part[nParts].szName = StrDup(szKeyWord);
                // read the type of the part
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                part[nParts].nType = GetPartName( szKeyWord );
                if(part[nParts].nType != PART_TEXT && part[nParts].nType != PART_ERROR && nPolicyPart != -1)
                    part[nPolicyPart].fRequired = FALSE;
                part[nParts].hkClass = hkCurrentClass;
                if(part[nParts].szCategory != NULL)
                    LocalFree(part[nParts].szCategory);
                part[nParts].szCategory = NULL;
                part[nParts].szCategory = StrDup(szCurrentCategory);
                part[nParts].nLine = g_nLine;
                part[nParts].nMax = MAX_NUMERIC;
                if (part[nParts].nType == PART_EDITTEXT)
                    part[nParts].nMax = MAX_PATH;
                if(part[nParts].nType == PART_CHECKBOX)
                {
                    part[nParts].value.nValueOn = nValueOn;
                    part[nParts].value.nValueOff = nValueOff;
                    if(*szValueOn != 0)
                    {
                        if(part[nParts].value.szValueOn != NULL)
                            LocalFree(part[nParts].value.szValueOn);
                        part[nParts].value.szValueOn = NULL;
                        part[nParts].value.szValueOn = StrDup(szValueOn);
                    }
                    if(*szValueOff != 0)
                    {
                        if(part[nParts].value.szValueOff != NULL)
                            LocalFree(part[nParts].value.szValueOff);
                        part[nParts].value.szValueOff = NULL;
                        part[nParts].value.szValueOff = StrDup(szValueOff);
                    }
                }
                nActionsAlloc = 0;
                nActions = 0;
                actionlist = NULL;
                nSuggestions = 0;
                nSuggestionsAlloc = 0;
                suggestions = NULL;
            }
            break;

        case KEY_POLICY:
            if(fInCategory)
            {
                fInPolicy = TRUE;
                nPolicyPart = nParts;
                part[nParts].fRequired = TRUE;
                memset(szValueOn, 0, sizeof(szValueOn));
                memset(szValueOff, 0, sizeof(szValueOff));
                nValueOn = 1;
                nValueOff = 0;
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                CheckStrings( szKeyWord, pcszFileName );
                // to display policy name, add as a text
                if(part[nParts].szName != NULL)
                    LocalFree(part[nParts].szName);
                part[nParts].szName = NULL;
                part[nParts].szName = StrDup(szKeyWord);
                part[nParts].nType = GetPartName( TEXT("POLICY") );
                part[nParts].hkClass = hkCurrentClass;
                if(part[nParts].szCategory != NULL)
                    LocalFree(part[nParts].szCategory);
                part[nParts].szCategory = NULL;
                part[nParts].szCategory = StrDup(szCurrentCategory);
                part[nParts].nLine = g_nLine;
                nParts++;           
                if(nParts >= nPartsAlloc)
                {
                    nPartsAlloc += 50;
                    lpTemp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, part, sizeof(PART) * nPartsAlloc);
                    if(lpTemp == NULL)
                        bContinue = FALSE;
                    else
                        part = (LPPART) lpTemp;
                }
            }
            break;

        case KEY_NAME:
            if(fInItemList)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                CheckStrings( szKeyWord, pcszFileName );
                if(part[nParts].nActions == 0)
                {
                    nActionsAlloc = 10;
                    if(!AllocateActions(&actionlist, nActionsAlloc, ALLOCATE))
                        bContinue = FALSE;
                    else
                        part[nParts].actionlist = &actionlist[0];
                }
                if(part[nParts].actionlist[part[nParts].nActions].szName != NULL)
                    LocalFree(part[nParts].actionlist[part[nParts].nActions].szName);
                part[nParts].actionlist[part[nParts].nActions].szName = NULL;
                part[nParts].actionlist[part[nParts].nActions].szName = StrDup(szKeyWord);
                part[nParts].nActions++;
                nActions++;
                if(nActions >= nActionsAlloc)
                {
                    nActionsAlloc += 10;
                    if(!AllocateActions(&actionlist, nActionsAlloc, REALLOCATE))
                        bContinue = FALSE;
                    else
                        part[nParts].actionlist = &actionlist[0];
                }
                nValues = 0;
                nValuesAlloc = 0;
                value = NULL;
            }
            break;

        case KEY_KEYNAME:
            pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
            pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
            if( fInActionList )
            {
                StrCpy( szRegKey[NACTIONLIST], szKeyWord );
                break;
            }
            if( fInPart )
            {
                StrCpy( szRegKey[NPART], szKeyWord );
                break;
            }
            if( fInPolicy )
            {
                StrCpy( szRegKey[NPOLICY], szKeyWord );
                break;
            }
            if( fInCategory )
            {
                StrCpy( szRegKey[NCATEGORY], szKeyWord );
                break;
            }
            break;

        case KEY_VALUENAME:
            if( fInActionList )
            {
                if(part[nParts].nActions == 0)
                    break;
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                // put the pointer to the current value into the actionlist
                if( part[nParts].actionlist[part[nParts].nActions - 1].nValues == 0)
                {
                    nValuesAlloc = 10;
                    if(!AllocateValues(&value, nValuesAlloc, ALLOCATE))
                        bContinue = FALSE;
                    else
                        part[nParts].actionlist[part[nParts].nActions - 1].value = &value[0];
                }
                else if (nValues >= nValuesAlloc)
                {
                    nValuesAlloc += 10;
                    if(!AllocateValues(&value, nValuesAlloc, REALLOCATE))
                        bContinue = FALSE;
                    else
                        part[nParts].actionlist[part[nParts].nActions - 1].value = &value[0];
                }

                if(value[nValues].szValueName != NULL)
                    LocalFree(value[nValues].szValueName);
                value[nValues].szValueName = NULL;
                value[nValues].szValueName = StrDup(szKeyWord);

                if(value[nValues].szKeyname != NULL)
                    LocalFree(value[nValues].szKeyname);
                value[nValues].szKeyname = NULL;

                if( ISNONNULL( szRegKey[NACTIONLIST] ))
                    value[nValues].szKeyname = StrDup(szRegKey[NACTIONLIST]);
                else if( ISNONNULL( szRegKey[NPART] ))
                    value[nValues].szKeyname = StrDup(szRegKey[NPART]);
                else if( ISNONNULL( szRegKey[NPOLICY] ))
                    value[nValues].szKeyname = StrDup(szRegKey[NPOLICY]);
                else if( ISNONNULL( szRegKey[NCATEGORY] ))
                    value[nValues].szKeyname = StrDup(szRegKey[NCATEGORY]);

                part[nParts].actionlist[part[nParts].nActions - 1].nValues++;

                pCurrent = ReadValue( pCurrent, &value[0], nValues, pcszFileName );

                if (part[nParts].nType == PART_CHECKBOX)
                    value[nValues].nValueOn = nActionListType;  // nValueOn is used as a buffer to hold the ACTIONLISTOFF/ON type.

                nValues++;
                break;
            }
            if( fInPolicy || fInPart )
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                StrCpy( szValueName, szKeyWord );
                break;
            }
            break;

        case KEY_SUGGESTIONS:
            if(fInPart)
            {
                while( StrCmp( szKeyWord, TEXT("END") ) != 0 && bContinue == TRUE)
                {
                    pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                    pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                    CheckStrings( szKeyWord, pcszFileName );
                    if( StrCmp( szKeyWord, TEXT("END") ) != 0 )
                    {
                        if(part[nParts].nSuggestions == 0)
                        {
                            nSuggestionsAlloc = 10;
                            if(!AllocateSuggestions(&suggestions, nSuggestionsAlloc, ALLOCATE))
                                bContinue = FALSE;
                            else
                                part[nParts].suggestions = &suggestions[0];
                        }
                        if(suggestions[nSuggestions].szText != NULL)
                            LocalFree(suggestions[nSuggestions].szText);
                        suggestions[nSuggestions].szText = NULL;
                        suggestions[nSuggestions].szText = StrDup(szKeyWord);
                        part[nParts].nSuggestions++;
                        nSuggestions++;
                        if(nSuggestions >= nSuggestionsAlloc)
                        {
                            nSuggestionsAlloc += 10;
                            if(!AllocateSuggestions(&suggestions, nSuggestionsAlloc, REALLOCATE))
                                bContinue = FALSE;
                            else
                                part[nParts].suggestions = &suggestions[0];
                        }
                    }
                }

                // throw out the word "suggestions"
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
            }
            break;

        case KEY_VALUEON:
        case KEY_VALUEOFF:
            if(fInPolicy || fInPart)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                //pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                //CheckStrings( szKeyWord, pcszFileName );
                if( StrCmp( szKeyWord, TEXT("NUMERIC") ) == 0 )
                {
                    pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                    if(nKeyValue == KEY_VALUEON)
                    {
                        if(!fInPart)
                            nValueOn = StrToInt( szKeyWord );
                        else if(fInPart && part[nParts].nType == PART_CHECKBOX)
                        {
                            part[nParts].value.nValueOn = StrToInt( szKeyWord );
                            if(part[nParts].value.szValueOn != NULL)
                                LocalFree(part[nParts].value.szValueOn);
                            part[nParts].value.szValueOn = NULL;
                        }
                    }
                    else
                    {
                        if(!fInPart)
                            nValueOff = StrToInt( szKeyWord );
                        else if(fInPart && part[nParts].nType == PART_CHECKBOX)
                        {
                            part[nParts].value.nValueOff = StrToInt( szKeyWord );
                            if(part[nParts].value.szValueOff != NULL)
                                LocalFree(part[nParts].value.szValueOff);
                            part[nParts].value.szValueOff = NULL;
                        }
                    }
                }
                else 
                {
                    if( StrCmp( szKeyWord, TEXT("TEXT") ) == 0 )
                        pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));

                    pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                    CheckStrings( szKeyWord, pcszFileName );

                    if(nKeyValue == KEY_VALUEON)
                    {
                        if(!fInPart)
                            StrCpy(szValueOn, szKeyWord);
                        else if(fInPart && part[nParts].nType == PART_CHECKBOX)
                        {
                            if(part[nParts].value.szValueOn != NULL)
                                LocalFree(part[nParts].value.szValueOn);
                            part[nParts].value.szValueOn = NULL;
                            part[nParts].value.szValueOn = StrDup(szKeyWord);
                        }
                    }
                    else
                    {
                        if (!fInPart)
                            StrCpy(szValueOff, szKeyWord);
                        else if (fInPart && part[nParts].nType == PART_CHECKBOX)
                        {
                            if(part[nParts].value.szValueOff != NULL)
                                LocalFree(part[nParts].value.szValueOff);
                            part[nParts].value.szValueOff = NULL;
                            part[nParts].value.szValueOff = StrDup(szKeyWord);
                        }
                    }
                }
            }
            break;

        case KEY_VALUE:
            if(fInItemList)
            {
                pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                //pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                //CheckStrings( szKeyWord, pcszFileName );
                
                part[nParts].actionlist[(part[nParts].nActions) - 1].dwValue = 0;
                if(part[nParts].actionlist[(part[nParts].nActions) - 1].szValue != NULL)
                    LocalFree(part[nParts].actionlist[(part[nParts].nActions) - 1].szValue);
                part[nParts].actionlist[(part[nParts].nActions) - 1].szValue = NULL;
                
                if( StrCmp( szKeyWord, TEXT("NUMERIC") ) == 0 )
                {
                    pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                    part[nParts].actionlist[(part[nParts].nActions) - 1].dwValue = StrToInt( szKeyWord );
                }
                else
                {
                    if( StrCmp( szKeyWord, TEXT("TEXT") ) == 0 )
                        pCurrent = ReadKeyword( pCurrent, szKeyWord, ARRAYSIZE( szKeyWord ));
                    
                    pCurrent = GetQuotedText( pCurrent, szKeyWord, sizeof( szKeyWord ));
                    CheckStrings( szKeyWord, pcszFileName );

                    part[nParts].actionlist[(part[nParts].nActions) - 1].szValue = StrDup( szKeyWord );
                }
            }
            break;

        case KEY_IF:
            pCurrent = ReadKeyword(pCurrent, szKeyWord, ARRAYSIZE(szKeyWord));

            if (KEY_VERSION == GetKeyName(szKeyWord))
            {
                int nVersion = 0;

                fSkip = FALSE;

                // get the operator keyword
                pCurrent = ReadKeyword(pCurrent, szKeyWord, ARRAYSIZE(szKeyWord));
                nKeyValue = GetKeyName(szKeyWord);

                // get the version number
                pCurrent = ReadKeyword(pCurrent, szKeyWord, ARRAYSIZE(szKeyWord));
                nVersion = StrToInt(szKeyWord);

                switch (nKeyValue)
                {
                    case KEY_LT:
                    case KEY_LTE:
                        break;

                    case KEY_GT:
                        if (ADM_VERSION <= nVersion)
                            fSkip = TRUE;
                        break;

                    case KEY_GTE:
                        if (ADM_VERSION < nVersion)
                            fSkip = TRUE;
                        break;                
                }
            }
            break;

        case KEY_ENDIF:
            fSkip = FALSE;
            break;

        }
    }
    while( lstrlen( pCurrent ) && bContinue);

    if (bContinue == FALSE)
    {
        FreeAdmMemory( admfile );
        SetLastError( ERROR_NOT_ENOUGH_MEMORY );
    }
    else
    {
        admfile->pParts = part;
        admfile->nParts = nParts;

        StrCpy(admfile->szFilename, pcszFileName);
    }

    // clean up
    LocalFree( hFileMem );
    
    return bContinue;
}

#define MAX_REGLINE     1024

BOOL CopyData(LPTSTR pData, int* pnData, int* pnCopyIndex, LPTSTR szTmpData)
{
    LPVOID lpTemp = NULL;

    if ((*pnCopyIndex + lstrlen(szTmpData) + 1) > ((*pnData) - 1))
    {
        (*pnData) += MAX_REGLINE;
        lpTemp = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pData, StrCbFromCch(*pnData));
        if (lpTemp == NULL)
            return FALSE;
        else
            pData = (LPTSTR) lpTemp;
    }

    CopyMemory(pData + *pnCopyIndex, szTmpData, StrCbFromSz(szTmpData));
    (*pnCopyIndex) += lstrlen(szTmpData);
    // skip over one byte so our list is 0 separated
    (*pnCopyIndex)++;
    return TRUE;
}


//--------------------------------------------------------------------------
//  W R I T E  I N F  F I L E       Exported Function
//
//  Creates an .inf file from a PART array.
//--------------------------------------------------------------------------
void WriteInfFile( LPADMFILE admfile, LPCTSTR pcszFileName, LPPARTDATA pData )
{
    LPPART  part;
    int     nParts;
    TCHAR   szClassString[5];
    TCHAR   szTmpData[MAX_REGLINE];
    int     i, j;
    BOOL    bContinue = TRUE;
    TCHAR   szValueText[1024];
    DWORD   dwValue;
    TCHAR   szKeyName[MAX_PATH];
    BOOL    fWrite = FALSE;
    LPTSTR  pHKLMData, pHKCUData;
    int     nHKLMCopyIndex = 0, 
            nHKCUCopyIndex = 0,
            nHKLMData = ((admfile->nParts + 1) * MAX_REGLINE),
            nHKCUData = ((admfile->nParts + 1) * MAX_REGLINE);

    // allocate memory for the .inf section
    pHKLMData = (LPTSTR) HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, StrCbFromCch(nHKLMData));
    pHKCUData = (LPTSTR) HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, StrCbFromCch(nHKCUData));

    if (pHKLMData == NULL || pHKCUData == NULL)
        return;

    part = (LPPART) admfile->pParts;
    nParts = admfile->nParts;

    // loop through parts, adding each one to the inf section
    for( i = 0; (i < nParts) && bContinue; i++ )
    {
        if (!pData[i].fSave)
            continue;

        fWrite = TRUE;

        if( (pData[i].value.szValue != NULL && lstrlen( pData[i].value.szValue ) > 0) || 
            (pData[i].value.fNumeric == TRUE) )
        {
            // get the class
            if( part[i].hkClass == HKEY_LOCAL_MACHINE )
                StrCpy( szClassString, TEXT("HKLM") );
            else
                StrCpy( szClassString, TEXT("HKCU") );

            ZeroMemory(szTmpData, sizeof(szTmpData));
            if( !pData[i].value.fNumeric )   // value is a string
            {
                ZeroMemory(szValueText, sizeof(szValueText));
                if(part[i].nType == PART_DROPDOWNLIST)
                {
                    if(pData[i].nSelectedAction != NO_ACTION && part[i].nActions > 0)
                    {
                        LPACTIONLIST action = &part[i].actionlist[pData[i].nSelectedAction];
                        if(action->szValue != NULL)
                            StrCpy(szValueText, action->szValue);
                        else
                        {
                            if(part[i].value.szKeyname != NULL && part[i].value.szValueName != NULL)
                            {
                                if ((lstrlen(szClassString) + lstrlen(part[i].value.szKeyname) + 
                                     lstrlen(part[i].value.szValueName) + 27) < MAX_REGLINE)
                                    wnsprintf(szTmpData, ARRAYSIZE(szTmpData), TEXT("%s,\"%s\",\"%s\",0x10001,%x,%x,%x,%x"), szClassString,
                                             part[i].value.szKeyname, part[i].value.szValueName,
                                             LOBYTE(LOWORD(action->dwValue)),
                                             HIBYTE(LOWORD(action->dwValue)),
                                             LOBYTE(HIWORD(action->dwValue)),
                                             HIBYTE(HIWORD(action->dwValue)));
                            }
                        }
                    }
                }
                else
                    StrCpy(szValueText, pData[i].value.szValue);

                if(part[i].value.szKeyname != NULL && part[i].value.szValueName != NULL && ISNONNULL(szValueText))
                {
                    if ((lstrlen(szClassString) + lstrlen(part[i].value.szKeyname) + lstrlen(part[i].value.szValueName) + 
                         lstrlen(szValueText) + 12) < MAX_REGLINE)
                        wnsprintf(szTmpData, ARRAYSIZE(szTmpData), TEXT("%s,\"%s\",\"%s\",0,\"%s\""), szClassString,
                                 part[i].value.szKeyname, part[i].value.szValueName,
                                 szValueText);
                }
            }
            else                            // value is a dword
            {
                if(((part[i].nType == PART_POLICY && part->fRequired) || part[i].nType == PART_CHECKBOX) &&
                    (part[i].value.szValueOn != NULL))
                {
                    if(pData[i].value.dwValue != 0)
                        StrCpy(szValueText, part[i].value.szValueOn);
                    else
                        StrCpy(szValueText, part[i].value.szValueOff);
                    
                    if(part[i].value.szKeyname != NULL && part[i].value.szValueName != NULL)
                    {
                        if ((lstrlen(szClassString) + lstrlen(part[i].value.szKeyname) + lstrlen(part[i].value.szValueName) + 
                             lstrlen(szValueText) + 12) < MAX_REGLINE)
                            wnsprintf(szTmpData, ARRAYSIZE(szTmpData), TEXT("%s,\"%s\",\"%s\",0,\"%s\""), szClassString,
                                     part[i].value.szKeyname, part[i].value.szValueName,
                                     szValueText);
                    }
                }
                else
                {
                    if((part[i].nType == PART_POLICY && part->fRequired) || part[i].nType == PART_CHECKBOX)
                    {
                        if(pData[i].value.dwValue != 0)
                            dwValue = part[i].value.nValueOn;
                        else
                            dwValue = part[i].value.nValueOff;
                    }
                    else
                        dwValue = pData[i].value.dwValue;

                    memset(szKeyName, 0, sizeof(szKeyName));
                    if(part[i].nType == PART_LISTBOX)
                        StrCpy(szKeyName, part[i].szDefaultValue);
                    else
                        StrCpy(szKeyName, part[i].value.szKeyname);

                    if(ISNONNULL(szKeyName) && part[i].value.szValueName != NULL)
                    {
                        if ((lstrlen(szClassString) + lstrlen(szKeyName) + 
                             lstrlen(part[i].value.szValueName) + 27) < MAX_REGLINE)
                            wnsprintf(szTmpData, ARRAYSIZE(szTmpData), TEXT("%s,\"%s\",\"%s\",0x10001,%x,%x,%x,%x"), szClassString,
                                     szKeyName, part[i].value.szValueName,
                                     LOBYTE(LOWORD(dwValue)),
                                     HIBYTE(LOWORD(dwValue)),
                                     LOBYTE(HIWORD(dwValue)),
                                     HIBYTE(HIWORD(dwValue)));
                    }
                }
            }

            if(ISNONNULL(szTmpData))
            {
                if (part[i].hkClass == HKEY_LOCAL_MACHINE)
                    bContinue = CopyData(pHKLMData, &nHKLMData, &nHKLMCopyIndex, szTmpData);
                else
                    bContinue = CopyData(pHKCUData, &nHKCUData, &nHKCUCopyIndex, szTmpData);
            }
        }

        // check to see if there is an item in an actionlist selected
        if( pData[i].nSelectedAction != NO_ACTION && (part[i].nActions > 0 || pData[i].nActions > 0))
        {
            LPACTIONLIST action =  NULL;

            if(part[i].nType == PART_LISTBOX)
                action =  &pData[i].actionlist[pData[i].nSelectedAction];
            else
                action =  &part[i].actionlist[pData[i].nSelectedAction];

            // get the class
            if( part[i].hkClass == HKEY_LOCAL_MACHINE )
            {
                StrCpy( szClassString, TEXT("HKLM") );
            }
            else
            {
                StrCpy( szClassString, TEXT("HKCU") );
            }

            for( j = 0; j < action->nValues; j++ )
            {
                if (part[i].nType == PART_CHECKBOX && ((int)pData[i].value.dwValue) != action->value[j].nValueOn)
                    continue;

                ZeroMemory(szTmpData, sizeof(szTmpData));
                if( !action->value[j].fNumeric )
                {
                    if(action->value[j].szKeyname != NULL && action->value[j].szValueName != NULL && action->value[j].szValue != NULL)
                    {
                        if ((lstrlen(szClassString) + lstrlen(action->value[j].szKeyname) + lstrlen(action->value[j].szValueName) +
                             lstrlen(action->value[j].szValue) + 12) < MAX_REGLINE)
                            wnsprintf(szTmpData, ARRAYSIZE(szTmpData), TEXT("%s,\"%s\",\"%s\",0,\"%s\""), szClassString,
                                     action->value[j].szKeyname, action->value[j].szValueName,
                                     action->value[j].szValue);
                    }
                }
                else                            // value is a dword
                {
                    if(action->value[j].szKeyname != NULL && action->value[j].szValueName != NULL)
                    {
                        if ((lstrlen(szClassString) + lstrlen(action->value[j].szKeyname) + 
                             lstrlen(action->value[j].szValueName) + 27) < MAX_REGLINE)
                            wnsprintf(szTmpData, ARRAYSIZE(szTmpData), TEXT("%s,\"%s\",\"%s\",0x10001,%x,%x,%x,%x"), szClassString,
                                     action->value[j].szKeyname, action->value[j].szValueName,
                                     LOBYTE(LOWORD(action->value[j].dwValue)),
                                     HIBYTE(LOWORD(action->value[j].dwValue)),
                                     LOBYTE(HIWORD(action->value[j].dwValue)),
                                     HIBYTE(HIWORD(action->value[j].dwValue)));
                    }
                }

                if(ISNONNULL(szTmpData))
                {
                    if (part[i].hkClass == HKEY_LOCAL_MACHINE)
                        bContinue = CopyData(pHKLMData, &nHKLMData, &nHKLMCopyIndex, szTmpData);
                    else
                        bContinue = CopyData(pHKCUData, &nHKCUData, &nHKCUCopyIndex, szTmpData);
                }
            }
        }
    }

    if (fWrite)
    {
        // write default headers into the .inf file
        InsWriteString( TEXT("Version"), TEXT("Signature"), TEXT("$CHICAGO$"), pcszFileName );
        InsWriteString( TEXT("Version"), TEXT("SetupClass"), TEXT("Base"), pcszFileName );
        InsWriteString( TEXT("DefaultInstall"), TEXT("AddReg"), TEXT("AddRegSection.HKLM,AddRegSection.HKCU"), pcszFileName );
        InsWriteString( TEXT("DefaultInstall"), TEXT("RequiredEngine"), TEXT("Setupapi,\"missing setupapi.dll\""), pcszFileName );

        InsWriteString( TEXT("DefaultInstall.HKLM"), TEXT("AddReg"), TEXT("AddRegSection.HKLM"), pcszFileName );
        InsWriteString( TEXT("DefaultInstall.HKLM"), TEXT("RequiredEngine"), TEXT("Setupapi,\"missing setupapi.dll\""), pcszFileName );
        
        InsWriteString( TEXT("IEAKInstall.HKLM"), TEXT("AddReg"), TEXT("AddRegSection.HKLM"), pcszFileName );
        InsWriteString( TEXT("IEAKInstall.HKLM"), TEXT("RequiredEngine"), TEXT("Setupapi,\"missing setupapi.dll\""), pcszFileName );

        InsWriteString( TEXT("DefaultInstall.HKCU"), TEXT("AddReg"), TEXT("AddRegSection.HKCU"), pcszFileName );
        InsWriteString( TEXT("DefaultInstall.HKCU"), TEXT("RequiredEngine"), TEXT("Setupapi,\"missing setupapi.dll\""), pcszFileName );

        InsWriteString( TEXT("IEAKInstall.HKCU"), TEXT("AddReg"), TEXT("AddRegSection.HKCU"), pcszFileName );
        InsWriteString( TEXT("IEAKInstall.HKCU"), TEXT("RequiredEngine"), TEXT("Setupapi,\"missing setupapi.dll\""), pcszFileName );

        InsDeleteSection( TEXT("AddRegSection"), pcszFileName );
        InsDeleteSection( TEXT("AddRegSection.HKLM"), pcszFileName );
        InsDeleteSection( TEXT("AddRegSection.HKCU"), pcszFileName );

        WritePrivateProfileSection( TEXT("AddRegSection.HKLM"), pHKLMData, pcszFileName );
        WritePrivateProfileSection( TEXT("AddRegSection.HKCU"), pHKCUData, pcszFileName );

        InsFlushChanges(pcszFileName);
    }

    HeapFree(GetProcessHeap(), 0, pHKLMData);
    HeapFree(GetProcessHeap(), 0, pHKCUData);
}

//--------------------------------------------------------------------------
//  R E M O V E  Q U O T E S
//
//  Removes and quotes surrounding a string
//--------------------------------------------------------------------------
void RemoveQuotes( LPTSTR pText )
{
    if( pText[0] == TEXT('\"') && pText[lstrlen(pText)-1] == TEXT('\"') )
    {
        memcpy( pText, &pText[1], (lstrlen( pText ) - 2) * sizeof(TCHAR) );
        pText[lstrlen( pText ) - 2] = TEXT('\0');
    }
}

//--------------------------------------------------------------------------
//  R E A D  H E X  S T R
//
//  Reads in a hex number from a string and converts it to an int
//--------------------------------------------------------------------------
int ReadHexStr( LPTSTR szStr )
{
    int i,j;        // counter
    int n = 1;      // multiplier
    int num = 0;    // return value
    int tmp = 0;    // temporary value
    int nLen = lstrlen( szStr );

    for( i = 0; i < nLen; i++ )
    {
        n = 1;

        for( j = 0; j < (nLen - i - 1); j++ )
            n *= 0x10;

        if( szStr[i] >= TEXT('0') && szStr[i] <= TEXT('9') )
            tmp = szStr[i] - TEXT('0');

        if( szStr[i] >= TEXT('a') && szStr[i] <= TEXT('f') )
            tmp = szStr[i] - TEXT('a') + 10;

        if( szStr[i] >= TEXT('A') && szStr[i] <= TEXT('F') )
            tmp = szStr[i] - TEXT('A') + 10;

        tmp *= n;
        num += tmp;
    }
    return num;
}

//--------------------------------------------------------------------------
//  R E A D  I N F  F I L E         Exported Function
//
//  Reads an .inf file into a PART array
//--------------------------------------------------------------------------
void ReadInfFile( LPADMFILE admfile, LPCTSTR pcszFileName, LPPARTDATA pPartData )
{
    LPPART part;
    LPTSTR pData;
    LPTSTR pCurrent;
    VALUE value;
    HKEY hkClass;
    TCHAR szClass[10];
    TCHAR szType[10];
    TCHAR szValue[MAX_PATH + 1];
    int i;
    int nSize;
    int nIndex;
    
    if( !FileExists( pcszFileName ))
        return;     // bug bug

    part = admfile->pParts;

    // allocate 32KB for GetPrivateProfileSection
    pData = (LPTSTR) LocalAlloc( LPTR, (MAX_NUMERIC + 1) * sizeof(TCHAR) );
    if (pData == NULL)
        return;

    nSize = GetPrivateProfileSection( TEXT("AddRegSection"), pData, MAX_NUMERIC, pcszFileName );
    if( nSize == 0 )
    {
        nSize = GetPrivateProfileSection( TEXT("AddRegSection.HKLM"), pData, MAX_NUMERIC, pcszFileName );
        nSize += GetPrivateProfileSection( TEXT("AddRegSection.HKCU"), pData + nSize, MAX_NUMERIC - nSize, pcszFileName );
        if (nSize == 0)
        {
            LocalFree((HGLOBAL)pData);
            return;     // bug bug
        }
    }

    // convert all zeros to newlines
    for( i = 0; i < nSize; i++ )
    {
        if( pData[i] == TEXT('\0') )
        {
            pData[i] = TEXT('\n');
        }
    }

    pCurrent = pData;

    while( pCurrent < pData + nSize - 2 )
    {
        memset( &value, 0, sizeof( value ));

        // read one line from the section
        i = StrCSpn( pCurrent, TEXT(",\n") );
        StrCpyN( szClass, pCurrent, i+1 );
        pCurrent += i+1;
        i = StrCSpn( pCurrent, TEXT(",\n") );
        value.szKeyname = (TCHAR *)LocalAlloc(LPTR, sizeof(TCHAR) * (i+2));
        StrCpyN( value.szKeyname, pCurrent, i+1 );
        pCurrent += i+1;
        i = StrCSpn( pCurrent, TEXT(",\n") );
        value.szValueName = (TCHAR *)LocalAlloc(LPTR, sizeof(TCHAR) * (i+2));
        StrCpyN( value.szValueName, pCurrent, i+1 );
        pCurrent += i+1;
        i = StrCSpn( pCurrent, TEXT(",\n") );
        StrCpyN( szType, pCurrent, i+1 );
        pCurrent += i+1;
        i = StrCSpn( pCurrent, TEXT("\n") );
        StrCpyN( szValue, pCurrent, i+1 );
        pCurrent += i+1;

        RemoveQuotes( value.szKeyname );
        RemoveQuotes( value.szValueName );
        RemoveQuotes( szValue );

        if( StrCmpI( szClass, TEXT("HKLM") ) == 0 )
            hkClass = HKEY_LOCAL_MACHINE;
        else
            hkClass = HKEY_CURRENT_USER;

        if( StrCmp(szType, TEXT("0") ) == 0 )
            value.fNumeric = FALSE;
        else
            value.fNumeric = TRUE;

        if( value.fNumeric )
        {
            int a[4]={0,0,0,0},j=0;
            TCHAR *p1, *p2;
            p1 = p2 = szValue;

            while( *p1 )
            {
                if( *p1 == TEXT(',') )
                {
                    *p1 = TEXT('\0');
                    a[j] = ReadHexStr( p2 );
                    j++;
                    p2 = p1 + 1;
                }
                p1++;
            }

            a[j] = ReadHexStr( p2 );

            value.dwValue = MAKELONG(MAKEWORD(a[0],a[1]),MAKEWORD(a[2],a[3]));
        }
        else
            value.szValue = StrDup(szValue);

        for( i = 0; i < admfile->nParts; i++ )
        {
            if( hkClass == part[i].hkClass )
            {
                if( part[i].value.szKeyname != NULL && StrCmpI( value.szKeyname, part[i].value.szKeyname ) == 0 )
                {
                    // special case out LISTBOX because there is no valuenames specified for
                    // individual list items.
                    if( part[i].nType == PART_LISTBOX || part[i].value.szValueName != NULL && StrCmpI( value.szValueName, part[i].value.szValueName) == 0 )
                    {
                        if(pPartData[i].value.szValue != NULL)
                            LocalFree(pPartData[i].value.szValue);
                        pPartData[i].value.szValue = NULL;
                        if((part[i].nType == PART_POLICY && part->fRequired) || part[i].nType == PART_CHECKBOX)
                        {
                            if(value.fNumeric)
                            {
                                if(value.dwValue == (DWORD) part[i].value.nValueOn)
                                    pPartData[i].value.dwValue = 1;
                                else
                                    pPartData[i].value.dwValue = 0;
                                if (value.szValue != NULL)
                                    pPartData[i].value.szValue = StrDup(value.szValue);
                                pPartData[i].value.fNumeric = value.fNumeric;
                            }
                            else
                            {
                                if(part[i].value.szValueOn != NULL && value.szValue != NULL && StrCmp(part[i].value.szValueOn, value.szValue) == 0)
                                    pPartData[i].value.dwValue = 1;
                                else
                                    pPartData[i].value.dwValue = 0;
                                if (value.szValue != NULL)
                                    pPartData[i].value.szValue = StrDup(value.szValue);
                                pPartData[i].value.fNumeric = TRUE;
                            }
                            pPartData[i].fSave = TRUE;
                        }
                        else if(part[i].nType == PART_DROPDOWNLIST)
                        {
                            if(part[i].nSelectedAction != NO_ACTION && part[i].nActions > 0)
                            {
                                for(nIndex = 0; nIndex < part[i].nActions; nIndex++)
                                {
                                    if(value.fNumeric)
                                    {
                                        if(part[i].actionlist[nIndex].dwValue == value.dwValue && part[i].actionlist[nIndex].szName)
                                        {
                                            pPartData[i].value.szValue = StrDup(part[i].actionlist[nIndex].szName);
                                            pPartData[i].nSelectedAction = nIndex;
                                        }
                                    }
                                    else
                                    {
                                        if(part[i].actionlist[nIndex].szValue != NULL && value.szValue != NULL &&
                                            StrCmp(part[i].actionlist[nIndex].szValue, value.szValue) == 0 &&
                                            part[i].actionlist[nIndex].szName != NULL)
                                        {
                                            pPartData[i].value.szValue = StrDup(part[i].actionlist[nIndex].szName);
                                            pPartData[i].nSelectedAction = nIndex;
                                        }
                                    }
                                }
                                pPartData[i].fSave = TRUE;
                            }
                            pPartData[i].value.fNumeric = FALSE;
                        }
                        else if(part[i].nType == PART_LISTBOX && !value.fNumeric)
                        {
                            // Allocate memory
                            if(pPartData[i].nActions == 0)
                                pPartData[i].actionlist = (LPACTIONLIST) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACTIONLIST));
                            if(pPartData[i].actionlist != NULL)
                            {
                                if(pPartData[i].nActions == 0)
                                {
                                    pPartData[i].nActions = 1;
                                    pPartData[i].actionlist[0].value = (LPVALUE) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(VALUE));
                                }
                                if(pPartData[i].actionlist[0].value != NULL)
                                {
                                    TCHAR szValueName[10];
                                    int nItems = pPartData[i].actionlist[0].nValues;

                                    if(nItems != 0)
                                    {
                                        LPVOID lpTemp;

                                        lpTemp = (LPVALUE) HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pPartData[i].actionlist[0].value, sizeof(VALUE) * (nItems + 1));
                                        if (lpTemp != NULL)
                                            pPartData[i].actionlist[0].value = (LPVALUE)lpTemp;
                                        else
                                            continue;
                                    }
                                    if (part[i].value.szKeyname != NULL)
                                        pPartData[i].actionlist[0].value[nItems].szKeyname = StrDup(part[i].value.szKeyname);
                                    wnsprintf(szValueName, ARRAYSIZE(szValueName), TEXT("%d"), nItems + 1);
                                    pPartData[i].actionlist[0].value[nItems].szValueName = StrDup(szValueName);
                                    if (value.szValue != NULL)
                                        pPartData[i].actionlist[0].value[nItems].szValue = StrDup(value.szValue);
                                    pPartData[i].actionlist[0].nValues++;
                                    pPartData[i].value.fNumeric = TRUE;
                                    pPartData[i].value.dwValue = 1;
                                    pPartData[i].fSave = TRUE;
                                }
                            }
                        }
                        else
                        {
                            if (value.szValue != NULL)
                                pPartData[i].value.szValue = StrDup(value.szValue);
                            pPartData[i].value.dwValue = value.dwValue;
                            pPartData[i].value.fNumeric = value.fNumeric;
                            pPartData[i].fSave = TRUE;
                        }
                    }
                }
            }
        }

        if(value.szKeyname != NULL)
            LocalFree(value.szKeyname);
        value.szKeyname = NULL;
        if(value.szValueName != NULL)
            LocalFree(value.szValueName);
        value.szValueName = NULL;
        if(value.szValue != NULL)
            LocalFree(value.szValue);
        value.szValue = NULL;
    }

    LocalFree( (HGLOBAL) pData );
}

//--------------------------------------------------------------------------
//  B A S E F I L E N A M E
//
//  Returns a pointer to the filename stripping directory path if any
//--------------------------------------------------------------------------
LPCTSTR BaseFileName(LPCTSTR pcszFileName)
{
    TCHAR* ptr = StrRChr(pcszFileName, NULL, TEXT('\\'));
    if(ptr == NULL)
        return pcszFileName;
    else
        return (LPCTSTR) ++ptr;
}