/******************************************************************************* * * (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)); }