able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/pchealth/sr/tools/rpctest/rpctest.cpp

1256 lines
35 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/********************************************************************
Copyright (c) 1999 Microsoft Corporation
Module Name:
rpcstest.cpp
Abstract:
This file is a unit test for the SFP client api
Revision History:
Brijesh Krishnaswami (brijeshk) - 06/29/99 - Created
********************************************************************/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <windows.h>
#include <shellapi.h>
#include <dbgtrace.h>
#include <stdio.h>
#include <stdlib.h>
#include "srrestoreptapi.h"
#include "srrpcapi.h"
#include "utils.h"
#include "srapi.h"
#include "wintrust.h"
#include "softpub.h"
#include "mscat.h"
#include "shlwapi.h"
void
PrintUsage()
{
printf("Usage: rpctest <option>");
printf("\n 1 = EnableSR <volumename>");
printf("\n 2 = DisableSR <volumename>");
printf("\n 3 = EnableFIFO");
printf("\n 4 = DisableFIFO <seqnum>");
printf("\n 5 = SRSetRestorePoint [Description] [Rptype] [EvtType] [SeqNum]");
printf("\n 6 = SRRemoveRestorePoint <seqnum>");
printf("\n 7 = SRUpdateMonitoredList <filepath>");
printf("\n 8 = SRFifo <volumename> <targetpercent>");
printf("\n 9 = SRFifo <volumename> <targetpercent> -- fifo atleast one rp");
printf("\n 10 = SRFifo <volumename> <targetRPNum> -- include current rp");
printf("\n 11 = SRFifo <volumename> <targetRPNum> -- exclude current rp");
printf("\n 12 = SRFreeze <volumename>");
printf("\n 13 = SRCompress <volumename>");
printf("\n 14 = SRNotify <volumename> <freespace> <direction=1/0>");
printf("\n 15 = Start/Stop Filter <1/0>");
printf("\n 16 = ResetSR <volumename>");
printf("\n 17 = SRUpdateDSSize <volumename> <newsize>");
printf("\n 18 = SRSwitchLog");
printf("\n 19 = AddCatalogToCryptoDB <catfilename> <fullpath>");
printf("\n 20 = RemoveCatalogFromCryptoDB <catfilename>");
printf("\n 21 = SRPrintState -- dump state to %%windir%%\\temp\\sr.txt and debugger");
printf("\n 22 = TestDriveRestore <oldsystemhivepath>");
printf("\n 25 = SRRegisterSnapshotCallback <dllfullpath>");
printf("\n 26 = SRUnregisterSnapshotCallback <dllfullpath>");
printf("\n 27 = EnableSREx <volumename> <fWait>");
printf("\n<volumename> must be specified as \"C:\\\" etc.");
}
// this calls the Crypto API to add a catalog to the Crypto DB
DWORD
AddCatalogToCryptoDB(LPCWSTR pszCatName, LPCWSTR pszCatPath)
{
DWORD dwErr = ERROR_SUCCESS;
HCATADMIN hCatAdmin = NULL;
HCATINFO hCatInfo = NULL;
GUID DriverVerifyGuid = DRIVER_ACTION_VERIFY;
TraceFunctEnter("AddCatalogToCryptoDB");
if (!CryptCATAdminAcquireContext(&hCatAdmin, &DriverVerifyGuid, 0))
{
dwErr = GetLastError();
ErrorTrace(0, "CryptCATAdminAcquireContext() failed, ec=%d",
dwErr);
goto Err;
}
hCatInfo= CryptCATAdminAddCatalog(hCatAdmin,
(LPWSTR) pszCatPath, // path of the temp cat file
(LPWSTR) pszCatName, // name of the cat file
0); // No Flags
if (NULL == hCatInfo)
{
dwErr = GetLastError();
DebugTrace(0, "CryptCATAdminAddCatalog() failed, ec=%d",
dwErr);
goto Err;
}
Err:
if (NULL != hCatInfo)
{
CryptCATAdminReleaseCatalogContext(hCatAdmin,
hCatInfo,
0); // no flags
}
if (NULL != hCatAdmin)
{
CryptCATAdminReleaseContext(hCatAdmin,
0); // no flags
}
TraceFunctLeave();
return dwErr;
}
// this calls the Crypto API to remove a catalog from the Crypto DB
DWORD
RemoveCatalogFromCryptoDB(LPCWSTR pszCatName)
{
DWORD dwErr = ERROR_SUCCESS;
HCATADMIN hCatAdmin = NULL;
HCATINFO hCatInfo = NULL;
GUID DriverVerifyGuid = DRIVER_ACTION_VERIFY;
TraceFunctEnter("RemoveCatalogFromCryptoDB");
if (!CryptCATAdminAcquireContext(&hCatAdmin, &DriverVerifyGuid, 0))
{
dwErr = GetLastError();
ErrorTrace(0, "CryptCATAdminAcquireContext() failed, ec=%d",
dwErr);
goto Err;
}
if (FALSE == CryptCATAdminRemoveCatalog(hCatAdmin,
(LPWSTR) pszCatName,
0)) // No Flags
{
dwErr = GetLastError();
DebugTrace(0, "CryptCATAdminRemoveCatalog() failed, ec=%d",
dwErr);
goto Err;
}
Err:
if (NULL != hCatAdmin)
{
CryptCATAdminReleaseContext(hCatAdmin,
0); // no flags
}
TraceFunctLeave();
return dwErr;
}
#define VALIDATE_DWRET(str) \
if ( dwRet != ERROR_SUCCESS ) \
{ \
ErrorTrace(0, "failed - %ld", dwRet); \
goto done; \
} \
DWORD
FindDriveMapping(HKEY hk, LPBYTE pSig, DWORD dwSig, LPWSTR pszDrive)
{
DWORD dwIndex = 0;
DWORD dwRet = ERROR_SUCCESS;
DWORD dwType, dwSize = MAX_PATH;
BYTE rgbSig[1024];
DWORD cbSig = sizeof(rgbSig);
LPCWSTR cszErr;
TENTER("FindDriveMapping");
while (ERROR_SUCCESS ==
(dwRet = RegEnumValue( hk,
dwIndex++,
pszDrive,
&dwSize,
NULL,
&dwType,
rgbSig,
&cbSig )))
{
if (0 == wcsncmp(pszDrive, L"\\DosDevice", 10))
{
if (cbSig == dwSig &&
(0 == memcmp(rgbSig, pSig, cbSig)))
break;
}
dwSize = MAX_PATH;
cbSig = sizeof(rgbSig);
}
TLEAVE();
return dwRet;
}
DWORD
KeepMountedDevices(HKEY hkMount)
{
HKEY hkNew = NULL, hkOld = NULL;
DWORD dwIndex = 0;
WCHAR szValue[MAX_PATH], szDrive[MAX_PATH];
BYTE rgbSig[1024];
DWORD cbSig;
DWORD dwSize, dwType;
DWORD dwRet = ERROR_SUCCESS;
LPCWSTR cszErr;
TENTER("KeepMountedDevices");
//
// open the old and new MountedDevices
//
dwRet = ::RegOpenKey( hkMount, L"MountedDevices", &hkOld );
VALIDATE_DWRET("::RegOpenKey");
dwRet = ::RegOpenKey( HKEY_LOCAL_MACHINE, L"System\\MountedDevices", &hkNew );
VALIDATE_DWRET("::RegOpenKey");
//
// enumerate the old devices
// delete volumes that don't exist in the new (i.e. current)
//
dwSize = MAX_PATH;
cbSig = sizeof(rgbSig);
while (ERROR_SUCCESS ==
(dwRet = RegEnumValue( hkOld,
dwIndex++,
szValue,
&dwSize,
NULL,
&dwType,
rgbSig,
&cbSig )))
{
if (0 == wcsncmp(szValue, L"\\??\\Volume", 10))
{
//
// this is a Volume -> Signature mapping
// check if the volume exists in the new
//
trace(0, "Old Volume = %S", szValue);
dwSize = sizeof(rgbSig);
dwRet = RegQueryValueEx(hkNew,
szValue,
NULL,
&dwType,
rgbSig,
&dwSize);
if (ERROR_SUCCESS != dwRet)
{
//
// nope
// so delete the volume and driveletter mapping from old
//
DWORD dwSave = FindDriveMapping(hkOld, rgbSig, cbSig, szDrive);
dwRet = RegDeleteValue(hkOld, szValue);
VALIDATE_DWRET("RegDeleteValue");
if (dwSave == ERROR_SUCCESS)
{
dwIndex--; // hack to make RegEnumValueEx work
dwRet = RegDeleteValue(hkOld, szDrive);
VALIDATE_DWRET("RegDeleteValue");
}
trace(0, "Deleted old volume");
}
}
else if (szValue[0] == L'#')
{
trace(0, "Old Mountpoint = %S", szValue);
}
else if (0 == wcsncmp(szValue, L"\\DosDevice", 10))
{
trace(0, "Old Drive = %S", szValue);
}
else
{
trace(0, "Old Unknown = %S", szValue);
}
dwSize = MAX_PATH;
cbSig = sizeof(rgbSig);
}
if (dwRet != ERROR_NO_MORE_ITEMS)
VALIDATE_DWRET("::RegEnumValue");
//
// now enumerate the current (new) devices
//
dwIndex = 0;
dwSize = MAX_PATH;
cbSig = sizeof(rgbSig);
while (ERROR_SUCCESS ==
(dwRet = RegEnumValue( hkNew,
dwIndex++,
szValue,
&dwSize,
NULL,
&dwType,
rgbSig,
&cbSig )))
{
if (0 == wcsncmp(szValue, L"\\??\\Volume", 10))
{
//
// this is a Volume -> Signature mapping
// copy the new volume to the old
//
trace(0, "New Volume = %S", szValue);
DWORD dwSave = FindDriveMapping(hkOld, rgbSig, cbSig, szDrive);
dwRet = RegSetValueEx(hkOld,
szValue,
NULL,
REG_BINARY,
rgbSig,
cbSig);
VALIDATE_DWRET("::RegSetValueEx");
if (dwSave == ERROR_NO_MORE_ITEMS)
{
//
// there is no driveletter for this volume in the old registry
// so copy the new one to the old if it exists
//
if (ERROR_SUCCESS ==
FindDriveMapping(hkNew, rgbSig, cbSig, szDrive))
{
dwRet = RegSetValueEx(hkOld,
szDrive,
NULL,
REG_BINARY,
rgbSig,
cbSig);
VALIDATE_DWRET("::RegSetValueEx");
trace(0, "Copied new driveletter %S to old", szDrive);
}
}
else
{
//
// preserve the old driveletter
//
trace(0, "Preserving old driveletter %S", szDrive);
}
}
else if (szValue[0] == L'#')
{
//
// this is a mountpoint specification
// BUGBUG - mount points should be restored
// so don't bother about these ?
//
trace(0, "New Mountpoint = %S", szValue);
}
else if (0 == wcsncmp(szValue, L"\\DosDevice", 10))
{
//
// this is a Driveletter -> Signature mapping
// don't touch these
//
trace(0, "New Drive = %S", szValue);
}
else
{
trace(0, "New Unknown = %S", szValue);
}
dwSize = MAX_PATH;
cbSig = sizeof(rgbSig);
}
if (dwRet == ERROR_NO_MORE_ITEMS)
dwRet = ERROR_SUCCESS;
VALIDATE_DWRET("::RegEnumValue");
done:
if (hkOld)
RegCloseKey(hkOld);
if (hkNew)
RegCloseKey(hkNew);
TLEAVE();
return dwRet;
}
LPCWSTR GetSysErrStr( )
{
TraceFunctEnter("GetSysErrStr(DWORD)");
static WCHAR szErr[1024+1];
DWORD dwErr = GetLastError();
::FormatMessage(
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
dwErr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
szErr,
1024,
NULL );
TraceFunctLeave();
return( szErr );
}
BOOL
CheckPrivilege( LPCWSTR szPriv, BOOL fCheckOnly )
{
TraceFunctEnter("CheckPrivilege");
BOOL fRet = FALSE;
LPCWSTR cszErr;
HANDLE hToken = NULL;
LUID luid;
TOKEN_PRIVILEGES tpNew;
TOKEN_PRIVILEGES tpOld;
DWORD dwRes;
// Prepare Process Token
if ( !::OpenProcessToken( ::GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&hToken ) )
{
cszErr = ::GetSysErrStr();
ErrorTrace(0, "::OpenProcessToken failed - %ls", cszErr);
goto Exit;
}
// Get Luid
if ( !::LookupPrivilegeValue( NULL, szPriv, &luid ) )
{
cszErr = ::GetSysErrStr();
ErrorTrace(0, "::LookupPrivilegeValue failed - %ls", cszErr);
goto Exit;
}
// Try to enable the privilege
tpNew.PrivilegeCount = 1;
tpNew.Privileges[0].Luid = luid;
tpNew.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if ( !::AdjustTokenPrivileges( hToken, FALSE, &tpNew, sizeof(tpNew), &tpOld, &dwRes ) )
{
cszErr = ::GetSysErrStr();
ErrorTrace(0, "::AdjustTokenPrivileges(ENABLE) failed - %ls", cszErr);
goto Exit;
}
if ( ::GetLastError() == ERROR_NOT_ALL_ASSIGNED )
{
// This means process does not even have the privilege so
// AdjustTokenPrivilege simply ignored the request.
ErrorTrace(0, "Privilege '%ls' does not exist, probably user is not an admin.", szPriv);
goto Exit;
}
DebugTrace(0, "old=%d", tpOld.Privileges[0].Attributes);
if ( fCheckOnly )
{
// Restore the privilege if it was not enabled
if ( tpOld.PrivilegeCount > 0 )
{
if ( !::AdjustTokenPrivileges( hToken, FALSE, &tpOld, sizeof(tpOld), NULL, NULL ) )
{
cszErr = ::GetSysErrStr();
ErrorTrace(0, "::AdjustTokenPrivileges(RESTORE) failed - %ls", cszErr);
goto Exit;
}
}
}
fRet = TRUE;
Exit:
if ( hToken != NULL )
::CloseHandle( hToken );
return( fRet );
}
BOOL DeleteRegKey(HKEY hkOpenKey,
const WCHAR * pszKeyNameToDelete)
{
TraceFunctEnter("DeleteRegKey");
BOOL fRet=FALSE;
DWORD dwRet;
// this recursively deletes the key and all its subkeys
dwRet = SHDeleteKey( hkOpenKey, // handle to open key
pszKeyNameToDelete); // subkey name
if (dwRet != ERROR_SUCCESS)
{
// key does not exist - this is not an error case.
DebugTrace(0, "RegDeleteKey of %S failed ec=%d. Not an error.",
pszKeyNameToDelete, dwRet);
goto cleanup;
}
DebugTrace(0, "RegDeleteKey of %S succeeded", pszKeyNameToDelete);
fRet = TRUE;
cleanup:
TraceFunctLeave();
return fRet;
}
DWORD PersistRegKeys( HKEY hkMountedHive,
const WCHAR * pszKeyNameInHive,
HKEY hkOpenKeyInRegistry,
const WCHAR * pszKeyNameInRegistry,
const WCHAR * pszKeyBackupFile,
WCHAR * pszSnapshotPath)
{
TraceFunctEnter("PersistRegKeys");
HKEY hKey=NULL;
WCHAR szDataFile[MAX_PATH];
LPCWSTR cszErr;
DWORD dwRet=ERROR_INTERNAL_ERROR;
BOOL fKeySaved;
DWORD dwDisposition;
// construct the name of the file that stores the backup we will
// construct the name such that the file will get deleted after
// the restore.
wsprintf(szDataFile, L"%s%s", pszSnapshotPath, pszKeyBackupFile);
DeleteFile(szDataFile); // delete the file if it exists
// first load the DRM key to a file
// open the DRM key
dwRet= RegOpenKeyEx(hkOpenKeyInRegistry, // handle to open key
pszKeyNameInRegistry, // name of subkey to open
0, // reserved
KEY_READ, // security access mask
&hKey); // handle to open key
if (dwRet != ERROR_SUCCESS)
{
// key does not exist - this is not an error case.
DebugTrace(0, "RegOpenKey of %S failed ec=%d", pszKeyNameInRegistry,
dwRet);
fKeySaved = FALSE;
}
else
{
// key exist
dwRet = RegSaveKey( hKey, // handle to key
szDataFile, // data file
NULL); // SD
if (dwRet != ERROR_SUCCESS)
{
// key does not exist - this is not an error case.
DebugTrace(0, "RegSaveKey of %S failed ec=%d",
pszKeyNameInRegistry, dwRet);
fKeySaved = FALSE;
}
else
{
DebugTrace(0, "Current DRM Key %S saved successfully",
pszKeyNameInRegistry);
fKeySaved = TRUE;
}
}
// close the key
if (hKey)
{
RegCloseKey(hKey);
hKey = NULL;
}
// now replace the snapshotted DRM key with the new key
// first delete the existing key
DeleteRegKey(hkMountedHive, pszKeyNameInHive);
// now check to see if the key existing in the old registry in
// the first place
if (fKeySaved == FALSE)
{
DebugTrace(0, "Current key %S did not exist. Leaving",
pszKeyNameInRegistry);
goto done;
}
// Create the new DRM key
dwRet = RegCreateKeyEx( hkMountedHive, // handle to open key
pszKeyNameInHive, // subkey name
0, // reserved
NULL, // class string
REG_OPTION_NON_VOLATILE, // special options
KEY_ALL_ACCESS, // desired security access
NULL, // inheritance
&hKey, // key handle
&dwDisposition); // disposition value buffer
VALIDATE_DWRET("::RegCreateKeyEx");
_VERIFY(dwDisposition == REG_CREATED_NEW_KEY);
dwRet= RegRestoreKey( hKey, // handle to key where restore begins
szDataFile, // registry file
REG_FORCE_RESTORE|REG_NO_LAZY_FLUSH); // options
VALIDATE_DWRET("::RegRestoreKey");
DebugTrace(0, "Successfully kept key %S", pszKeyNameInRegistry);
dwRet = ERROR_SUCCESS;
done:
if (hKey)
RegCloseKey(hKey);
DeleteFile(szDataFile); // delete the file if it exists
TraceFunctLeave();
return dwRet;
}
LPWSTR
GetNextMszString(LPWSTR pszBuffer)
{
return pszBuffer + lstrlen(pszBuffer) + 1;
}
DWORD
ValueReplace(HKEY hkOldSystem, HKEY hkNewSystem, LPWSTR pszString)
{
tenter("ValueReplace");
WCHAR szBuffer[MAX_PATH];
BYTE *pData = NULL;
DWORD dwType, dwSize, dwRet = ERROR_SUCCESS;
LPWSTR pszValue = NULL;
LPCWSTR cszErr;
// split up the key and value in pszString
lstrcpy(szBuffer, pszString);
pszValue = wcsrchr(szBuffer, L'\\');
if (! pszValue)
{
trace(0, "No value in %S", pszString);
goto done;
}
*pszValue=L'\0';
pszValue++;
trace(0, "Key=%S, Value=%S", szBuffer, pszValue);
// get the value size
dwRet = SHGetValue(hkNewSystem, szBuffer, pszValue, &dwType, NULL, &dwSize);
VALIDATE_DWRET("SHGetValue");
pData = (BYTE *) SRMemAlloc(dwSize);
if (! pData)
{
trace(0, "! SRMemAlloc");
dwRet = ERROR_OUTOFMEMORY;
goto done;
}
// get the value
dwRet = SHGetValue(hkNewSystem, szBuffer, pszValue, &dwType, pData, &dwSize);
VALIDATE_DWRET("SHGetValue");
// set the value in the old registry
SHSetValue(hkOldSystem, szBuffer, pszValue, dwType, pData, dwSize);
VALIDATE_DWRET("SHGetValue");
done:
if (pData)
{
SRMemFree(pData);
}
tleave();
return dwRet;
}
//
// list of keys in KeysNotToRestore that we should ignore
//
LPWSTR g_rgKeysToRestore[] = {
L"Installed Services",
L"Mount Manager",
L"Pending Rename Operations",
L"Session Manager"
};
int g_nKeysToRestore = 4;
BOOL
IsKeyToBeRestored(LPWSTR pszKey)
{
for (int i=0; i < g_nKeysToRestore; i++)
{
if (lstrcmpi(g_rgKeysToRestore[i], pszKey) == 0)
return TRUE;
}
return FALSE;
}
BOOL SRGetRegDword( HKEY hKey, LPCWSTR cszSubKey, LPCWSTR cszValue, DWORD *pdwData )
{
TraceFunctEnter("SRGetRegDword");
BOOL fRet = FALSE;
DWORD dwType;
DWORD dwRes;
DWORD cbData;
dwType = REG_DWORD;
cbData = sizeof(DWORD);
dwRes = ::SHGetValue( hKey, cszSubKey, cszValue, &dwType, pdwData, &cbData );
if ( dwRes != ERROR_SUCCESS )
{
ErrorTrace(0, "::SHGetValue failed - %ld", GetLastError() );
goto Exit;
}
fRet = TRUE;
Exit:
TraceFunctLeave();
return( fRet );
}
void
ChangeCCS(HKEY hkMount, LPWSTR pszString)
{
tenter("ChangeCCS");
int nCS = lstrlen(L"CurrentControlSet");
if (StrCmpNI(pszString, L"CurrentControlSet", nCS) == 0)
{
LPWSTR pszCS = L"ControlSet001";
DWORD dwCurrent = 0;
if (::SRGetRegDword (hkMount, L"Select", L"Current", &dwCurrent) &&
dwCurrent == 2)
{
pszCS[lstrlenW(L"ControlSet00")] = L'2';
}
WCHAR szTemp[MAX_PATH];
lstrcpy(szTemp, &(pszString[nCS]));
wsprintf(pszString, L"%s%s", pszCS, szTemp);
trace(0, "ChangeCCS: pszString = %S", pszString);
}
tleave();
}
DWORD
PreserveKeysNotToRestore(HKEY hkOldSystem, LPWSTR pszSnapshotPath)
{
HKEY hkNewSystem = NULL;
DWORD dwIndex = 0;
WCHAR szName[MAX_PATH], szKey[MAX_PATH];
BYTE *pMszString = NULL;
DWORD dwSize, dwType, cbValue;
DWORD dwRet = ERROR_SUCCESS;
LPCWSTR cszErr;
HKEY hkKNTR = NULL;
TENTER("PreserveKeysNotToRestore");
//
// open the new system hive
//
dwRet = ::RegOpenKeyEx( HKEY_LOCAL_MACHINE, L"System", 0, KEY_ALL_ACCESS, &hkNewSystem );
VALIDATE_DWRET("::RegOpenKey");
//
// enumerate KeysNotToRestore
//
dwRet = ::RegOpenKeyEx( hkNewSystem,
L"CurrentControlSet\\Control\\BackupRestore\\KeysNotToRestore",
0, KEY_READ,
&hkKNTR );
VALIDATE_DWRET("::RegOpenKey");
dwSize = MAX_PATH;
cbValue = 0;
while (ERROR_SUCCESS ==
(dwRet = RegEnumValue(hkKNTR,
dwIndex++,
szName,
&dwSize,
NULL,
&dwType,
NULL,
&cbValue )))
{
trace(0, "Name=%S", szName);
if (FALSE == IsKeyToBeRestored(szName))
{
//
// should preserve the keys specified in this multisz value
//
LPWSTR pszString = NULL;
pMszString = (BYTE *) SRMemAlloc(cbValue);
if (NULL == pMszString)
{
trace(0, "! SRMemAlloc");
goto done;
}
// read the multisz string
dwRet = RegQueryValueEx(hkKNTR,
szName,
NULL,
&dwType,
pMszString,
&cbValue);
VALIDATE_DWRET("RegQueryValueEx");
// process each element in the multisz string
pszString = (LPWSTR) pMszString;
do
{
// stop on null or empty string
if (! pszString || ! *pszString)
break;
trace(0, "Key = %S", pszString);
// replace based on the last character of each key
// if '\', then the whole key and subkeys are to be replaced in the old registry
// if '*', it should be merged with the old -- we don't support this and will ignore
// otherwise, it is a value to be replaced
switch (pszString[lstrlen(pszString)-1])
{
case L'*' :
trace(0, "Merge key - ignoring");
break;
case L'\\':
trace(0, "Replacing key");
lstrcpy(szKey, pszString);
szKey[lstrlen(szKey)-1]=L'\0';
ChangeCCS(hkOldSystem, szKey);
PersistRegKeys(hkOldSystem, // mounted hive
szKey, // key name in hive
hkNewSystem, // open key in registry
szKey, // key name in registry
L"srtemp.dat", // name of backup file
pszSnapshotPath); // snapshot path
break;
default:
trace(0, "Replacing value");
lstrcpy(szKey, pszString);
ChangeCCS(hkOldSystem, szKey);
ValueReplace(hkOldSystem, hkNewSystem, szKey);
break;
}
} while (pszString = GetNextMszString(pszString));
SRMemFree(pMszString);
}
dwSize = MAX_PATH;
cbValue = 0;
}
done:
if (hkNewSystem)
RegCloseKey(hkNewSystem);
if (pMszString)
{
SRMemFree(pMszString);
}
if (hkKNTR)
{
RegCloseKey(hkKNTR);
}
TLEAVE();
return dwRet;
}
void _cdecl
main()
{
int nOption;
LPWSTR pwszFileName = NULL;
DWORD dwSize;
RESTOREPOINTINFO rpti;
STATEMGRSTATUS smgrs;
LPWSTR * argv = NULL;
int argc;
HGLOBAL hMem = NULL;
int fStart;
HANDLE hFilter = NULL;
DWORD dwRet;
HKEY hkMount = NULL;
InitAsyncTrace();
TENTER("main");
argv = CommandLineToArgvW(GetCommandLine(), &argc);
if (! argv)
{
printf("Error parsing arguments");
exit(1);
}
if (argc < 2 || argc > 6)
{
PrintUsage();
goto done;
}
nOption = _wtoi(argv[1]);
switch(nOption)
{
case 1:
printf("EnableSR...DWORD %ld", EnableSR(argc == 3 ? argv[2] : NULL));
break;
case 2:
printf("DisableSR...DWORD %ld", DisableSR(argc == 3 ? argv[2] : NULL));
break;
case 3:
printf("EnableFIFO...DWORD %ld", EnableFIFO());
break;
case 4:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("DisableFIFO...DWORD %ld", DisableFIFO(_wtol(argv[2])));
break;
case 5:
if (argc < 3)
lstrcpyn(rpti.szDescription, L"Rpctest", MAX_DESC_W);
else
lstrcpyn(rpti.szDescription, argv[2], MAX_DESC_W);
if (argc < 4)
rpti.dwRestorePtType = APPLICATION_INSTALL;
else
rpti.dwRestorePtType = _wtol(argv[3]);
if (argc < 5)
rpti.dwEventType = BEGIN_SYSTEM_CHANGE;
else
rpti.dwEventType = _wtol(argv[4]);
if (argc < 6)
rpti.llSequenceNumber = 0;
else
rpti.llSequenceNumber = _wtol(argv[5]);
printf("SRSetRestorePoint...BOOL %d", SRSetRestorePoint(&rpti, &smgrs));
printf("\nStateMgrStatus.nStatus = %d, StateMgrStatus.llSequenceNumber = %I64d",
smgrs.nStatus, smgrs.llSequenceNumber);
break;
case 6:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("SRRemoveRestorePoint...DWORD %ld", SRRemoveRestorePoint(_wtol(argv[2])));
break;
case 7:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("SRUpdateMonitoredList...DWORD %ld", SRUpdateMonitoredList(argv[2]));
break;
case 8:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("SRFifo...DWORD %ld", SRFifo(argv[2], 0, _wtoi(argv[3]), TRUE, FALSE));
break;
case 9:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("SRFifo...DWORD %ld", SRFifo(argv[2], 0, _wtoi(argv[3]), TRUE, TRUE));
break;
case 10:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("SRFifo...DWORD %ld", SRFifo(argv[2], _wtoi(argv[3]), 0, TRUE, FALSE));
break;
case 11:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("SRFifo...DWORD %ld", SRFifo(argv[2], _wtoi(argv[3]), 0, FALSE, FALSE));
break;
case 12:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("Freeze...DWORD %ld", SRFreeze(argv[2]));
break;
case 13:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("Compress...DWORD %ld", SRCompress(argv[2]));
break;
case 14:
if (argc != 5)
{
PrintUsage();
goto done;
}
SRNotify(argv[2], _wtol(argv[3]), _wtoi(argv[4]));
printf("SRNotify...no return");
break;
case 15:
if (argc != 3)
{
PrintUsage();
goto done;
}
if (ERROR_SUCCESS != SrCreateControlHandle(SR_OPTION_OVERLAPPED, &hFilter))
{
printf("! SrCreateControlHandle");
goto done;
}
fStart = _wtoi(argv[2]);
printf("Sr%SMonitoring : %ld", fStart ? L"Start" : L"Stop",
fStart ? SrStartMonitoring(hFilter) : SrStopMonitoring(hFilter));
CloseHandle(hFilter);
break;
case 16:
printf("ResetSR...DWORD %ld", ResetSR((argc >= 3) ? argv[2] : NULL));
break;
case 17:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("SRUpdateDSSize...DWORD %ld", SRUpdateDSSize(argv[2], _wtol(argv[3])));
break;
case 18:
printf("SRSwitchLog...DWORD %ld", SRSwitchLog());
break;
case 19:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("AddCatalogToCryptoDB...DWORD %ld", AddCatalogToCryptoDB(argv[2], argv[3]));
break;
case 20:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("RemoveCatalogFromCryptoDB...DWORD %ld", RemoveCatalogFromCryptoDB(argv[2]));
break;
case 21:
SRPrintState();
break;
case 22:
if (argc != 3)
{
PrintUsage();
goto done;
}
if (FALSE == CheckPrivilege(SE_RESTORE_NAME, FALSE))
{
printf("Cannot get RESTORE privilege");
goto done;
}
dwRet = ::RegLoadKey( HKEY_LOCAL_MACHINE, L"SRSys", argv[2] );
VALIDATE_DWRET("::RegLoadKey");
dwRet = ::RegOpenKey( HKEY_LOCAL_MACHINE, L"SRSys", &hkMount );
VALIDATE_DWRET("::RegOpenKey");
dwRet = KeepMountedDevices(hkMount);
printf("KeepMountedDevices = %ld", dwRet);
RegCloseKey(hkMount);
RegUnLoadKey(HKEY_LOCAL_MACHINE, L"SRSys");
break;
case 25:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("SRRegisterSnapshotCallback...DWORD %ld", SRRegisterSnapshotCallback(argv[2]));
break;
case 26:
if (argc != 3)
{
PrintUsage();
goto done;
}
printf("SRUnregisterSnapshotCallback...DWORD %ld", SRUnregisterSnapshotCallback(argv[2]));
break;
case 27:
if (argc != 4)
{
PrintUsage();
goto done;
}
printf("EnableSREx...DWORD %ld", EnableSREx(argv[2], _wtoi(argv[3])));
break;
case 28:
if (argc != 3)
{
PrintUsage();
goto done;
}
if (FALSE == CheckPrivilege(SE_BACKUP_NAME, FALSE))
{
printf("Cannot get RESTORE privilege");
goto done;
}
if (FALSE == CheckPrivilege(SE_RESTORE_NAME, FALSE))
{
printf("Cannot get RESTORE privilege");
goto done;
}
dwRet = ::RegLoadKey( HKEY_LOCAL_MACHINE, L"SRSys", argv[2] );
VALIDATE_DWRET("::RegLoadKey");
dwRet = ::RegOpenKeyEx( HKEY_LOCAL_MACHINE, L"SRSys", 0, KEY_ALL_ACCESS, &hkMount );
VALIDATE_DWRET("::RegOpenKey");
dwRet = PreserveKeysNotToRestore(hkMount, L"c:\\");
printf("PreserveKeysNotToRestore = %ld", dwRet);
RegCloseKey(hkMount);
RegUnLoadKey(HKEY_LOCAL_MACHINE, L"SRSys");
break;
default:
printf("Invalid option\n");
PrintUsage();
break;
}
done:
if (argv) hMem = GlobalHandle(argv);
if (hMem) GlobalFree(hMem);
TLEAVE();
TermAsyncTrace();
}
Reference in a new issue Copy permalink