747 lines
24 KiB
C++
747 lines
24 KiB
C++
/////////////////////////////////////////////////////////////////////////
|
|
// Copyright © Microsoft Corporation. All rights reserved.
|
|
//
|
|
// This file may contain preliminary information or inaccuracies,
|
|
// and may not correctly represent any associated Microsoft
|
|
// Product as commercially released. All Materials are provided entirely
|
|
// “AS IS.” To the extent permitted by law, MICROSOFT MAKES NO
|
|
// WARRANTY OF ANY KIND, DISCLAIMS ALL EXPRESS, IMPLIED AND STATUTORY
|
|
// WARRANTIES, AND ASSUMES NO LIABILITY TO YOU FOR ANY DAMAGES OF
|
|
// ANY TYPE IN CONNECTION WITH THESE MATERIALS OR ANY INTELLECTUAL PROPERTY IN THEM.
|
|
//
|
|
|
|
|
|
#pragma once
|
|
|
|
#include <resapi.h>
|
|
#include "stdafx.h"
|
|
|
|
|
|
//for IsUNCPath method
|
|
#define UNC_PATH_PREFIX1 (L"\\\\?\\UNC\\")
|
|
#define NONE_UNC_PATH_PREFIX1 (L"\\\\?\\")
|
|
#define UNC_PATH_PREFIX2 (L"\\\\")
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// Utility classes
|
|
//
|
|
|
|
// Used to automatically release a CoTaskMemAlloc allocated pointer when
|
|
// when the instance of this class goes out of scope
|
|
// (even if an exception is thrown)
|
|
class CAutoComPointer
|
|
{
|
|
public:
|
|
CAutoComPointer(LPVOID ptr): m_ptr(ptr) {};
|
|
~CAutoComPointer() { CoTaskMemFree(m_ptr); }
|
|
private:
|
|
LPVOID m_ptr;
|
|
|
|
};
|
|
|
|
|
|
// Used to automatically release the contents of a VSS_SNAPSHOT_PROP structure
|
|
// (but not the structure itself)
|
|
// when the instance of this class goes out of scope
|
|
// (even if an exception is thrown)
|
|
class CAutoSnapPointer
|
|
{
|
|
public:
|
|
CAutoSnapPointer(VSS_SNAPSHOT_PROP * ptr): m_ptr(ptr) {};
|
|
~CAutoSnapPointer() { ::VssFreeSnapshotProperties(m_ptr); }
|
|
private:
|
|
VSS_SNAPSHOT_PROP * m_ptr;
|
|
};
|
|
|
|
|
|
// Used to automatically release the given handle
|
|
// when the instance of this class goes out of scope
|
|
// (even if an exception is thrown)
|
|
class CAutoHandle
|
|
{
|
|
public:
|
|
CAutoHandle(HANDLE h): m_h(h) {};
|
|
~CAutoHandle() { ::CloseHandle(m_h); }
|
|
private:
|
|
HANDLE m_h;
|
|
};
|
|
|
|
|
|
// Used to automatically release the given handle
|
|
// when the instance of this class goes out of scope
|
|
// (even if an exception is thrown)
|
|
class CAutoSearchHandle
|
|
{
|
|
public:
|
|
CAutoSearchHandle(HANDLE h): m_h(h) {};
|
|
~CAutoSearchHandle() { ::FindClose(m_h); }
|
|
private:
|
|
HANDLE m_h;
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// Wrapper class to convert a wstring to/from a temporary WCHAR
|
|
// buffer to be used as an in/out parameter in Win32 APIs
|
|
//
|
|
class WString2Buffer
|
|
{
|
|
public:
|
|
|
|
WString2Buffer(wstring & s):
|
|
m_s(s), m_sv(s.length() + 1, L'\0')
|
|
{
|
|
// Move data from wstring to the temporary vector
|
|
std::copy(m_s.begin(), m_s.end(), m_sv.begin());
|
|
}
|
|
|
|
~WString2Buffer()
|
|
{
|
|
// Move data from the temporary vector to the string
|
|
m_sv.resize(wcslen(&m_sv[0]));
|
|
m_s.assign(m_sv.begin(), m_sv.end());
|
|
}
|
|
|
|
// Return the temporary WCHAR buffer
|
|
operator WCHAR* () { return &(m_sv[0]); }
|
|
|
|
// Return the available size of the temporary WCHAR buffer
|
|
size_t length() { return m_s.length(); }
|
|
|
|
private:
|
|
wstring & m_s;
|
|
vector<WCHAR> m_sv;
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// String-related utility functions
|
|
//
|
|
|
|
|
|
// Converts a wstring to a string class
|
|
inline string WString2String(wstring src)
|
|
{
|
|
vector<CHAR> chBuffer;
|
|
int iChars = WideCharToMultiByte(CP_ACP, 0, src.c_str(), -1, NULL, 0, NULL, NULL);
|
|
if (iChars > 0)
|
|
{
|
|
chBuffer.resize(iChars);
|
|
WideCharToMultiByte(CP_ACP, 0, src.c_str(), -1, &chBuffer.front(), (int)chBuffer.size(), NULL, NULL);
|
|
}
|
|
|
|
return std::string(&chBuffer.front());
|
|
}
|
|
|
|
|
|
// Converts a wstring into a GUID
|
|
inline GUID & WString2Guid(wstring src)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
// Check if this is a GUID
|
|
static GUID result;
|
|
HRESULT hr = ::CLSIDFromString(W2OLE(const_cast<WCHAR*>(src.c_str())), &result);
|
|
if (FAILED(hr))
|
|
{
|
|
ft.WriteLine(L"ERROR: The string '%s' is not formatted as a GUID!", src.c_str());
|
|
throw(E_INVALIDARG);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// Splits a string into a list of substrings separated by the given character
|
|
inline vector<wstring> SplitWString(wstring str, WCHAR separator)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
vector<wstring> strings;
|
|
|
|
wstring remainder = str;
|
|
while(true)
|
|
{
|
|
size_t position = remainder.find(separator);
|
|
if (position == wstring::npos)
|
|
{
|
|
// Add the last string
|
|
strings.push_back(remainder);
|
|
break;
|
|
}
|
|
|
|
wstring token = remainder.substr(0, position);
|
|
ft.Trace(DBG_INFO, L"Extracting token: '%s' from '%s' between 0..%d",
|
|
token.c_str(), remainder.c_str(), position);
|
|
|
|
// Add this substring and continue with the rest
|
|
strings.push_back(token);
|
|
remainder = remainder.substr(position + 1);
|
|
}
|
|
|
|
return strings;
|
|
}
|
|
|
|
|
|
// Converts a GUID to a wstring
|
|
inline wstring Guid2WString(GUID guid)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
wstring guidString(100, L'\0');
|
|
CHECK_COM(StringCchPrintfW(WString2Buffer(guidString), guidString.length(), WSTR_GUID_FMT, GUID_PRINTF_ARG(guid)));
|
|
|
|
return guidString;
|
|
}
|
|
|
|
|
|
// Convert the given BSTR (potentially NULL) into a valid wstring
|
|
inline wstring BSTR2WString(BSTR bstr)
|
|
{
|
|
return (bstr == NULL)? wstring(L""): wstring(bstr);
|
|
}
|
|
|
|
|
|
|
|
// Case insensitive comparison
|
|
inline bool IsEqual(wstring str1, wstring str2)
|
|
{
|
|
return (_wcsicmp(str1.c_str(), str2.c_str()) == 0);
|
|
}
|
|
|
|
|
|
// Returns TRUE if the string is already present in the string list
|
|
// (performs case insensitive comparison)
|
|
inline bool FindStringInList(wstring str, vector<wstring> stringList)
|
|
{
|
|
// Check to see if the volume is already added
|
|
for (unsigned i = 0; i < stringList.size( ); i++)
|
|
if (IsEqual(str, stringList[i]))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Append a backslash to the current string
|
|
inline wstring AppendBackslash(wstring str)
|
|
{
|
|
if (str.length() == 0)
|
|
return wstring(L"\\");
|
|
if (str[str.length() - 1] == L'\\')
|
|
return str;
|
|
return str.append(L"\\");
|
|
}
|
|
|
|
//This method determins if a given volume is a UNC path, returns true if it has a UNC path prefix and false if it has not
|
|
inline bool IsUNCPath(
|
|
_In_ VSS_PWSZ pwszVolumeName
|
|
)
|
|
{
|
|
// Check UNC path prefix
|
|
if (_wcsnicmp(pwszVolumeName, UNC_PATH_PREFIX1, wcslen(UNC_PATH_PREFIX1)) == 0)
|
|
return true;
|
|
else if (_wcsnicmp(pwszVolumeName, NONE_UNC_PATH_PREFIX1, wcslen(NONE_UNC_PATH_PREFIX1)) == 0)
|
|
return false;
|
|
else if (_wcsnicmp(pwszVolumeName, UNC_PATH_PREFIX2, wcslen(UNC_PATH_PREFIX2)) == 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// Volume, File -related utility functions
|
|
//
|
|
|
|
|
|
// Returns TRUE if this is a real volume (for eample C:\ or C:)
|
|
// - The backslash termination is optional
|
|
inline bool IsVolume(wstring volumePath)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
bool bIsVolume = false;
|
|
ft.Trace(DBG_INFO, L"Checking if %s is a real volume path...", volumePath.c_str());
|
|
_ASSERTE(volumePath.length() > 0);
|
|
|
|
// If the last character is not '\\', append one
|
|
volumePath = AppendBackslash(volumePath);
|
|
|
|
if (!ClusterIsPathOnSharedVolume(volumePath.c_str()))
|
|
{
|
|
// Get the volume name
|
|
wstring volumeName(MAX_PATH, L'\0');
|
|
if (!GetVolumeNameForVolumeMountPoint( volumePath.c_str(), WString2Buffer(volumeName), (DWORD)volumeName.length()))
|
|
{
|
|
ft.Trace(DBG_INFO, L"GetVolumeNameForVolumeMountPoint(%s) failed with %d", volumePath, GetLastError());
|
|
}
|
|
else
|
|
{
|
|
bIsVolume = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bIsVolume = ::PathFileExists(volumePath.c_str()) == TRUE;
|
|
}
|
|
|
|
ft.Trace(DBG_INFO, L"IsVolume returns %s", (bIsVolume) ? L"TRUE" : L"FALSE");
|
|
return bIsVolume;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get the unique volume name for the given mount point
|
|
inline wstring GetUniqueVolumeNameForMountPoint(wstring mountPoint)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
_ASSERTE(mountPoint.length() > 0);
|
|
|
|
ft.Trace(DBG_INFO, L"- Get volume name for %s ...", mountPoint.c_str());
|
|
|
|
// Add the backslash termination, if needed
|
|
mountPoint = AppendBackslash(mountPoint);
|
|
|
|
// Get the volume name alias (might be different from the unique volume name in rare cases)
|
|
wstring volumeName(MAX_PATH, L'\0');
|
|
CHECK_WIN32(GetVolumeNameForVolumeMountPointW((LPCWSTR)mountPoint.c_str(), WString2Buffer(volumeName), (DWORD)volumeName.length()));
|
|
ft.Trace(DBG_INFO, L"- Volume name for mount point: %s ...", volumeName.c_str());
|
|
|
|
// Get the unique volume name
|
|
wstring volumeUniqueName(MAX_PATH, L'\0');
|
|
CHECK_WIN32(GetVolumeNameForVolumeMountPointW((LPCWSTR)volumeName.c_str(), WString2Buffer(volumeUniqueName), (DWORD)volumeUniqueName.length()));
|
|
ft.Trace(DBG_INFO, L"- Unique volume name: %s ...", volumeUniqueName.c_str());
|
|
|
|
return volumeUniqueName;
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get the unique volume name for the given path
|
|
inline wstring GetUniqueVolumeNameForPath(wstring path, bool bIsBackup=false)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
_ASSERTE(path.length() > 0);
|
|
|
|
wstring volumeRootPath(MAX_PATH, L'\0');
|
|
wstring volumeUniqueName(MAX_PATH, L'\0');
|
|
|
|
ft.Trace(DBG_INFO, L"- Get volume path name for %s ...", path.c_str());
|
|
|
|
// Add the backslash termination, if needed
|
|
path = AppendBackslash(path);
|
|
if(!IsUNCPath((VSS_PWSZ)path.c_str()))
|
|
{
|
|
if (bIsBackup && ClusterIsPathOnSharedVolume(path.c_str()))
|
|
{
|
|
DWORD cchVolumeRootPath = MAX_PATH;
|
|
DWORD cchVolumeUniqueName = MAX_PATH;
|
|
|
|
DWORD dwRet = ClusterPrepareSharedVolumeForBackup(
|
|
path.c_str(),
|
|
WString2Buffer(volumeRootPath),
|
|
&cchVolumeRootPath,
|
|
WString2Buffer(volumeUniqueName),
|
|
&cchVolumeUniqueName);
|
|
|
|
CHECK_WIN32_ERROR(dwRet, "ClusterPrepareSharedVolumeForBackup");
|
|
|
|
ft.Trace(DBG_INFO, L"- Path name: %s ...", volumeRootPath.c_str());
|
|
ft.Trace(DBG_INFO, L"- Unique volume name: %s ...", volumeUniqueName.c_str());
|
|
}
|
|
else
|
|
{
|
|
// Get the root path of the volume
|
|
|
|
CHECK_WIN32(GetVolumePathNameW((LPCWSTR)path.c_str(), WString2Buffer(volumeRootPath), (DWORD)volumeRootPath.length()));
|
|
ft.Trace(DBG_INFO, L"- Path name: %s ...", volumeRootPath.c_str());
|
|
|
|
// Get the unique volume name
|
|
CHECK_WIN32(GetVolumeNameForVolumeMountPointW((LPCWSTR)volumeRootPath.c_str(), WString2Buffer(volumeUniqueName), (DWORD)volumeUniqueName.length()));
|
|
ft.Trace(DBG_INFO, L"- Unique volume name: %s ...", volumeUniqueName.c_str());
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CComPtr<IVssBackupComponents> lvssObject;
|
|
CComPtr<IVssBackupComponentsEx4> lvssObject4;
|
|
CHECK_COM( CreateVssBackupComponents(&lvssObject) );
|
|
CHECK_COM(lvssObject->QueryInterface<IVssBackupComponentsEx4>(&lvssObject4));
|
|
VSS_PWSZ pwszVolumeUniqueName = NULL;
|
|
VSS_PWSZ pwszVolumeRootPath = NULL;
|
|
CHECK_COM(lvssObject4->GetRootAndLogicalPrefixPaths((VSS_PWSZ)path.c_str(), &pwszVolumeUniqueName, &pwszVolumeRootPath));
|
|
|
|
volumeUniqueName = BSTR2WString(pwszVolumeUniqueName);
|
|
volumeRootPath = BSTR2WString(pwszVolumeRootPath);
|
|
|
|
::CoTaskMemFree(pwszVolumeUniqueName);
|
|
pwszVolumeUniqueName = NULL;
|
|
::CoTaskMemFree(pwszVolumeRootPath);
|
|
pwszVolumeRootPath = NULL;
|
|
|
|
ft.Trace(DBG_INFO, L"- Path name: %s ...", volumeRootPath.c_str());
|
|
ft.Trace(DBG_INFO, L"- Unique volume name: %s ...", volumeUniqueName.c_str());
|
|
}
|
|
return volumeUniqueName;
|
|
}
|
|
|
|
|
|
// Get the unique volume name for the given path without throwing on error
|
|
inline bool GetUniqueVolumeNameForPathNoThrow(wstring path, wstring &volname)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
_ASSERTE(path.length() > 0);
|
|
|
|
ft.Trace(DBG_INFO, L"- Get volume path name for %s ...", path.c_str());
|
|
|
|
// Add the backslash termination, if needed
|
|
path = AppendBackslash(path);
|
|
|
|
wstring volumeRootPath(MAX_PATH, L'\0');
|
|
wstring volumeUniqueName(MAX_PATH, L'\0');
|
|
|
|
if (ClusterIsPathOnSharedVolume(path.c_str()))
|
|
{
|
|
DWORD dwRet = ClusterGetVolumePathName(path.c_str(),
|
|
WString2Buffer(volumeUniqueName),
|
|
(DWORD)volumeUniqueName.length());
|
|
|
|
if (dwRet != ERROR_SUCCESS)
|
|
return false;
|
|
|
|
ft.Trace(DBG_INFO, L"- Path name: %s ...", volumeRootPath.c_str());
|
|
ft.Trace(DBG_INFO, L"- Unique volume name: Deffering until component selection ...");
|
|
}
|
|
else
|
|
{
|
|
// Get the root path of the volume
|
|
if (!GetVolumePathNameW((LPCWSTR)path.c_str(),
|
|
WString2Buffer(volumeRootPath),
|
|
(DWORD)volumeRootPath.length()))
|
|
{
|
|
ft.Trace(DBG_INFO, L"GetVolumePathNameW(%s) fails winerror %d", path.c_str(), GetLastError());
|
|
return false;
|
|
}
|
|
|
|
ft.Trace(DBG_INFO, L"- Path name: %s ...", volumeRootPath.c_str());
|
|
|
|
// Get the unique volume name
|
|
if (!GetVolumeNameForVolumeMountPointW((LPCWSTR)volumeRootPath.c_str(),
|
|
WString2Buffer(volumeUniqueName),
|
|
(DWORD)volumeUniqueName.length()))
|
|
{
|
|
ft.Trace(DBG_INFO, L"GetVolumeNameForVolumeMountPointW(%s) fails winerror %d", volumeRootPath.c_str(), GetLastError());
|
|
return false;
|
|
}
|
|
|
|
ft.Trace(DBG_INFO, L"- Unique volume name: %s ...", volumeUniqueName.c_str());
|
|
}
|
|
|
|
volname = volumeUniqueName;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
// Get the Win32 device for the volume name
|
|
inline wstring GetDeviceForVolumeName(wstring volumeName)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
ft.Trace(DBG_INFO, L"- GetDeviceForVolumeName for '%s' ... ", volumeName.c_str());
|
|
|
|
// The input parameter is a valid volume name
|
|
_ASSERTE(wcslen(volumeName.c_str()) > 0);
|
|
|
|
// Eliminate the last backslash, if present
|
|
if (volumeName[wcslen(volumeName.c_str()) - 1] == L'\\')
|
|
volumeName[wcslen(volumeName.c_str()) - 1] = L'\0';
|
|
|
|
// Eliminate the GLOBALROOT prefix if present
|
|
wstring globalRootPrefix = L"\\\\?\\GLOBALROOT";
|
|
if (IsEqual(volumeName.substr(0,globalRootPrefix.size()), globalRootPrefix))
|
|
{
|
|
wstring kernelDevice = volumeName.substr(globalRootPrefix.size());
|
|
ft.Trace(DBG_INFO, L"- GLOBALROOT prefix eliminated. Returning kernel device: '%s' ", kernelDevice.c_str());
|
|
|
|
return kernelDevice;
|
|
}
|
|
|
|
// If this is a volume name, get the device
|
|
wstring dosPrefix = L"\\\\?\\";
|
|
wstring volumePrefix = L"\\\\?\\Volume";
|
|
if (IsEqual(volumeName.substr(0,volumePrefix.size()), volumePrefix))
|
|
{
|
|
// Isolate the DOS device for the volume name (in the format Volume{GUID})
|
|
wstring dosDevice = volumeName.substr(dosPrefix.size());
|
|
ft.Trace(DBG_INFO, L"- DOS device for '%s' is '%s'", volumeName.c_str(), dosDevice.c_str() );
|
|
|
|
// Get the real device underneath
|
|
wstring kernelDevice(MAX_PATH, L'\0');
|
|
CHECK_WIN32(QueryDosDevice((LPCWSTR)dosDevice.c_str(), WString2Buffer(kernelDevice), (DWORD)kernelDevice.size()));
|
|
ft.Trace(DBG_INFO, L"- Kernel device for '%s' is '%s'", volumeName.c_str(), kernelDevice.c_str() );
|
|
|
|
return kernelDevice;
|
|
}
|
|
|
|
return volumeName;
|
|
}
|
|
|
|
|
|
|
|
// Get the displayable root path for the given volume name
|
|
inline wstring GetDisplayNameForVolume(wstring volumeName)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
DWORD dwRequired = 0;
|
|
wstring volumeMountPoints(MAX_PATH, L'\0');
|
|
if (!GetVolumePathNamesForVolumeName((LPCWSTR)volumeName.c_str(),
|
|
WString2Buffer(volumeMountPoints),
|
|
(DWORD)volumeMountPoints.length(),
|
|
&dwRequired))
|
|
{
|
|
// If not enough, retry with a larger size
|
|
volumeMountPoints.resize(dwRequired, L'\0');
|
|
CHECK_WIN32(!GetVolumePathNamesForVolumeName((LPCWSTR)volumeName.c_str(),
|
|
WString2Buffer(volumeMountPoints),
|
|
(DWORD)volumeMountPoints.length(),
|
|
&dwRequired));
|
|
}
|
|
|
|
// compute the smallest mount point by enumerating the returned MULTI_SZ
|
|
wstring mountPoint = volumeMountPoints;
|
|
for(LPWSTR pwszString = (LPWSTR)volumeMountPoints.c_str(); pwszString[0]; pwszString += wcslen(pwszString) + 1)
|
|
if (mountPoint.length() > wcslen(pwszString))
|
|
mountPoint = pwszString;
|
|
|
|
return mountPoint;
|
|
}
|
|
|
|
inline bool GetDisplayNameForVolumeNoThrow(wstring volumeName, wstring &volumeNameCanon)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
DWORD dwRequired = 0;
|
|
wstring volumeMountPoints(MAX_PATH, L'\0');
|
|
if (!GetVolumePathNamesForVolumeName((LPCWSTR)volumeName.c_str(),
|
|
WString2Buffer(volumeMountPoints),
|
|
(DWORD)volumeMountPoints.length(),
|
|
&dwRequired))
|
|
{
|
|
// If not enough, retry with a larger size
|
|
volumeMountPoints.resize(dwRequired, L'\0');
|
|
if(!dwRequired || !GetVolumePathNamesForVolumeName((LPCWSTR)volumeName.c_str(),
|
|
WString2Buffer(volumeMountPoints),
|
|
(DWORD)volumeMountPoints.length(),
|
|
&dwRequired))
|
|
{
|
|
ft.Trace(DBG_INFO, L"GetVolumePathNamesForVolumeName(%s) fails winerror %d", volumeName.c_str(), GetLastError());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// compute the smallest mount point by enumerating the returned MULTI_SZ
|
|
wstring mountPoint = volumeMountPoints;
|
|
for(LPWSTR pwszString = (LPWSTR)volumeMountPoints.c_str(); pwszString[0]; pwszString += wcslen(pwszString) + 1)
|
|
if (mountPoint.length() > wcslen(pwszString))
|
|
mountPoint = pwszString;
|
|
|
|
volumeNameCanon = mountPoint;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// Utility function to read the contents of a file
|
|
inline wstring ReadFileContents(wstring fileName)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
ft.WriteLine(L"Reading the file '%s' ...", fileName.c_str());
|
|
|
|
HANDLE hFile = CreateFile((LPWSTR)fileName.c_str(),
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
CHECK_WIN32_ERROR(GetLastError(), L"CreateFile");
|
|
|
|
// Will automatically call CloseHandle at the end of scope
|
|
// (even if an exception is thrown)
|
|
CAutoHandle autoCleanupHandle(hFile);
|
|
|
|
// Allocate the read buffer
|
|
DWORD dwFileSize = GetFileSize(hFile, 0);
|
|
wstring contents(dwFileSize / sizeof(WCHAR), L'\0');
|
|
|
|
// Read the file contents
|
|
DWORD dwRead;
|
|
CHECK_WIN32(ReadFile(hFile, WString2Buffer(contents), dwFileSize, &dwRead, NULL));
|
|
|
|
return contents;
|
|
}
|
|
|
|
|
|
// Utility function to write a new file
|
|
inline void WriteFile(wstring fileName, wstring contents)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
ft.WriteLine(L"Writing the file '%s' ...", fileName.c_str());
|
|
|
|
HANDLE hFile = CreateFile((LPWSTR)fileName.c_str(),
|
|
GENERIC_WRITE,
|
|
FILE_SHARE_READ|FILE_SHARE_WRITE,
|
|
NULL,
|
|
CREATE_ALWAYS,
|
|
0,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
CHECK_WIN32_ERROR(GetLastError(), L"CreateFile");
|
|
|
|
// Will automatically call CloseHandle at the end of scope
|
|
// (even if an exception is thrown)
|
|
CAutoHandle autoCleanupHandle(hFile);
|
|
|
|
// Write the file contents
|
|
DWORD dwWritten;
|
|
DWORD cbWrite = (DWORD)((contents.length() + 1) * sizeof(WCHAR));
|
|
CHECK_WIN32(WriteFile(hFile, (LPWSTR)contents.c_str(), cbWrite, &dwWritten, NULL));
|
|
}
|
|
|
|
|
|
// Execute a command
|
|
inline void ExecCommand(wstring execCommand)
|
|
{
|
|
FunctionTracer ft(DBG_INFO);
|
|
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
|
|
ZeroMemory( &si, sizeof(si) );
|
|
si.cb = sizeof(si);
|
|
ZeroMemory( &pi, sizeof(pi) );
|
|
|
|
ft.WriteLine(L"- Executing command '%s' ...", execCommand.c_str());
|
|
ft.WriteLine(L"-----------------------------------------------------");
|
|
|
|
//
|
|
// Security Remarks - CreateProcess
|
|
//
|
|
// The first parameter, lpApplicationName, can be NULL, in which case the
|
|
// executable name must be in the white space-delimited string pointed to
|
|
// by lpCommandLine. If the executable or path name has a space in it, there
|
|
// is a risk that a different executable could be run because of the way the
|
|
// function parses spaces. The following example is dangerous because the
|
|
// function will attempt to run "Program.exe", if it exists, instead of "MyApp.exe".
|
|
//
|
|
// CreateProcess(NULL, "C:\\Program Files\\MyApp", ...)
|
|
//
|
|
// If a malicious user were to create an application called "Program.exe"
|
|
// on a system, any program that incorrectly calls CreateProcess
|
|
// using the Program Files directory will run this application
|
|
// instead of the intended application.
|
|
//
|
|
// For this reason we blocked parameters in the executed command.
|
|
//
|
|
|
|
// Prepend/append the command with double-quotes. This will prevent adding parameters
|
|
execCommand = wstring(L"\"") + execCommand + wstring(L"\"");
|
|
|
|
// Start the child process.
|
|
CHECK_WIN32( CreateProcess( NULL, // No module name (use command line).
|
|
(LPWSTR)execCommand.c_str(), // Command line.
|
|
NULL, // Process handle not inheritable.
|
|
NULL, // Thread handle not inheritable.
|
|
FALSE, // Set handle inheritance to FALSE.
|
|
0, // No creation flags.
|
|
NULL, // Use parent's environment block.
|
|
NULL, // Use parent's starting directory.
|
|
&si, // Pointer to STARTUPINFO structure.
|
|
&pi )) // Pointer to PROCESS_INFORMATION structure.
|
|
|
|
// Close process and thread handles automatically when we wil leave this function
|
|
CAutoHandle autoCleanupHandleProcess(pi.hProcess);
|
|
CAutoHandle autoCleanupHandleThread(pi.hThread);
|
|
|
|
// Wait until child process exits.
|
|
CHECK_WIN32( WaitForSingleObject( pi.hProcess, INFINITE ) == WAIT_OBJECT_0);
|
|
ft.WriteLine(L"-----------------------------------------------------");
|
|
|
|
// Checking the exit code
|
|
DWORD dwExitCode = 0;
|
|
CHECK_WIN32( GetExitCodeProcess( pi.hProcess, &dwExitCode ) );
|
|
if (dwExitCode != 0)
|
|
{
|
|
ft.WriteLine(L"ERROR: Command line '%s' failed!. Aborting the backup...", execCommand.c_str());
|
|
ft.WriteLine(L"- Returned error code: %d", dwExitCode);
|
|
throw(E_UNEXPECTED);
|
|
}
|
|
}
|
|
|
|
inline wstring VssTimeToString(VSS_TIMESTAMP& vssTime)
|
|
{
|
|
wstring stringDateTime;
|
|
SYSTEMTIME stLocal = {0};
|
|
FILETIME ftLocal = {0};
|
|
|
|
// Compensate for local TZ
|
|
::FileTimeToLocalFileTime( (FILETIME *)(&vssTime), &ftLocal );
|
|
|
|
// Finally convert it to system time
|
|
::FileTimeToSystemTime( &ftLocal, &stLocal );
|
|
|
|
WCHAR pwszDate[64];
|
|
WCHAR pwszTime[64];
|
|
// Convert timestamp to a date string
|
|
::GetDateFormatW( GetThreadLocale( ),
|
|
DATE_SHORTDATE,
|
|
&stLocal,
|
|
NULL,
|
|
pwszDate,
|
|
sizeof( pwszDate ) / sizeof( pwszDate[0] ));
|
|
|
|
// Convert timestamp to a time string
|
|
::GetTimeFormatW( GetThreadLocale( ),
|
|
0,
|
|
&stLocal,
|
|
NULL,
|
|
pwszTime,
|
|
sizeof( pwszTime ) / sizeof( pwszTime[0] ));
|
|
|
|
stringDateTime = pwszDate;
|
|
stringDateTime += L" ";
|
|
stringDateTime += pwszTime;
|
|
|
|
return stringDateTime;
|
|
}
|
|
|
|
struct ltguid
|
|
{
|
|
bool operator()(GUID guid1, GUID guid2) const
|
|
{
|
|
return (guid1.Data1 < guid2.Data1) ||
|
|
(guid1.Data1 == guid2.Data1 && guid1.Data2 < guid1.Data2) ||
|
|
(guid1.Data1 == guid2.Data1 && guid1.Data2 == guid2.Data2 && guid1.Data3 < guid2.Data3);
|
|
}
|
|
};
|