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.
651 lines
12 KiB
651 lines
12 KiB
/*++
|
|
|
|
© 1998 Seagate Software, Inc. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
hsmpolcy.cpp
|
|
|
|
Abstract:
|
|
|
|
This component represents a job's policy.
|
|
|
|
Author:
|
|
|
|
Chuck Bardeen [cbardeen] 29-Oct-1996
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "wsb.h"
|
|
#include "job.h"
|
|
#include "hsmpolcy.h"
|
|
|
|
#define WSB_TRACE_IS WSB_TRACE_BIT_JOB
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::CompareTo(
|
|
IN IUnknown* pUnknown,
|
|
OUT SHORT* pResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbCollectable::CompareTo().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IHsmPolicy> pPolicy;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::CompareTo"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item to compare to?
|
|
WsbAssert(0 != pUnknown, E_POINTER);
|
|
|
|
// We need the IWsbBool interface to get the value of the object.
|
|
WsbAffirmHr(pUnknown->QueryInterface(IID_IHsmPolicy, (void**) &pPolicy));
|
|
|
|
// Compare the rules.
|
|
hr = CompareToIPolicy(pPolicy, pResult);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPolicy::CompareTo"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::CompareToIPolicy(
|
|
IN IHsmPolicy* pPolicy,
|
|
OUT SHORT* pResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::CompareToIPolicy().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
GUID id;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::CompareToIPolicy"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
// Did they give us a valid item to compare to?
|
|
WsbAssert(0 != pPolicy, E_POINTER);
|
|
|
|
// Get the path and name.
|
|
WsbAffirmHr(pPolicy->GetIdentifier(&id));
|
|
|
|
// Compare to the path and name.
|
|
hr = CompareToIdentifier(id, pResult);
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPolicy::CompareToIPolicy"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString(hr), WsbPtrToShortAsString(pResult));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::CompareToIdentifier(
|
|
IN GUID id,
|
|
OUT SHORT* pResult
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::CompareToIdentifier().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SHORT aResult = 0;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::CompareToIdentifier"), OLESTR("id = <%ls>"), WsbGuidAsString(id));
|
|
|
|
try {
|
|
|
|
// Compare the guids.
|
|
aResult = WsbSign( memcmp(&m_id, &id, sizeof(GUID)) );
|
|
|
|
if (0 != aResult) {
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
if (0 != pResult) {
|
|
*pResult = aResult;
|
|
}
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPolicy::CompareToIdentifier"), OLESTR("hr = <%ls>, result = <%d>"), WsbHrAsString(hr), aResult);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::EnumRules(
|
|
OUT IWsbEnum** ppEnum
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::EnumRules().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != ppEnum, E_POINTER);
|
|
WsbAffirmHr(m_pRules->Enum(ppEnum));
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::FinalConstruct(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
CComObjectRoot::FinalConstruct().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAffirmHr(CWsbObject::FinalConstruct());
|
|
|
|
m_scale = 1000;
|
|
m_usesDefaultRules = FALSE;
|
|
|
|
//Create the criteria collection.
|
|
WsbAffirmHr(CoCreateInstance(CLSID_CWsbOrderedCollection, NULL, CLSCTX_ALL, IID_IWsbCollection, (void**) &m_pRules));
|
|
|
|
// Each instance should have its own unique identifier.
|
|
WsbAffirmHr(CoCreateGuid(&m_id));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::GetAction(
|
|
OUT IHsmAction** ppAction
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::GetAction().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != ppAction, E_POINTER);
|
|
*ppAction = m_pAction;
|
|
m_pAction.p->AddRef();
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::GetClassID(
|
|
OUT CLSID* pClsid
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersist::GetClassID().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::GetClassID"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pClsid, E_POINTER);
|
|
*pClsid = CLSID_CHsmPolicy;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPolicy::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsid));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::GetIdentifier(
|
|
OUT GUID* pId
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::GetIdentifier().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != pId, E_POINTER);
|
|
*pId = m_id;
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::GetName(
|
|
OUT OLECHAR** pName,
|
|
IN ULONG bufferSize
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::GetName().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != pName, E_POINTER);
|
|
WsbAffirmHr(m_name.CopyTo(pName, bufferSize));
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::GetScale(
|
|
OUT USHORT* pScale
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::GetScale().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
WsbAssert(0 != pScale, E_POINTER);
|
|
*pScale = m_scale;
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::GetSizeMax(
|
|
OUT ULARGE_INTEGER* pSize
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::GetSizeMax().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IPersistStream> pPersistStream;
|
|
ULARGE_INTEGER entrySize;
|
|
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::GetSizeMax"), OLESTR(""));
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != pSize, E_POINTER);
|
|
|
|
// Determine the size for a rule with no criteria.
|
|
pSize->QuadPart = WsbPersistSize((wcslen(m_name) + 1) * sizeof(OLECHAR)) + WsbPersistSizeOf(GUID) + WsbPersistSizeOf(USHORT) + 2 * WsbPersistSizeOf(BOOL);
|
|
|
|
// If there is an action, how big is it?
|
|
if (m_pAction != 0) {
|
|
WsbAffirmHr(m_pAction->QueryInterface(IID_IPersistStream, (void**) &pPersistStream));
|
|
WsbAffirmHr(pPersistStream->GetSizeMax(&entrySize));
|
|
pSize->QuadPart += entrySize.QuadPart;
|
|
pPersistStream = 0;
|
|
}
|
|
|
|
// Now allocate space for the rules (assume they are all the
|
|
// same size).
|
|
WsbAffirmHr(m_pRules->QueryInterface(IID_IPersistStream, (void**) &pPersistStream));
|
|
WsbAffirmHr(pPersistStream->GetSizeMax(&entrySize));
|
|
pSize->QuadPart += entrySize.QuadPart;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPolicy::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pSize));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::Load(
|
|
IN IStream* pStream
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Load().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IPersistStream> pPersistStream;
|
|
BOOL hasAction;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::Load"), OLESTR(""));
|
|
|
|
try {
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
// Do the easy stuff, but make sure that this order matches the order
|
|
// in the save method.
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_id));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_name, 0));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_scale));
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &m_usesDefaultRules));
|
|
|
|
// Is there an action?
|
|
WsbAffirmHr(WsbLoadFromStream(pStream, &hasAction));
|
|
if (hasAction) {
|
|
WsbAffirmHr(OleLoadFromStream(pStream, IID_IHsmAction, (void**) &m_pAction));
|
|
}
|
|
|
|
WsbAffirmHr(m_pRules->QueryInterface(IID_IPersistStream, (void**) &pPersistStream));
|
|
WsbAffirmHr(pPersistStream->Load(pStream));
|
|
|
|
} WsbCatch(hr);
|
|
|
|
WsbTraceOut(OLESTR("CHsmPolicy::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::Rules(
|
|
OUT IWsbCollection** ppRules
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::Rules().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != ppRules, E_POINTER);
|
|
*ppRules = m_pRules;
|
|
m_pRules.p->AddRef();
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::Save(
|
|
IN IStream* pStream,
|
|
IN BOOL clearDirty
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IPersistStream::Save().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
CComPtr<IWsbEnum> pEnum;
|
|
CComPtr<IPersistStream> pPersistStream;
|
|
BOOL hasAction = FALSE;
|
|
|
|
WsbTraceIn(OLESTR("CHsmPolicy::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
|
|
|
|
try {
|
|
WsbAssert(0 != pStream, E_POINTER);
|
|
|
|
// Do the easy stuff, but make sure that this order matches the order
|
|
// in the save method.
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_id));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_name));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_scale));
|
|
WsbAffirmHr(WsbSaveToStream(pStream, m_usesDefaultRules));
|
|
|
|
// Is there an action?
|
|
if (m_pAction != 0) {
|
|
hasAction = TRUE;
|
|
WsbAffirmHr(WsbSaveToStream(pStream, hasAction));
|
|
WsbAffirmHr(m_pAction->QueryInterface(IID_IPersistStream, (void**) &pPersistStream));
|
|
WsbAffirmHr(OleSaveToStream(pPersistStream, pStream));
|
|
pPersistStream = 0;
|
|
} else {
|
|
hasAction = FALSE;
|
|
WsbAffirmHr(WsbSaveToStream(pStream, hasAction));
|
|
}
|
|
|
|
WsbAffirmHr(m_pRules->QueryInterface(IID_IPersistStream, (void**) &pPersistStream));
|
|
WsbAffirmHr(pPersistStream->Save(pStream, clearDirty));
|
|
|
|
// The loop should terminate with a not found error.
|
|
WsbAffirm(hr == WSB_E_NOTFOUND, hr);
|
|
hr = S_OK;
|
|
|
|
// 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("CHsmPolicy::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::SetAction(
|
|
IN IHsmAction* pAction
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::SetAction().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
m_pAction = pAction;
|
|
m_isDirty = TRUE;
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::SetName(
|
|
IN OLECHAR* name
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::SetName().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
m_name = name;
|
|
m_isDirty = TRUE;
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::SetScale(
|
|
IN USHORT scale
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::SetScale().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
m_scale = scale;
|
|
m_isDirty = TRUE;
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::SetUsesDefaultRules(
|
|
IN BOOL usesDefaultRules
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::SetUsesDefaultRules().
|
|
|
|
--*/
|
|
{
|
|
m_usesDefaultRules = usesDefaultRules;
|
|
m_isDirty = TRUE;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::Test(
|
|
USHORT* passed,
|
|
USHORT* failed
|
|
)
|
|
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IWsbTestable::Test().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
try {
|
|
|
|
WsbAssert(0 != passed, E_POINTER);
|
|
WsbAssert(0 != failed, E_POINTER);
|
|
|
|
*passed = 0;
|
|
*failed = 0;
|
|
|
|
} WsbCatch(hr);
|
|
|
|
return(hr);
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CHsmPolicy::UsesDefaultRules(
|
|
void
|
|
)
|
|
/*++
|
|
|
|
Implements:
|
|
|
|
IHsmPolicy::UsesDefaultRules().
|
|
|
|
--*/
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!m_usesDefaultRules) {
|
|
hr = S_FALSE;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|