1600 lines
47 KiB
C++
1600 lines
47 KiB
C++
#include "stdafx.hxx"
|
|
#include "vs_idl.hxx"
|
|
#include "vswriter.h"
|
|
#include "vsbackup.h"
|
|
#include "compont.h"
|
|
#include <debug.h>
|
|
#include <cwriter.h>
|
|
#include <lmshare.h>
|
|
#include <lmaccess.h>
|
|
#include <time.h>
|
|
|
|
|
|
// Globals
|
|
BOOL g_bBackupOnly = FALSE;
|
|
BOOL g_bRestoreOnly = FALSE;
|
|
WCHAR g_wszBackupDocumentFileName[MAX_PATH];
|
|
WCHAR g_wszComponentsFileName[MAX_PATH];
|
|
LONG g_lWriterWait = 0;
|
|
|
|
CComPtr<CWritersSelection> g_pWriterSelection;
|
|
|
|
void TestSnapshotXML();
|
|
void EnumVolumes();
|
|
|
|
// forward declarations
|
|
void CheckStatus(IVssBackupComponents *pvbc, LPCWSTR wszWhen);
|
|
HRESULT ParseCommnadLine (int argc, WCHAR **argv);
|
|
BOOL SaveBackupDocument(CComBSTR &bstr);
|
|
BOOL LoadBackupDocument(CComBSTR &bstr);
|
|
|
|
BOOL AssertPrivilege( LPCWSTR privName )
|
|
{
|
|
HANDLE tokenHandle;
|
|
BOOL stat = FALSE;
|
|
|
|
if ( OpenProcessToken (GetCurrentProcess(),
|
|
TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,
|
|
&tokenHandle))
|
|
{
|
|
LUID value;
|
|
|
|
if ( LookupPrivilegeValue( NULL, privName, &value ) )
|
|
{
|
|
TOKEN_PRIVILEGES newState;
|
|
DWORD error;
|
|
|
|
newState.PrivilegeCount = 1;
|
|
newState.Privileges[0].Luid = value;
|
|
newState.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED_BY_DEFAULT|SE_PRIVILEGE_ENABLED;
|
|
|
|
/*
|
|
* We will always call GetLastError below, so clear
|
|
* any prior error values on this thread.
|
|
*/
|
|
SetLastError( ERROR_SUCCESS );
|
|
|
|
stat = AdjustTokenPrivileges (tokenHandle,
|
|
FALSE,
|
|
&newState,
|
|
(DWORD)0,
|
|
NULL,
|
|
NULL );
|
|
|
|
/*
|
|
* Supposedly, AdjustTokenPriveleges always returns TRUE
|
|
* (even when it fails). So, call GetLastError to be
|
|
* extra sure everything's cool.
|
|
*/
|
|
if ( (error = GetLastError()) != ERROR_SUCCESS )
|
|
{
|
|
stat = FALSE;
|
|
}
|
|
|
|
if ( !stat )
|
|
{
|
|
wprintf( L"AdjustTokenPrivileges for %s failed with %d",
|
|
privName,
|
|
error );
|
|
}
|
|
}
|
|
|
|
DWORD cbTokens;
|
|
GetTokenInformation (tokenHandle,
|
|
TokenPrivileges,
|
|
NULL,
|
|
0,
|
|
&cbTokens);
|
|
|
|
TOKEN_PRIVILEGES *pTokens = (TOKEN_PRIVILEGES *) new BYTE[cbTokens];
|
|
GetTokenInformation (tokenHandle,
|
|
TokenPrivileges,
|
|
pTokens,
|
|
cbTokens,
|
|
&cbTokens);
|
|
|
|
delete pTokens;
|
|
CloseHandle( tokenHandle );
|
|
}
|
|
|
|
|
|
return stat;
|
|
}
|
|
|
|
|
|
LPCWSTR GetStringFromUsageType (VSS_USAGE_TYPE eUsageType)
|
|
{
|
|
LPCWSTR pwszRetString = L"UNDEFINED";
|
|
|
|
switch (eUsageType)
|
|
{
|
|
case VSS_UT_BOOTABLESYSTEMSTATE: pwszRetString = L"BootableSystemState"; break;
|
|
case VSS_UT_SYSTEMSERVICE: pwszRetString = L"SystemService"; break;
|
|
case VSS_UT_USERDATA: pwszRetString = L"UserData"; break;
|
|
case VSS_UT_OTHER: pwszRetString = L"Other"; break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
return (pwszRetString);
|
|
}
|
|
|
|
|
|
LPCWSTR GetStringFromSourceType (VSS_SOURCE_TYPE eSourceType)
|
|
{
|
|
LPCWSTR pwszRetString = L"UNDEFINED";
|
|
|
|
switch (eSourceType)
|
|
{
|
|
case VSS_ST_TRANSACTEDDB: pwszRetString = L"TransactionDb"; break;
|
|
case VSS_ST_NONTRANSACTEDDB: pwszRetString = L"NonTransactionDb"; break;
|
|
case VSS_ST_OTHER: pwszRetString = L"Other"; break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
return (pwszRetString);
|
|
}
|
|
|
|
|
|
LPCWSTR GetStringFromRestoreMethod (VSS_RESTOREMETHOD_ENUM eRestoreMethod)
|
|
{
|
|
LPCWSTR pwszRetString = L"UNDEFINED";
|
|
|
|
switch (eRestoreMethod)
|
|
{
|
|
case VSS_RME_RESTORE_IF_NOT_THERE: pwszRetString = L"RestoreIfNotThere"; break;
|
|
case VSS_RME_RESTORE_IF_CAN_REPLACE: pwszRetString = L"RestoreIfCanReplace"; break;
|
|
case VSS_RME_STOP_RESTORE_START: pwszRetString = L"StopRestoreStart"; break;
|
|
case VSS_RME_RESTORE_TO_ALTERNATE_LOCATION: pwszRetString = L"RestoreToAlternateLocation"; break;
|
|
case VSS_RME_RESTORE_AT_REBOOT: pwszRetString = L"RestoreAtReboot"; break;
|
|
case VSS_RME_CUSTOM: pwszRetString = L"Custom"; break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
return (pwszRetString);
|
|
}
|
|
|
|
|
|
LPCWSTR GetStringFromWriterRestoreMethod (VSS_WRITERRESTORE_ENUM eWriterRestoreMethod)
|
|
{
|
|
LPCWSTR pwszRetString = L"UNDEFINED";
|
|
|
|
switch (eWriterRestoreMethod)
|
|
{
|
|
case VSS_WRE_NEVER: pwszRetString = L"RestoreNever"; break;
|
|
case VSS_WRE_IF_REPLACE_FAILS: pwszRetString = L"RestoreIfReplaceFailsI"; break;
|
|
case VSS_WRE_ALWAYS: pwszRetString = L"RestoreAlways"; break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
return (pwszRetString);
|
|
}
|
|
|
|
|
|
LPCWSTR GetStringFromComponentType (VSS_COMPONENT_TYPE eComponentType)
|
|
{
|
|
LPCWSTR pwszRetString = L"UNDEFINED";
|
|
|
|
switch (eComponentType)
|
|
{
|
|
case VSS_CT_DATABASE: pwszRetString = L"Database"; break;
|
|
case VSS_CT_FILEGROUP: pwszRetString = L"FileGroup"; break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
return (pwszRetString);
|
|
}
|
|
|
|
|
|
|
|
|
|
void PrintFiledesc(IVssWMFiledesc *pFiledesc, LPCWSTR wszDescription)
|
|
{
|
|
CComBSTR bstrPath;
|
|
CComBSTR bstrFilespec;
|
|
CComBSTR bstrAlternate;
|
|
CComBSTR bstrDestination;
|
|
bool bRecursive;
|
|
HRESULT hr;
|
|
|
|
CHECK_SUCCESS(pFiledesc->GetPath(&bstrPath));
|
|
CHECK_SUCCESS(pFiledesc->GetFilespec(&bstrFilespec));
|
|
CHECK_NOFAIL(pFiledesc->GetRecursive(&bRecursive));
|
|
CHECK_NOFAIL(pFiledesc->GetAlternateLocation(&bstrAlternate));
|
|
|
|
wprintf (L"%s\n Path = %s, Filespec = %s, Recursive = %s\n",
|
|
wszDescription,
|
|
bstrPath,
|
|
bstrFilespec,
|
|
bRecursive ? L"yes" : L"no");
|
|
|
|
if (bstrAlternate && wcslen(bstrAlternate) > 0)
|
|
wprintf(L" Alternate Location = %s\n", bstrAlternate);
|
|
}
|
|
|
|
|
|
/*
|
|
void AddShares(IVssSnapshot **rgpSnapshot, UINT cSnapshot)
|
|
{
|
|
VSS_PWSZ wszDeviceName = NULL;
|
|
|
|
try
|
|
{
|
|
for(UINT iSnapshot = 0; iSnapshot < cSnapshot; iSnapshot++)
|
|
{
|
|
SHARE_INFO_502 info;
|
|
CHECK_SUCCESS(rgpSnapshot[iSnapshot]->GetDevice(&wszDeviceName));
|
|
WCHAR *wszPath = new WCHAR[wcslen(wszDeviceName) + 2];
|
|
if (wszPath != NULL)
|
|
{
|
|
wcscpy(wszPath, wszDeviceName);
|
|
wcscat(wszPath, L"\\");
|
|
memset(&info, 0, sizeof(info));
|
|
WCHAR wszName[20];
|
|
swprintf(wszName, L"Snapshot%d", iSnapshot);
|
|
|
|
info.shi502_netname = wszName;
|
|
info.shi502_type = STYPE_DISKTREE;
|
|
info.shi502_permissions = ACCESS_READ;
|
|
info.shi502_max_uses = 10;
|
|
info.shi502_path = wszDeviceName;
|
|
|
|
NET_API_STATUS status;
|
|
DWORD parm_err;
|
|
|
|
status = NetShareAdd(NULL, 502, (LPBYTE) &info, &parm_err);
|
|
}
|
|
|
|
CoTaskMemFree(wszDeviceName);
|
|
wszDeviceName = NULL;
|
|
}
|
|
}
|
|
catch(...)
|
|
{
|
|
}
|
|
|
|
if (wszDeviceName)
|
|
CoTaskMemFree(wszDeviceName);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
// wait a maximum number of seconds before cancelling the operation
|
|
void LoopWait
|
|
(
|
|
IVssAsync *pAsync,
|
|
LONG seconds,
|
|
LPCWSTR wszOperation
|
|
)
|
|
{
|
|
clock_t start = clock();
|
|
HRESULT hr, hrStatus;
|
|
while(TRUE)
|
|
{
|
|
Sleep(1000);
|
|
CHECK_SUCCESS(pAsync->QueryStatus(&hrStatus, NULL));
|
|
if (hrStatus != VSS_S_ASYNC_PENDING)
|
|
break;
|
|
|
|
if (((clock() - start)/CLOCKS_PER_SEC) >= seconds)
|
|
break;
|
|
}
|
|
|
|
if (hrStatus == VSS_S_ASYNC_PENDING)
|
|
{
|
|
CHECK_NOFAIL(pAsync->Cancel());
|
|
wprintf(L"Called cancelled for %s.\n", wszOperation);
|
|
}
|
|
|
|
CHECK_SUCCESS(pAsync->QueryStatus(&hrStatus, NULL));
|
|
CHECK_NOFAIL(hrStatus);
|
|
}
|
|
|
|
|
|
void DoPrepareBackup(IVssBackupComponents *pvbc)
|
|
{
|
|
CComPtr<IVssAsync> pAsync;
|
|
INT nPercentDone;
|
|
HRESULT hrResult;
|
|
HRESULT hr;
|
|
|
|
|
|
CHECK_SUCCESS(pvbc->PrepareForBackup(&pAsync));
|
|
LoopWait(pAsync, 5, L"PrepareForBackup");
|
|
CHECK_SUCCESS(pAsync->QueryStatus(&hrResult, &nPercentDone));
|
|
CHECK_NOFAIL(hrResult);
|
|
}
|
|
|
|
|
|
void DoSnapshotSet(IVssBackupComponents *pvbc, HRESULT &hrResult)
|
|
{
|
|
CComPtr<IVssAsync> pAsync;
|
|
INT nPercentDone;
|
|
HRESULT hr;
|
|
|
|
CHECK_SUCCESS(pvbc->DoSnapshotSet (&pAsync));
|
|
|
|
CHECK_SUCCESS(pAsync->Wait());
|
|
CHECK_SUCCESS(pAsync->QueryStatus(&hrResult, &nPercentDone));
|
|
}
|
|
|
|
|
|
void DoBackupComplete(IVssBackupComponents *pvbc)
|
|
{
|
|
CComPtr<IVssAsync> pAsync;
|
|
HRESULT hr;
|
|
|
|
CHECK_SUCCESS(pvbc->BackupComplete(&pAsync));
|
|
LoopWait(pAsync, 5, L"BackupComplete");
|
|
}
|
|
|
|
|
|
void DoRestore(IVssBackupComponents *pvbc)
|
|
{
|
|
CComPtr<IVssAsync> pAsync;
|
|
HRESULT hr;
|
|
|
|
pvbc->GatherWriterMetadata(&pAsync);
|
|
LoopWait(pAsync, 60, L"GetherWriterMetadata");
|
|
pAsync = NULL;
|
|
UINT cWriters, iWriter;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterMetadataCount(&cWriters));
|
|
for(iWriter = 0; iWriter < cWriters; iWriter++)
|
|
{
|
|
CComPtr<IVssExamineWriterMetadata> pMetadata;
|
|
VSS_ID idInstance;
|
|
CHECK_SUCCESS(pvbc->GetWriterMetadata(iWriter, &idInstance, &pMetadata));
|
|
}
|
|
|
|
UINT cWriterComponents;
|
|
CHECK_SUCCESS(pvbc->GetWriterComponentsCount(&cWriterComponents));
|
|
for(UINT iWriterComponent = 0; iWriterComponent < cWriterComponents; iWriterComponent++)
|
|
{
|
|
CComPtr<IVssWriterComponentsExt> pWriter;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterComponents(iWriterComponent, &pWriter));
|
|
VSS_ID idInstance;
|
|
VSS_ID idWriter;
|
|
UINT cComponents;
|
|
CHECK_SUCCESS(pWriter->GetComponentCount(&cComponents));
|
|
CHECK_SUCCESS(pWriter->GetWriterInfo(&idInstance, &idWriter));
|
|
|
|
for(UINT iComponent = 0; iComponent < cComponents; iComponent++)
|
|
{
|
|
CComPtr<IVssComponent> pComponent;
|
|
|
|
CHECK_SUCCESS(pWriter->GetComponent(iComponent, &pComponent));
|
|
|
|
CComBSTR bstrLogicalPath;
|
|
CComBSTR bstrComponentName;
|
|
CHECK_NOFAIL(pComponent->GetLogicalPath(&bstrLogicalPath));
|
|
CHECK_SUCCESS(pComponent->GetComponentName(&bstrComponentName));
|
|
|
|
// For RestoreOnly case, we check if the user provided a component selection
|
|
BOOL bSelected = TRUE;
|
|
if (g_bRestoreOnly && g_pWriterSelection)
|
|
{
|
|
// User provided a valid selection file
|
|
bSelected = g_pWriterSelection->IsComponentSelected(idWriter, bstrLogicalPath, bstrComponentName);
|
|
if (bSelected)
|
|
{
|
|
wprintf (L"\n Component \"%s\" is selected for Restore\n", bstrComponentName);
|
|
}
|
|
else
|
|
{
|
|
wprintf (L"\n Component \"%s\" is NOT selected for Restore\n", bstrComponentName);
|
|
}
|
|
}
|
|
|
|
if (bSelected)
|
|
{
|
|
VSS_COMPONENT_TYPE ct;
|
|
CHECK_SUCCESS(pComponent->GetComponentType(&ct));
|
|
if (ct == VSS_CT_DATABASE)
|
|
{
|
|
WCHAR wszPath[256];
|
|
if (!bstrLogicalPath)
|
|
wcscpy(wszPath, bstrComponentName);
|
|
else
|
|
wsprintf(wszPath, L"%s/%s", bstrLogicalPath, bstrComponentName);
|
|
|
|
CHECK_SUCCESS(pvbc->AddRestoreSubcomponent
|
|
(
|
|
idWriter,
|
|
VSS_CT_DATABASE,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
wszPath,
|
|
L"dbFiles",
|
|
false
|
|
));
|
|
|
|
CHECK_SUCCESS(pvbc->SetSelectedForRestore
|
|
(
|
|
idWriter,
|
|
VSS_CT_DATABASE,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
true
|
|
));
|
|
|
|
CHECK_SUCCESS(pvbc->SetRestoreOptions
|
|
(
|
|
idWriter,
|
|
VSS_CT_DATABASE,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
L"DIFFRESTORE"));
|
|
|
|
CHECK_SUCCESS(pvbc->SetAdditionalRestores
|
|
(
|
|
idWriter,
|
|
VSS_CT_DATABASE,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
false
|
|
));
|
|
}
|
|
else
|
|
{
|
|
CHECK_SUCCESS(pvbc->SetSelectedForRestore
|
|
(
|
|
idWriter,
|
|
ct,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
true
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
CHECK_SUCCESS(pvbc->PreRestore(&pAsync));
|
|
LoopWait(pAsync, 5, L"PreRestore");
|
|
pAsync = NULL;
|
|
|
|
CheckStatus(pvbc, L"After PreRestore");
|
|
|
|
for(UINT iWriterComponent = 0; iWriterComponent < cWriterComponents; iWriterComponent++)
|
|
{
|
|
CComPtr<IVssWriterComponentsExt> pWriter;
|
|
VSS_ID idWriter;
|
|
VSS_ID idInstance;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterComponents(iWriterComponent, &pWriter));
|
|
UINT cComponents;
|
|
CHECK_SUCCESS(pWriter->GetComponentCount(&cComponents));
|
|
CHECK_SUCCESS(pWriter->GetWriterInfo(&idInstance, &idWriter));
|
|
|
|
for(UINT iComponent = 0; iComponent < cComponents; iComponent++)
|
|
{
|
|
CComPtr<IVssComponent> pComponent;
|
|
CComBSTR bstrLogicalPath;
|
|
CComBSTR bstrComponentName;
|
|
CComBSTR bstrFailureMsg;
|
|
|
|
CHECK_SUCCESS(pWriter->GetComponent(iComponent, &pComponent));
|
|
VSS_COMPONENT_TYPE ct;
|
|
CHECK_SUCCESS(pComponent->GetComponentType(&ct));
|
|
CHECK_NOFAIL(pComponent->GetLogicalPath(&bstrLogicalPath));
|
|
CHECK_SUCCESS(pComponent->GetComponentName(&bstrComponentName));
|
|
CHECK_NOFAIL(pComponent->GetPreRestoreFailureMsg(&bstrFailureMsg));
|
|
|
|
VSS_RESTORE_TARGET rt;
|
|
CHECK_SUCCESS(pComponent->GetRestoreTarget(&rt));
|
|
|
|
if (bstrFailureMsg || rt != VSS_RT_ORIGINAL)
|
|
{
|
|
wprintf(L"\nComponent Path=%s Name=%s\n",
|
|
bstrLogicalPath ? bstrLogicalPath : L"",
|
|
bstrComponentName);
|
|
|
|
if (bstrFailureMsg)
|
|
wprintf(L"\nPreRestoreFailureMsg=%s\n", bstrFailureMsg);
|
|
|
|
wprintf(L"restore target = %s\n", WszFromRestoreTarget(rt));
|
|
if (rt == VSS_RT_NEW)
|
|
PrintNewTargets(pComponent);
|
|
else if (rt == VSS_RT_DIRECTED)
|
|
PrintDirectedTargets(pComponent);
|
|
|
|
wprintf(L"\n");
|
|
}
|
|
|
|
CHECK_SUCCESS(pvbc->SetFileRestoreStatus
|
|
(
|
|
idWriter,
|
|
ct,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
VSS_RS_ALL
|
|
));
|
|
}
|
|
}
|
|
|
|
wprintf(L"\n");
|
|
|
|
|
|
CHECK_SUCCESS(pvbc->PostRestore(&pAsync));
|
|
LoopWait(pAsync, 5, L"PostRestore");
|
|
pAsync = NULL;
|
|
|
|
CheckStatus(pvbc, L"After PostRestore");
|
|
|
|
for(UINT iWriterComponent = 0; iWriterComponent < cWriterComponents; iWriterComponent++)
|
|
{
|
|
CComPtr<IVssWriterComponentsExt> pWriter;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterComponents(iWriterComponent, &pWriter));
|
|
UINT cComponents;
|
|
CHECK_SUCCESS(pWriter->GetComponentCount(&cComponents));
|
|
|
|
for(UINT iComponent = 0; iComponent < cComponents; iComponent++)
|
|
{
|
|
CComPtr<IVssComponent> pComponent;
|
|
CComBSTR bstrLogicalPath;
|
|
CComBSTR bstrComponentName;
|
|
CComBSTR bstrFailureMsg;
|
|
|
|
CHECK_SUCCESS(pWriter->GetComponent(iComponent, &pComponent));
|
|
VSS_COMPONENT_TYPE ct;
|
|
CHECK_SUCCESS(pComponent->GetComponentType(&ct));
|
|
CHECK_NOFAIL(pComponent->GetLogicalPath(&bstrLogicalPath));
|
|
CHECK_SUCCESS(pComponent->GetComponentName(&bstrComponentName));
|
|
CHECK_NOFAIL(pComponent->GetPostRestoreFailureMsg(&bstrFailureMsg));
|
|
if (bstrFailureMsg)
|
|
{
|
|
wprintf(L"\nComponent Path=%s Name=%s\n",
|
|
bstrLogicalPath ? bstrLogicalPath : L"",
|
|
bstrComponentName);
|
|
|
|
if (bstrFailureMsg)
|
|
wprintf(L"\nPostRestoreFailureMsg=%s\n", bstrFailureMsg);
|
|
|
|
wprintf(L"\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
wprintf(L"\n");
|
|
}
|
|
|
|
|
|
void DoAddToSnapshotSet
|
|
(
|
|
IN IVssBackupComponents *pvbc,
|
|
IN BSTR bstrPath,
|
|
IN LPWSTR wszVolumes,
|
|
VSS_ID *rgpSnapshotId,
|
|
UINT *pcSnapshot
|
|
)
|
|
{
|
|
PWCHAR pwszPath = NULL;
|
|
PWCHAR pwszMountPointName = NULL;
|
|
WCHAR wszVolumeName [50];
|
|
ULONG ulPathLength;
|
|
ULONG ulMountpointBufferLength;
|
|
HRESULT hr;
|
|
|
|
|
|
ulPathLength = ExpandEnvironmentStringsW (bstrPath, NULL, 0);
|
|
|
|
pwszPath = (PWCHAR) malloc (ulPathLength * sizeof (WCHAR));
|
|
|
|
ulPathLength = ExpandEnvironmentStringsW (bstrPath, pwszPath, ulPathLength);
|
|
|
|
|
|
ulMountpointBufferLength = GetFullPathName (pwszPath, 0, NULL, NULL);
|
|
|
|
pwszMountPointName = (PWCHAR) malloc (ulMountpointBufferLength * sizeof (WCHAR));
|
|
|
|
bool fSuccess = false;
|
|
if (wcslen(pwszPath) >= 3 && pwszPath[1] == L':' && pwszPath[2] == L'\\')
|
|
{
|
|
wcsncpy(pwszMountPointName, pwszPath, 3);
|
|
pwszMountPointName[3] = L'\0';
|
|
fSuccess = true;
|
|
}
|
|
else
|
|
{
|
|
if (GetVolumePathNameW (pwszPath, pwszMountPointName, ulMountpointBufferLength))
|
|
fSuccess = true;
|
|
else
|
|
printf("GetVolumeMountPointW failed with error %d\n", GetLastError());
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
if (!GetVolumeNameForVolumeMountPointW (pwszMountPointName, wszVolumeName, sizeof (wszVolumeName) / sizeof (WCHAR)))
|
|
printf("GetVolumeNameForVolumeMountPointW failed with error %d\n", GetLastError());
|
|
else
|
|
{
|
|
if (NULL == wcsstr (wszVolumes, wszVolumeName))
|
|
{
|
|
if (L'\0' != wszVolumes [0])
|
|
wcscat (wszVolumes, L";");
|
|
|
|
wcscat (wszVolumes, wszVolumeName);
|
|
|
|
CHECK_SUCCESS
|
|
(
|
|
pvbc->AddToSnapshotSet
|
|
(
|
|
wszVolumeName,
|
|
GUID_NULL,
|
|
&rgpSnapshotId[*pcSnapshot]
|
|
)
|
|
);
|
|
wprintf(L"Volume <%s> <%s>\n", wszVolumeName, pwszMountPointName);
|
|
wprintf(L"is added to the snapshot set\n\n");
|
|
|
|
*pcSnapshot += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (NULL != pwszPath) free (pwszPath);
|
|
if (NULL != pwszMountPointName) free (pwszMountPointName);
|
|
}
|
|
|
|
static LPCWSTR s_rgwszStates[] =
|
|
{
|
|
NULL,
|
|
L"STABLE",
|
|
L"WAIT_FOR_FREEZE",
|
|
L"WAIT_FOR_THAW",
|
|
L"WAIT_FOR_POST_SNAPSHOT",
|
|
L"WAIT_FOR_BACKUP_COMPLETE",
|
|
L"FAILED_AT_IDENTIFY",
|
|
L"FAILED_AT_PREPARE_BACKUP",
|
|
L"FAILED_AT_PREPARE_SNAPSHOT",
|
|
L"FAILED_AT_FREEZE",
|
|
L"FAILED_AT_THAW",
|
|
L"FAILED_AT_POST_SNAPSHOT",
|
|
L"FAILED_AT_BACKUP_COMPLETE",
|
|
L"FAILED_AT_PRE_RESTORE",
|
|
L"FAILED_AT_POST_RESTORE"
|
|
};
|
|
|
|
|
|
void CheckStatus(IVssBackupComponents *pvbc, LPCWSTR wszWhen)
|
|
{
|
|
unsigned cWriters;
|
|
CComPtr<IVssAsync> pAsync;
|
|
HRESULT hr;
|
|
|
|
CHECK_NOFAIL(pvbc->GatherWriterStatus(&pAsync));
|
|
CHECK_NOFAIL(pAsync->Wait());
|
|
CHECK_NOFAIL(pvbc->GetWriterStatusCount(&cWriters));
|
|
|
|
|
|
wprintf(L"\n\nstatus %s (%d writers)\n\n", wszWhen, cWriters);
|
|
|
|
for(unsigned iWriter = 0; iWriter < cWriters; iWriter++)
|
|
{
|
|
VSS_ID idInstance;
|
|
VSS_ID idWriter;
|
|
VSS_WRITER_STATE status;
|
|
CComBSTR bstrWriter;
|
|
HRESULT hrWriterFailure;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterStatus (iWriter,
|
|
&idInstance,
|
|
&idWriter,
|
|
&bstrWriter,
|
|
&status,
|
|
&hrWriterFailure));
|
|
|
|
wprintf (L"Status for writer %s: %s(0x%08lx%s%s)\n",
|
|
bstrWriter,
|
|
s_rgwszStates[status],
|
|
hrWriterFailure,
|
|
SUCCEEDED (hrWriterFailure) ? L"" : L" - ",
|
|
GetStringFromFailureType (hrWriterFailure));
|
|
}
|
|
|
|
pvbc->FreeWriterStatus();
|
|
}
|
|
|
|
void PrintPartialFilesForComponents(IVssBackupComponents *pvbc)
|
|
{
|
|
HRESULT hr;
|
|
UINT cWriterComponents;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterComponentsCount(&cWriterComponents));
|
|
for(UINT iWriterComponent = 0; iWriterComponent < cWriterComponents; iWriterComponent++)
|
|
{
|
|
CComPtr<IVssWriterComponentsExt> pWriter;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterComponents(iWriterComponent, &pWriter));
|
|
UINT cComponents;
|
|
CHECK_SUCCESS(pWriter->GetComponentCount(&cComponents));
|
|
|
|
for(UINT iComponent = 0; iComponent < cComponents; iComponent++)
|
|
{
|
|
CComPtr<IVssComponent> pComponent;
|
|
|
|
CHECK_SUCCESS(pWriter->GetComponent(iComponent, &pComponent));
|
|
|
|
CComBSTR bstrLogicalPath;
|
|
CComBSTR bstrComponentName;
|
|
|
|
CHECK_NOFAIL(pComponent->GetLogicalPath(&bstrLogicalPath));
|
|
CHECK_SUCCESS(pComponent->GetComponentName(&bstrComponentName));
|
|
UINT cPartialFiles;
|
|
|
|
CHECK_SUCCESS(pComponent->GetPartialFileCount(&cPartialFiles));
|
|
if (cPartialFiles > 0)
|
|
{
|
|
wprintf(L"\nPartial files for Component Path=%s Name=%s\n",
|
|
bstrLogicalPath ? bstrLogicalPath : L"",
|
|
bstrComponentName);
|
|
|
|
PrintPartialFiles(pComponent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL SaveBackupDocument(CComBSTR &bstr)
|
|
{
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
DWORD dwByteToWrite = (bstr.Length() + 1) * sizeof(WCHAR);
|
|
DWORD dwBytesWritten;
|
|
|
|
// Create the file (override if exists)
|
|
hFile = CreateFile(g_wszBackupDocumentFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Write the XML string
|
|
if (! WriteFile(hFile, (LPVOID)(BSTR)bstr, dwByteToWrite, &dwBytesWritten, NULL))
|
|
{
|
|
CloseHandle(hFile);
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL LoadBackupDocument(CComBSTR &bstr)
|
|
{
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
DWORD dwBytesToRead = 0;
|
|
DWORD dwBytesRead;
|
|
|
|
// Create the file (must exist)
|
|
hFile = CreateFile(g_wszBackupDocumentFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ((dwBytesToRead = GetFileSize(hFile, NULL)) <= 0)
|
|
{
|
|
CloseHandle(hFile);
|
|
return FALSE;
|
|
}
|
|
|
|
WCHAR *pwszBuffer = NULL;
|
|
DWORD dwNofChars = 0;
|
|
|
|
if ((dwBytesToRead % sizeof(WCHAR)) != 0)
|
|
{
|
|
CloseHandle(hFile);
|
|
wprintf(L"Invalid file lenght %lu for backup document file\n", dwBytesToRead);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
dwNofChars = dwBytesToRead / sizeof(WCHAR);
|
|
}
|
|
|
|
pwszBuffer = (PWCHAR) malloc (dwNofChars * sizeof (WCHAR));
|
|
if (! pwszBuffer)
|
|
{
|
|
CloseHandle(hFile);
|
|
wprintf(L"Failed to allocate memory for backup document buffer\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// Read the XML string
|
|
if (! ReadFile(hFile, (LPVOID)pwszBuffer, dwBytesToRead, &dwBytesRead, NULL))
|
|
{
|
|
CloseHandle(hFile);
|
|
free (pwszBuffer);
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
|
|
if (dwBytesToRead != dwBytesRead)
|
|
{
|
|
free (pwszBuffer);
|
|
wprintf(L"Backup document file is supposed to have %lu bytes but only %lu bytes are read\n", dwBytesToRead, dwBytesRead);
|
|
return FALSE;
|
|
}
|
|
|
|
// Copy to output bstr
|
|
bstr.Empty();
|
|
if (bstr.Append(pwszBuffer, dwNofChars-1) != S_OK) // don't copy the NULL
|
|
{
|
|
free (pwszBuffer);
|
|
wprintf(L"Failed to copy from temporary buffer into Backup Document XML string\n");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HRESULT ParseCommnadLine (int argc, WCHAR **argv)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int iArg;
|
|
|
|
g_wszBackupDocumentFileName[0] = L'\0';
|
|
g_wszComponentsFileName[0] = L'\0';
|
|
|
|
try
|
|
{
|
|
for (iArg=1; iArg<argc; iArg++)
|
|
{
|
|
if ((_wcsicmp(argv[iArg], L"/W") == 0) || (_wcsicmp(argv[iArg], L"-W") == 0))
|
|
{
|
|
iArg++;
|
|
|
|
if (iArg >= argc)
|
|
{
|
|
wprintf(L"/W switch missing wait-time argument\n");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
if (argv[iArg][0] >= L'0' && argv[iArg][0] <= L'9'||
|
|
argv[iArg][0] >= L'a' && argv[iArg][0] <= L'f')
|
|
{
|
|
if (argv[iArg][0] >= L'0' && argv[iArg][0] <= L'9')
|
|
g_lWriterWait = argv[iArg][0] - L'0';
|
|
else
|
|
g_lWriterWait = argv[iArg][0] - L'a' + 10;
|
|
|
|
wprintf(L"Writer wait parameter=%ld.\n", g_lWriterWait);
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"/W switch is followed by invalid wait-time argument\n");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
}
|
|
else if ((_wcsicmp(argv[iArg], L"/B") == 0) || (_wcsicmp(argv[iArg], L"-B") == 0))
|
|
{
|
|
g_bBackupOnly = TRUE;
|
|
wprintf(L"Asked to do Backup only\n");
|
|
}
|
|
else if ((_wcsicmp(argv[iArg], L"/R") == 0) || (_wcsicmp(argv[iArg], L"-R") == 0))
|
|
{
|
|
g_bRestoreOnly = TRUE;
|
|
wprintf(L"Asked to do Restore only\n");
|
|
}
|
|
else if ((_wcsicmp(argv[iArg], L"/S") == 0) || (_wcsicmp(argv[iArg], L"-S") == 0))
|
|
{
|
|
iArg++;
|
|
|
|
if (iArg >= argc)
|
|
{
|
|
wprintf(L"/S switch missing file-name to save/load backup document\n");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
if (wcslen(argv[iArg]) >= MAX_PATH)
|
|
{
|
|
wprintf(L"Path for file-name to save/load backup document is limited to %d\n", MAX_PATH);
|
|
throw(E_INVALIDARG);
|
|
}
|
|
wcscpy(g_wszBackupDocumentFileName, argv[iArg]);
|
|
wprintf(L"File name to save/load Backup Document is \"%s\"\n", g_wszBackupDocumentFileName);
|
|
}
|
|
else if ((_wcsicmp(argv[iArg], L"/C") == 0) || (_wcsicmp(argv[iArg], L"-C") == 0))
|
|
{
|
|
iArg++;
|
|
|
|
if (iArg >= argc)
|
|
{
|
|
wprintf(L"/C switch missing file-name to load components selection from\n");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
if (wcslen(argv[iArg]) >= MAX_PATH)
|
|
{
|
|
wprintf(L"Path for file-name to load components selection is limited to %d\n", MAX_PATH);
|
|
throw(E_INVALIDARG);
|
|
}
|
|
wcscpy(g_wszComponentsFileName, argv[iArg]);
|
|
wprintf(L"File name for Components Selection is \"%s\"\n", g_wszComponentsFileName);
|
|
}
|
|
else if ((_wcsicmp(argv[iArg], L"/?") == 0) || (_wcsicmp(argv[iArg], L"-?") == 0))
|
|
{
|
|
// Print help
|
|
wprintf(L"BETEST [/B] [/R] [/S filename] [/C filename]\n\n");
|
|
wprintf(L"/B\t\t Performs backup only\n");
|
|
wprintf(L"/R\t\t Performs restore only\n");
|
|
wprintf(L"\t\t Restore-only must be used with /S for a backup document file\n\n");
|
|
wprintf(L"/S filename\t In case of backup, saves the backup document to file\n");
|
|
wprintf(L"\t\t In case of restore-only, loads the backup document from file\n\n");
|
|
wprintf(L"/C filename\t Selects which components to backup/restore based on the file\n\n");
|
|
wprintf(L"Components selection file format:\n");
|
|
wprintf(L"\"<writer-id>\": \"<component-logical-path>\", ...\"<component-logical-path>\";\n\n");
|
|
wprintf(L"where several writers may be specified, each one with its own components\n");
|
|
wprintf(L"<writer-id> is in standard GUID format\n");
|
|
wprintf(L"<component-logical-path> is either logical-path, logical-path\\component-name\n");
|
|
wprintf(L"or component-name-only (if there's no logical path)\n\n");
|
|
wprintf(L"For example:\n");
|
|
wprintf(L"\"{c0577ae6-d741-452a-8cba-99d744008c04}\": \"\\mydatabases\", \"\\mylogfiles\";\n");
|
|
wprintf(L"\"{f2436e37-09f5-41af-9b2a-4ca2435dbfd5}\" : \"Registry\" ;\n\n");
|
|
wprintf(L"If no argument is specified, BETEST performs a backup followed by a restore\n");
|
|
wprintf(L"choosing all components reported by all writers\n\n");
|
|
|
|
// Set hr such that program terminates
|
|
hr = S_FALSE;
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"Invalid switch\n");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
}
|
|
|
|
// Check for invalid combinations
|
|
if (g_bBackupOnly && g_bRestoreOnly)
|
|
{
|
|
wprintf(L"Cannot backup-only and restore-only at the same time...\n");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
if (g_bRestoreOnly && (wcslen(g_wszBackupDocumentFileName) == 0))
|
|
{
|
|
wprintf(L"Cannot restore-only with no backup-document to use.\nUse the /S switch for specifying a file name with backup document from a previous BETEST backup");
|
|
throw(E_INVALIDARG);
|
|
}
|
|
|
|
}
|
|
catch (HRESULT hrParse)
|
|
{
|
|
hr = hrParse;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
extern "C" __cdecl wmain(int argc, WCHAR **argv)
|
|
{
|
|
WCHAR wszVolumes[2048];
|
|
wszVolumes[0] = L'\0';
|
|
|
|
UINT cSnapshot = 0;
|
|
VSS_ID rgpSnapshotId[64];
|
|
|
|
CTestVssWriter *pInstance = NULL;
|
|
bool bCreated = false;
|
|
bool bSubscribed = false;
|
|
HRESULT hrMain = S_OK;
|
|
bool bCoInitializeSucceeded = false;
|
|
|
|
|
|
try
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComBSTR bstrXML;
|
|
BOOL bXMLSaved = FALSE;
|
|
|
|
// Parse command line arguments
|
|
if (ParseCommnadLine(argc, argv) != S_OK)
|
|
{
|
|
// Don't throw since we want to avoid assertions here - we can return safely
|
|
return (3);
|
|
}
|
|
|
|
CHECK_SUCCESS(CoInitializeEx(NULL, COINIT_MULTITHREADED));
|
|
|
|
// Initialize COM security
|
|
CHECK_SUCCESS
|
|
(
|
|
CoInitializeSecurity
|
|
(
|
|
NULL, // IN PSECURITY_DESCRIPTOR pSecDesc,
|
|
-1, // IN LONG cAuthSvc,
|
|
NULL, // IN SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
|
|
NULL, // IN void *pReserved1,
|
|
RPC_C_AUTHN_LEVEL_CONNECT, // IN DWORD dwAuthnLevel,
|
|
RPC_C_IMP_LEVEL_IMPERSONATE, // IN DWORD dwImpLevel,
|
|
NULL, // IN void *pAuthList,
|
|
EOAC_NONE, // IN DWORD dwCapabilities,
|
|
NULL // IN void *pReserved3
|
|
)
|
|
);
|
|
|
|
bCoInitializeSucceeded = true;
|
|
|
|
if ( !AssertPrivilege( SE_BACKUP_NAME ) )
|
|
{
|
|
wprintf( L"AssertPrivilege returned error, rc:%d\n", GetLastError() );
|
|
return 2;
|
|
}
|
|
|
|
// Get chosen components for backup and/or restore
|
|
if (wcslen(g_wszComponentsFileName) > 0)
|
|
{
|
|
g_pWriterSelection = CWritersSelection::CreateInstance();
|
|
if (g_pWriterSelection == NULL)
|
|
{
|
|
wprintf(L"allocation failure\n");
|
|
DebugBreak();
|
|
}
|
|
|
|
if (g_pWriterSelection->BuildChosenComponents(g_wszComponentsFileName) != S_OK)
|
|
{
|
|
wprintf(L"Component selection in %s is ignored due to a failure in processing the file\n", g_wszComponentsFileName);
|
|
g_pWriterSelection = 0;
|
|
}
|
|
}
|
|
|
|
// EnumVolumes();
|
|
|
|
TestSnapshotXML();
|
|
|
|
pInstance = new CTestVssWriter(g_lWriterWait);
|
|
if (pInstance == NULL)
|
|
{
|
|
wprintf(L"allocation failure\n");
|
|
DebugBreak();
|
|
}
|
|
|
|
bCreated = true;
|
|
pInstance->Initialize();
|
|
CHECK_SUCCESS(pInstance->Subscribe());
|
|
bSubscribed = true;
|
|
|
|
if (! g_bRestoreOnly)
|
|
{
|
|
CComBSTR strSnapshotSetId = "12345678-1234-1234-1234-1234567890ab";
|
|
|
|
CComPtr<IVssBackupComponents> pvbc;
|
|
|
|
CHECK_SUCCESS(CreateVssBackupComponents(&pvbc));
|
|
|
|
|
|
CHECK_SUCCESS(pvbc->InitializeForBackup());
|
|
CHECK_SUCCESS(pvbc->SetBackupState (true,
|
|
false,
|
|
VSS_BT_DIFFERENTIAL,
|
|
true));
|
|
|
|
|
|
/*
|
|
VSS_ID idWMIWriter =
|
|
{
|
|
0xa6ad56c2,
|
|
0xb509, 0x4e6c,
|
|
0xbb, 0x19, 0x49, 0xd8, 0xf4, 0x35, 0x32, 0xf0
|
|
};
|
|
|
|
pvbc->DisableWriterClasses(&idWMIWriter, 1);
|
|
|
|
|
|
VSS_ID idCWriter =
|
|
{
|
|
0xc0577ae6, 0xd741, 0x452a,
|
|
0x8c, 0xba, 0x99, 0xd7, 0x44, 0x00, 0x8c, 0x04
|
|
};
|
|
|
|
|
|
pvbc->EnableWriterClasses(&idCWriter, 1);
|
|
*/
|
|
|
|
unsigned cWriters;
|
|
CComPtr<IVssAsync> pAsync;
|
|
CHECK_NOFAIL(pvbc->GatherWriterMetadata(&pAsync));
|
|
LoopWait(pAsync, 30, L"GatherWriterMetadata");
|
|
CHECK_NOFAIL(pvbc->GetWriterMetadataCount(&cWriters));
|
|
|
|
VSS_ID id;
|
|
|
|
while(TRUE)
|
|
{
|
|
hr = pvbc->StartSnapshotSet(&id);
|
|
if (hr == S_OK)
|
|
break;
|
|
|
|
if (hr == VSS_E_SNAPSHOT_SET_IN_PROGRESS)
|
|
Sleep(1000);
|
|
else
|
|
CHECK_SUCCESS(hr);
|
|
}
|
|
|
|
BOOL bAtLeastOneSelected = FALSE;
|
|
|
|
for(unsigned iWriter = 0; iWriter < cWriters; iWriter++)
|
|
{
|
|
CComPtr<IVssExamineWriterMetadata> pMetadata;
|
|
VSS_ID idInstance;
|
|
|
|
CHECK_SUCCESS(pvbc->GetWriterMetadata(iWriter, &idInstance, &pMetadata));
|
|
VSS_ID idInstanceT;
|
|
VSS_ID idWriter;
|
|
CComBSTR bstrWriterName;
|
|
VSS_USAGE_TYPE usage;
|
|
VSS_SOURCE_TYPE source;
|
|
|
|
CHECK_SUCCESS(pMetadata->GetIdentity (&idInstanceT,
|
|
&idWriter,
|
|
&bstrWriterName,
|
|
&usage,
|
|
&source));
|
|
|
|
wprintf (L"\n\n");
|
|
|
|
if (memcmp(&idInstance, &idInstanceT, sizeof(VSS_ID)) != 0)
|
|
{
|
|
wprintf(L"Instance id mismatch\n");
|
|
DebugBreak();
|
|
}
|
|
|
|
WCHAR *pwszInstanceId;
|
|
WCHAR *pwszWriterId;
|
|
UuidToString(&idInstance, &pwszInstanceId);
|
|
UuidToString(&idWriter, &pwszWriterId);
|
|
wprintf (L"WriterName = %s\n\n"
|
|
L" WriterId = %s\n"
|
|
L" InstanceId = %s\n"
|
|
L" UsageType = %d (%s)\n"
|
|
L" SourceType = %d (%s)\n",
|
|
bstrWriterName,
|
|
pwszWriterId,
|
|
pwszInstanceId,
|
|
usage,
|
|
GetStringFromUsageType (usage),
|
|
source,
|
|
GetStringFromSourceType (source));
|
|
|
|
RpcStringFree(&pwszInstanceId);
|
|
RpcStringFree(&pwszWriterId);
|
|
|
|
unsigned cIncludeFiles, cExcludeFiles, cComponents;
|
|
CHECK_SUCCESS(pMetadata->GetFileCounts (&cIncludeFiles,
|
|
&cExcludeFiles,
|
|
&cComponents));
|
|
|
|
CComBSTR bstrPath;
|
|
CComBSTR bstrFilespec;
|
|
CComBSTR bstrAlternate;
|
|
CComBSTR bstrDestination;
|
|
|
|
for(unsigned i = 0; i < cIncludeFiles; i++)
|
|
{
|
|
CComPtr<IVssWMFiledesc> pFiledesc;
|
|
CHECK_SUCCESS(pMetadata->GetIncludeFile(i, &pFiledesc));
|
|
|
|
PrintFiledesc(pFiledesc, L"\n Include File");
|
|
}
|
|
|
|
for(i = 0; i < cExcludeFiles; i++)
|
|
{
|
|
CComPtr<IVssWMFiledesc> pFiledesc;
|
|
CHECK_SUCCESS(pMetadata->GetExcludeFile(i, &pFiledesc));
|
|
PrintFiledesc(pFiledesc, L"\n Exclude File");
|
|
}
|
|
|
|
for(unsigned iComponent = 0; iComponent < cComponents; iComponent++)
|
|
{
|
|
CComPtr<IVssWMComponent> pComponent;
|
|
PVSSCOMPONENTINFO pInfo;
|
|
CHECK_SUCCESS(pMetadata->GetComponent(iComponent, &pComponent));
|
|
CHECK_SUCCESS(pComponent->GetComponentInfo(&pInfo));
|
|
wprintf (L"\n"
|
|
L" Component %d, type = %d (%s)\n"
|
|
L" LogicalPath = %s\n"
|
|
L" Name = %s\n"
|
|
L" Caption = %s\n",
|
|
iComponent,
|
|
pInfo->type,
|
|
GetStringFromComponentType (pInfo->type),
|
|
pInfo->bstrLogicalPath,
|
|
pInfo->bstrComponentName,
|
|
pInfo->bstrCaption);
|
|
|
|
|
|
|
|
if (pInfo->cbIcon > 0)
|
|
{
|
|
if (pInfo->cbIcon != 10 ||
|
|
pInfo->pbIcon[0] != 1 ||
|
|
pInfo->pbIcon[1] != 2 ||
|
|
pInfo->pbIcon[2] != 3 ||
|
|
pInfo->pbIcon[3] != 4 ||
|
|
pInfo->pbIcon[4] != 5 ||
|
|
pInfo->pbIcon[5] != 6 ||
|
|
pInfo->pbIcon[6] != 7 ||
|
|
pInfo->pbIcon[7] != 8 ||
|
|
pInfo->pbIcon[8] != 9 ||
|
|
pInfo->pbIcon[9] != 10)
|
|
{
|
|
wprintf(L" Icon is not valid.\n");
|
|
DebugBreak();
|
|
}
|
|
else
|
|
wprintf(L" Icon is valid.\n");
|
|
}
|
|
|
|
wprintf (L" RestoreMetadata = %s\n"
|
|
L" NotifyOnBackupComplete = %s\n"
|
|
L" Selectable = %s\n",
|
|
pInfo->bRestoreMetadata ? L"yes" : L"no",
|
|
pInfo->bNotifyOnBackupComplete ? L"yes" : L"no",
|
|
pInfo->bSelectable ? L"yes" : L"no");
|
|
|
|
BOOL bSelected = TRUE;
|
|
if (g_pWriterSelection)
|
|
{
|
|
// User provided a valid selection file
|
|
bSelected = g_pWriterSelection->IsComponentSelected(idWriter, pInfo->bstrLogicalPath, pInfo->bstrComponentName);
|
|
if (bSelected)
|
|
{
|
|
wprintf (L"\n Component \"%s\" IS selected for Backup\n\n", pInfo->bstrComponentName);
|
|
}
|
|
else
|
|
{
|
|
wprintf (L"\n Component \"%s\" is NOT selected for Backup\n\n", pInfo->bstrComponentName);
|
|
}
|
|
}
|
|
|
|
if (bSelected)
|
|
{
|
|
|
|
CHECK_SUCCESS(pvbc->AddComponent (idInstance,
|
|
idWriter,
|
|
pInfo->type,
|
|
pInfo->bstrLogicalPath,
|
|
pInfo->bstrComponentName));
|
|
|
|
|
|
if (pInfo->type == VSS_CT_DATABASE)
|
|
{
|
|
CHECK_SUCCESS
|
|
(
|
|
pvbc->SetPreviousBackupStamp
|
|
(
|
|
idWriter,
|
|
pInfo->type,
|
|
pInfo->bstrLogicalPath,
|
|
pInfo->bstrComponentName,
|
|
L"LASTFULLBACKUP"
|
|
));
|
|
|
|
CHECK_SUCCESS
|
|
(
|
|
pvbc->SetBackupOptions
|
|
(
|
|
idWriter,
|
|
pInfo->type,
|
|
pInfo->bstrLogicalPath,
|
|
pInfo->bstrComponentName,
|
|
L"DOFASTINCREMENAL"
|
|
));
|
|
}
|
|
|
|
|
|
if (pInfo->cFileCount > 0)
|
|
{
|
|
for(i = 0; i < pInfo->cFileCount; i++)
|
|
{
|
|
CComPtr<IVssWMFiledesc> pFiledesc;
|
|
CHECK_SUCCESS(pComponent->GetFile(i, &pFiledesc));
|
|
|
|
CComBSTR bstrPath;
|
|
CHECK_SUCCESS(pFiledesc->GetPath(&bstrPath));
|
|
DoAddToSnapshotSet(pvbc, bstrPath, wszVolumes, rgpSnapshotId, &cSnapshot);
|
|
bAtLeastOneSelected = TRUE;
|
|
PrintFiledesc(pFiledesc, L" FileGroupFile");
|
|
}
|
|
}
|
|
|
|
if (pInfo->cDatabases > 0)
|
|
{
|
|
for(i = 0; i < pInfo->cDatabases; i++)
|
|
{
|
|
CComPtr<IVssWMFiledesc> pFiledesc;
|
|
CHECK_SUCCESS(pComponent->GetDatabaseFile(i, &pFiledesc));
|
|
|
|
CComBSTR bstrPath;
|
|
CHECK_SUCCESS(pFiledesc->GetPath(&bstrPath));
|
|
DoAddToSnapshotSet(pvbc, bstrPath, wszVolumes, rgpSnapshotId, &cSnapshot);
|
|
bAtLeastOneSelected = TRUE;
|
|
PrintFiledesc(pFiledesc, L" DatabaseFile");
|
|
}
|
|
}
|
|
|
|
if (pInfo->cLogFiles > 0)
|
|
{
|
|
for(i = 0; i < pInfo->cLogFiles; i++)
|
|
{
|
|
CComPtr<IVssWMFiledesc> pFiledesc;
|
|
CHECK_SUCCESS(pComponent->GetDatabaseLogFile(i, &pFiledesc));
|
|
|
|
CComBSTR bstrPath;
|
|
CHECK_SUCCESS(pFiledesc->GetPath(&bstrPath));
|
|
DoAddToSnapshotSet(pvbc, bstrPath, wszVolumes, rgpSnapshotId, &cSnapshot);
|
|
bAtLeastOneSelected = TRUE;
|
|
PrintFiledesc(pFiledesc, L" DatabaseLogFile");
|
|
}
|
|
}
|
|
}
|
|
|
|
pComponent->FreeComponentInfo(pInfo);
|
|
}
|
|
|
|
VSS_RESTOREMETHOD_ENUM method;
|
|
CComBSTR bstrUserProcedure;
|
|
CComBSTR bstrService;
|
|
VSS_WRITERRESTORE_ENUM writerRestore;
|
|
unsigned cMappings;
|
|
bool bRebootRequired;
|
|
|
|
CHECK_NOFAIL(pMetadata->GetRestoreMethod (&method,
|
|
&bstrService,
|
|
&bstrUserProcedure,
|
|
&writerRestore,
|
|
&bRebootRequired,
|
|
&cMappings));
|
|
|
|
|
|
wprintf (L"\n"
|
|
L" Restore method = %d (%s)\n"
|
|
L" Service = %s\n"
|
|
L" User Procedure = %s\n"
|
|
L" WriterRestore = %d (%s)\n"
|
|
L" RebootRequired = %s\n",
|
|
method,
|
|
GetStringFromRestoreMethod (method),
|
|
bstrService,
|
|
bstrUserProcedure,
|
|
writerRestore,
|
|
GetStringFromWriterRestoreMethod (writerRestore),
|
|
bRebootRequired ? L"yes" : L"no");
|
|
|
|
for(i = 0; i < cMappings; i++)
|
|
{
|
|
CComPtr<IVssWMFiledesc> pFiledesc;
|
|
|
|
CHECK_SUCCESS(pMetadata->GetAlternateLocationMapping(i, &pFiledesc));
|
|
|
|
PrintFiledesc(pFiledesc, L"AlternateMapping");
|
|
}
|
|
|
|
CComBSTR bstrMetadata;
|
|
CHECK_SUCCESS(pMetadata->SaveAsXML(&bstrMetadata));
|
|
CComPtr<IVssExamineWriterMetadata> pMetadataNew;
|
|
CHECK_SUCCESS(CreateVssExamineWriterMetadata(bstrMetadata, &pMetadataNew));
|
|
CHECK_SUCCESS(pMetadataNew->GetIdentity (&idInstanceT,
|
|
&idWriter,
|
|
&bstrWriterName,
|
|
&usage,
|
|
&source));
|
|
|
|
wprintf (L"\n\n");
|
|
|
|
if (memcmp(&idInstance, &idInstanceT, sizeof(VSS_ID)) != 0)
|
|
{
|
|
wprintf(L"Instance id mismatch\n");
|
|
DebugBreak();
|
|
}
|
|
|
|
UuidToString(&idInstance, &pwszInstanceId);
|
|
UuidToString(&idWriter, &pwszWriterId);
|
|
wprintf (L"WriterName = %s\n\n"
|
|
L" WriterId = %s\n"
|
|
L" InstanceId = %s\n"
|
|
L" UsageType = %d (%s)\n"
|
|
L" SourceType = %d (%s)\n",
|
|
bstrWriterName,
|
|
pwszWriterId,
|
|
pwszInstanceId,
|
|
usage,
|
|
GetStringFromUsageType (usage),
|
|
source,
|
|
GetStringFromSourceType (source));
|
|
|
|
RpcStringFree(&pwszInstanceId);
|
|
RpcStringFree(&pwszWriterId);
|
|
}
|
|
|
|
CHECK_SUCCESS(pvbc->FreeWriterMetadata());
|
|
|
|
//
|
|
// Proceed with backup only if at least one component and one volume was selected for backup
|
|
//
|
|
if (bAtLeastOneSelected)
|
|
{
|
|
|
|
DoPrepareBackup(pvbc);
|
|
|
|
CheckStatus(pvbc, L"After Prepare Backup");
|
|
|
|
unsigned cWriterComponents;
|
|
CHECK_SUCCESS(pvbc->GetWriterComponentsCount(&cWriterComponents));
|
|
|
|
for(iWriter = 0; iWriter < cWriterComponents; iWriter++)
|
|
{
|
|
CComPtr<IVssWriterComponentsExt> pWriter;
|
|
CHECK_SUCCESS(pvbc->GetWriterComponents(iWriter, &pWriter));
|
|
|
|
unsigned cComponents;
|
|
CHECK_SUCCESS(pWriter->GetComponentCount(&cComponents));
|
|
VSS_ID idWriter, idInstance;
|
|
CHECK_SUCCESS(pWriter->GetWriterInfo(&idInstance, &idWriter));
|
|
for(unsigned iComponent = 0; iComponent < cComponents; iComponent++)
|
|
{
|
|
CComPtr<IVssComponent> pComponent;
|
|
CHECK_SUCCESS(pWriter->GetComponent(iComponent, &pComponent));
|
|
|
|
VSS_COMPONENT_TYPE ct;
|
|
CComBSTR bstrLogicalPath;
|
|
CComBSTR bstrComponentName;
|
|
|
|
CHECK_NOFAIL(pComponent->GetLogicalPath(&bstrLogicalPath));
|
|
CHECK_SUCCESS(pComponent->GetComponentType(&ct));
|
|
CHECK_SUCCESS(pComponent->GetComponentName(&bstrComponentName));
|
|
CComBSTR bstrStamp;
|
|
|
|
CHECK_NOFAIL(pComponent->GetBackupStamp(&bstrStamp));
|
|
if (bstrStamp)
|
|
wprintf(L"Backup stamp for component %s = %s\n", bstrComponentName, bstrStamp);
|
|
|
|
CHECK_SUCCESS(pvbc->SetBackupSucceeded (idInstance,
|
|
idWriter,
|
|
ct,
|
|
bstrLogicalPath,
|
|
bstrComponentName,
|
|
true));
|
|
}
|
|
}
|
|
|
|
|
|
HRESULT hrResult;
|
|
DoSnapshotSet(pvbc, hrResult);
|
|
|
|
if (FAILED(hrResult))
|
|
{
|
|
wprintf(L"Creating the snapshot failed. hr = 0x%08lx\n", hrResult);
|
|
CheckStatus(pvbc, L"After Do Snapshot");
|
|
}
|
|
else
|
|
{
|
|
CheckStatus(pvbc, L"After Do Snapshot");
|
|
|
|
PrintPartialFilesForComponents(pvbc);
|
|
|
|
|
|
DoBackupComplete(pvbc);
|
|
CheckStatus(pvbc, L"After Backup Complete");
|
|
|
|
// Save backup document in a string
|
|
CHECK_SUCCESS(pvbc->SaveAsXML(&bstrXML));
|
|
bXMLSaved = TRUE;
|
|
|
|
// Save backup document (XML string) in a file
|
|
if (wcslen(g_wszBackupDocumentFileName) > 0)
|
|
{
|
|
if (SaveBackupDocument(bstrXML))
|
|
{
|
|
wprintf(L"Backup document saved successfully in %s\n", g_wszBackupDocumentFileName);
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"Failed to save backup document: SaveBackupDocument returned error %d\n", GetLastError());
|
|
}
|
|
}
|
|
|
|
// Delete the snapshot set
|
|
LONG lSnapshotsNotDeleted;
|
|
VSS_ID rgSnapshotsNotDeleted[10];
|
|
|
|
hr = pvbc->DeleteSnapshots (id,
|
|
VSS_OBJECT_SNAPSHOT_SET,
|
|
false,
|
|
&lSnapshotsNotDeleted,
|
|
rgSnapshotsNotDeleted);
|
|
|
|
if (FAILED(hr))
|
|
wprintf(L"Deletion of Snapshots failed. hr = 0x%08lx\n", hr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"\nBackup test is aborted since no component is selected, therefore, there are no volumes added to the snapshot set\n\n");
|
|
}
|
|
}
|
|
|
|
// Restore is done if
|
|
// 1. User did not ask backup-only AND
|
|
// 2. User asked restore-only OR user asked both, and backup succeeded
|
|
if (! g_bBackupOnly)
|
|
{
|
|
if (g_bRestoreOnly || bXMLSaved)
|
|
{
|
|
BOOL bXMLLoaded = FALSE;
|
|
|
|
// Load XML string only in Restore-only case
|
|
if (g_bRestoreOnly)
|
|
{
|
|
if (LoadBackupDocument(bstrXML))
|
|
{
|
|
bXMLLoaded = TRUE;
|
|
wprintf(L"Backup document was loaded from %s\n", g_wszBackupDocumentFileName);
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"Failed to load backup document: LoadBackupDocument returned error %d\n", GetLastError());
|
|
}
|
|
}
|
|
|
|
// If we have a backup document from current backup or loaded successfully froma previous backup
|
|
if (bXMLSaved || bXMLLoaded)
|
|
{
|
|
// Prepare for restore
|
|
CComPtr<IVssBackupComponents> pvbcRestore;
|
|
|
|
CHECK_SUCCESS(CreateVssBackupComponents(&pvbcRestore));
|
|
CHECK_SUCCESS(pvbcRestore->InitializeForRestore(bstrXML));
|
|
wprintf(L"InitializeForRestore succeeded.\n");
|
|
|
|
// Do the restore
|
|
DoRestore(pvbcRestore);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wprintf(L"\nRestore test is not done due to a failure in the preceding Backup test\n\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
catch(...)
|
|
{
|
|
BS_ASSERT(FALSE);
|
|
hrMain = E_UNEXPECTED;
|
|
}
|
|
|
|
if (bSubscribed)
|
|
pInstance->Unsubscribe();
|
|
|
|
if (bCreated)
|
|
delete pInstance;
|
|
|
|
if (FAILED(hrMain))
|
|
wprintf(L"Failed with %08x.\n", hrMain);
|
|
|
|
if (bCoInitializeSucceeded)
|
|
CoUninitialize();
|
|
|
|
return(0);
|
|
}
|
|
|