//-----------------------------------------------------------------------//
//
// File: copy.cpp
// Created: April 1997
// By: Martin Holladay (a-martih)
// Purpose: Registry Copy Support for REG.CPP
// Modification History:
// Copied from Update.cpp and modificd - April 1997 (a-martih)
// April 1999 Zeyong Xu: re-design, revision -> version 2.0
//
//------------------------------------------------------------------------//
#include "stdafx.h"
#include "reg.h"
//-----------------------------------------------------------------------//
//
// CopyRegistry()
//
//-----------------------------------------------------------------------//
LONG CopyRegistry(PAPPVARS pAppVars,
PAPPVARS pDstVars,
UINT argc,
TCHAR *argv[])
{
LONG nResult;
HKEY hKey;
HKEY hDstKey;
DWORD dwDisposition;
BOOL bOverWriteAll = FALSE;
//
// Parse the cmd-line
//
nResult = ParseCopyCmdLine(pAppVars, pDstVars, argc, argv);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
//
// Connect to the Remote Machine(s) - if applicable
//
nResult = RegConnectMachine(pAppVars);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
nResult = RegConnectMachine(pDstVars);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
//
// Now implement the body of the Copy Operation
//
nResult = RegOpenKeyEx(pAppVars->hRootKey,
pAppVars->szSubKey,
0,
KEY_READ,
&hKey);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
if (pAppVars->hRootKey == pDstVars->hRootKey &&
_tcsicmp(pAppVars->szFullKey, pDstVars->szFullKey) == 0)
{
RegCloseKey(hKey);
return REG_STATUS_COPYTOSELF;
}
else
{
//
// Different Key or Different Root or Different Machine
// So Create/Open it
//
nResult = RegCreateKeyEx(pDstVars->hRootKey,
pDstVars->szSubKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hDstKey,
&dwDisposition);
if (nResult != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return nResult;
}
}
//
// Recursively copy all subkeys and values
//
bOverWriteAll = pAppVars->bForce;
nResult = CopyEnumerateKey(hKey,
pAppVars->szSubKey,
hDstKey,
pDstVars->szSubKey,
&bOverWriteAll,
pAppVars->bRecurseSubKeys);
//
// lets clean up
//
RegCloseKey(hDstKey);
RegCloseKey(hKey);
return nResult;
}
REG_STATUS ParseCopyCmdLine(PAPPVARS pAppVars,
PAPPVARS pDstVars,
UINT argc,
TCHAR *argv[])
{
UINT i;
REG_STATUS nResult = ERROR_SUCCESS;
//
// Do we have a *valid* number of cmd-line params
//
if(argc < 4)
{
return REG_STATUS_TOFEWPARAMS;
}
else if(argc > 6)
{
return REG_STATUS_TOMANYPARAMS;
}
//
// Source Machine Name and Registry key
//
nResult = BreakDownKeyString(argv[2], pAppVars);
if(nResult != ERROR_SUCCESS)
return nResult;
//
// Destination Machine Name and Registry key
//
nResult = BreakDownKeyString(argv[3], pDstVars);
if(nResult != ERROR_SUCCESS)
return nResult;
// parsing
for(i=4; i<argc; i++)
{
if(!_tcsicmp(argv[i], _T("/f")))
{
pAppVars->bForce = TRUE;
}
else if(!_tcsicmp(argv[i], _T("/s")))
{
pAppVars->bRecurseSubKeys = TRUE;
}
else
{
nResult = REG_STATUS_INVALIDPARAMS;
}
}
return nResult;
}
//-----------------------------------------------------------------------//
//
// QueryValue()
//
//-----------------------------------------------------------------------//
LONG CopyValue(HKEY hKey,
TCHAR* szValueName,
HKEY hDstKey,
TCHAR* szDstValueName,
BOOL *pbOverWriteAll)
{
LONG nResult;
DWORD dwType, dwTmpType;
DWORD dwSize, dwTmpSize;
BYTE *pBuff;
TCHAR ch;
PTSTR PromptBuffer,PromptBufferFmt;
DWORD PromptBufferSize;
//
// First find out how much memory to allocate.
//
nResult = RegQueryValueEx(hKey,
szValueName,
0,
&dwType,
NULL,
&dwSize);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
pBuff = (BYTE*) calloc(dwSize + 1, sizeof(BYTE));
if (!pBuff)
return ERROR_NOT_ENOUGH_MEMORY;
//
// Now get the data
//
nResult = RegQueryValueEx(hKey,
szValueName,
0,
&dwType,
(LPBYTE) pBuff,
&dwSize);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
//
// Copy it to the destination
//
if (!*pbOverWriteAll)
{
//
// See if it already exists
//
nResult = RegQueryValueEx(hDstKey,
szDstValueName,
0,
&dwTmpType,
NULL,
&dwTmpSize);
if (nResult == ERROR_SUCCESS)
{
BOOL bGoodResponse = FALSE;
//
// allocate and fill in the prompt message
//
PromptBufferSize = 100;
PromptBufferSize += _tcslen(
szDstValueName
? szDstValueName
: g_NoName);
PromptBuffer = calloc(PromptBufferSize, sizeof(TCHAR));
if (!PromptBuffer) {
return ERROR_SUCCESS;
}
PromptBufferFmt = calloc(PromptBufferSize, sizeof(TCHAR));
if (!PromptBufferFmt) {
free(PromptBuffer);
return ERROR_SUCCESS;
}
LoadString( NULL, IDS_OVERWRITE, PromptBufferFmt, PromptBufferSize);
wsprintf(
PromptBuffer,
PromptBufferFmt,
szDstValueName
? szDstValueName
: g_NoName );
free( PromptBufferFmt);
while (!bGoodResponse) {
MyTPrintf(stdout,PromptBuffer);
ch = _gettchar();
_flushall();
switch (ch) {
case _T('a'): //fall through
case _T('y'): //fall through
case _T('n'):
bGoodResponse = TRUE;
break;
default:
//
// keep scanning.
//
;
}
}
free(PromptBuffer);
MyTPrintf(stdout,_T("\r\n"));
if (ch == _T('a') || ch == _T('A'))
{
*pbOverWriteAll = TRUE;
bGoodResponse = TRUE;
}
else if (ch == _T('y') || ch == _T('Y'))
{
bGoodResponse = TRUE;
}
else if (ch == _T('n') || ch == _T('N'))
{
return ERROR_SUCCESS;
}
}
}
//
// Write the Value
//
nResult = RegSetValueEx(hDstKey,
szDstValueName,
0,
dwType,
(PBYTE) pBuff,
dwSize);
if(pBuff)
free(pBuff);
return nResult;
}
//-----------------------------------------------------------------------//
//
// EnumerateKey() - Recursive
//
//-----------------------------------------------------------------------//
LONG CopyEnumerateKey(HKEY hKey,
TCHAR* szSubKey,
HKEY hDstKey,
TCHAR* szDstSubKey,
BOOL *pbOverWriteAll,
BOOL bRecurseSubKeys)
{
DWORD nResult;
UINT i;
DWORD dwSize;
DWORD dwDisposition;
HKEY hSubKey;
HKEY hDstSubKey;
TCHAR* szNameBuf;
TCHAR* szTempName;
TCHAR* szDstTempName;
// query source key info
DWORD dwLenOfKeyName;
DWORD dwLenOfValueName;
nResult = RegQueryInfoKey(hKey,
NULL,
NULL,
NULL,
NULL,
&dwLenOfKeyName,
NULL,
NULL,
&dwLenOfValueName,
NULL,
NULL,
NULL);
if (nResult != ERROR_SUCCESS)
{
return nResult;
}
#ifndef REG_FOR_WIN2000 // ansi version for win98
// fix API bugs: RegQueryInfoKey() returns non-correct length values
// on remote Win98
if(dwLenOfKeyName < MAX_PATH)
dwLenOfKeyName = MAX_PATH;
if(dwLenOfValueName < MAX_PATH)
dwLenOfValueName = MAX_PATH;
#endif
//
// First enumerate all of the values
//
dwLenOfValueName++;
szNameBuf = (TCHAR*) calloc(dwLenOfValueName, sizeof(TCHAR));
if (!szNameBuf) {
return ERROR_NOT_ENOUGH_MEMORY;
}
i = 0;
do
{
dwSize = dwLenOfValueName;
nResult = RegEnumValue(hKey,
i,
szNameBuf,
&dwSize,
NULL,
NULL,
NULL,
NULL);
if (nResult == ERROR_SUCCESS)
{
nResult = CopyValue(hKey,
szNameBuf,
hDstKey,
szNameBuf,
pbOverWriteAll);
}
i++;
} while (nResult == ERROR_SUCCESS);
if(szNameBuf)
free(szNameBuf);
if (nResult == ERROR_NO_MORE_ITEMS)
nResult = ERROR_SUCCESS;
if( !bRecurseSubKeys ||
nResult != ERROR_SUCCESS )
return nResult;
//
// Now Enumerate all of the keys
//
dwLenOfKeyName++;
szNameBuf = (TCHAR*) calloc(dwLenOfKeyName, sizeof(TCHAR));
if (!szNameBuf) {
return ERROR_NOT_ENOUGH_MEMORY;
}
i = 0;
do
{
dwSize = dwLenOfKeyName;
nResult = RegEnumKeyEx(hKey,
i,
szNameBuf,
&dwSize,
NULL,
NULL,
NULL,
NULL);
//
// Else open up the subkey, create the destination key
// and enumerate it
//
if (nResult == ERROR_SUCCESS)
{
nResult = RegOpenKeyEx(hKey,
szNameBuf,
0,
KEY_READ,
&hSubKey);
}
if (nResult == ERROR_SUCCESS)
{
nResult = RegCreateKeyEx(hDstKey,
szNameBuf,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_ALL_ACCESS,
NULL,
&hDstSubKey,
&dwDisposition);
if (nResult == ERROR_SUCCESS)
{
//
// Build up the needed string and go to town enumerating again
//
szTempName = (TCHAR*) calloc(_tcslen(szSubKey) +
_tcslen(szNameBuf) +
3,
sizeof(TCHAR));
if (!szTempName) {
nResult = ERROR_NOT_ENOUGH_MEMORY;
goto Cleanup;
}
if(_tcslen(szSubKey) > 0)
{
_tcscpy(szTempName, szSubKey);
_tcscat(szTempName, _T("\\"));
}
_tcscat(szTempName, szNameBuf);
szDstTempName = (TCHAR*) calloc(_tcslen(szDstSubKey) +
_tcslen(szNameBuf) +
3,
sizeof(TCHAR));
if (!szDstTempName) {
free (szTempName);
nResult = ERROR_NOT_ENOUGH_MEMORY;
goto Cleanup;
}
if(_tcslen(szDstSubKey) > 0)
{
_tcscpy(szDstTempName, szDstSubKey);
_tcscat(szDstTempName, _T("\\"));
}
_tcscat(szDstTempName, szNameBuf);
// recursive copy
nResult = CopyEnumerateKey(hSubKey,
szTempName,
hDstSubKey,
szDstTempName,
pbOverWriteAll,
bRecurseSubKeys);
RegCloseKey(hSubKey);
RegCloseKey(hDstSubKey);
if(szTempName)
free(szTempName);
if(szDstTempName)
free(szDstTempName);
}
}
i++;
} while (nResult == ERROR_SUCCESS);
Cleanup:
if(szNameBuf)
free(szNameBuf);
if (nResult == ERROR_NO_MORE_ITEMS)
nResult = ERROR_SUCCESS;
return nResult;
}