|
|
// expire.cpp : Implementation of CnntpadmApp and DLL registration.
#include "stdafx.h"
#include "nntpcmn.h"
#include "expire.h"
#include "oleutil.h"
#include "nntptype.h"
#include "nntpapi.h"
#include <lmapibuf.h>
// Must define THIS_FILE_* macros to use NntpCreateException()
#define THIS_FILE_HELP_CONTEXT 0
#define THIS_FILE_PROG_ID _T("Nntpadm.Expiration.1")
#define THIS_FILE_IID IID_INntpAdminExpiration
/////////////////////////////////////////////////////////////////////////////
//
//
// Use a macro to define all the default methods
//
DECLARE_METHOD_IMPLEMENTATION_FOR_STANDARD_EXTENSION_INTERFACES(NntpAdminExpiration, CNntpAdminExpiration, IID_INntpAdminExpiration)
STDMETHODIMP CNntpAdminExpiration::InterfaceSupportsErrorInfo(REFIID riid) { static const IID* arr[] = { &IID_INntpAdminExpiration, };
for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++) { if (InlineIsEqualGUID(*arr[i],riid)) return S_OK; } return S_FALSE; }
CNntpAdminExpiration::CNntpAdminExpiration () : m_fEnumerated ( FALSE ), m_bvChangedFields ( 0 ), m_cCount ( 0 ), m_rgExpires ( NULL ) // CComBSTR's are initialized to NULL by default.
{ InitAsyncTrace ( );
m_iadsImpl.SetService ( MD_SERVICE_NAME ); m_iadsImpl.SetName ( _T("Expires") ); m_iadsImpl.SetClass ( _T("IIsNntpExpires") ); }
CNntpAdminExpiration::~CNntpAdminExpiration () { // All CComBSTR's are freed automatically.
if ( m_rgExpires ) { delete [] m_rgExpires;
m_rgExpires = NULL; }
TermAsyncTrace ( ); }
//
// IADs methods:
//
DECLARE_SIMPLE_IADS_IMPLEMENTATION(CNntpAdminExpiration,m_iadsImpl)
//////////////////////////////////////////////////////////////////////
// Properties:
//////////////////////////////////////////////////////////////////////
// Enumeration Properties:
STDMETHODIMP CNntpAdminExpiration::get_Count ( long * plCount ) { return StdPropertyGet ( m_cCount, plCount ); }
// Cursor Expire Properties:
STDMETHODIMP CNntpAdminExpiration::get_ExpireId ( long * plId ) { return StdPropertyGet ( m_expireCurrent.m_dwExpireId, plId ); }
STDMETHODIMP CNntpAdminExpiration::put_ExpireId ( long lId ) { return StdPropertyPut ( &m_expireCurrent.m_dwExpireId, lId, &m_bvChangedFields, CHNG_EXPIRE_ID ); }
STDMETHODIMP CNntpAdminExpiration::get_PolicyName ( BSTR * pstrPolicyName ) { return StdPropertyGet ( m_expireCurrent.m_strPolicyName, pstrPolicyName ); }
STDMETHODIMP CNntpAdminExpiration::put_PolicyName ( BSTR strPolicyName ) { return StdPropertyPut ( &m_expireCurrent.m_strPolicyName, strPolicyName, &m_bvChangedFields, CHNG_EXPIRE_POLICY_NAME ); }
STDMETHODIMP CNntpAdminExpiration::get_ExpireTime ( long * plExpireTime ) { return StdPropertyGet ( m_expireCurrent.m_dwTime, plExpireTime ); }
STDMETHODIMP CNntpAdminExpiration::put_ExpireTime ( long lExpireTime ) { return StdPropertyPut ( &m_expireCurrent.m_dwTime, lExpireTime, &m_bvChangedFields, CHNG_EXPIRE_TIME ); }
STDMETHODIMP CNntpAdminExpiration::get_ExpireSize ( long * plExpireSize ) { return StdPropertyGet ( m_expireCurrent.m_dwSize, plExpireSize ); }
STDMETHODIMP CNntpAdminExpiration::put_ExpireSize ( long lExpireSize ) { return StdPropertyPut ( &m_expireCurrent.m_dwSize, lExpireSize, &m_bvChangedFields, CHNG_EXPIRE_SIZE ); }
STDMETHODIMP CNntpAdminExpiration::get_Newsgroups ( SAFEARRAY ** ppsastrNewsgroups ) { return StdPropertyGet ( &m_expireCurrent.m_mszNewsgroups, ppsastrNewsgroups ); }
STDMETHODIMP CNntpAdminExpiration::put_Newsgroups ( SAFEARRAY * psastrNewsgroups ) { return StdPropertyPut ( &m_expireCurrent.m_mszNewsgroups, psastrNewsgroups, &m_bvChangedFields, CHNG_EXPIRE_NEWSGROUPS ); }
STDMETHODIMP CNntpAdminExpiration::get_NewsgroupsVariant ( SAFEARRAY ** ppsavarNewsgroups ) { HRESULT hr; SAFEARRAY * psastrNewsgroups = NULL;
hr = get_Newsgroups ( &psastrNewsgroups ); if ( FAILED(hr) ) { goto Exit; }
hr = StringArrayToVariantArray ( psastrNewsgroups, ppsavarNewsgroups );
Exit: if ( psastrNewsgroups ) { SafeArrayDestroy ( psastrNewsgroups ); }
return hr; }
STDMETHODIMP CNntpAdminExpiration::put_NewsgroupsVariant ( SAFEARRAY * psavarNewsgroups ) { HRESULT hr; SAFEARRAY * psastrNewsgroups = NULL;
hr = VariantArrayToStringArray ( psavarNewsgroups, &psastrNewsgroups ); if ( FAILED(hr) ) { goto Exit; }
hr = put_Newsgroups ( psastrNewsgroups );
Exit: if ( psastrNewsgroups ) { SafeArrayDestroy ( psastrNewsgroups ); }
return hr; }
//////////////////////////////////////////////////////////////////////
// Methods:
//////////////////////////////////////////////////////////////////////
STDMETHODIMP CNntpAdminExpiration::Default ( ) { TraceFunctEnter ( "CNntpAdminExpiration::Default" ); HRESULT hr = NOERROR;
m_expireCurrent.m_dwSize = DEFAULT_EXPIRE_SIZE; m_expireCurrent.m_dwTime = DEFAULT_EXPIRE_TIME; m_expireCurrent.m_mszNewsgroups = DEFAULT_EXPIRE_NEWSGROUPS;
m_bvChangedFields = (DWORD) -1;
if ( !m_expireCurrent.CheckValid() ) { BAIL_WITH_FAILURE(hr, E_OUTOFMEMORY); }
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Enumerate ( ) { TraceFunctEnter ( "CNntpAdminExpiration::Enumerate" );
HRESULT hr = NOERROR; DWORD dwError = NOERROR; DWORD cExpires = 0; LPNNTP_EXPIRE_INFO pExpireInfo = NULL; CExpirationPolicy * rgNewExpires = NULL; DWORD i;
dwError = NntpEnumerateExpires ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance(), &cExpires, &pExpireInfo ); if ( dwError != 0 ) { ErrorTrace ( (LPARAM) this, "Error enumerating Expires: %x", dwError ); hr = RETURNCODETOHRESULT ( dwError ); goto Exit; }
// Empty the old Expire list:
m_fEnumerated = FALSE;
if ( m_rgExpires ) { delete [] m_rgExpires; m_rgExpires = NULL; } m_cCount = 0;
// Attempt to copy the Expire list into our structures:
if ( cExpires > 0 ) { rgNewExpires = new CExpirationPolicy [ cExpires ]; for ( i = 0; i < cExpires; i++ ) { rgNewExpires[i].FromExpireInfo ( &pExpireInfo[i] );
if ( !rgNewExpires[i].CheckValid () ) { hr = E_OUTOFMEMORY; goto Exit; } } }
m_fEnumerated = TRUE; m_rgExpires = rgNewExpires; m_cCount = cExpires;
Exit: if ( FAILED(hr) ) { delete [] rgNewExpires; }
if ( pExpireInfo ) { ::NetApiBufferFree ( pExpireInfo ); }
TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::GetNth ( long lIndex ) { TraceFunctEnter ( "CNntpAdminExpiration::GetNth" );
HRESULT hr = NOERROR;
// Did we enumerate first?
if ( m_rgExpires == NULL ) { TraceFunctLeave (); return NntpCreateException ( IDS_NNTPEXCEPTION_DIDNT_ENUMERATE ); } // Is the index valid?
if ( lIndex < 0 || (DWORD) lIndex >= m_cCount ) { TraceFunctLeave (); return NntpCreateException ( IDS_NNTPEXCEPTION_INVALID_INDEX ); }
//
// Copy the properties from m_rgExpires [ lIndex ] to member variables:
//
_ASSERT ( lIndex >= 0 ); _ASSERT ( (DWORD) lIndex < m_cCount ); _ASSERT ( m_rgExpires != NULL );
m_expireCurrent = m_rgExpires[ (DWORD) lIndex ];
// Check to make sure the strings were copied okay:
if ( !m_expireCurrent.CheckValid() ) { return E_OUTOFMEMORY; }
_ASSERT ( m_expireCurrent.CheckValid() );
// ( CComBSTR handles free-ing of old properties )
TraceFunctLeave (); return NOERROR; }
STDMETHODIMP CNntpAdminExpiration::FindID ( long lID, long * plIndex ) { TraceFunctEnter ( "CNntpAdminExpiration::FindID" );
HRESULT hr = NOERROR;
// Assume that we can't find it:
*plIndex = IndexFromID ( lID );
TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Add ( ) { TraceFunctEnter ( "CNntpAdminExpiration::Add" );
HRESULT hr = NOERROR; CExpirationPolicy * rgNewExpireArray = NULL; DWORD cNewCount = m_cCount + 1; DWORD i;
hr = m_expireCurrent.Add ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); BAIL_ON_FAILURE(hr);
// Add the new Expire to our current Expire list:
_ASSERT ( IndexFromID ( m_expireCurrent.m_dwExpireId ) == (DWORD) -1 );
// Allocate the new array:
_ASSERT ( cNewCount == m_cCount + 1 );
rgNewExpireArray = new CExpirationPolicy [ cNewCount ]; if ( rgNewExpireArray == NULL ) { FatalTrace ( (LPARAM) this, "Out of memory" );
hr = E_OUTOFMEMORY; goto Exit; }
// Copy the old array into the new one:
for ( i = 0; i < m_cCount; i++ ) { rgNewExpireArray[i] = m_rgExpires[i]; }
// Add the new element:
rgNewExpireArray[cNewCount - 1] = m_expireCurrent;
// Check to make sure everything was allocated okay:
for ( i = 0; i < cNewCount; i++ ) { if ( !rgNewExpireArray[i].CheckValid() ) { FatalTrace ( (LPARAM) this, "Out of memory" );
hr = E_OUTOFMEMORY; goto Exit; } }
// Replace the old array with the new one:
delete [] m_rgExpires; m_rgExpires = rgNewExpireArray; m_cCount = cNewCount;
Exit: if ( FAILED(hr) ) { delete [] rgNewExpireArray; }
TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Set ( ) { TraceFunctEnter ( "CNntpAdminExpiration::Set" );
HRESULT hr = NOERROR; DWORD index;
hr = m_expireCurrent.Set ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); if ( FAILED(hr) ) { goto Exit; }
index = IndexFromID ( m_expireCurrent.m_dwExpireId ); if ( index == (DWORD) -1 ) { ErrorTraceX ( (LPARAM) this, "Couldn't find Expire with ID: %d", m_expireCurrent.m_dwExpireId ); // This is okay, since we succeeded in setting the current Expire already.
goto Exit; }
// Set the current Expire in the current Expire list:
m_rgExpires[index] = m_expireCurrent;
if ( !m_rgExpires[index].CheckValid () ) { FatalTrace ( (LPARAM) this, "Out of memory" );
hr = E_OUTOFMEMORY; goto Exit; }
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Remove ( long lID ) { TraceFunctEnter ( "CNntpAdminExpiration::Remove" );
HRESULT hr = NOERROR; DWORD index;
index = IndexFromID ( lID ); if ( index == (DWORD) -1 ) { ErrorTraceX ( (LPARAM) this, "Couldn't find Expire with ID: %d", lID ); hr = NntpCreateException ( IDS_NNTPEXCEPTION_INVALID_INDEX ); goto Exit; }
hr = m_rgExpires[index].Remove ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); if ( FAILED(hr) ) { goto Exit; }
// Slide the array down by one position:
_ASSERT ( m_rgExpires );
DWORD cPositionsToSlide;
cPositionsToSlide = (m_cCount - 1) - index;
_ASSERT ( cPositionsToSlide < m_cCount );
if ( cPositionsToSlide > 0 ) { CExpirationPolicy temp; // Save the deleted binding in temp:
CopyMemory ( &temp, &m_rgExpires[index], sizeof ( CExpirationPolicy ) );
// Move the array down one:
MoveMemory ( &m_rgExpires[index], &m_rgExpires[index + 1], sizeof ( CExpirationPolicy ) * cPositionsToSlide );
// Put the deleted binding on the end (so it gets destructed):
CopyMemory ( &m_rgExpires[m_cCount - 1], &temp, sizeof ( CExpirationPolicy ) );
// Zero out the temp binding:
ZeroMemory ( &temp, sizeof ( CExpirationPolicy ) ); }
m_cCount--;
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
long CNntpAdminExpiration::IndexFromID ( long dwExpireId ) { TraceFunctEnter ( "CNntpAdminExpiration::IndexFromID" );
DWORD i;
if ( m_rgExpires == NULL ) { return -1; }
_ASSERT ( !IsBadReadPtr ( m_rgExpires, sizeof ( CExpirationPolicy ) * m_cCount ) );
for ( i = 0; i < m_cCount; i++ ) { _ASSERT ( m_rgExpires[i].m_dwExpireId != 0 );
if ( (DWORD) dwExpireId == m_rgExpires[i].m_dwExpireId ) { TraceFunctLeave (); return i; } }
TraceFunctLeave (); return (DWORD) -1; }
//
// Use RPCs instead of direct metabase calls:
//
#if 0
STDMETHODIMP CNntpAdminExpiration::Enumerate ( ) { TraceFunctEnter ( "CNntpadminExpiration::Enumerate" );
HRESULT hr = NOERROR; CComPtr<IMSAdminBase> pMetabase;
// Reset our last enumeration:
delete [] m_rgExpires; m_rgExpires = NULL; m_cCount = 0; m_fEnumerated = FALSE;
// Get the metabase pointer:
hr = m_mbFactory.GetMetabaseObject ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); if ( FAILED(hr) ) { goto Exit; }
// Enumerate the policies:
hr = EnumerateMetabaseExpirationPolicies ( pMetabase ); if ( FAILED(hr) ) { goto Exit; }
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::GetNth ( DWORD lIndex ) { HRESULT hr = NOERROR;
// Did we enumerate first?
if ( m_rgExpires == NULL ) { return NntpCreateException ( IDS_NNTPEXCEPTION_DIDNT_ENUMERATE ); } // Is the index valid?
if ( lIndex < 0 || (DWORD) lIndex >= m_cCount ) { return NntpCreateException ( IDS_NNTPEXCEPTION_INVALID_INDEX ); }
//
// Copy the properties from m_rgExpires [ lIndex ] to member variables:
//
_ASSERT ( lIndex >= 0 ); _ASSERT ( (DWORD) lIndex < m_cCount ); _ASSERT ( m_rgExpires != NULL );
m_expireCurrent = m_rgExpires[ (DWORD) lIndex ];
// Check to make sure the strings were copied okay:
if ( !m_expireCurrent.CheckValid() ) { return E_OUTOFMEMORY; }
m_bvChangedFields = 0;
_ASSERT ( m_expireCurrent.CheckValid() );
// ( CComBSTR handles free-ing of old properties )
return NOERROR; }
STDMETHODIMP CNntpAdminExpiration::FindID ( DWORD lID, DWORD * plIndex ) { TraceFunctEnter ( "CNntpAdminExpiration::FindID" );
HRESULT hr = NOERROR; DWORD i;
_ASSERT ( IS_VALID_OUT_PARAM ( plIndex ) );
*plIndex = IndexFromID ( lID );
TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Add ( ) { TraceFunctEnter ( "CNntpAdminExpiration::Add" ); HRESULT hr = NOERROR; CComPtr<IMSAdminBase> pMetabase;
// Get the metabase pointer:
hr = m_mbFactory.GetMetabaseObject ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); if ( FAILED(hr) ) { goto Exit; }
hr = AddPolicyToMetabase ( pMetabase ); if ( FAILED(hr) ) { goto Exit; }
m_bvChangedFields = 0; hr = AddPolicyToArray ( ); if ( FAILED(hr) ) { goto Exit; }
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Set ( BOOL fFailIfChanged) { TraceFunctEnter ( "CNntpadminExpiration::Enumerate" );
HRESULT hr = NOERROR; CComPtr<IMSAdminBase> pMetabase;
// Get the metabase pointer:
hr = m_mbFactory.GetMetabaseObject ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); if ( FAILED(hr) ) { goto Exit; }
// Set the policy:
hr = SetPolicyToMetabase ( pMetabase ); if ( FAILED(hr) ) { goto Exit; } m_bvChangedFields = 0; hr = SetPolicyToArray ( ); if ( FAILED(hr) ) { goto Exit; }
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
STDMETHODIMP CNntpAdminExpiration::Remove ( DWORD lID) { TraceFunctEnter ( "CNntpadminExpiration::Remove" );
HRESULT hr = NOERROR; CComPtr<IMSAdminBase> pMetabase; DWORD index;
// Find the index of the policy to remove:
index = IndexFromID ( lID );
if ( index == (DWORD) -1 ) { hr = RETURNCODETOHRESULT ( ERROR_INVALID_PARAMETER ); goto Exit; }
// Get the metabase pointer:
hr = m_mbFactory.GetMetabaseObject ( m_iadsImpl.QueryComputer(), m_iadsImpl.QueryInstance() ); if ( FAILED(hr) ) { goto Exit; }
// Remove the current policy:
hr = RemovePolicyFromMetabase ( pMetabase, index ); if ( FAILED(hr) ) { goto Exit; }
hr = RemovePolicyFromArray ( index ); if ( FAILED(hr) ) { goto Exit; }
Exit: TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::EnumerateMetabaseExpirationPolicies ( IMSAdminBase * pMetabase) { TraceFunctEnter ( "CNE::EnumerateMetabaseExpirationPolicies" );
_ASSERT ( pMetabase );
HRESULT hr = NOERROR; char szExpirationPath[ METADATA_MAX_NAME_LEN ]; METADATA_HANDLE hExpiration = NULL; CMetabaseKey mkeyExpiration ( pMetabase ); DWORD cExpires; DWORD i;
_ASSERT ( m_dwServiceInstance != 0 );
hr = CreateSubkeyOfInstanceKey ( pMetabase, NNTP_MD_ROOT_PATH, m_dwServiceInstance, NNTP_MD_EXPIRES_PATH, &hExpiration );
if ( FAILED(hr) ) { goto Exit; }
mkeyExpiration.Attach ( hExpiration );
// Count the items under the /LM/NntpSvc/Expires/ key:
hr = mkeyExpiration.GetCustomChildCount ( IsKeyValidExpire, &cExpires ); if ( FAILED (hr) ) { goto Exit; }
if ( cExpires != 0 ) { // Allocate the expiration policy array:
m_rgExpires = new CExpirationPolicy [ cExpires ];
mkeyExpiration.BeginChildEnumeration ();
for ( i = 0; i < cExpires; i++ ) { char szName[ METADATA_MAX_NAME_LEN ]; DWORD dwID;
hr = mkeyExpiration.NextCustomChild ( IsKeyValidExpire, szName ); _ASSERT ( SUCCEEDED(hr) );
hr = m_rgExpires[i].GetFromMetabase ( &mkeyExpiration, szName ); if ( FAILED (hr) ) { goto Exit; } } }
m_cCount = cExpires; m_fEnumerated = TRUE;
_ASSERT ( SUCCEEDED(hr) );
Exit: if ( FAILED(hr) ) { delete [] m_rgExpires; m_rgExpires = NULL; m_cCount = 0; m_fEnumerated = FALSE; }
TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::AddPolicyToMetabase ( IMSAdminBase * pMetabase) { TraceFunctEnter ( "CNE::AddPolicyToMetabase" );
_ASSERT ( pMetabase );
HRESULT hr = NOERROR; char szExpirationPath [ METADATA_MAX_NAME_LEN ]; METADATA_HANDLE hExpiration = NULL; CMetabaseKey mkeyExpiration ( pMetabase ); char szNewId [ METADATA_MAX_NAME_LEN ]; DWORD dwNewId;
if ( !m_expireCurrent.CheckPolicyProperties ( ) ) { hr = RETURNCODETOHRESULT ( ERROR_INVALID_PARAMETER ); goto Exit; }
hr = CreateSubkeyOfInstanceKey ( pMetabase, NNTP_MD_ROOT_PATH, m_dwServiceInstance, NNTP_MD_EXPIRES_PATH, &hExpiration, METADATA_PERMISSION_WRITE ); if ( FAILED(hr) ) { goto Exit; }
mkeyExpiration.Attach ( hExpiration );
hr = m_expireCurrent.AddToMetabase ( &mkeyExpiration ); if ( FAILED(hr) ) { goto Exit; }
_ASSERT ( SUCCEEDED(hr) ); hr = pMetabase->SaveData ( ); if ( FAILED(hr) ) { goto Exit; }
Exit: TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::AddPolicyToArray ( ) { TraceFunctEnter ( "CNE::AddPolicyToArray" );
HRESULT hr = NOERROR; CExpirationPolicy * rgNewPolicyArray = NULL; DWORD i;
// Adjust the expiration policy array:
rgNewPolicyArray = new CExpirationPolicy [ m_cCount + 1 ];
if ( rgNewPolicyArray == NULL ) { hr = E_OUTOFMEMORY; goto Exit; }
// Copy the old entries:
for ( i = 0; i < m_cCount; i++ ) { _ASSERT ( m_rgExpires[i].CheckValid() ); rgNewPolicyArray[i] = m_rgExpires[i];
if ( !rgNewPolicyArray[i].CheckValid() ) { hr = E_OUTOFMEMORY; goto Exit; } }
// Add the new entry:
_ASSERT ( m_expireCurrent.CheckValid() ); rgNewPolicyArray[m_cCount] = m_expireCurrent; if ( !rgNewPolicyArray[m_cCount].CheckValid() ) { hr = E_OUTOFMEMORY; goto Exit; }
_ASSERT ( SUCCEEDED(hr) ); delete [] m_rgExpires; m_rgExpires = rgNewPolicyArray; m_cCount++;
Exit: if ( FAILED(hr) ) { delete [] rgNewPolicyArray; }
TRACE_HRESULT(hr); TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::SetPolicyToMetabase ( IMSAdminBase * pMetabase) { TraceFunctEnter ( "CNE::SetPolicyToMetabase" );
_ASSERT ( pMetabase );
HRESULT hr = NOERROR; CMetabaseKey mkeyExpiration ( pMetabase ); char szExpirationPath [ METADATA_MAX_NAME_LEN ];
if ( !m_expireCurrent.CheckPolicyProperties ( ) ) { hr = RETURNCODETOHRESULT ( ERROR_INVALID_PARAMETER ); goto Exit; }
GetMDExpirationPath ( szExpirationPath, m_dwServiceInstance );
hr = mkeyExpiration.Open ( szExpirationPath, METADATA_PERMISSION_WRITE ); if ( FAILED(hr) ) { goto Exit; }
_ASSERT ( m_expireCurrent.m_dwExpireId != 0 );
hr = m_expireCurrent.SendToMetabase ( &mkeyExpiration, m_bvChangedFields ); if ( FAILED(hr) ) { goto Exit; }
hr = pMetabase->SaveData ( ); if ( FAILED(hr) ) { goto Exit; }
Exit: TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::SetPolicyToArray ( ) { TraceFunctEnter ( "CNE::SetPolicyToArray" );
HRESULT hr = NOERROR;
// Find the index of the current ID:
DWORD i; BOOL fFound = FALSE; DWORD index;
index = IndexFromID ( m_expireCurrent.m_dwExpireId ); if ( index == (DWORD) -1 ) { // Couldn't find an id that matched, but the policy was successfully
// set. Just ignore:
goto Exit; }
_ASSERT ( index >= 0 && index < m_cCount );
m_rgExpires[index] = m_expireCurrent; if ( !m_rgExpires[index].CheckValid() ) { FatalTrace ( (LPARAM) this, "Out of memory" ); hr = E_OUTOFMEMORY; goto Exit; }
Exit: TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::RemovePolicyFromMetabase ( IMSAdminBase * pMetabase, DWORD index) { TraceFunctEnter ( "CNE::RemovePolicyFromMetabase" );
_ASSERT ( pMetabase );
HRESULT hr = NOERROR; CMetabaseKey mkeyExpiration ( pMetabase ); char szExpirationPath [ METADATA_MAX_NAME_LEN ]; char szID [ METADATA_MAX_NAME_LEN ];
GetMDExpirationPath ( szExpirationPath, m_dwServiceInstance );
hr = mkeyExpiration.Open ( szExpirationPath, METADATA_PERMISSION_WRITE ); if ( FAILED(hr) ) { goto Exit; }
_ASSERT ( index >= 0 && index < m_cCount );
wsprintfA ( szID, "expire%ud", m_rgExpires[index].m_dwExpireId );
hr = mkeyExpiration.DestroyChild ( szID ); if ( FAILED(hr) ) { goto Exit; }
_ASSERT ( SUCCEEDED(hr) );
hr = pMetabase->SaveData ( ); if ( FAILED(hr) ) { goto Exit; }
Exit: TraceFunctLeave (); return hr; }
HRESULT CNntpAdminExpiration::RemovePolicyFromArray ( DWORD index ) { TraceFunctEnter ( "CNE::RemovePolicyFromArray" );
HRESULT hr = NOERROR; CExpirationPolicy * rgNewExpireArray = NULL; DWORD i;
// !!!magnush - Should I just do a memmove and slide the entries
// down, and zero out the last entry?
_ASSERT ( index >= 0 && index < m_cCount );
// Adjust the Expiration policy array:
if ( m_cCount > 1 ) { // Allocate a new expiration policy array:
rgNewExpireArray = new CExpirationPolicy [ m_cCount - 1 ];
// Copy the items from 0 .. (current index) to the new list:
for ( i = 0; i < index; i++ ) { _ASSERT ( m_rgExpires[i].CheckValid() );
rgNewExpireArray[i] = m_rgExpires[i];
if ( !rgNewExpireArray[i].CheckValid() ) { hr = E_OUTOFMEMORY; goto Exit; } }
// Copy the items from (current index + 1) .. m_cCount to the new list:
for ( i = index + 1; i < m_cCount; i++ ) { _ASSERT ( m_rgExpires[i].CheckValid() );
rgNewExpireArray[i - 1] = m_rgExpires[i];
if ( !rgNewExpireArray[i - 1].CheckValid() ) { hr = E_OUTOFMEMORY; goto Exit; } } }
_ASSERT ( SUCCEEDED(hr) );
// Replace the old expiration list with the new one:
delete [] m_rgExpires; m_rgExpires = rgNewExpireArray; m_cCount--;
Exit: if ( FAILED (hr) ) { delete [] rgNewExpireArray; }
TraceFunctLeave (); return hr; }
long CNntpAdminExpiration::IndexFromID ( long dwID ) { TraceFunctEnter ( "CNE::IndexFromID" );
DWORD i;
if ( m_rgExpires == NULL ) {
DebugTrace ( (LPARAM) this, "Expire array is NULL" ); TraceFunctLeave ();
return (DWORD) -1; }
_ASSERT ( !IsBadReadPtr ( m_rgExpires, sizeof ( CExpirationPolicy ) * m_cCount ) );
for ( i = 0; i < m_cCount; i++ ) { if ( m_rgExpires[i].m_dwExpireId == dwID ) {
DebugTraceX ( (LPARAM) this, "Found ID: %d, index = ", dwID, i ); TraceFunctLeave ();
return i; } }
DebugTraceX ( (LPARAM) this, "Failed to find ID: %d", dwID ); TraceFunctLeave (); return (DWORD) -1; }
#endif
|