1334 lines
42 KiB
C++
1334 lines
42 KiB
C++
|
|
// Copyright (c) 1996-1999 Microsoft Corporation
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// File: quota.cxx
|
|
//
|
|
// Contents: quota table
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// Notes: This table is hidden in the volume table
|
|
//
|
|
// History: 18-Nov-97 WeiruC Created.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include "trksvr.hxx"
|
|
#include <commctrl.h>
|
|
#include <time.h>
|
|
|
|
CQuotaTable::CQuotaTable(CDbConnection& dbc) :
|
|
_dbc(dbc),
|
|
#if DBG
|
|
_cLocks(0),
|
|
#endif
|
|
_mcid(MCID_LOCAL),
|
|
_cftCacheLastUpdated(0),
|
|
_cftDesignatedDc(0),
|
|
_pvoltab(NULL)
|
|
{
|
|
_fIsDesignatedDc = FALSE;
|
|
_fInitializeCalled = FALSE;
|
|
_fStopping = FALSE;
|
|
_dwMoveLimit = 0;
|
|
|
|
_lCachedMoveTableCount = _lCachedVolumeTableCount = 0;
|
|
|
|
}
|
|
|
|
CQuotaTable::~CQuotaTable()
|
|
{
|
|
UnInitialize();
|
|
}
|
|
|
|
void
|
|
CQuotaTable::Initialize(CVolumeTable *pvoltab,
|
|
CIntraDomainTable *pidt,
|
|
CTrkSvrSvc *psvrsvc,
|
|
CTrkSvrConfiguration *pcfgsvr )
|
|
{
|
|
CMachineId mcid;
|
|
HRESULT hr;
|
|
|
|
_cs.Initialize();
|
|
#if DBG
|
|
_cLocks = 0;
|
|
#endif
|
|
|
|
_fInitializeCalled = TRUE;
|
|
|
|
_pvoltab = pvoltab;
|
|
_pcfgsvr = pcfgsvr;
|
|
_pidt = pidt;
|
|
_psvrsvc = psvrsvc;
|
|
|
|
_timer.Initialize(this,
|
|
TEXT("NextDcSyncTime"), // Name (this is a persistent timer)
|
|
QUOTA_TIMER, // Context ID
|
|
_pcfgsvr->GetDcUpdateCounterPeriod(), // Period
|
|
CNewTimer::NO_RETRY,
|
|
0, 0, 0 ); // Ignored for non-retrying timers
|
|
_timer.SetRecurring();
|
|
TrkLog(( TRKDBG_VOLUME, TEXT("DC sync timer: %s"),
|
|
(const TCHAR*) CDebugString(_timer) ));
|
|
|
|
|
|
// The Reset* routines assume that an entry already exists for
|
|
// this DC. If the operation fails because the entry doesn't exist, it
|
|
// will add the entry. We ignore any error because if we can't add
|
|
// the entry it only means that we are not participating in the race
|
|
// for the designated DC.
|
|
}
|
|
|
|
void
|
|
CQuotaTable::UnInitialize()
|
|
{
|
|
if(_fInitializeCalled)
|
|
{
|
|
_timer.UnInitialize();
|
|
_lCachedMoveTableCount = 0;
|
|
_lCachedVolumeTableCount = 0;
|
|
_cftCacheLastUpdated = CFILETIME(0);
|
|
_cs.UnInitialize();
|
|
_fInitializeCalled = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::Timer
|
|
//
|
|
// This method is called when _timer fires. If we're the designated
|
|
// DC, we'll go through the move table and count the uncounted entries,
|
|
// delete the deleted entries, and shorten any moves chains.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
PTimerCallback::TimerContinuation
|
|
CQuotaTable::Timer(ULONG ulTimer)
|
|
{
|
|
DWORD dwTrueCount = 0;
|
|
|
|
Lock();
|
|
|
|
__try
|
|
{
|
|
TrkLog((TRKDBG_QUOTA, TEXT("DC synchronization time")));
|
|
g_ptrksvr->RaiseIfStopped();
|
|
|
|
TrkAssert( QUOTA_TIMER == ulTimer );
|
|
|
|
if( QUOTA_TIMER == ulTimer )
|
|
{
|
|
if( IsDesignatedDc() )
|
|
{
|
|
GetTrueCount( &dwTrueCount, BACKGROUND );
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Updated counter")));
|
|
_psvrsvc->_OperationLog.Add( COperationLog::TRKSVR_QUOTA, S_OK, CMachineId(MCID_INVALID), dwTrueCount );
|
|
}
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
// This timer fires often enough that we'll just
|
|
// wait until it fires again.
|
|
TrkLog(( TRKDBG_WARNING,
|
|
TEXT("Ignoring exception in CQuotaTable::Timer (%08x)"),
|
|
GetExceptionCode() ));
|
|
_psvrsvc->_OperationLog.Add( COperationLog::TRKSVR_QUOTA, GetExceptionCode() );
|
|
}
|
|
Unlock();
|
|
|
|
TrkAssert( _timer.IsRecurring() );
|
|
return( CONTINUE_TIMER );
|
|
}
|
|
|
|
BOOL
|
|
CQuotaTable::IsMoveQuotaExceeded()
|
|
{
|
|
BOOL fExceeded = TRUE;
|
|
|
|
Lock();
|
|
|
|
__try
|
|
{
|
|
ValidateCache();
|
|
|
|
// Compare the cached counter with the limit. The cached value should
|
|
// never be negative. But if for some reason it is, don't get confused by it
|
|
// (i.e. bottom it out at zero). The cached value will get automatically
|
|
// corrected when the cache gets refreshed.
|
|
|
|
if( (DWORD) max(0,_lCachedMoveTableCount) < _dwMoveLimit )
|
|
{
|
|
fExceeded = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// Try to force the cache to be updated
|
|
ValidateCache( TRUE );
|
|
if( (DWORD) max(0,_lCachedMoveTableCount) < _dwMoveLimit)
|
|
{
|
|
fExceeded = FALSE;
|
|
}
|
|
}
|
|
|
|
if(fExceeded)
|
|
{
|
|
TrkLog((TRKDBG_QUOTA, TEXT("*** Move table quota exceeded (%li/%lu)"), _lCachedMoveTableCount, _dwMoveLimit ));
|
|
}
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Move quota not exceeded (%li/%lu)"), _lCachedMoveTableCount, _dwMoveLimit ));
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return fExceeded;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::IsVolumeQuotaExceeded
|
|
//
|
|
// See if this machine is at or over its quota (it can go over in a replicated
|
|
// environment). The total number of
|
|
// volumes it has is the count of DS entries for the machine, plus
|
|
// cUncountedVolumes. cUncountedVolumes is non-zero when a machine
|
|
// sends up a request to create multiple volumes, and increments
|
|
// as the service iterates through the requests.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CQuotaTable::IsVolumeQuotaExceeded( const CMachineId& mcid, ULONG cUncountedVolumes )
|
|
{
|
|
Lock();
|
|
|
|
__try
|
|
{
|
|
// How many entries does this machine have in the DS?
|
|
ULONG cVolumes = _pvoltab->CountVolumes(mcid);
|
|
|
|
// Is it at/over quota?
|
|
if( cVolumes + cUncountedVolumes >= _pcfgsvr->GetVolumeLimit() )
|
|
{
|
|
TrkLog((TRKDBG_QUOTA, TEXT("VOLUME QUOTA EXCEEDED for %s (%d+%d)"),
|
|
(const TCHAR*) CDebugString(mcid),
|
|
cVolumes, cUncountedVolumes ));
|
|
return TRUE;
|
|
}
|
|
else
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Volume quota not exceeded for %s (%d+%d, %d)"),
|
|
(const TCHAR*) CDebugString(mcid),
|
|
cVolumes, cUncountedVolumes, _pcfgsvr->GetVolumeLimit() ));
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// ReadAttribute
|
|
//
|
|
// Given an LDAP pointer, a DN, and an attribute name, read the attribute
|
|
// for the entry with that DN.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
int
|
|
ReadAttribute( LDAP* pldap, const TCHAR *ptszDN, const TCHAR *ptszAttributeName,
|
|
TCHAR ***ppptszAttributeValue )
|
|
{
|
|
int ldapRV = 0;
|
|
const TCHAR *rgptszAttrs[] = { ptszAttributeName, NULL };
|
|
int cEntries = 0;
|
|
LDAPMessage *pRes = NULL;
|
|
LDAPMessage *pEntry = NULL;
|
|
|
|
__try
|
|
{
|
|
ldapRV = ldap_search_s(pldap,
|
|
const_cast<TCHAR*>(ptszDN),
|
|
LDAP_SCOPE_BASE,
|
|
TEXT("(ObjectClass=*)"),
|
|
const_cast<TCHAR**>(rgptszAttrs),
|
|
0,
|
|
&pRes);
|
|
if( LDAP_SUCCESS != ldapRV )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't find %s (%lu)"), ptszDN, ldapRV ));
|
|
__leave;
|
|
}
|
|
|
|
cEntries = ldap_count_entries(pldap, pRes);
|
|
if( cEntries < 1 )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("No entries returned for %s in %s"), ptszAttributeName, ptszDN ));
|
|
ldapRV = LDAP_NO_SUCH_OBJECT;
|
|
__leave;
|
|
}
|
|
|
|
pEntry = ldap_first_entry(pldap, pRes);
|
|
if(NULL == pEntry)
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Entries couldn't be read from result for %s"), ptszDN ));
|
|
ldapRV = LDAP_NO_SUCH_OBJECT;
|
|
__leave;
|
|
}
|
|
|
|
*ppptszAttributeValue = ldap_get_values(pldap, pEntry, const_cast<TCHAR*>(ptszAttributeName) );
|
|
if( NULL == *ppptszAttributeValue )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't find %s in %s"), ptszAttributeName, ptszDN ));
|
|
ldapRV = LDAP_NO_SUCH_OBJECT;
|
|
__leave;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if(NULL != pRes)
|
|
{
|
|
ldap_msgfree(pRes);
|
|
}
|
|
}
|
|
|
|
return( ldapRV );
|
|
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::IsDesignatedDc
|
|
//
|
|
// Determine if this machine is the designated DC. (The designated DC is
|
|
// responsible for all modifications to link tracking data in the DS that
|
|
// requires a single master). The "RID Master" DC is used as the designated
|
|
// DC.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CQuotaTable::IsDesignatedDc( BOOL fRaiseOnError )
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
BOOL fDesignatedDc = FALSE;
|
|
HRESULT hr = E_FAIL;
|
|
int ldapRV = 0;
|
|
int cEntries = 0;
|
|
TCHAR **pptszRidManagerReference = NULL;
|
|
TCHAR **pptszRoleOwner = NULL;
|
|
const TCHAR *rgtszAttrs[] = { s_rIDManagerReference, NULL };
|
|
TCHAR *ptszDesignatedDC = NULL, *ptszAfterDesignatedDC = NULL;
|
|
CMachineId mcidDesignated, mcidLocal(MCID_LOCAL);
|
|
CFILETIME cftNow;
|
|
LONGLONG llDelta;
|
|
|
|
// How old (in seconds) is the _fIsDesignatedDc value?
|
|
|
|
llDelta = (LONGLONG) cftNow - (LONGLONG) _cftDesignatedDc;
|
|
llDelta /= 10000000;
|
|
if( llDelta < _pcfgsvr->GetDesignatedDcCacheTTL() )
|
|
{
|
|
// The cached value is young enough.
|
|
//TrkLog(( TRKDBG_QUOTA, TEXT("Cache: %s designated DC"),
|
|
// _fIsDesignatedDc ? TEXT("is") : TEXT("isn't") ));
|
|
return( _fIsDesignatedDc );
|
|
}
|
|
// The cached value is too old. Recalculate.
|
|
|
|
__try
|
|
{
|
|
// Read the "rIDManagerReference" from the root DC=<domain> object.
|
|
|
|
ldapRV = ReadAttribute(Ldap(), GetBaseDn(), s_rIDManagerReference, &pptszRidManagerReference );
|
|
|
|
if( LDAP_SUCCESS != ldapRV )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( LdapMapErrorToWin32(ldapRV) );
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't get RID manager reference (%lu)"), ldapRV ));
|
|
__leave;
|
|
}
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("RID manager reference: %s"), *pptszRidManagerReference ));
|
|
|
|
// The value of the rIDManagerReference is a DN. Read the "fSMORoleOwner" attribute
|
|
// from that object.
|
|
|
|
ldapRV = ReadAttribute( Ldap(), *pptszRidManagerReference, s_fSMORoleOwner, &pptszRoleOwner );
|
|
if( LDAP_SUCCESS != ldapRV )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( LdapMapErrorToWin32(ldapRV) );
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't get RID role owner (%lu)"), ldapRV ));
|
|
__leave;
|
|
}
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Role owner: %s"), *pptszRoleOwner ));
|
|
|
|
|
|
// The role owner is of the form
|
|
// "CN=NTDS Settings,CN=mikehill4,CN=Servers,CN=Default-FirstSite-Name,CN=Sites,CN=Configuration,DC=trkmikehill,DC=nttest,DC=microsoft,DC=com"
|
|
// Pull out the DC's machine name by getting the second "CN=".
|
|
|
|
ptszDesignatedDC = _tcsstr( *pptszRoleOwner, TEXT("CN=") );
|
|
if( NULL == ptszDesignatedDC )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( LdapMapErrorToWin32(LDAP_NO_SUCH_OBJECT) );
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't find first component of FSMO role owner") ));
|
|
__leave;
|
|
}
|
|
|
|
ptszDesignatedDC = _tcsstr( &ptszDesignatedDC[1], TEXT("CN=") );
|
|
if( NULL == ptszDesignatedDC )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( LdapMapErrorToWin32(LDAP_NO_SUCH_OBJECT) );
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't find second component of FSMO role owner") ));
|
|
__leave;
|
|
}
|
|
|
|
ptszDesignatedDC += 3;
|
|
ptszAfterDesignatedDC = _tcsstr( ptszDesignatedDC, TEXT(",CN=") );
|
|
if( NULL == ptszAfterDesignatedDC )
|
|
{
|
|
hr = HRESULT_FROM_WIN32( LdapMapErrorToWin32(LDAP_NO_SUCH_OBJECT) );
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't find third component of FSMO role owner") ));
|
|
__leave;
|
|
}
|
|
*ptszAfterDesignatedDC = TEXT('\0');
|
|
|
|
// Are we the same (and therefore the designated) DC?
|
|
|
|
mcidDesignated = CMachineId(ptszDesignatedDC );
|
|
if( mcidDesignated == mcidLocal )
|
|
fDesignatedDc = TRUE;
|
|
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Designated DC is %s %s"), ptszDesignatedDC,
|
|
fDesignatedDc ? TEXT("(this DC)") : TEXT("") ));
|
|
|
|
_fIsDesignatedDc = fDesignatedDc;
|
|
_cftDesignatedDc = cftNow;
|
|
|
|
fSuccess = TRUE;
|
|
}
|
|
__finally
|
|
{
|
|
if( NULL != pptszRidManagerReference )
|
|
ldap_value_free( pptszRidManagerReference );
|
|
|
|
if( NULL != pptszRoleOwner )
|
|
ldap_value_free( pptszRoleOwner );
|
|
}
|
|
|
|
if( !fSuccess && fRaiseOnError )
|
|
TrkRaiseException( hr );
|
|
|
|
return( fDesignatedDc );
|
|
}
|
|
|
|
// Returns TRUE if successful, FALSE if entry doesn't exist, raise exception
|
|
// otherwise.
|
|
BOOL
|
|
CQuotaTable::ReadCounter(DWORD* pdwCounter)
|
|
{
|
|
BOOL fSuccess = FALSE;
|
|
struct berval** ppbvCounter = NULL;
|
|
TCHAR* rgtszAttrs[2];
|
|
LDAPMessage* pRes = NULL;
|
|
int ldapRV;
|
|
int cEntries = 0;
|
|
LDAPMessage* pEntry = NULL;
|
|
CLdapQuotaCounterKeyDn dnKeyCounter(GetBaseDn());
|
|
|
|
__try
|
|
{
|
|
*pdwCounter = 0;
|
|
rgtszAttrs[0] = const_cast<TCHAR*>(s_volumeSecret);
|
|
rgtszAttrs[1] = NULL;
|
|
ldapRV = ldap_search_s(Ldap(),
|
|
dnKeyCounter,
|
|
LDAP_SCOPE_BASE,
|
|
TEXT("(ObjectClass=*)"),
|
|
rgtszAttrs,
|
|
0,
|
|
&pRes);
|
|
if( LDAP_NO_SUCH_OBJECT == ldapRV )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Move table counter doesn't exist") ));
|
|
__leave;
|
|
}
|
|
else if( LDAP_SUCCESS != ldapRV )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Couldn't read move table counter (%d)"), ldapRV ));
|
|
__leave;
|
|
}
|
|
|
|
cEntries = ldap_count_entries(Ldap(), pRes);
|
|
if( cEntries != 1 )
|
|
{
|
|
// This should never happen, the counter has an explicit name.
|
|
// We'll assume that when the designated DC does a WriteCounter, this
|
|
// will be fixed.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Too many move table counters!") ));
|
|
__leave;
|
|
}
|
|
|
|
pEntry = ldap_first_entry(Ldap(), pRes);
|
|
if(NULL == pEntry)
|
|
{
|
|
// This should also never happen, we already know the entry count for
|
|
// this search result is 1. Again assume that when the designated DC does
|
|
// a WriteCounter, this will be fixed.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Entries couldn't be read from result") ));
|
|
__leave;
|
|
}
|
|
|
|
ppbvCounter = ldap_get_values_len(Ldap(), pEntry, const_cast<TCHAR*>(s_volumeSecret) );
|
|
if (ppbvCounter == NULL)
|
|
{
|
|
// The designated DC will fix this in WriteCounter.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Move table counter is corrupt, missing %s attribute"),
|
|
s_volumeSecret ));
|
|
__leave;
|
|
}
|
|
|
|
if ((*ppbvCounter)->bv_len < sizeof(DWORD))
|
|
{
|
|
// The designated DC will fix this in WriteCounter
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Move table counter attribute %s has wrong type (%d)"),
|
|
s_volumeSecret, (*ppbvCounter)->bv_len ));
|
|
__leave;
|
|
}
|
|
|
|
memcpy( (PCHAR)pdwCounter, (*ppbvCounter)->bv_val, sizeof(DWORD) );
|
|
fSuccess = TRUE;
|
|
}
|
|
__finally
|
|
{
|
|
if(NULL != pRes)
|
|
{
|
|
ldap_msgfree(pRes);
|
|
}
|
|
if (ppbvCounter != NULL)
|
|
{
|
|
ldap_value_free_len(ppbvCounter);
|
|
}
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::GetTrueCount
|
|
//
|
|
// Update our cached count of the move table entries. If we're the designated
|
|
// DC, this will also clean up the move table: count uncounted entries, delete
|
|
// deleted entries, and shorten any move chains.
|
|
//
|
|
// This routine can be called to run in the background or foreground. In the
|
|
// background it does periodic sleeps so that we don't use up the CPU.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CQuotaTable::GetTrueCount( DWORD* pdwTrueCount,
|
|
EBackgroundForegroundTask eBackgroundForegroundTask )
|
|
{
|
|
CLdapIdtKeyDn dnKey(GetBaseDn());
|
|
int ldapRV;
|
|
TCHAR* rgptszAttrs[3];
|
|
TCHAR ldapSearchFilter[256];
|
|
DWORD dwCounter = 0;
|
|
BOOL fDoWriteCounter = FALSE;
|
|
BOOL fNoExistingCounter = FALSE;
|
|
TRUE_COUNT_ENUM_CONTEXT Context;
|
|
|
|
__try
|
|
{
|
|
// Read the current counter.
|
|
|
|
if( !ReadCounter( &dwCounter ) )
|
|
{
|
|
// There is no counter. We'll enumerate everything.
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Getting move table count") ));
|
|
|
|
_tcscpy( ldapSearchFilter, TEXT("(ObjectClass=*)") );
|
|
fDoWriteCounter = TRUE;
|
|
Context.fCountAll = TRUE;
|
|
fNoExistingCounter = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Only enumerate the uncounted and/or deleted entries.
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Getting delta move table count") ));
|
|
|
|
_tcscpy(ldapSearchFilter, TEXT("("));
|
|
_tcscat(ldapSearchFilter, s_oMTIndxGuid);
|
|
_tcscat(ldapSearchFilter, TEXT("=*"));
|
|
_tcscat(ldapSearchFilter, TEXT(")"));
|
|
Context.fCountAll = FALSE;
|
|
}
|
|
|
|
rgptszAttrs[0] = const_cast<TCHAR*>(s_currentLocation);
|
|
rgptszAttrs[1] = const_cast<TCHAR*>(s_birthLocation);
|
|
rgptszAttrs[2] = NULL;
|
|
|
|
|
|
Context.cDelta = 0;
|
|
Context.dwRepetitiveTaskDelay = (BACKGROUND == eBackgroundForegroundTask)
|
|
? _pcfgsvr->GetRepetitiveTaskDelay()
|
|
: 0;
|
|
Context.dwPass = Context.FIRST_PASS;
|
|
|
|
// Enumerate the move table, subject to the search filter determined
|
|
// above.
|
|
|
|
if( !LdapEnumerate( Ldap(),
|
|
dnKey,
|
|
LDAP_SCOPE_ONELEVEL,
|
|
ldapSearchFilter,
|
|
rgptszAttrs,
|
|
MoveTableEnumCallback,
|
|
&Context,
|
|
this) )
|
|
{
|
|
TrkRaiseException(TRK_E_SERVICE_STOPPING);
|
|
}
|
|
|
|
// If we're the designated DC, we need to do a second pass.
|
|
// The first pass may have done some string shortening,
|
|
// and in the process marked some entries for delete. We need to
|
|
// go through now and remove those entries.
|
|
|
|
if( IsDesignatedDc() )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Getting delta move table count (pass 2)") ));
|
|
Context.dwPass = Context.SECOND_PASS;
|
|
|
|
// We only need to count the delta this time
|
|
|
|
_tcscpy(ldapSearchFilter, TEXT("("));
|
|
_tcscat(ldapSearchFilter, s_oMTIndxGuid);
|
|
_tcscat(ldapSearchFilter, TEXT("=*"));
|
|
_tcscat(ldapSearchFilter, TEXT(")"));
|
|
Context.fCountAll = FALSE;
|
|
|
|
if( !LdapEnumerate( Ldap(),
|
|
dnKey,
|
|
LDAP_SCOPE_ONELEVEL,
|
|
ldapSearchFilter,
|
|
rgptszAttrs,
|
|
MoveTableEnumCallback,
|
|
&Context,
|
|
this) )
|
|
{
|
|
TrkRaiseException(TRK_E_SERVICE_STOPPING);
|
|
}
|
|
}
|
|
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Uncounted entries ---- %d"), Context.cDelta));
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Counter ---- %d"), dwCounter));
|
|
}
|
|
__finally
|
|
{
|
|
if( Context.cDelta != 0 )
|
|
fDoWriteCounter = TRUE;
|
|
|
|
*pdwTrueCount = max( 0, (LONG)dwCounter + Context.cDelta );
|
|
|
|
// If we're the designated DC, we may need to write the counter.
|
|
// But only do so if this is a normal termination, or if there
|
|
// wasn't already a counter. This covers the three cases:
|
|
//
|
|
// 1) The counter didn't already exist, so we were enumerating everything.
|
|
// a) Normal termination, so we should update the counter
|
|
// with the newly calculated value.
|
|
// b) Abnormal termination, so we shouldn't update the counter.
|
|
// That way we'll know to do the count again later.
|
|
//
|
|
// 2) The counter already existed, so we were counting the uncounted
|
|
// entries. In this case, the entries were being updated to
|
|
// be counted as we went through the enumeration. So whether
|
|
// or not we had a normal termination, we need to updated the
|
|
// counter with what we did so far.
|
|
//
|
|
// The only reason we expect an exception is in the case of a
|
|
// service stop.
|
|
|
|
if( IsDesignatedDc()
|
|
&&
|
|
fDoWriteCounter
|
|
&&
|
|
( !AbnormalTermination() || !fNoExistingCounter ) )
|
|
{
|
|
WriteCounter(*pdwTrueCount);
|
|
}
|
|
|
|
TrkLog((TRKDBG_QUOTA, TEXT("True count ---- %d"), *pdwTrueCount));
|
|
}
|
|
}
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::OnMoveTableGcComplete
|
|
//
|
|
// This method is called after a GC of the move table, telling us how
|
|
// many entries were deleted. We use this to update the move counter
|
|
// (if it still exists).
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CQuotaTable::OnMoveTableGcComplete( ULONG cEntriesDeleted )
|
|
{
|
|
DWORD dwCounter = 0;
|
|
|
|
if( 0 == cEntriesDeleted )
|
|
return;
|
|
|
|
if( ReadCounter( &dwCounter ) )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Old move counter was %d"), dwCounter ));
|
|
|
|
if( dwCounter >= cEntriesDeleted )
|
|
dwCounter -= cEntriesDeleted;
|
|
else
|
|
dwCounter = 0;
|
|
|
|
WriteCounter(dwCounter);
|
|
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("New move counter is %d"), dwCounter ));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void
|
|
CQuotaTable::WriteCounter(DWORD dwCounter)
|
|
{
|
|
LDAPMod* mods[3];
|
|
int ldapRV;
|
|
CLdapQuotaCounterKeyDn dnKeyCounter(GetBaseDn());
|
|
|
|
CLdapBinaryMod lbmCounter(s_volumeSecret, (PCHAR)&dwCounter, sizeof(DWORD), LDAP_MOD_REPLACE);
|
|
mods[0] = &lbmCounter._mod;
|
|
mods[1] = NULL;
|
|
ldapRV = ldap_modify_s(Ldap(), dnKeyCounter, mods);
|
|
if( LDAP_SUCCESS != ldapRV )
|
|
{
|
|
if( LDAP_NO_SUCH_OBJECT != ldapRV )
|
|
{
|
|
// There's some kind of problem with the existing counter.
|
|
// Delete and re-create it.
|
|
ldap_delete_s( Ldap(), dnKeyCounter );
|
|
}
|
|
|
|
CLdapStringMod lsmClass(s_objectClass, s_linkTrackVolEntry, LDAP_MOD_ADD);
|
|
CLdapBinaryMod lbmCounter(s_volumeSecret, (PCHAR)&dwCounter, sizeof(DWORD), LDAP_MOD_ADD);
|
|
mods[0] = &lsmClass._mod;
|
|
mods[1] = &lbmCounter._mod;
|
|
mods[2] = NULL;
|
|
|
|
ldapRV = ldap_add_s(Ldap(), dnKeyCounter, mods);
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Created counter %d, ldap returned %d"), dwCounter, ldapRV ));
|
|
}
|
|
else
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Wrote counter %d, ldap returned %d"), dwCounter, ldapRV));
|
|
}
|
|
|
|
HRESULT
|
|
CQuotaTable::DeleteCounter()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
int LdapError = 0;
|
|
CLdapQuotaCounterKeyDn dnKeyCounter(GetBaseDn());
|
|
|
|
LdapError = ldap_delete_s(Ldap(), dnKeyCounter);
|
|
if( LDAP_SUCCESS == LdapError )
|
|
hr = S_OK;
|
|
else
|
|
hr = HRESULT_FROM_WIN32( LdapMapErrorToWin32(LdapError) );
|
|
|
|
if( FAILED(hr) )
|
|
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't delete move-table counter (%08x)"), hr ));
|
|
else
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Deleted move-table counter") ));
|
|
|
|
return( hr );
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::ValidateCache
|
|
//
|
|
// Validate the cached move and volume counts. They are valid if they exist
|
|
// and are newer than the max time-to-live. If they aren't valid, they are
|
|
// re-calculated. They are also recalculated if the caller sets the
|
|
// fForceHint parameter, and the cache is at least of minimum age.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
void
|
|
CQuotaTable::ValidateCache( BOOL fForceHint )
|
|
{
|
|
// How old is the cache in seconds?
|
|
DWORD dwDelta = ( (LONGLONG)CFILETIME() - (LONGLONG)_cftCacheLastUpdated ) / 10000000;
|
|
|
|
// The cache should be updated if any of the following are true
|
|
|
|
if( 0 == _cftCacheLastUpdated // We have no cached values
|
|
||
|
|
dwDelta > _pcfgsvr->GetCacheMaxTimeToLive() // The cached values are too old
|
|
||
|
|
// The cached values are old enough, and the
|
|
// the caller wants us to be aggressive.
|
|
fForceHint && (dwDelta > _pcfgsvr->GetCacheMinTimeToLive()) )
|
|
{
|
|
// Yes, we need to update the cached values.
|
|
|
|
CLdapVolumeKeyDn dnKey(GetBaseDn());
|
|
TCHAR* rgptszAttrs[2];
|
|
DWORD cVolumeTableEntries = 0;
|
|
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Updating quota caches (%s)"),
|
|
fForceHint ? TEXT("forced") : TEXT("not forced") ));
|
|
|
|
// Get the true count of move table entries.
|
|
GetTrueCount( (DWORD*) &_lCachedMoveTableCount, FOREGROUND );
|
|
TrkAssert( _lCachedMoveTableCount >= 0 );
|
|
|
|
// Get the count of volume table entries
|
|
|
|
rgptszAttrs[0] = const_cast<TCHAR*>(s_Cn);
|
|
rgptszAttrs[1] = NULL;
|
|
|
|
if( !LdapEnumerate( Ldap(),
|
|
dnKey,
|
|
LDAP_SCOPE_ONELEVEL,
|
|
TEXT("(&(ObjectClass=*)(!(cn=QT*)))"),
|
|
rgptszAttrs,
|
|
VolumeTableEnumCallback,
|
|
&cVolumeTableEntries,
|
|
this) )
|
|
{
|
|
TrkRaiseException( TRK_E_SERVICE_STOPPING );
|
|
}
|
|
_lCachedVolumeTableCount = (LONG) cVolumeTableEntries;
|
|
|
|
// Calculate the move table limit
|
|
_dwMoveLimit = CalculateMoveLimit();
|
|
|
|
|
|
// Show that the cache is up-to-date
|
|
_cftCacheLastUpdated.SetToUTC();
|
|
}
|
|
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Cache: MoveCount=%d, MoveLimit=%d, VolCount=%d"),
|
|
_lCachedMoveTableCount, _dwMoveLimit, _lCachedVolumeTableCount ));
|
|
|
|
}
|
|
|
|
|
|
DWORD
|
|
CQuotaTable::CalculateMoveLimit() // Doesn't raise
|
|
{
|
|
DWORD dwMoveLimit = 0;
|
|
LONG lVolumeCount = max( 0, _lCachedVolumeTableCount );
|
|
|
|
if( lVolumeCount <= _pcfgsvr->GetMoveLimitTransition() )
|
|
dwMoveLimit = lVolumeCount * _pcfgsvr->GetMoveLimitPerVolumeLower();
|
|
else
|
|
{
|
|
dwMoveLimit = _pcfgsvr->GetMoveLimitTransition()
|
|
*
|
|
_pcfgsvr->GetMoveLimitPerVolumeLower();
|
|
|
|
dwMoveLimit += ( lVolumeCount - _pcfgsvr->GetMoveLimitTransition() )
|
|
*
|
|
_pcfgsvr->GetMoveLimitPerVolumeUpper();
|
|
}
|
|
|
|
|
|
return( dwMoveLimit );
|
|
}
|
|
|
|
|
|
HRESULT
|
|
CQuotaTable::ReadFlags(LDAP* pLdap, TCHAR* dnKey, BYTE* bFlags)
|
|
{
|
|
struct berval** ppbvFlags = NULL;
|
|
TCHAR* rgptszAttrs[2];
|
|
LDAPMessage* pRes = NULL;
|
|
int ldapRV;
|
|
int cEntries;
|
|
LDAPMessage* pEntry = NULL;
|
|
HRESULT hr = S_OK;
|
|
|
|
__try
|
|
{
|
|
*bFlags = 0x0;
|
|
rgptszAttrs[0] = const_cast<TCHAR*>(s_oMTIndxGuid);
|
|
rgptszAttrs[1] = NULL;
|
|
ldapRV = ldap_search_s(pLdap,
|
|
dnKey,
|
|
LDAP_SCOPE_BASE,
|
|
TEXT("(ObjectClass=*)"),
|
|
rgptszAttrs,
|
|
0,
|
|
&pRes);
|
|
hr = HRESULT_FROM_WIN32(LdapMapErrorToWin32(ldapRV));
|
|
if(ldapRV != LDAP_SUCCESS)
|
|
__leave;
|
|
|
|
cEntries = ldap_count_entries(pLdap, pRes);
|
|
if(cEntries != 1)
|
|
{
|
|
// This shouldn't happen. The caller asked for flags on an entry
|
|
// which doesn't exist.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("ReadFlags, entry doesn't exist: %s"), dnKey ));
|
|
hr = HRESULT_FROM_WIN32(LdapMapErrorToWin32(LDAP_NO_SUCH_OBJECT));
|
|
__leave;
|
|
}
|
|
|
|
pEntry = ldap_first_entry(pLdap, pRes);
|
|
if(NULL == pEntry)
|
|
{
|
|
// This should never happen. We already know that there's an entry.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("ReadFlags, couldn't get first entry on %s"), dnKey ));
|
|
hr = HRESULT_FROM_WIN32(LdapMapErrorToWin32(LDAP_NO_SUCH_OBJECT));
|
|
__leave;
|
|
}
|
|
|
|
ppbvFlags = ldap_get_values_len(pLdap, pEntry, const_cast<TCHAR*>(s_oMTIndxGuid) );
|
|
if(NULL == ppbvFlags)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(LdapMapErrorToWin32(LDAP_NO_SUCH_ATTRIBUTE));
|
|
__leave;
|
|
}
|
|
|
|
if( (*ppbvFlags)->bv_len < sizeof(BYTE)
|
|
||
|
|
((*ppbvFlags)->bv_val == NULL) )
|
|
{
|
|
// The best we can do is pretend the attribute doesn't exist.
|
|
TrkLog(( TRKDBG_ERROR, TEXT("ReadFlags, attribute is wrong type or missing (%d/%p)"),
|
|
(*ppbvFlags)->bv_len, (*ppbvFlags)->bv_val ));
|
|
hr = HRESULT_FROM_WIN32(LdapMapErrorToWin32(LDAP_NO_SUCH_ATTRIBUTE));
|
|
__leave;
|
|
}
|
|
|
|
*bFlags = *(BYTE*)(*ppbvFlags)->bv_val;
|
|
hr = S_OK;
|
|
}
|
|
__finally
|
|
{
|
|
if(pRes != NULL)
|
|
{
|
|
ldap_msgfree(pRes);
|
|
}
|
|
if(ppbvFlags != NULL)
|
|
{
|
|
ldap_value_free_len(ppbvFlags);
|
|
}
|
|
}
|
|
|
|
|
|
return hr;
|
|
}
|
|
|
|
void
|
|
CQuotaTable::DeleteFlags(LDAP* pLdap, TCHAR* dnKey)
|
|
{
|
|
BYTE bFlags = 0x0;
|
|
int err;
|
|
|
|
Lock();
|
|
|
|
__try
|
|
{
|
|
CLdapBinaryMod lbm(s_oMTIndxGuid, NULL, 0, LDAP_MOD_DELETE );//reinterpret_cast<PCCH>(&bFlags), sizeof(BYTE), LDAP_MOD_DELETE);
|
|
LDAPMod* mods[2];
|
|
|
|
mods[0] = &lbm._mod;
|
|
mods[1] = NULL;
|
|
|
|
err = ldap_modify_s(pLdap, dnKey, mods);
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Deleted flag %x on entry %s, ldap returned %d"), bFlags, dnKey, err));
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
}
|
|
|
|
|
|
// TRUE => Found, FALSE => Not found, Raise otherwise
|
|
BOOL
|
|
CQuotaTable::UpdateFlags(LDAP* pLdap, TCHAR* dnKey, BYTE bFlags)
|
|
{
|
|
BOOL fFound = FALSE;
|
|
BYTE bOrigFlags;
|
|
HRESULT hr;
|
|
LDAPMod* mods[2];
|
|
int err;
|
|
|
|
TrkAssert(!(bFlags & QFLAG_UNCOUNTED && bFlags & QFLAG_DELETED));
|
|
|
|
Lock();
|
|
|
|
__try
|
|
{
|
|
hr = ReadFlags(pLdap, dnKey, &bOrigFlags);
|
|
if(hr == (HRESULT) HRESULT_FROM_WIN32(LdapMapErrorToWin32(LDAP_NO_SUCH_ATTRIBUTE)))
|
|
{
|
|
CLdapBinaryMod lbm(s_oMTIndxGuid, reinterpret_cast<PCCH>(&bFlags), sizeof(BYTE), LDAP_MOD_ADD);
|
|
|
|
mods[0] = &lbm._mod;
|
|
mods[1] = NULL;
|
|
|
|
err = ldap_modify_s(pLdap, dnKey, mods);
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Added flag %01x on entry %s, ldap returned %d"), bFlags, dnKey, err));
|
|
}
|
|
else if(hr == S_OK)
|
|
{
|
|
if(bOrigFlags == QFLAG_UNCOUNTED && bFlags == QFLAG_DELETED)
|
|
{
|
|
bOrigFlags = bOrigFlags | bFlags;
|
|
CLdapBinaryMod lbm(s_oMTIndxGuid, reinterpret_cast<PCCH>(&bOrigFlags), sizeof(BYTE), LDAP_MOD_REPLACE);
|
|
mods[0] = &lbm._mod;
|
|
mods[1] = NULL;
|
|
err = ldap_modify_s(pLdap, dnKey, mods);
|
|
TrkLog((TRKDBG_QUOTA, TEXT("Updated flag to %01x on entry %s, ldap returned %d"), bOrigFlags, dnKey, err));
|
|
}
|
|
else if(bOrigFlags == QFLAG_DELETED && bFlags == QFLAG_UNCOUNTED)
|
|
{
|
|
DeleteFlags(pLdap, dnKey);
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
__leave;
|
|
}
|
|
|
|
fFound = TRUE;
|
|
}
|
|
__finally
|
|
{
|
|
Unlock();
|
|
}
|
|
|
|
|
|
return( fFound );
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::DeleteOrphanedEntries
|
|
//
|
|
// This routine is given a list of move table entries. The birth entry has
|
|
// been updated by the caller to point to the final entry. As a result, all
|
|
// the other entries are orphaned and must be deleted.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CQuotaTable::DeleteOrphanedEntries( const CDomainRelativeObjId rgdroidList[], ULONG cSegments,
|
|
const CDomainRelativeObjId &droidBirth,
|
|
const CDomainRelativeObjId &droidCurrent )
|
|
{
|
|
BOOL fCurrentNeedsToBeDeleted = FALSE;
|
|
|
|
for( int j=0; j < cSegments; j++ )
|
|
{
|
|
// Don't do anything if this is the birth entry
|
|
|
|
if( rgdroidList[j] != droidBirth )
|
|
{
|
|
// If this is the current entry we don't delete it, but tell the
|
|
// caller about it.
|
|
if( rgdroidList[j] == droidCurrent )
|
|
{
|
|
fCurrentNeedsToBeDeleted = TRUE;
|
|
}
|
|
|
|
// Otherwise, we delete it directly
|
|
else if( _pidt->Delete( rgdroidList[j] ) )
|
|
{
|
|
TrkLog((TRKDBG_QUOTA,
|
|
TEXT("Orphaned segment deleted %s"),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(rgdroidList[j])) ));
|
|
}
|
|
else
|
|
{
|
|
TrkLog((TRKDBG_QUOTA|TRKDBG_WARNING,
|
|
TEXT("Orphaned segment failed to delete %s"),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(rgdroidList[j])) ));
|
|
}
|
|
}
|
|
}
|
|
|
|
return( fCurrentNeedsToBeDeleted );
|
|
}
|
|
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::ShortenString
|
|
//
|
|
// Given an entry in the move table, see if it is part of a string that
|
|
// needs to be shortened, and if so do the shortening.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
CQuotaTable::ShortenString( LDAP* pLdap, LDAPMessage* pMessage, BYTE *pbFlags,
|
|
const CDomainRelativeObjId &droidCurrent )
|
|
{
|
|
|
|
CDomainRelativeObjId droidBirth;
|
|
CDomainRelativeObjId droidScan;
|
|
CDomainRelativeObjId droidNext;
|
|
CDomainRelativeObjId rgdroidList[MAX_SHORTENABLE_SEGMENTS];
|
|
int cSegments = 0;
|
|
TCHAR *ptszCurrentCN = NULL;
|
|
|
|
__try
|
|
{
|
|
// Attempt to read the entry and get its birth ID.
|
|
|
|
if( _pidt->Query( pLdap, pMessage, droidCurrent, &droidNext, &droidBirth ) )
|
|
{
|
|
// We have a successful read.
|
|
|
|
BOOL fStringDeleted = FALSE;
|
|
|
|
// Scan forward from that birth to see if we can find multiple entries.
|
|
|
|
droidScan = droidBirth;
|
|
_psvrsvc->Scan( NULL, NULL, droidBirth,
|
|
rgdroidList, ELEMENTS(rgdroidList), &cSegments,
|
|
&droidScan, &fStringDeleted );
|
|
|
|
// If this is a multi-segment string, reduce it to a single segment.
|
|
|
|
if( cSegments > 1 )
|
|
{
|
|
// Was the last segment of the string deleted?
|
|
if( fStringDeleted )
|
|
{
|
|
// Yes, that means that the entired string has been deleted.
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Deleting string starting at %s"),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidBirth)) ));
|
|
|
|
if( droidCurrent == droidBirth )
|
|
*pbFlags |= QFLAG_DELETED;
|
|
else
|
|
_pidt->Delete( droidBirth );
|
|
}
|
|
|
|
// Otherwise, map from the birth to the last droid.
|
|
else if( !_pidt->Modify( droidBirth, droidScan, droidBirth ))
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA|TRKDBG_WARNING, TEXT("Couldn't shorten %s -> %s"),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidBirth)),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidScan)) ));
|
|
__leave;
|
|
}
|
|
else
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Shortened %s -> %s [%s]"),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidBirth)),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidScan)),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidBirth)) ));
|
|
}
|
|
|
|
// The birth entry has been shortened, or deleted. So we can delete the
|
|
// rest of the entries.
|
|
|
|
if( DeleteOrphanedEntries( rgdroidList, cSegments,
|
|
droidBirth, // Don't delete this one
|
|
droidCurrent // Or this one
|
|
))
|
|
{
|
|
// Amongst the orphans in need of a delete is the current
|
|
// entry. Set the deleted flag, and the caller will take
|
|
// care of removing the entry.
|
|
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Current is orphaned and will be deleted") ));
|
|
*pbFlags |= QFLAG_DELETED;
|
|
}
|
|
|
|
} // if( cSegments > 1 )
|
|
|
|
}
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Ignoring exception from Scan in FlaggedEntriesEnumCallback (%08x)"),
|
|
GetExceptionCode() ));
|
|
}
|
|
|
|
if( NULL != ptszCurrentCN )
|
|
ldap_memfree(ptszCurrentCN);
|
|
}
|
|
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// CQuotaTable::MoveTableEnumCallback
|
|
//
|
|
// When the move table is enumerated, this routine is passed to LdapEnumerate
|
|
// as the callback function. If we're the designated DC, this function
|
|
// takes care of uncounted/deleted entries and shortens move table strings.
|
|
// Whether or not we're the designated DC, we update the count value,
|
|
// according to the uncounted/deleted entries, in the pvContext structure.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
|
|
ENUM_ACTION // static
|
|
CQuotaTable::MoveTableEnumCallback(LDAP* pLdap, LDAPMessage* pMessage, void* pvContext, void* pvThis )
|
|
{
|
|
struct berval ** ppbvFlags = NULL;
|
|
BYTE bFlags = 0;
|
|
ENUM_ACTION action = ENUM_KEEP_ENTRY;
|
|
TRUE_COUNT_ENUM_CONTEXT *pContext = (TRUE_COUNT_ENUM_CONTEXT*) pvContext;
|
|
CQuotaTable *pThis = (CQuotaTable*)pvThis;
|
|
TCHAR *ptszCurrentDN = NULL;
|
|
CDomainRelativeObjId droidCurrent;
|
|
|
|
if( pThis->_fStopping )
|
|
return( ENUM_ABORT );
|
|
|
|
__try
|
|
{
|
|
// Read the quota flags for this entry. We can't read them out of the
|
|
// enumeration buffer, because the flags can get updated by the enumeration
|
|
// and the enumeration buffer doesn't reflect the change.
|
|
|
|
ptszCurrentDN = ldap_get_dn( pLdap, pMessage );
|
|
if (ptszCurrentDN == NULL)
|
|
{
|
|
TrkLog((TRKDBG_ERROR, TEXT("Couldn't get DN") ));
|
|
TrkRaiseLastError();
|
|
}
|
|
droidCurrent.ReadLdapIdtKeyBuffer(ptszCurrentDN);
|
|
TrkLog(( TRKDBG_QUOTA, TEXT("Enumerating %s"),
|
|
static_cast<const TCHAR*>(CAbbreviatedIDString(droidCurrent)) ));
|
|
|
|
pThis->ReadFlags(pLdap, ptszCurrentDN, &bFlags );
|
|
|
|
// Count this entry if we're counting everything, or if we're only
|
|
// counting flagged values and this one is flagged as uncounted.
|
|
|
|
if( pContext->fCountAll || (bFlags & QFLAG_UNCOUNTED) )
|
|
pContext->cDelta++;
|
|
|
|
// If this is uncounted and we're the designated DC, then it's
|
|
// counted now and we can delete the flags attribute.
|
|
|
|
if( (bFlags & QFLAG_UNCOUNTED) && pThis->IsDesignatedDc() )
|
|
action = ENUM_DELETE_QUOTAFLAGS;
|
|
|
|
// If we're the designated DC, we can do some additional cleanup here.
|
|
// It's because of this work that we need two passes; one to do the
|
|
// cleanup, and one to delete the entries that this cleanup marked
|
|
// for deletion (by calling _pidt->Delete).
|
|
|
|
if( pThis->IsDesignatedDc() && pContext->FIRST_PASS == pContext->dwPass )
|
|
{
|
|
pThis->ShortenString( pLdap, pMessage, &bFlags, droidCurrent );
|
|
}
|
|
|
|
// If this entry is marked for delete, decrement the count.
|
|
// Note that if the entry was marked uncounted and deleted,
|
|
// we incremented at the top and will decrement here for the
|
|
// correct change of zero.
|
|
|
|
if( bFlags & QFLAG_DELETED )
|
|
{
|
|
pContext->cDelta--;
|
|
|
|
// If we're the designated DC, we can delete the entry.
|
|
if( pThis->IsDesignatedDc() )
|
|
action = ENUM_DELETE_ENTRY;
|
|
}
|
|
}
|
|
__finally
|
|
{
|
|
if(ppbvFlags != NULL)
|
|
{
|
|
ldap_value_free_len(ppbvFlags);
|
|
}
|
|
|
|
if( NULL != ptszCurrentDN )
|
|
ldap_memfree( ptszCurrentDN );
|
|
}
|
|
|
|
// Be nice to the DS
|
|
if( 0 != pContext->dwRepetitiveTaskDelay )
|
|
Sleep( pContext->dwRepetitiveTaskDelay );
|
|
|
|
return action;
|
|
}
|
|
|
|
|
|
ENUM_ACTION // static
|
|
CQuotaTable::VolumeTableEnumCallback( LDAP * pLdap, LDAPMessage * pResult, void* pcEntries, void* pvThis )
|
|
{
|
|
CQuotaTable* pThis = (CQuotaTable*)pvThis;
|
|
|
|
if( pThis->_fStopping )
|
|
return( ENUM_ABORT );
|
|
|
|
(*((DWORD*)pcEntries))++;
|
|
return ENUM_KEEP_ENTRY;
|
|
}
|
|
|
|
|
|
void
|
|
CQuotaTable::Statistics( TRKSVR_STATISTICS *pTrkSvrStatistics )
|
|
{
|
|
pTrkSvrStatistics->dwMoveLimit = _dwMoveLimit;
|
|
pTrkSvrStatistics->dwCachedVolumeTableCount = (DWORD) _lCachedVolumeTableCount;
|
|
pTrkSvrStatistics->dwCachedMoveTableCount = (DWORD) _lCachedMoveTableCount;
|
|
pTrkSvrStatistics->ftCacheLastUpdated = _cftCacheLastUpdated;
|
|
pTrkSvrStatistics->fIsDesignatedDc = IsDesignatedDc();
|
|
}
|
|
|
|
|
|
|