windows-server-2003/admin/pchealth/sr/tools/rpctest/rpctest.cpp

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