windows-server-2003/base/fs/utils/reg/regporte.c

/*******************************************************************************
*
*  (C) COPYRIGHT MICROSOFT CORP., 1993-1994
*
*  TITLE:       REGPORTE.C
*
*  VERSION:     5.00
*
*  AUTHOR:      Tracy Sharpe
*
*  DATE:        06 Apr 1994
*
*  Histry:      Zeyong Xu modified it in March 1999
*
*  .REG format file import and export engine routines for the Registry Editor.
*
*******************************************************************************/

#include "stdafx.h"
#include "reg.h"
#include "reg1632.h"
#include "regdef.h"
#include "regdebug.h"
#include "regporte.h"
#include "malloc.h"

//  Association between the ASCII name and the handle of the registry key.
const REGISTRY_ROOT g_RegistryRoots[] = {
    TEXT("HKEY_CLASSES_ROOT"), HKEY_CLASSES_ROOT,
    TEXT("HKEY_CURRENT_USER"), HKEY_CURRENT_USER,
    TEXT("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE,
    TEXT("HKEY_USERS"), HKEY_USERS,
    TEXT("HKEY_CURRENT_CONFIG"), HKEY_CURRENT_CONFIG,
    TEXT("HKEY_DYN_DATA"), HKEY_DYN_DATA
};

const TCHAR s_RegistryHeader[] = TEXT("REGEDIT");

const TCHAR s_OldWin31RegFileRoot[] = TEXT(".classes");

const TCHAR s_Win40RegFileHeader[] = TEXT("REGEDIT4\n\n");

TCHAR g_ValueNameBuffer[MAXVALUENAME_LENGTH];

#define IsRegStringType(x)  (((x) == REG_SZ) || ((x) == REG_EXPAND_SZ) || ((x) == REG_MULTI_SZ))
#define ExtraAllocLen(Type) (IsRegStringType((Type)) ? sizeof(TCHAR) : 0)

#ifdef UNICODE
//
// New header is required for version 5.0 because the version detection code
// in Win 4.0 regedit wasn't very good (See comments in ImportRegFile for
// details)
//
const WORD s_UnicodeByteOrderMark = 0xFEFF;
const TCHAR s_WinNT50RegFileHeader[] = TEXT("Windows Registry Editor Version");
const TCHAR s_WinNT50RegFileVersion[] = TEXT("5.00");
#endif

const TCHAR s_HexPrefix[] = TEXT("hex");
const TCHAR s_DwordPrefix[] = TEXT("dword:");
const TCHAR g_HexConversion[16] = {TEXT('0'), TEXT('1'), TEXT('2'), TEXT('3'), TEXT('4'),
                                   TEXT('5'), TEXT('6'), TEXT('7'), TEXT('8'), TEXT('9'),
                                   TEXT('a'), TEXT('b'), TEXT('c'), TEXT('d'), TEXT('e'), TEXT('f')};
const TCHAR s_FileLineBreak[] = TEXT(",\\\n  ");

//REARCHITECT - we upped the size of this buffer from 512 to 64K to reduce the chance of hitting the bug
//where a DBCS character is split across two buffers.  The true fix was too risky at the time.
//Changed for NT5 RC2
#define SIZE_FILE_IO_BUFFER             0x10000 //64K

typedef struct _FILE_IO{
#ifdef UNICODE
    //
    // Space for unicode/ansi conversions, assumes worst case
    // where every unicode char is a double-byte char
    //
    CHAR ConversionBuffer[SIZE_FILE_IO_BUFFER*2];
#endif
    TCHAR Buffer[SIZE_FILE_IO_BUFFER];
    FILE_HANDLE hFile;
    int BufferOffset;
    int CurrentColumn;
    int CharsAvailable;
    DWORD FileSizeDiv100;
    DWORD FileOffset;
    UINT LastPercentage;
#ifdef DEBUG
    BOOL fValidateUngetChar;
#endif
}   FILE_IO;

FILE_IO s_FileIo;

UINT g_FileErrorStringID;

UINT g_ImportFileVersion;

DWORD g_dwTotalKeysSaved = 0;

BOOL s_fTreatFileAsUnicode = TRUE;

VOID NEAR PASCAL ImportWin31RegFile( VOID );

VOID
NEAR PASCAL
ImportNewerRegFile( VOID );

VOID ParseHeader( LPHKEY lphKey );

VOID
NEAR PASCAL
ParseValue(
    HKEY hKey,
    LPCTSTR lpszValueName
    );

VOID
NEAR PASCAL
ParseValuename(
    HKEY hKey
    );

BOOL
NEAR PASCAL
ParseString(LPPORTVALUEPARAM pPortValueParam);

BOOL
NEAR PASCAL
ParseHexSequence(LPPORTVALUEPARAM pPortValueParam);

BOOL
NEAR PASCAL
ParseHexDword(
    LPDWORD lpDword
    );

BOOL
NEAR PASCAL
ParseHexByte(
    LPBYTE lpByte
    );

BOOL
NEAR PASCAL
ParseHexDigit(
    LPBYTE lpDigit
    );

BOOL
NEAR PASCAL
ParseEndOfLine(
    VOID
    );

VOID
NEAR PASCAL
SkipWhitespace(
    VOID
    );

VOID
NEAR PASCAL
SkipPastEndOfLine(
    VOID
    );

BOOL
NEAR PASCAL
GetChar(
    PTCHAR lpChar
    );

VOID
NEAR PASCAL
UngetChar(
    VOID
    );

BOOL
NEAR PASCAL
MatchChar(
    TCHAR CharToMatch
    );

BOOL
NEAR PASCAL
IsWhitespace(
    TCHAR Char
    );

BOOL
NEAR PASCAL
IsNewLine(
    TCHAR Char
    );

VOID
NEAR PASCAL
PutBranch(
    HKEY hKey,
    LPTSTR lpKeyName
    );

VOID
NEAR PASCAL
PutLiteral(
    LPCTSTR lpString
    );

VOID
NEAR PASCAL
PutString(
    LPCTSTR lpString
    );

VOID
NEAR PASCAL
PutBinary(
    CONST BYTE FAR* lpBuffer,
    DWORD Type,
    DWORD cbBytes
    );

VOID
NEAR PASCAL
PutDword(
    DWORD Dword,
    BOOL fLeadingZeroes
    );

VOID
NEAR PASCAL
PutChar(
    TCHAR Char
    );

VOID
NEAR PASCAL
FlushIoBuffer(
    VOID
    );

/*******************************************************************************
*
*  EditRegistryKey
*
*  DESCRIPTION:
*     Parses the pFullKeyName string and creates a handle to the registry key.
*
*  PARAMETERS:
*     lphKey, location to store handle to registry key.
*     lpFullKeyName, string of form "HKEY_LOCAL_MACHINE\Subkey1\Subkey2".
*     fCreate, TRUE if key should be created, else FALSE for open only.
*     (returns), ERROR_SUCCESS, no errors occurred, phKey is valid,
*                ERROR_CANTOPEN, registry access error of some form,
*                ERROR_BADKEY, incorrectly formed pFullKeyName.
*
*******************************************************************************/

DWORD
PASCAL
EditRegistryKey(
    LPHKEY lphKey,
    LPTSTR lpFullKeyName,
    UINT uOperation
    )
{

    LPTSTR lpSubKeyName = NULL;
    TCHAR PrevChar = L'\0';
    HKEY hRootKey;
    UINT Counter;
    DWORD Result;

    if ((lpSubKeyName = (LPTSTR) StrChr(lpFullKeyName, TEXT('\\'))) != NULL) {

        PrevChar = *lpSubKeyName;
        *lpSubKeyName++ = 0;

    }

    CharUpper(lpFullKeyName);

    hRootKey = NULL;

    for (Counter = 0; Counter < NUMBER_REGISTRY_ROOTS; Counter++) {

        if (lstrcmp(g_RegistryRoots[Counter].lpKeyName, lpFullKeyName) == 0) {

            hRootKey = g_RegistryRoots[Counter].hKey;
            break;

        }

    }

    if (hRootKey) {

        Result = ERROR_CANTOPEN;

        switch (uOperation)
        {
        case ERK_CREATE:
            //
            // If trying to open one of these keys just return OK
            // When lpSubKeyName is NULL, you recreate the parent key
            // Since these keys are usually in use this will fail
            // This code path only occurs when restoring a whole root key
            // from a .reg file.
            //
            if (((hRootKey == HKEY_LOCAL_MACHINE) || (hRootKey == HKEY_USERS))
                && lpSubKeyName == NULL) {
                Result = ERROR_SUCCESS;
            }
            else if (RegCreateKey(hRootKey, lpSubKeyName, lphKey) == ERROR_SUCCESS)
                Result = ERROR_SUCCESS;
            break;

        case ERK_OPEN:
            //
            // Used when exporting.
            //
            if(RegOpenKeyEx(hRootKey,lpSubKeyName,0,KEY_ENUMERATE_SUB_KEYS|KEY_QUERY_VALUE,lphKey) == ERROR_SUCCESS)
                Result = ERROR_SUCCESS;
            break;

        case ERK_DELETE:
            RegDeleteKeyRecursive(hRootKey, lpSubKeyName);
            // asssume success... don't care if this fails
            Result = ERROR_SUCCESS;
            *lphKey = NULL;
            break;
        }

    }
    else
    {
        Result = ERROR_BADKEY;
    }

    if (lpSubKeyName != NULL) {

        lpSubKeyName--;
        *lpSubKeyName = PrevChar;

    }

    return Result;

}

/*******************************************************************************
*
*  ImportRegFileWorker
*
*  DESCRIPTION:
*
*  PARAMETERS:
*     lpFileName, address of name of file to be imported.
*
*******************************************************************************/

VOID
PASCAL
ImportRegFileWorker(
    LPTSTR lpFileName
    )
{

    TCHAR Char;
    LPCTSTR lpHeader = NULL;
    BOOL fNewRegistryFile;
#ifdef UNICODE
    UINT Temp, i;
    TCHAR StrToIntBuf[2];
    LPCTSTR lp50Header = NULL;
#endif // UNICODE
    DWORD cch;
    TCHAR tchBuffer[MAX_PATH] = {0};
    LPTSTR lpFilePart = NULL;

    g_FileErrorStringID = IDS_IMPFILEERRSUCCESS;

    // OPENREADFILE used to be OpenFile(), but there isn't any Unicode version
    // of that API, so now it's CreateFile().  But OpenFile searched the path
    // automatically, whereas CreateFile does not.  Corel's 'Perfect Office v6'
    // install app depends on the path being searched, so do it manually.

    cch = SearchPath(NULL,                // pointer to search path
                     lpFileName,          // pointer to filename
                     NULL,                // pointer to extension
                     ARRAYSIZE(tchBuffer), // size, in characters, of buffer
                     (TCHAR*)tchBuffer,   // pointer to buffer for found filename
                     &lpFilePart);        // pointer to pointer to file component);

    if ((cch != 0) && (cch <= MAX_PATH) && OPENREADFILE((TCHAR*)tchBuffer, s_FileIo.hFile)) 
    {
        WORD wBOM;
        DWORD NumberOfBytesRead;

        s_FileIo.FileSizeDiv100 = GetFileSize(s_FileIo.hFile, NULL) / 100;
        s_FileIo.FileOffset = 0;
        s_FileIo.CharsAvailable = 0;
        s_FileIo.LastPercentage = 0;

        //
        // Read the first two bytes. If it's the Unicode byte order mark,
        // set a flag so all the rest of the file will be interpreted
        // as ANSI or Unicode text properly.
        //
        if (!READFILE(s_FileIo.hFile, &wBOM,
            sizeof(wBOM), &NumberOfBytesRead)) {

            g_FileErrorStringID = IDS_IMPFILEERRFILEREAD;
            goto exit_gracefully;
        }

        if (wBOM == s_UnicodeByteOrderMark)
            s_fTreatFileAsUnicode = TRUE;
        else {
            s_fTreatFileAsUnicode = FALSE;
            // We probably just read "RE" from "REGEDIT4".  Back up the file
            // position so the ANSI import routines get what they expect
            SetFilePointer(s_FileIo.hFile, -2, NULL, FILE_CURRENT);
        }

        //
        //  The following will force GetChar to read in the first block of data.
        //

        s_FileIo.BufferOffset = 0;

        SkipWhitespace();

        lpHeader = s_RegistryHeader;
        g_ImportFileVersion = 0;

# if 0
    Sit back, and I will tell ye a tale of woe.

    Win95 and NT 4 shipped with regedit compiled ANSI.  There are a couple
    of registry types on NT (namely REG_EXPAND_SZ and REG_MULTI_SZ) that
    weren't on Win95, and which regedit doesn't really understand.  regedit
    treats these registry types as hex binary streams.

    You can probably see where this is going.

    If you exported, say your user TEMP environment variable on NT 4
    using regedit, you'd get something that looked like this:

REGEDIT4

[HKEY_CURRENT_USER\Environment]
"TEMP"=hex(2):25,53,59,53,54,45,4d,44,52,49,56,45,25,5c,53,48,54,65,6d,70,00

    ...a nice, null-terminated ANSI string.  Nice, that is, until we decided
    to compile regedit UNICODE for NT 5.  A unicode regedit exports your
    user TEMP variable like this:

REGEDIT4

[HKEY_CURRENT_USER\Environment]
"TEMP"=hex(2):25,00,53,00,59,00,53,00,54,00,45,00,4d,00,44,00,52,00,49,00,56,\
  00,45,00,25,00,5c,00,53,00,48,00,54,00,65,00,6d,00,70,00,00,00

    ...mmmm.  Unicode.  Of course, a unicode regedit also expects anything
    it imports to have all those interspersed zeroes, too.  Otherwise,
    it dumps garbage into your registry.  All it takes is a -DUNICODE, and
    regedit is suddenly incompatible with the thousdands of existing .reg
    files out there.

    So just bump the version in the header to REGEDIT5 and be done with
    it, right?  Wrong.  The regedit on Win95 and NT 4 looks at the first
    character after the string "REGEDIT" and compares it to the digit "4".
    If that character is anything other than the digit "4", the parser
    assumes it is looking at a Windows 3.1 file.  Yep.  There will only
    ever be two formats, right?  Just Win95 and Win3.1.  That's all the
    world needs.

    So a completely new .reg file header had to be invented, so that the
    older, regedits of the world would simply regect the new,
    unicodized .reg files outright.  An NT 5 .reg file, exporting your user
    TEMP variable, looks like this:

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Environment]
"TEMP"=hex(2):25,00,53,00,59,00,53,00,54,00,45,00,4d,00,44,00,52,00,49,00,56,\
  00,45,00,25,00,5c,00,53,00,48,00,54,00,65,00,6d,00,70,00,00,00

    The parser is still not very good, but it does bother to convert that 5.00
    into a version number, so that future generations can bump it to 5.50 or
    6.00, and the regedit 5.00 that shipped with NT 5.00 will properly reject
    the files.
#endif // 0

#ifdef UNICODE
        //
        // Compare to the new .reg file header
        //
        lp50Header = s_WinNT50RegFileHeader;
        while (*lp50Header != 0) {

            if (MatchChar(*lp50Header))
                lp50Header = CharNext(lp50Header);

            else
                break;

        }

        //
        // If the above loop pushed lp50Header to its terminating null
        // character, then the header matches.
        //
        if (0 == *lp50Header) {

            SkipWhitespace();
            //
            // Now, decode the version number into a hex, _WIN32_WINNT
            // style version number.
            //
            StrToIntBuf[1] = 0;

            //
            // Any number of digits can come before the decimal point
            //
            while (!MatchChar(TEXT('.'))) {
                if (!GetChar(StrToIntBuf) || !IsCharAlphaNumeric(*StrToIntBuf)) {
                    g_FileErrorStringID = IDS_IMPFILEERRFORMATBAD;
                    goto exit_gracefully;
                }

                Temp = StrToInt(StrToIntBuf);
                // Hex version number, so move left four bits.
                g_ImportFileVersion <<= 4;
                g_ImportFileVersion += Temp;
            }

            //
            // Fixed at two digits after the decimal point
            //
            for (i = 0; i < 2; i++) {
                if (!GetChar(StrToIntBuf) || !IsCharAlphaNumeric(*StrToIntBuf)) {
                    g_FileErrorStringID = IDS_IMPFILEERRFORMATBAD;
                    goto exit_gracefully;
                }

                Temp = StrToInt(StrToIntBuf);
                // Hex version number, so move left four bits.
                g_ImportFileVersion <<= 4;
                g_ImportFileVersion += Temp;
            }

            //
            // For NT 5, reject any version number that isn't
            // 5.  This can be expanded into a switch statement
            // when the version number is bumped later.
            //
            if (0x0500 != g_ImportFileVersion) {
                g_FileErrorStringID = IDS_IMPFILEERRVERBAD;
                goto exit_gracefully;
            }
            else {
                SkipWhitespace();
                ImportNewerRegFile();
            }

        } // if (0 == *lp50Header)
        //
        // It doesn't use the new .reg file header, so
        // it's not an NT 5.0+ registry file, so use the
        // older algorithm to see if it's a valid older registry file
        //
        else {
#endif // UNICODE

            while (*lpHeader != 0) {

                if (MatchChar(*lpHeader))
                    lpHeader = CharNext(lpHeader);

                else
                    break;

            }

            if (*lpHeader == 0) {

                //
                // Win95's and NT 4's regedit shipped with this line
                // of code.  It is the cause of all of the suffering above.
                // Notice the incorrect assumption:  "If the very next
                // character isn't a '4', then we must be reading
                // a Windows 3.1 registry file!"  Of course there won't
                // be a version 5 of regedit.  Version 4 was perfect!
                //
                fNewRegistryFile = MatchChar(TEXT('4'));

                SkipWhitespace();

                if (GetChar(&Char) && IsNewLine(Char)) {

                    if (fNewRegistryFile) {
                        g_ImportFileVersion = 0x0400;
                        ImportNewerRegFile();
                    }
                    else {
                        g_ImportFileVersion = 0x0310;
                        ImportWin31RegFile();
                    }
                }
            }
            else
            {
                g_FileErrorStringID = IDS_IMPFILEERRFORMATBAD;
            }
#ifdef UNICODE
        }
#endif // UNICODE

    } // if (OPENREADFILE...

    else 
    {
        { 
            TCHAR buff[250];
            StringCchPrintf(buff, ARRAYSIZE(buff), L"REGEDIT:  CreateFile failed, GetLastError() = %d\n", 
                    GetLastError());
            OutputDebugString(buff);
        }
        s_FileIo.hFile = NULL;
        g_FileErrorStringID = IDS_IMPFILEERRFILEOPEN;
    }

#ifdef UNICODE // Urefd labels generate warnings
exit_gracefully:
#endif // UNICODE
    if (s_FileIo.hFile) {
        CloseHandle(s_FileIo.hFile);
    }

}

/*******************************************************************************
*
*  ImportWin31RegFile
*
*  DESCRIPTION:
*     Imports the contents of a Windows 3.1 style registry file into the
*     registry.
*
*     We scan over the file looking for lines of the following type:
*        HKEY_CLASSES_ROOT\keyname = value_data
*        HKEY_CLASSES_ROOT\keyname =value_data
*        HKEY_CLASSES_ROOT\keyname value_data
*        HKEY_CLASSES_ROOT\keyname                          (null value data)
*
*     In all cases, any number of spaces may follow 'keyname'.  Although we
*     only document the first syntax, the Windows 3.1 Regedit handled all of
*     these formats as valid, so this version will as well (fortunately, it
*     doesn't make the parsing any more complex!).
*
*     Note, we also support replacing HKEY_CLASSES_ROOT with \.classes above
*     which must come from some early releases of Windows.
*
*  PARAMETERS:
*     (none).
*
*******************************************************************************/

VOID
NEAR PASCAL
ImportWin31RegFile(
    VOID
    )
{

    HKEY hKey;
    TCHAR Char;
    BOOL fSuccess;
    LPCTSTR lpClassesRoot;
    TCHAR KeyName[MAXKEYNAME];
    UINT Index;

    //
    //  Keep an open handle to the classes root.  We may prevent some
    //  unneccessary flushing.
    //
    if(RegOpenKeyEx(HKEY_CLASSES_ROOT,NULL,0,KEY_SET_VALUE,&hKey) != ERROR_SUCCESS) {

        g_FileErrorStringID = IDS_IMPFILEERRREGOPEN;
        return;
    }

    for (;;) {

        //
        //  Check for the end of file condition.
        //

        if (!GetChar(&Char))
            break;

        UngetChar();                    //  Not efficient, but works for now.

        //
        //  Match the beginning of the line against one of the two aliases for
        //  HKEY_CLASSES_ROOT.
        //

        if (MatchChar(TEXT('\\')))
            lpClassesRoot = s_OldWin31RegFileRoot;

        else
            lpClassesRoot = g_RegistryRoots[INDEX_HKEY_CLASSES_ROOT].lpKeyName;

        fSuccess = TRUE;

        while (*lpClassesRoot != 0) {

            if (!MatchChar(*lpClassesRoot++)) {

                fSuccess = FALSE;
                break;

            }

        }

        //
        //  Make sure that we have a backslash seperating one of the aliases
        //  from the keyname.
        //

        if (fSuccess)
            fSuccess = MatchChar(TEXT('\\'));

        if (fSuccess) {

            //
            //  We've found one of the valid aliases, so read in the keyname.
            //

            //  fSuccess = TRUE;        //  Must be TRUE if we're in this block
            Index = 0;

            while (GetChar(&Char)) {

                if (Char == TEXT(' ') || IsNewLine(Char))
                    break;

                //
                //  Make sure that the keyname buffer doesn't overflow.  We must
                //  leave room for a terminating null.
                //

                if (Index >= (ARRAYSIZE(KeyName)) - 1) 
                {
                    fSuccess = FALSE;
                    break;
                }

                KeyName[Index++] = Char;

            }

            if (fSuccess)
            {
                UINT cMaxDataLength = ALLOCATION_INCR;
                PBYTE pbValueDataBuffer;

                KeyName[Index] = 0;

                //
                //  Now see if we have a value to assign to this keyname.
                //

                SkipWhitespace();

                if (MatchChar(TEXT('=')))
                    MatchChar(TEXT(' '));

                //  fSuccess = TRUE;    //  Must be TRUE if we're in this block
                Index = 0;

                pbValueDataBuffer = LocalAlloc(LPTR, cMaxDataLength);
                fSuccess = (pbValueDataBuffer != NULL);

                while (GetChar(&Char) && fSuccess)
                {

                    if (IsNewLine(Char))
                        break;

                    //
                    //  Make sure that the value data buffer doesn't overflow.
                    //  Because this is always string data, we must leave room
                    //  for a terminating null.
                    //

                    if (Index >= cMaxDataLength - 1)
                    {
                        PBYTE pbValueData =
                            LocalReAlloc(pbValueDataBuffer, cMaxDataLength + ALLOCATION_INCR, LMEM_MOVEABLE);

                        fSuccess = (pbValueData != NULL);
                        if (!fSuccess)
                        {
                            break;
                        }
                        else
                        {
                            pbValueDataBuffer = pbValueData;
                            cMaxDataLength += ALLOCATION_INCR;
                        }
                    }

                    ((PTSTR)pbValueDataBuffer)[Index++] = Char;

                }

                if (fSuccess)
                {

                    ((PTSTR)pbValueDataBuffer)[Index] = 0;

                    if (RegSetValue(hKey, KeyName, REG_SZ, (LPCTSTR)pbValueDataBuffer,
                        Index*sizeof(TCHAR)) != ERROR_SUCCESS)
                        g_FileErrorStringID = IDS_IMPFILEERRREGSET;
                }
                else
                {
                    g_FileErrorStringID = IDS_NOMEMORY;
                }

                if (pbValueDataBuffer)
                {
                    LocalFree(pbValueDataBuffer);
                }
            }

        }

        //
        //  Somewhere along the line, we had a parsing error, so resynchronize
        //  on the next line.
        //

        if (!fSuccess)
            SkipPastEndOfLine();

    }

    RegFlushKey(hKey);
    RegCloseKey(hKey);

}

/*******************************************************************************
*
*  ImportNewerRegFile
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
NEAR PASCAL
ImportNewerRegFile(
    VOID
    )
{

    HKEY hLocalMachineKey = NULL;
    HKEY hUsersKey = NULL;
    HKEY hKey = NULL;
    TCHAR Char;

#ifdef WINNT
    hLocalMachineKey = NULL;
    hUsersKey = NULL;
#else
    //
    //  Keep open handles for the predefined roots to prevent the registry
    //  library from flushing after every single RegOpenKey/RegCloseKey
    //  operation.
    //

    RegOpenKey(HKEY_LOCAL_MACHINE, NULL, &hLocalMachineKey);
    RegOpenKey(HKEY_USERS, NULL, &hUsersKey);

#ifdef DEBUG
    if (hLocalMachineKey == NULL)
        DbgPrintf(("Unable to open HKEY_LOCAL_MACHINE\n\r"));
    if (hUsersKey == NULL)
        DbgPrintf(("Unable to open HKEY_USERS\n\r"));
#endif
#endif

    hKey = NULL;

    for (;;) {

        SkipWhitespace();

        //
        //  Check for the end of file condition.
        //

        if (!GetChar(&Char))
            break;

        switch (Char) {

            case TEXT('['):
                //
                //  If a registry key is currently open, we must close it first.
                //  If ParseHeader happens to fail (for example, no closing
                //  bracket), then hKey will be NULL and any values that we
                //  parse must be ignored.
                //

                if (hKey != NULL) {

                    RegCloseKey(hKey);
                    hKey = NULL;

                }

                ParseHeader(&hKey);

                break;

            case TEXT('"'):
                //
                //  As noted above, if we don't have an open registry key, then
                //  just skip the line.
                //

                if (hKey != NULL)
                    ParseValuename(hKey);

                else
                    SkipPastEndOfLine();

                break;

            case TEXT('@'):
                //
                //
                //

                if (hKey != NULL)
                    ParseValue(hKey, NULL);

                else
                    SkipPastEndOfLine();

                break;

            case TEXT(';'):
                //
                //  This line is a comment so just dump the rest of it.
                //

                SkipPastEndOfLine();

                break;

            default:
                if (IsNewLine(Char))
                    break;

                SkipPastEndOfLine();

                break;

        }

    }

    if (hKey != NULL)
        RegCloseKey(hKey);

    if (hUsersKey != NULL)
        RegCloseKey(hUsersKey);

    if (hLocalMachineKey != NULL)
        RegCloseKey(hLocalMachineKey);

}

/*******************************************************************************
*
*  ParseHeader
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

// REARCHITECT - each subkeyname can be MAXKEYNAME in size
// ideally - we should handle unlimited size names
// let's at least handle bigger names for now
// at least a depth of 10 with maximum length subkey names

#define SIZE_FULL_KEYNAME ((MAXKEYNAME + 40)*10)

VOID NEAR PASCAL ParseHeader( LPHKEY lphKey )
{

    TCHAR FullKeyName[SIZE_FULL_KEYNAME];
    int CurrentIndex;
    int LastRightBracketIndex;
    TCHAR Char;
    UINT uOperation = ERK_CREATE;

    CurrentIndex = 0;
    LastRightBracketIndex = -1;

    if (!GetChar(&Char))
        return;

    if (Char == TEXT('-')) {
        if (!GetChar(&Char))
            return;
        uOperation = ERK_DELETE;
    }

    do {

        if (IsNewLine(Char))
            break;

        if (Char == TEXT(']'))
            LastRightBracketIndex = CurrentIndex;

        FullKeyName[CurrentIndex++] = Char;

        if (CurrentIndex == SIZE_FULL_KEYNAME) {

            do {

                if (Char == TEXT(']'))
                    LastRightBracketIndex = -1;

                if (IsNewLine(Char))
                    break;

            }   while (GetChar(&Char));

            break;

        }

    } while (GetChar(&Char));

    if (LastRightBracketIndex != -1)
    {
        FullKeyName[LastRightBracketIndex] = 0;

        switch (EditRegistryKey(lphKey, FullKeyName, uOperation))
        {
            //
            // Be afraid of adding code to handle more error cases here.
            //
            // We broke Picture Publisher 8.0 by adding an ERROR_BADKEY
            // case.  As part of their setup, they run regedit on a v4
            // reg file that has a bad section, which EditRegistryKey
            // will fail to parse with ERROR_BADKEY.  We need to keep
            // chugging along in that case like Win2K did, or else we
            // break their setup.
            //
            case ERROR_CANTOPEN:
                g_FileErrorStringID = IDS_IMPFILEERRREGOPEN;
                break;
        }

    }

}

/*******************************************************************************
*
*  ParseValuename
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
NEAR PASCAL
ParseValuename(
    HKEY hKey
    )
{
    PORTVALUEPARAM PortValueParam;
    PortValueParam.cbData = MAXVALUENAME_LENGTH * sizeof(TCHAR);
    PortValueParam.pbData = LocalAlloc(LPTR, PortValueParam.cbData);

    if (PortValueParam.pbData)
    {
        if (ParseString(&PortValueParam))
        {
            ParseValue(hKey, (PTSTR)PortValueParam.pbData);
        }
        else
        {
            SkipPastEndOfLine();
        }
        LocalFree(PortValueParam.pbData);
    }
}

VOID
NEAR PASCAL
ParseValue(
           HKEY hKey,
           LPCTSTR lpszValueName
           )
{
    BOOL fSuccess = TRUE;
    BOOL fSkipPastLine = FALSE;
    DWORD Type = 0;
    DWORD cbData = 0;
    DWORD cbMaxData = ALLOCATION_INCR;
    LPCTSTR lpPrefix;
    PBYTE pbValueDataBuffer;

    SkipWhitespace();

    if (!MatchChar(TEXT('=')))
    {
        fSuccess = FALSE;
        fSkipPastLine = TRUE;
    }
    else
    {

        SkipWhitespace();

        pbValueDataBuffer = LocalAlloc(LPTR, cbMaxData);
        if (!pbValueDataBuffer)
        {
            g_FileErrorStringID = IDS_IMPFILEERRREGSET;
            fSuccess = FALSE;
        }
        else
        {
            //
            //  REG_SZ.
            //
            //  "ValueName" = "string of text"
            //

            if (MatchChar(TEXT('"')))
            {

                //  FEATURE:  Line continuations for strings?

                PORTVALUEPARAM PortValueParam;
                PortValueParam.pbData = pbValueDataBuffer;
                PortValueParam.cbData = cbMaxData;

                if (!ParseString(&PortValueParam) || !ParseEndOfLine())
                {
                    fSuccess = FALSE;
                    fSkipPastLine = TRUE;
                }

                // pointer might have been swapped for one with more memory
                pbValueDataBuffer = PortValueParam.pbData;
                cbData = PortValueParam.cbData;
                Type = REG_SZ;

            }

            //
            //  REG_DWORD.
            //
            //  "ValueName" = dword: 12345678
            //

            else if (MatchChar(s_DwordPrefix[0])) {

                lpPrefix = &s_DwordPrefix[1];

                while (*lpPrefix != 0)
                {
                    if (!MatchChar(*lpPrefix++))
                    {
                        fSuccess = FALSE;
                        fSkipPastLine = TRUE;
                    }
                }

                if (fSuccess)
                {
                    SkipWhitespace();

                    if (!ParseHexDword((LPDWORD) pbValueDataBuffer) || !ParseEndOfLine())
                    {
                        fSuccess = FALSE;
                        fSkipPastLine = TRUE;
                    }

                    Type = REG_DWORD;
                    cbData = sizeof(DWORD);
                }
            }
            else if (MatchChar('-'))
            {
                if (!ParseEndOfLine())
                {
                    fSuccess = FALSE;
                    fSkipPastLine = TRUE;
                }
                else
                {
                    RegDeleteValue(hKey, lpszValueName);
                    fSuccess = FALSE;
                }
            }

            //
            //  REG_BINARY and other.
            //
            //  "ValueName" = hex: 00 , 11 , 22
            //  "ValueName" = hex(12345678): 00, 11, 22
            //

            else {

                lpPrefix = s_HexPrefix;

                while (*lpPrefix != 0)
                {
                    if (!MatchChar(*lpPrefix++))
                    {
                        fSuccess = FALSE;
                        fSkipPastLine = TRUE;
                    }
                }

                if (fSuccess)
                {
                    //
                    //  Check if this is a type of registry data that we don't directly
                    //  support.  If so, then it's just a dump of hex data of the specified
                    //  type.
                    //

                    if (MatchChar(TEXT('(')))
                    {
                        if (!ParseHexDword(&Type) || !MatchChar(TEXT(')')))
                        {
                            fSuccess = FALSE;
                            fSkipPastLine = TRUE;
                        }
                    }

                    else
                        Type = REG_BINARY;

                    if (fSuccess)
                    {
                        PORTVALUEPARAM PortValueParam;
                        PortValueParam.pbData = pbValueDataBuffer;
                        PortValueParam.cbData = cbMaxData;

                        if (!MatchChar(TEXT(':')) || !ParseHexSequence(&PortValueParam) ||
                            !ParseEndOfLine())
                        {
                            fSuccess = FALSE;
                            fSkipPastLine = TRUE;
                        }

                        // pointer might have been swapped for one with more memory
                        pbValueDataBuffer = PortValueParam.pbData;
                        cbData = PortValueParam.cbData;
                    }
                }
            }

            if (fSuccess)
            {

#ifdef UNICODE
                //
                // If we're compiled UNICODE and we're reading an older, ANSI .reg
                // file, we have to write all of the data to the registry using
                // RegSetValueExA, because it was read from the registry using
                // RegQueryValueExA.
                //
                if ((g_ImportFileVersion < 0x0500) && ((REG_EXPAND_SZ == Type) || (REG_MULTI_SZ == Type)))
                {
                    CHAR AnsiValueName[MAXVALUENAME_LENGTH];
                    AnsiValueName[0] = 0;

                    //
                    // It's much easier to convert the value name to ANSI
                    // and call RegSetValueExA than to try to convert
                    // a REG_MULTI_SZ to Unicode before calling RegSetValueExW.
                    // We don't lose anything because this is coming from a
                    // downlevel .reg file that could only contain ANSI characters
                    // to begin with.
                    //
                    WideCharToMultiByte(
                        CP_THREAD_ACP,
                        0,
                        lpszValueName,
                        -1,
                        AnsiValueName,
                        ARRAYSIZE(AnsiValueName),
                        NULL,
                        NULL
                        );

                    if (RegSetValueExA(
                        hKey,
                        AnsiValueName,
                        0,
                        Type,
                        pbValueDataBuffer,
                        cbData)
                        != ERROR_SUCCESS)
                        g_FileErrorStringID = IDS_IMPFILEERRREGSET;
                }
                else 
                {
#endif // UNICODE
                    if (RegSetValueEx(hKey, lpszValueName, 0, Type, pbValueDataBuffer, cbData) != ERROR_SUCCESS)
                        g_FileErrorStringID = IDS_IMPFILEERRREGSET;
#ifdef UNICODE
                }
#endif // UNICODE

            }
            LocalFree(pbValueDataBuffer);
        }
    }

    if (fSkipPastLine)
    {
        SkipPastEndOfLine();
    }
}

/*******************************************************************************
*
*  ParseString
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL
NEAR PASCAL
ParseString(LPPORTVALUEPARAM pPortValueParam)
{
    TCHAR Char;
    DWORD cbMaxStringData;
    DWORD cbStringData;


    LPTSTR psz = (LPTSTR)pPortValueParam->pbData; // this one is incremented
    cbMaxStringData = pPortValueParam->cbData;
    cbStringData = sizeof(TCHAR);                   //  Account for the null terminator

    while (GetChar(&Char))
    {
        if (cbStringData >= cbMaxStringData)
        {
            // allocate a bigger buffer
            PBYTE pbValueData =
                LocalReAlloc(pPortValueParam->pbData, cbMaxStringData + ALLOCATION_INCR, LMEM_MOVEABLE);
            if (pbValueData)
            {
                pPortValueParam->pbData = pbValueData;
                // incr psz to next char in new buffer
                psz = (LPTSTR)(pPortValueParam->pbData + (cbMaxStringData - sizeof(TCHAR)));

                cbMaxStringData += ALLOCATION_INCR;
            }
            else
            {
                break;
            }
        }

        switch (Char) {

            case TEXT('\\'):
                if (!GetChar(&Char))
                    return FALSE;

                switch (Char) {

                    case TEXT('\\'):
                        *psz++ = TEXT('\\');
                        break;

                    case TEXT('"'):
                        *psz++ = TEXT('"');
                        break;

                    default:
                        DebugPrintf(("ParseString:  Invalid escape sequence"));
                        return FALSE;

                }
                break;

            case TEXT('"'):
                *psz = 0;
                pPortValueParam->cbData = cbStringData;
                return TRUE;

            default:
                if (IsNewLine(Char))
                    return FALSE;

                *psz++ = Char;
                break;

        }

        cbStringData += sizeof(TCHAR);

    }

    return FALSE;

}


/*******************************************************************************
*
*  ParseHexSequence
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL
NEAR PASCAL
ParseHexSequence(LPPORTVALUEPARAM pPortValueParam)
{
    BOOL  fSuccess = TRUE;
    DWORD cbHexData = 0;
    DWORD cbMaxStringData = pPortValueParam->cbData;
    LPBYTE lpHexData = pPortValueParam->pbData;

    do
    {
        if (cbHexData >= cbMaxStringData)
        {
            // allocate a bigger buffer
            PBYTE pbValueData = LocalReAlloc(pPortValueParam->pbData,
                cbMaxStringData + ALLOCATION_INCR, LMEM_MOVEABLE);
            if (pbValueData)
            {
                pPortValueParam->pbData = pbValueData;
                // incr psz to next char in new buffer
                lpHexData = pPortValueParam->pbData + cbMaxStringData;

                cbMaxStringData += ALLOCATION_INCR;
            }
            else
            {
                fSuccess = FALSE;
                break;
            }
        }

        SkipWhitespace();

        if (MatchChar(TEXT('\\')) && !ParseEndOfLine())
        {
            fSuccess = FALSE;
            break;
        }

        SkipWhitespace();

        if (!ParseHexByte(lpHexData++))
            break;

        cbHexData++;

        SkipWhitespace();

    }   while (MatchChar(TEXT(',')));

    pPortValueParam->cbData = cbHexData;

    return fSuccess;

}

/*******************************************************************************
*
*  ParseHexDword
*
*  DESCRIPTION:
*     Parses a one dword hexadecimal string from the registry file stream and
*     converts it to a binary number.  A maximum of eight hex digits will be
*     parsed from the stream.
*
*  PARAMETERS:
*     lpByte, location to store binary number.
*     (returns), TRUE if a hexadecimal dword was parsed, else FALSE.
*
*******************************************************************************/

BOOL
NEAR PASCAL
ParseHexDword(
    LPDWORD lpDword
    )
{

    UINT CountDigits;
    DWORD Dword;
    BYTE Byte;

    Dword = 0;
    CountDigits = 0;

    for (;;) {

        if (!ParseHexDigit(&Byte))
            break;

        Dword = (Dword << 4) + (DWORD) Byte;

        if (++CountDigits == 8)
            break;

    }

    *lpDword = Dword;

    return CountDigits != 0;

}

/*******************************************************************************
*
*  ParseHexByte
*
*  DESCRIPTION:
*     Parses a one byte hexadecimal string from the registry file stream and
*     converts it to a binary number.
*
*  PARAMETERS:
*     lpByte, location to store binary number.
*     (returns), TRUE if a hexadecimal byte was parsed, else FALSE.
*
*******************************************************************************/

BOOL
NEAR PASCAL
ParseHexByte(
    LPBYTE lpByte
    )
{

    BYTE SecondDigit;

    if (ParseHexDigit(lpByte)) {

        if (ParseHexDigit(&SecondDigit))
            *lpByte = (BYTE) ((*lpByte << 4) | SecondDigit);

        return TRUE;

    }

    else
        return FALSE;

}

/*******************************************************************************
*
*  ParseHexDigit
*
*  DESCRIPTION:
*     Parses a hexadecimal character from the registry file stream and converts
*     it to a binary number.
*
*  PARAMETERS:
*     lpDigit, location to store binary number.
*     (returns), TRUE if a hexadecimal digit was parsed, else FALSE.
*
*******************************************************************************/

BOOL
NEAR PASCAL
ParseHexDigit(
    LPBYTE lpDigit
    )
{

    TCHAR Char;
    BYTE Digit;

    if (GetChar(&Char)) {

        if (Char >= TEXT('0') && Char <= TEXT('9'))
            Digit = (BYTE) (Char - TEXT('0'));

        else if (Char >= TEXT('a') && Char <= TEXT('f'))
            Digit = (BYTE) (Char - TEXT('a') + 10);

        else if (Char >= TEXT('A') && Char <= TEXT('F'))
            Digit = (BYTE) (Char - TEXT('A') + 10);

        else {

            UngetChar();

            return FALSE;

        }

        *lpDigit = Digit;

        return TRUE;

    }

    return FALSE;

}

/*******************************************************************************
*
*  ParseEndOfLine
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL
NEAR PASCAL
ParseEndOfLine(
    VOID
    )
{

    TCHAR Char;
    BOOL fComment;
    BOOL fFoundOneEndOfLine;
    BOOL fEOF;

    fComment = FALSE;
    fFoundOneEndOfLine = FALSE;
    fEOF = TRUE;

    while (GetChar(&Char)) {

        if (IsWhitespace(Char))
            continue;

        if (IsNewLine(Char)) {

            fComment = FALSE;
            fFoundOneEndOfLine = TRUE;

        }

        //
        //  Like .INIs and .INFs, comments begin with a semicolon character.
        //

        else if (Char == TEXT(';'))
            fComment = TRUE;

        else if (!fComment) {

            UngetChar();
            fEOF = FALSE;
            break;

        }

    }

    return fFoundOneEndOfLine || fEOF;

}

/*******************************************************************************
*
*  SkipWhitespace
*
*  DESCRIPTION:
*     Advances the registry file pointer to the first character past any
*     detected whitespace.
*
*  PARAMETERS:
*     (none).
*
*******************************************************************************/

VOID
NEAR PASCAL
SkipWhitespace(
    VOID
    )
{

    TCHAR Char;

    while (GetChar(&Char)) {

        if (!IsWhitespace(Char)) {

            UngetChar();
            break;

        }

    }

}

/*******************************************************************************
*
*  SkipPastEndOfLine
*
*  DESCRIPTION:
*     Advances the registry file pointer to the first character past the first
*     detected new line character.
*
*  PARAMETERS:
*     (none).
*
*******************************************************************************/

VOID
NEAR PASCAL
SkipPastEndOfLine(
    VOID
    )
{

    TCHAR Char;

    while (GetChar(&Char)) {

        if (IsNewLine(Char))
            break;

    }

    while (GetChar(&Char)) {

        if (!IsNewLine(Char)) {

            UngetChar();
            break;

        }

    }

}

/*******************************************************************************
*
*  GetChar
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL
NEAR PASCAL
GetChar(
    PTCHAR lpChar
    )
{

    DWORD NumberOfBytesRead;
    UINT NewPercentage;

    // If we're at the end of the buffer, read some more.
    // Initially BufferOffset and CharsAvailable will be 0
    if (s_FileIo.BufferOffset == s_FileIo.CharsAvailable) {

        if (TRUE == s_fTreatFileAsUnicode) 
        {
            if (!READFILE(s_FileIo.hFile, s_FileIo.Buffer, SIZE_FILE_IO_BUFFER, &NumberOfBytesRead)) 
            {
                g_FileErrorStringID = IDS_IMPFILEERRFILEREAD;
                return FALSE;
            }

            s_FileIo.CharsAvailable = ((int) NumberOfBytesRead / 2);
        }
        else 
        {
            if (!READFILE(s_FileIo.hFile, s_FileIo.ConversionBuffer, SIZE_FILE_IO_BUFFER, &NumberOfBytesRead)) 
            {
                g_FileErrorStringID = IDS_IMPFILEERRFILEREAD;
                return FALSE;
            }

            {
                int i;

                i = MultiByteToWideChar(
                        CP_THREAD_ACP,
                        MB_PRECOMPOSED,
                        s_FileIo.ConversionBuffer,
                        NumberOfBytesRead,
                        s_FileIo.Buffer,
                        ARRAYSIZE(s_FileIo.Buffer)
                        );

                s_FileIo.CharsAvailable = i;
            }
        }

        s_FileIo.BufferOffset = 0;
        s_FileIo.FileOffset += NumberOfBytesRead;

        if (s_FileIo.FileSizeDiv100 != 0) {

            NewPercentage = ((UINT) (s_FileIo.FileOffset /
                s_FileIo.FileSizeDiv100));

            if (NewPercentage > 100)
                NewPercentage = 100;

        }

        else
            NewPercentage = 100;

        if (s_FileIo.LastPercentage != NewPercentage) {

            s_FileIo.LastPercentage = NewPercentage;
            // ImportRegFileUICallback(NewPercentage);

        }

    }

    if (s_FileIo.BufferOffset >= s_FileIo.CharsAvailable)
        return FALSE;

    *lpChar = s_FileIo.Buffer[s_FileIo.BufferOffset++];

    return TRUE;

}

/*******************************************************************************
*
*  UngetChar
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

VOID
NEAR PASCAL
UngetChar(
    VOID
    )
{

#ifdef DEBUG
    if (s_FileIo.fValidateUngetChar)
        DebugPrintf(("REGEDIT ERROR: Too many UngetChar's called!\n\r"));
#endif

    s_FileIo.BufferOffset--;

}

/*******************************************************************************
*
*  MatchChar
*
*  DESCRIPTION:
*
*  PARAMETERS:
*
*******************************************************************************/

BOOL
NEAR PASCAL
MatchChar(
    TCHAR CharToMatch
    )
{

    BOOL fMatch;
    TCHAR NextChar;

    fMatch = FALSE;

    if (GetChar(&NextChar)) {

        if (CharToMatch == NextChar)
            fMatch = TRUE;

        else
            UngetChar();

    }

    return fMatch;

}

/*******************************************************************************
*
*  IsWhitespace
*
*  DESCRIPTION:
*     Checks if the given character is whitespace.
*
*  PARAMETERS:
*     Char, character to check.
*     (returns), TRUE if character is whitespace, else FALSE.
*
*******************************************************************************/

BOOL
NEAR PASCAL
IsWhitespace(
    TCHAR Char
    )
{

    return Char == TEXT(' ') || Char == TEXT('\t');

}

/*******************************************************************************
*
*  IsNewLine
*
*  DESCRIPTION:
*     Checks if the given character is a new line character.
*
*  PARAMETERS:
*     Char, character to check.
*     (returns), TRUE if character is a new line, else FALSE.
*
*******************************************************************************/

BOOL
NEAR PASCAL
IsNewLine(
    TCHAR Char
    )
{

    return Char == TEXT('\n') || Char == TEXT('\r');

}

/*******************************************************************************
*
*  ExportWinNT50RegFile
*
*  DESCRIPTION:
*      Exports an NT 5.0, unicode registry file.  Use this export function
*      for all future .reg file writing.
*
*  PARAMETERS:
*
*******************************************************************************/
VOID ExportWinNT50RegFile(LPTSTR lpFileName, LPTSTR lpSelectedPath)
{

    HKEY hKey = INVALID_HANDLE_VALUE;
    TCHAR SelectedPath[SIZE_SELECTED_PATH];

    g_FileErrorStringID = IDS_EXPFILEERRSUCCESS;

    if (lpSelectedPath != NULL && 
        EditRegistryKey(&hKey, lpSelectedPath, ERK_OPEN) != ERROR_SUCCESS)
    {
        g_FileErrorStringID = IDS_EXPFILEERRBADREGPATH;
        return;
    }

    g_dwTotalKeysSaved = 0;
    if (OPENWRITEFILE(lpFileName, s_FileIo.hFile)) 
    {

        DWORD dwNumberOfBytesWritten;

        s_FileIo.BufferOffset = 0;
        s_FileIo.CurrentColumn = 0;

        WRITEFILE(s_FileIo.hFile, &s_UnicodeByteOrderMark, sizeof(s_UnicodeByteOrderMark), &dwNumberOfBytesWritten);

        PutLiteral(s_WinNT50RegFileHeader);
        PutLiteral(TEXT(" "));
        PutLiteral(s_WinNT50RegFileVersion);
        PutLiteral(TEXT("\n\n"));

        if (lpSelectedPath != NULL) 
        {
            StringCchCopy(SelectedPath, ARRAYSIZE(SelectedPath), lpSelectedPath);
            PutBranch(hKey, SelectedPath);

        }
        else
        {

            StringCchCopy(SelectedPath, ARRAYSIZE(SelectedPath), g_RegistryRoots[INDEX_HKEY_LOCAL_MACHINE].lpKeyName);

            PutBranch(HKEY_LOCAL_MACHINE, SelectedPath);

            StringCchCopy(SelectedPath, ARRAYSIZE(SelectedPath), g_RegistryRoots[INDEX_HKEY_USERS].lpKeyName);

            PutBranch(HKEY_USERS, SelectedPath);

        }

        FlushIoBuffer();

        CloseHandle(s_FileIo.hFile);

    }
    else
        g_FileErrorStringID = IDS_EXPFILEERRFILEOPEN;

    if (lpSelectedPath != NULL)
        RegCloseKey(hKey);

}


/*******************************************************************************
*
*  PutBranch
*
*  DESCRIPTION:
*     Writes out all of the value names and their data and recursively calls
*     this routine for all of the key's subkeys to the registry file stream.
*
*  PARAMETERS:
*     hKey, registry key to write to file.
*     lpFullKeyName, string that gives the full path, including the root key
*        name, of the hKey.
*
*******************************************************************************/

VOID
NEAR PASCAL
PutBranch(
    HKEY hKey,
    LPTSTR lpFullKeyName
    )
{
    HKEY hSubKey;
    LONG RegError;
    DWORD EnumIndex;
    DWORD cchValueName;
    DWORD cbValueData;
    DWORD Type;
    LPTSTR lpSubKeyName;
    LPTSTR lpTempFullKeyName;
    BOOL bFlag = FALSE;
    int nLenTempFullKey;
    int nLenFullKey;    

    //
    //  Write out the section header.
    //

    PutChar(TEXT('['));
    PutLiteral(lpFullKeyName);
    PutLiteral(TEXT("]\n"));

    //
    //  Write out all of the value names and their data.
    //

    EnumIndex = 0;

    for (;;)
    {
        PBYTE pbValueData;
        cchValueName = ARRAYSIZE(g_ValueNameBuffer);

        // VALUE DATA
        // Query for data size
        RegError = RegEnumValue(hKey, EnumIndex++, g_ValueNameBuffer,
            &cchValueName, NULL, &Type, NULL, &cbValueData);

        if (RegError != ERROR_SUCCESS)
        {
            break;
        }

        // allocate memory for data
        g_FileErrorStringID = IDS_EXPFILEERRSUCCESS;
        pbValueData =  LocalAlloc(LPTR, cbValueData+ExtraAllocLen(Type));
        if (pbValueData)
        {
            if (RegQueryValueEx(hKey, g_ValueNameBuffer,
                NULL, &Type, pbValueData, &cbValueData) !=
                ERROR_SUCCESS)
            {
                g_FileErrorStringID = IDS_EXPFILEERRFILEWRITE;
            }
            else
            {
                //
                //  If cbValueName is zero, then this is the default value of
                //  the key, or the Windows 3.1 compatible key value.
                //

                if (cchValueName)
                    PutString(g_ValueNameBuffer);

                else
                    PutChar(TEXT('@'));

                PutChar(TEXT('='));

                switch (Type)
                {

                case REG_SZ:
                    PutString((LPTSTR) pbValueData);
                    break;

                case REG_DWORD:
                    if (cbValueData == sizeof(DWORD))
                    {
                        PutLiteral(s_DwordPrefix);
                        PutDword(*((LPDWORD) pbValueData), TRUE);
                        break;
                    }
                    //  FALL THROUGH

                case REG_BINARY:
                default:
                    PutBinary((LPBYTE) pbValueData, Type, cbValueData);
                    break;

                }

                PutChar(TEXT('\n'));
            }
            LocalFree(pbValueData);
        }
        else
        {
            g_FileErrorStringID = IDS_EXPFILEERRFILEWRITE;
        }

        if (g_FileErrorStringID == IDS_EXPFILEERRFILEWRITE)
            return;

        if ( g_FileErrorStringID == IDS_EXPFILEERRSUCCESS )
        {
            bFlag = TRUE;
        }
    }

    PutChar(TEXT('\n'));

    if (RegError != ERROR_NO_MORE_ITEMS)
        g_FileErrorStringID = IDS_EXPFILEERRREGENUM;

    if ( bFlag == TRUE )
    {
        g_dwTotalKeysSaved++;
    }

    //
    //  Write out all of the subkeys and recurse into them.
    //

    //copy the existing key into a new buffer with enough room for the next key
    nLenFullKey = lstrlen(lpFullKeyName);
    nLenTempFullKey = nLenFullKey + MAXKEYNAME;
    __try
    {
        lpTempFullKeyName = (LPTSTR) alloca(nLenTempFullKey * sizeof(TCHAR));
    }
    __except(GetExceptionCode() == STATUS_STACK_OVERFLOW)
    {
        _resetstkoflw();
        return;
    }

    StringCchCopy(lpTempFullKeyName, nLenTempFullKey, lpFullKeyName);
    lpSubKeyName = lpTempFullKeyName + nLenFullKey;
    *lpSubKeyName++ = TEXT('\\');
    *lpSubKeyName = 0;

    EnumIndex = 0;

    for(;;) 
    {
        if ((RegError = RegEnumKey(hKey, EnumIndex++, lpSubKeyName, MAXKEYNAME-1)) != ERROR_SUCCESS)
            break;

        if(RegOpenKeyEx(hKey,lpSubKeyName,0,KEY_ENUMERATE_SUB_KEYS|KEY_QUERY_VALUE,&hSubKey) == ERROR_SUCCESS) 
        {
            // reset the previous error
            g_FileErrorStringID = IDS_EXPFILEERRSUCCESS;

			PutBranch(hSubKey, lpTempFullKeyName);

            RegCloseKey(hSubKey);

            if ( bFlag == FALSE && g_FileErrorStringID == IDS_EXPFILEERRSUCCESS )
            {
                g_dwTotalKeysSaved++;
                bFlag = TRUE;
            }

            if (g_FileErrorStringID == IDS_EXPFILEERRFILEWRITE)
                return;
        }

        else
            g_FileErrorStringID = IDS_EXPFILEERRREGOPEN;
    }

    if (RegError != ERROR_NO_MORE_ITEMS)
        g_FileErrorStringID = IDS_EXPFILEERRREGENUM;

}

/*******************************************************************************
*
*  PutLiteral
*
*  DESCRIPTION:
*     Writes a literal string to the registry file stream.  No special handling
*     is done for the string-- it is written out as is.
*
*  PARAMETERS:
*     lpLiteral, null-terminated literal to write to file.
*
*******************************************************************************/

VOID
NEAR PASCAL
PutLiteral(
    LPCTSTR lpLiteral
    )
{

    while (*lpLiteral != 0)
        PutChar(*lpLiteral++);

}

/*******************************************************************************
*
*  PutString
*
*  DESCRIPTION:
*     Writes a string to the registry file stream.  A string is surrounded by
*     double quotes and some characters may be translated to escape sequences
*     to enable a parser to read the string back in.
*
*  PARAMETERS:
*     lpString, null-terminated string to write to file.
*
*******************************************************************************/

VOID
NEAR PASCAL
PutString(
    LPCTSTR lpString
    )
{

    TCHAR Char;

    PutChar(TEXT('"'));

    while ((Char = *lpString++) != 0) {

        switch (Char) {

            case TEXT('\\'):
            case TEXT('"'):
                PutChar(TEXT('\\'));
                //  FALL THROUGH

            default:
                PutChar(Char);
                break;

        }

    }

    PutChar(TEXT('"'));

}

/*******************************************************************************
*
*  PutBinary
*
*  DESCRIPTION:
*     Writes a sequence of hexadecimal bytes to the registry file stream.  The
*     output is formatted such that it doesn't exceed a defined line length.
*
*  PARAMETERS:
*     lpBuffer, bytes to write to file.
*     Type, value data type.
*     cbBytes, number of bytes to write.
*
*******************************************************************************/

VOID
NEAR PASCAL
PutBinary(
    CONST BYTE FAR* lpBuffer,
    DWORD Type,
    DWORD cbBytes
    )
{

    BOOL fFirstByteOnLine;
    BYTE Byte;

    // If we're writing one of the string formats that regedit doesn't write
    // natively (but rather converts to a string of hex digits for streaming
    // out), AND we're writing in downlevel/ANSI/REGEDIT4 format, we aren't
    // going to write out the high byte of each (internally Unicode) character.
    // So we will be writing half as many characters as the buffer byte size.

    // if ((g_RegEditData.uExportFormat == FILE_TYPE_REGEDIT4) &&
    //     ((Type == REG_EXPAND_SZ) || (Type == REG_MULTI_SZ))) {
    //     cbBytes = cbBytes / 2;
    // }

    PutLiteral(s_HexPrefix);

    if (Type != REG_BINARY) {

        PutChar(TEXT('('));
        PutDword(Type, FALSE);
        PutChar(TEXT(')'));

    }

    PutChar(TEXT(':'));

    fFirstByteOnLine = TRUE;

    while (cbBytes--) {

        if (s_FileIo.CurrentColumn > 75 && !fFirstByteOnLine) {

            PutLiteral(s_FileLineBreak);

            fFirstByteOnLine = TRUE;

        }

        if (!fFirstByteOnLine)
            PutChar(TEXT(','));

        Byte = *lpBuffer++;

        // If we're writing one of the string formats that regedit doesn't
        // write natively (REG_EXPAND_SZ and REG_MULTI_SZ values get converted
        // to a string of hex digits for streaming out), AND we're writing in
        // downlevel/ANSI/REGEDIT4 format, we don't want to write out the high
        // byte of each (internally Unicode) character.  So in those cases, we
        // advance another byte to get to the next ANSI character.  Yes, this
        // will lose data on non-SBCS characters, but that's what you get for
        // saving in the downlevel format.

        // if ((g_RegEditData.uExportFormat == FILE_TYPE_REGEDIT4) &&
        //     ((Type == REG_EXPAND_SZ) || (Type == REG_MULTI_SZ))) {
        //     lpBuffer++;
        // }

        PutChar(g_HexConversion[Byte >> 4]);
        PutChar(g_HexConversion[Byte & 0x0F]);

        fFirstByteOnLine = FALSE;

    }

}

/*******************************************************************************
*
*  PutChar
*
*  DESCRIPTION:
*     Writes a 32-bit word to the registry file stream.
*
*  PARAMETERS:
*     Dword, dword to write to file.
*
*******************************************************************************/

VOID
NEAR PASCAL
PutDword(
    DWORD Dword,
    BOOL fLeadingZeroes
    )
{

    int CurrentNibble;
    TCHAR Char;
    BOOL fWroteNonleadingChar;

    fWroteNonleadingChar = fLeadingZeroes;

    for (CurrentNibble = 7; CurrentNibble >= 0; CurrentNibble--) {

        Char = g_HexConversion[(Dword >> (CurrentNibble * 4)) & 0x0F];

        if (fWroteNonleadingChar || Char != TEXT('0')) {

            PutChar(Char);
            fWroteNonleadingChar = TRUE;

        }

    }

    //
    //  We need to write at least one character, so if we haven't written
    //  anything yet, just spit out one zero.
    //

    if (!fWroteNonleadingChar)
        PutChar(TEXT('0'));

}

/*******************************************************************************
*
*  PutChar
*
*  DESCRIPTION:
*     Writes one character to the registry file stream using an intermediate
*     buffer.
*
*  PARAMETERS:
*     Char, character to write to file.
*
*******************************************************************************/

VOID
NEAR PASCAL
PutChar(
    TCHAR Char
    )
{

    //
    //  Keep track of what column we're currently at.  This is useful in cases
    //  such as writing a large binary registry record.  Instead of writing one
    //  very long line, the other Put* routines can break up their output.
    //

    if (Char != TEXT('\n'))
        s_FileIo.CurrentColumn++;

    else {

        //
        //  Force a carriage-return, line-feed sequence to keep things like, oh,
        //  Notepad happy.
        //

        PutChar(TEXT('\r'));

        s_FileIo.CurrentColumn = 0;

    }

    s_FileIo.Buffer[s_FileIo.BufferOffset++] = Char;

    if (s_FileIo.BufferOffset == SIZE_FILE_IO_BUFFER)
        FlushIoBuffer();

}

/*******************************************************************************
*
*  FlushIoBuffer
*
*  DESCRIPTION:
*     Flushes the contents of the registry file stream to the disk and resets
*     the buffer pointer.
*
*  PARAMETERS:
*     (none).
*
*******************************************************************************/

VOID
NEAR PASCAL
FlushIoBuffer(
    VOID
    )
{

    DWORD NumberOfBytesWritten;

    if (s_FileIo.BufferOffset) 
    {
        // if (g_RegEditData.uExportFormat == FILE_TYPE_REGEDIT4)
        // {
        //     //
        //     // Convert Unicode to ANSI before writing.
        //     //
        // 
        //     int i;
        // 
        //     i = WideCharToMultiByte(
        //             CP_THREAD_ACP,
        //             0,
        //             s_FileIo.Buffer,
        //             s_FileIo.BufferOffset,
        //             s_FileIo.ConversionBuffer,
        //             sizeof(s_FileIo.ConversionBuffer),      // Number of bytes...
        //             NULL,
        //             NULL
        //             );
        // 
        //     if (!WRITEFILE(s_FileIo.hFile, s_FileIo.ConversionBuffer, i, &NumberOfBytesWritten) 
        //             ||  (DWORD) i != NumberOfBytesWritten)
        // 
        //         g_FileErrorStringID = IDS_EXPFILEERRFILEWRITE;
        // }
        // else
        {
            //
            // Write Unicode text
            //
            if (!WRITEFILE(s_FileIo.hFile, s_FileIo.Buffer, s_FileIo.BufferOffset * sizeof(WCHAR), 
                            &NumberOfBytesWritten) 
                    || (DWORD) (s_FileIo.BufferOffset * sizeof(WCHAR)) != NumberOfBytesWritten)
            {
                g_FileErrorStringID = IDS_EXPFILEERRFILEWRITE;
            }
        }
    }

    s_FileIo.BufferOffset = 0;

}

//  RegDeleteKeyRecursive
//  DESCRIPTION:
//     Adapted from \\kernel\razzle3,mvdm\wow32\wshell.c,WOWRegDeleteKey().
//     The Windows 95 implementation of RegDeleteKey recursively deletes all
//     the subkeys of the specified registry branch, but the NT implementation
//     only deletes leaf keys.


LONG RegDeleteKeyRecursive(HKEY hKey,
                           LPCTSTR lpszSubKey)
/*++
Routine Description:

    There is a significant difference between the Win3.1 and Win32
    behavior of RegDeleteKey when the key in question has subkeys.
    The Win32 API does not allow you to delete a key with subkeys,
    while the Win3.1 API deletes a key and all its subkeys.

    This routine is a recursive worker that enumerates the subkeys
    of a given key, applies itself to each one, then deletes itself.

    It specifically does not attempt to deal rationally with the
    case where the caller may not have access to some of the subkeys
    of the key to be deleted.  In this case, all the subkeys which
    the caller can delete will be deleted, but the api will still
    return ERROR_ACCESS_DENIED.

Arguments:
    hKey - Supplies a handle to an open registry key.
    lpszSubKey - Supplies the name of a subkey which is to be deleted
                 along with all of its subkeys.
Return Value:
    ERROR_SUCCESS - entire subtree successfully deleted.
    ERROR_ACCESS_DENIED - given subkey could not be deleted.
--*/
{
    DWORD i;
    HKEY Key;
    LONG Status;
    DWORD ClassLength=0;
    DWORD SubKeys;
    DWORD MaxSubKey;
    DWORD MaxClass;
    DWORD Values;
    DWORD MaxValueName;
    DWORD MaxValueData;
    DWORD SecurityLength;
    FILETIME LastWriteTime;
    LPTSTR NameBuffer;

    //
    // First open the given key so we can enumerate its subkeys
    //
    Status = RegOpenKeyEx(hKey,
                          lpszSubKey,
                          0,
                          KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
                          &Key);
    if (Status != ERROR_SUCCESS)
    {
        //
        // possibly we have delete access, but not enumerate/query.
        // So go ahead and try the delete call, but don't worry about
        // any subkeys.  If we have any, the delete will fail anyway.
        //
        return(RegDeleteKey(hKey,lpszSubKey));
    }

    //
    // Use RegQueryInfoKey to determine how big to allocate the buffer
    // for the subkey names.
    //
    Status = RegQueryInfoKey(Key,
                             NULL,
                             &ClassLength,
                             0,
                             &SubKeys,
                             &MaxSubKey,
                             &MaxClass,
                             &Values,
                             &MaxValueName,
                             &MaxValueData,
                             &SecurityLength,
                             &LastWriteTime);
    if ((Status != ERROR_SUCCESS) &&
        (Status != ERROR_MORE_DATA) &&
        (Status != ERROR_INSUFFICIENT_BUFFER))
    {
        RegCloseKey(Key);
        return(Status);
    }

    NameBuffer = (LPTSTR) LocalAlloc(LPTR, (MaxSubKey + 1)*sizeof(TCHAR));
    if (NameBuffer == NULL)
    {
        RegCloseKey(Key);
        return(ERROR_NOT_ENOUGH_MEMORY);
    }

    //
    // Enumerate subkeys and apply ourselves to each one.
    //
    i=0;
    do
    {
        Status = RegEnumKey(Key,
                            i,
                            NameBuffer,
                            MaxSubKey+1);

        if (Status == ERROR_SUCCESS)
        {
            Status = RegDeleteKeyRecursive(Key,NameBuffer);
        }

        if (Status != ERROR_SUCCESS)
        {
            //
            // Failed to delete the key at the specified index.  Increment
            // the index and keep going.  We could probably bail out here,
            // since the api is going to fail, but we might as well keep
            // going and delete everything we can.
            //
            ++i;
        }

    } while ( (Status != ERROR_NO_MORE_ITEMS) &&
              (i < SubKeys) );

    LocalFree((HLOCAL) NameBuffer);
    RegCloseKey(Key);
    return(RegDeleteKey(hKey,lpszSubKey));
}