mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
646 lines
12 KiB
646 lines
12 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
fsarcvy.cpp
|
|
|
|
Abstract:
|
|
|
|
Defines the functions for the recovery record class.
|
|
|
|
Author:
|
|
|
|
Ron White [ronw] 8-Sep-1997
|
|
|
|
Revision History:
|
|
|
|
Steve Wimmer [stevew] 30-July-1998
|
|
- updated CFsaRecoveryRec::GetClassId's WsbTraceOut to hold
|
|
the proper function name
|
|
|
|
--*/
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "wsb.h"
|
|
|
|
|
|
#include "fsarcvy.h"
|
|
|
|
#define WSB_TRACE_IS WSB_TRACE_BIT_FSA
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetBagId(
|
|
OUT GUID* pId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetBagId
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetBagId"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssert(0 != pId, E_POINTER);
|
|
|
|
*pId = m_BagId;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetBagId"), OLESTR("hr = <%ls> Id = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pId));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetBagOffset(
|
|
OUT LONGLONG* pOffset
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetBagOffset
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetBagOffset"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssert(0 != pOffset, E_POINTER);
|
|
*pOffset = m_BagOffset;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetBagOffset"), OLESTR("hr = <%ls> Offset = <%ls>"), WsbHrAsString(hr), WsbLonglongAsString(*pOffset));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetFileId(
|
|
OUT LONGLONG* pFileId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetFileId
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetFileId"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssert(0 != pFileId, E_POINTER);
|
|
*pFileId = m_FileId;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetFileId"),
|
|
OLESTR("hr = <%ls> Size = <%ls>"), WsbHrAsString( hr ), WsbLonglongAsString( *pFileId ) );
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetOffsetSize(
|
|
OUT LONGLONG* pOffset,
|
|
OUT LONGLONG* pSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetOffsetSize
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetOffsetSize"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssertPointer(pOffset);
|
|
WsbAssertPointer(pSize);
|
|
*pOffset = m_Offset;
|
|
*pSize = m_Size;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetOffsetSize"), OLESTR("hr = <%ls> Offset = %I64d, Size = %I64d"),
|
|
WsbHrAsString(hr), *pOffset, *pSize);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetPath(
|
|
OUT OLECHAR** ppPath,
|
|
IN ULONG bufferSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetPath
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetPath"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssert(0 != ppPath, E_POINTER);
|
|
WsbAffirmHr(m_Path.CopyTo(ppPath, bufferSize));
|
|
WsbTrace( OLESTR("CFsaRecoveryRec::GetPath path = <%ls>\n"), *ppPath );
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetPath"),
|
|
OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetRecoveryCount(
|
|
OUT LONG* pRecoveryCount
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetRecoveryCount
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetRecoveryCount"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssertPointer(pRecoveryCount);
|
|
*pRecoveryCount = m_RecoveryCount;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetRecoveryCount"), OLESTR("hr = <%ls> RecoveryCount = %ld"),
|
|
WsbHrAsString(hr), *pRecoveryCount);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::GetStatus(
|
|
OUT ULONG* pStatus
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::GetStatus
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetStatus"),OLESTR(""));
|
|
|
|
try {
|
|
WsbAssertPointer(pStatus);
|
|
*pStatus = m_Status;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetStatus"), OLESTR("hr = <%ls> Status = %lx"),
|
|
WsbHrAsString(hr), *pStatus);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::FinalConstruct(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalConstruct().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssertHr(CWsbDbEntity::FinalConstruct());
|
|
|
|
m_BagId = GUID_NULL;
|
|
m_BagOffset = 0;
|
|
m_FileId = 0;
|
|
m_Offset = 0;
|
|
m_RecoveryCount = 0;
|
|
m_Size = 0;
|
|
m_Status = 0;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::FinalRelease(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalRelease
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
CWsbDbEntity::FinalRelease();
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT CFsaRecoveryRec::GetClassID
|
|
(
|
|
OUT LPCLSID pclsid
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPerist::GetClassID
|
|
|
|
--*/
|
|
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::GetClassID"), OLESTR(""));
|
|
|
|
|
|
try {
|
|
WsbAssertPointer(pclsid);
|
|
*pclsid = CLSID_CFsaRecoveryRec;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pclsid));
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT CFsaRecoveryRec::Load
|
|
(
|
|
IN IStream* pStream
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Load
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::Load"), OLESTR(""));
|
|
|
|
try {
|
|
OLECHAR* pPath = NULL;
|
|
|
|
WsbAssertPointer(pStream);
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_BagId));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_BagOffset));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_FileId));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_Offset));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_Path, 0));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_RecoveryCount));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_Size));
|
|
WsbAssertHr(WsbLoadFromStream(pStream, &m_Status));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::Load"),
|
|
OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT CFsaRecoveryRec::Print
|
|
(
|
|
IN IStream* pStream
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbDbEntity::Print
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::Print"), OLESTR(""));
|
|
|
|
try {
|
|
WsbAssertPointer(pStream);
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" BagId = %ls"), WsbGuidAsString(m_BagId)));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" BagOffset = %I64d"), m_BagOffset));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" FileId = %I64d"), m_FileId));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Offset = %I64d"), m_Offset));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Size = %I64d"), m_Size));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RecoveryCount = %ld"),
|
|
m_RecoveryCount));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Status = %lx"), m_Status));
|
|
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", Path = %ls"),
|
|
static_cast<OLECHAR*>(m_Path)));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::Print"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT CFsaRecoveryRec::Save
|
|
(
|
|
IN IStream* pStream,
|
|
IN BOOL clearDirty
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Save
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
|
|
|
|
try {
|
|
WsbAssertPointer(pStream);
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_BagId));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_BagOffset));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_FileId));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_Offset));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_Path));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_RecoveryCount));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_Size));
|
|
WsbAssertHr(WsbSaveToStream(pStream, m_Status));
|
|
|
|
// If we got it saved and we were asked to clear the dirty bit, then
|
|
// do so now.
|
|
if (clearDirty) {
|
|
m_isDirty = FALSE;
|
|
}
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetBagId(
|
|
IN GUID BagId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetBagId
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetBagId"),OLESTR(""));
|
|
|
|
m_BagId = BagId;
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetBagId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetBagOffset(
|
|
IN LONGLONG BagOffset
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetBagOffset
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetBagOffset"),OLESTR(""));
|
|
|
|
m_BagOffset = BagOffset;
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetBagOffset"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetFileId(
|
|
IN LONGLONG FileId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetFileId
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetFileId"),OLESTR(""));
|
|
|
|
try {
|
|
m_FileId = FileId;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetFileId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetOffsetSize(
|
|
IN LONGLONG Offset,
|
|
IN LONGLONG Size
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetOffsetSize
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetOffsetSize"),OLESTR("Offset = %I64d, Size = %I64d"),
|
|
Offset, Size);
|
|
|
|
m_Offset = Offset;
|
|
m_Size = Size;
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetOffsetSize"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetPath(
|
|
IN OLECHAR* Path
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetPath
|
|
|
|
--*/
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetPath"),OLESTR("Path = <%ls>"),
|
|
Path);
|
|
|
|
try {
|
|
m_Path = Path;
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetPath"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetRecoveryCount(
|
|
IN LONG RecoveryCount
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetRecoveryCount
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetRecoveryCount"),OLESTR("RecoveryCount = %ld"),
|
|
RecoveryCount);
|
|
|
|
m_RecoveryCount = RecoveryCount;
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetRecoveryCount"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::SetStatus(
|
|
IN ULONG Status
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IFsaRecoveryRec::SetStatus
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CFsaRecoveryRec::SetStatus"),OLESTR("Status = %lx"),
|
|
Status);
|
|
|
|
m_Status = Status;
|
|
|
|
WsbTraceOut(OLESTR("CFsaRecoveryRec::SetStatus"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CFsaRecoveryRec::UpdateKey(
|
|
IWsbDbKey *pKey
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbDbEntity::UpdateKey
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
try {
|
|
UCHAR FileKey[RECOVERY_KEY_SIZE + 1];
|
|
ULONG KeyType;
|
|
|
|
WsbAffirmHr(pKey->GetType(&KeyType));
|
|
if (RECOVERY_KEY_TYPE == KeyType) {
|
|
WsbAffirmHr(SquashFilepath(m_Path, FileKey, RECOVERY_KEY_SIZE));
|
|
WsbAffirmHr(pKey->SetToBytes(FileKey, RECOVERY_KEY_SIZE));
|
|
hr = S_OK;
|
|
}
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|