able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/svcdlls/trksvcs/trkwks/wkssvc.cxx
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4039 lines
130 KiB
C++
Raw Blame History

// Copyright (c) 1996-1999 Microsoft Corporation
//+-------------------------------------------------------------------------
//
// wkssvc.cxx
//
// Top level class for Tracking (Workstation) Service
//
//--------------------------------------------------------------------------
#include "pch.cxx"
#pragma hdrstop
#define INITGUID
#include <guiddef.h>
#include <ioevent.h>
#include <mountmgr.h> // MOUNTMGR_CHANGE_NOTIFY_INFO, MOUNTDEV_MOUNTED_DEVICE_GUID
#include "trkwks.hxx"
#include <dbt.h>
#include <lmconfig.h>
#define THIS_FILE_NUMBER WKSSVC_CXX_FILE_NO
#if DBG
DWORD g_Debug = 0;
int CVolume::_cVolumes = 0;
#endif
const extern TCHAR s_tszKeyNameLinkTrack[] = TEXT("System\\CurrentControlSet\\Services\\TrkWks\\Parameters");
#if TRK_OWN_PROCESS
#pragma message("Building TrkWks for services.exe")
#else
#pragma message("Building TrkWks for separate process")
#endif
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::Initialize/UnInitialize
//
// Initialize the tracking service (trkwks).
//
//+----------------------------------------------------------------------------
#if DBG
#include <locale.h>
#endif
void
CTrkWksSvc::Initialize( SVCHOST_GLOBAL_DATA * pSvcsGlobalData )
{
NTSTATUS Status;
__try
{
g_ptrkwks = this;
_csDomainNameChangeNotify.Initialize();
_csmcidDC.Initialize();
_fInitializeCalled = TRUE;
_MoveQuotaReached.Initialize();
// Initialize the entropy object, which is used to generate volume secrets.
_entropy.Initialize();
_entropy.Put();
// Get configuration information from HKLM\System\CurrentControlSet\Services\TrkWks\Parameters
// This can't be initialized until _entropy is.
_configWks.Initialize();
/*
if( _configWks.UseOperationLog() )
_OperationLog.Initialize( _configWks.GetOperationLog() );
*/
#if DBG
{
CMachineId mcidLocal( MCID_LOCAL );
TrkLog(( TRKDBG_WKS,
TEXT("Distributed Link Tracking service starting on thread=%d(0x%x) for %hs"),
GetCurrentThreadId(), GetCurrentThreadId(),
(CHAR*)&mcidLocal ));
TrkLog(( TRKDBG_WKS, TEXT("Locale: %hs"), setlocale( LC_ALL, NULL ) ));
}
#endif
// This is a hacked stub that looks and acts like the Win32 thread pool services
#ifdef PRIVATE_THREAD_POOL
{
HRESULT hr = S_OK;
g_pworkman2 = new CThreadPoolStub;
if( NULL == g_pworkman2 )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't create the thread pool manager") ));
TrkRaiseWin32Error( ERROR_NOT_ENOUGH_MEMORY );
}
hr = g_pworkman2->Initialize();
if( FAILED(hr) )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't initialize the thread pool manager") ));
TrkRaiseException( hr );
}
}
#endif
// Disable popup dialogs during critical errors
// (i.e., during NtRaiseHardError).
NtCurrentTeb()->HardErrorsAreDisabled = TRUE;
// Save the global structure for the services.exe process (though we don't currently
// use it).
_pSvcsGlobalData = pSvcsGlobalData;
// Initialize the object that manages the SCM.
_svcctrl.Initialize(TEXT("TrkWks"), this);
#ifdef VOL_REPL
_persistentVolumeMap.Initialize();
#endif
// Initialize our local cache of the VolId->MachineID table (the
// real table is maintained in the DS)
_volumeLocCache.Initialize( _configWks.GetParameter( VOLCACHE_TIME_TO_LIVE_CONFIG ));
_entropy.Put();
// See if we're in a domain, and initialize timers, etc., accordingly
CheckForDomainOrWorkgroup();
// These synchronization objects are used during test to emulate
// race conditions.
#if DBG
if (_configWks.GetTestFlags() & TRK_TEST_FLAG_MOVE_BATCH_SYNC)
_testsyncMoveBatch.Initialize(TEXT("MoveBatchTimeout"));
if (_configWks.GetTestFlags() & TRK_TEST_FLAG_TUNNEL_SYNC)
_testsyncTunnel.Initialize(TEXT("TunnelSync"));
#endif
// Build up a linked list of volume structures.
_volumes.Initialize( static_cast<CTrkWksSvc*>(this), &_configWks, this,
_svcctrl._ssh
#if DBG
,&_testsyncTunnel
#endif
);
/*
if( !_configWks._fIsWorkgroup )
{
_volumes.InitializeDomainObjects();
_volumes.StartDomainTimers();
}
*/
//_mountmanager.Initialize( this, &_volumes );
// Initialize the LPC port which receives the up-calls from the kernel
// during a MoveFile notification
_port.Initialize(this, _configWks.GetPortThreadKeepAliveTime() );
// Initialize our RPC server, which receives requests to mend from shell shortcuts,
// and requests to search from other trkwks instances (on other machines).
_rpc.Initialize( _pSvcsGlobalData, &_configWks );
// Initialize an object that handles changes to the domain name (i.e., when
// we move into a new domain).
_dnchnotify.Initialize();
// Register with PNP to be notified of events from the volume mount manager
// (i.e. drives appearing and disappearing).
/*
DEV_BROADCAST_DEVICEINTERFACE DevClass;
memset( &DevClass, 0, sizeof(DevClass) );
DevClass.dbcc_size=sizeof(DEV_BROADCAST_DEVICEINTERFACE);
DevClass.dbcc_devicetype=DBT_DEVTYP_DEVICEINTERFACE;
memcpy( &DevClass.dbcc_classguid, &MOUNTDEV_MOUNTED_DEVICE_GUID, sizeof(DevClass.dbcc_classguid) );
_hdnDeviceInterface = RegisterDeviceNotification( reinterpret_cast<HANDLE>(_svcctrl._ssh),
&DevClass,
DEVICE_NOTIFY_SERVICE_HANDLE);
if( NULL == _hdnDeviceInterface )
{
// There's nothing we can do, so we'll just ignore the error.
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't register w/PNP for DeviceInterface broadcasts (%08x)"),
HRESULT_FROM_WIN32(GetLastError()) ));
}
else
TrkLog(( TRKDBG_WKS, TEXT("Registered for device interface notifications") ));
*/
// Start the port that receives move notifications from ntos
_port.EnableKernelNotifications();
// Let that SCM know that we're running
_svcctrl.SetServiceStatus(SERVICE_RUNNING,
SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_SHUTDOWN, // for log safe closedown
NO_ERROR);
}
__except( BreakOnDebuggableException() )
{
TrkReportEvent( EVENT_TRK_SERVICE_START_FAILURE, EVENTLOG_ERROR_TYPE,
static_cast<const TCHAR*>( CHexStringize( GetExceptionCode() )),
NULL );
TrkRaiseException( GetExceptionCode() );
}
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::UnInitialize
//
// Called during service stop to close everything down and clean up.
//
//+----------------------------------------------------------------------------
void
CTrkWksSvc::UnInitialize(HRESULT hr)
{
if (_fInitializeCalled)
{
TrkLog(( TRKDBG_WKS, TEXT("Stopping TrkWks Service") ));
/*
UnregisterDeviceNotification( _hdnDeviceInterface );
_hdnDeviceInterface = NULL;
*/
// Force the volumes to close their handles. We do this now because
// some of the following calls could block
_volumes.FlushAllVolumes( TRUE ); // TRUE => fServiceShutdown
_volumes.CloseVolumeHandles();
IFDBG( _testsyncTunnel.UnInitialize(); )
IFDBG( _testsyncMoveBatch.UnInitialize(); )
// Cancel any out-going RPCs on threads in this service
if( NULL != g_pActiveThreadList )
g_pActiveThreadList->CancelAllRpc();
// Close down our RPC server and LPC port. Each will block until
// all active threads have exited. Once these two calls have completed,
// we know that the current thread is the only thread in the service.
_rpc.UnInitialize( _pSvcsGlobalData );
_port.UnInitialize();
//_mountmanager.UnInitialize();
_dnchnotify.UnInitialize();
// Stop the timers before stopping the volumes. That way we don't have
// a Refresh or MoveNotify going on while the volumes are being deleted.
_volumes.UnInitializeDomainObjects();
_volumes.UnInitialize();
_volumeLocCache.UnInitialize();
#ifdef VOL_REPL
_persistentVolumeMap.UnInitialize();
#endif
_entropy.UnInitialize();
#if PRIVATE_THREAD_POOL
{
g_pworkman2->UnInitialize();
delete g_pworkman2;
g_pworkman2 = NULL;
}
#endif
_csDomainNameChangeNotify.UnInitialize();
_fInitializeCalled = FALSE;
if (_configWks.GetTestFlags() & TRK_TEST_FLAG_WAIT_ON_EXIT)
{
TrkLog((TRKDBG_ERROR, TEXT("Waiting 60 seconds before exitting for heap dump")));
Sleep( 60 * 1000 );
}
TrkAssert( 0 == g_cTrkWksRpcThreads );
g_ptrkwks = NULL;
_fInitialized = FALSE;
TrkLog((TRKDBG_WKS, TEXT("CVolume::_cVolumes = %d"), CVolume::_cVolumes ));
TrkAssert( 0 == CVolume::_cVolumes );
// This must be the last call.
if( (hr & 0x0FFF0000) == FACILITY_WIN32 )
hr = hr & ~(0x0FFF0000);
_svcctrl.SetServiceStatus(SERVICE_STOPPED, 0, hr);
//_svcctrl.UnInitialize();
}
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::CheckForDomainOrWorkgroup
//
// Determine if this computer is a member of a domain or just a workgroup.
// Even if we're in a domain, there might be a policy setting in the registry
// that tells us that we should behave as if we're in a workgroup (i.e. don't
// talk to the DC for anything).
//
// The result of this check is stored in _configWks._fIsWorkgroup.
//
//+----------------------------------------------------------------------------
void
CTrkWksSvc::CheckForDomainOrWorkgroup()
{
NET_API_STATUS NetStatus;
WCHAR * pwszDomain = NULL;
BOOLEAN fIsWorkGroup;
ULONG lResult;
HKEY hkey = NULL;
DWORD dwType;
DWORD dwValue;
DWORD cbValue = sizeof(dwValue);
__try
{
// Check to see if we're in a domain or a workgroup.
NetStatus = NetpGetDomainNameEx(&pwszDomain, &fIsWorkGroup);
if (NetStatus != NO_ERROR)
{
pwszDomain = NULL;
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__, HRESULT_FROM_WIN32(NetStatus),
TRKREPORT_LAST_PARAM );
TrkRaiseWin32Error(NetStatus);
}
TrkLog(( TRKDBG_WKS, TEXT("In %s %s"), fIsWorkGroup ? TEXT("workgroup") : TEXT("domain"), pwszDomain ));
// If we're in a workgroup, we don't need to check the behave-like-your-in-a-workgroup
// policy setting.
if( fIsWorkGroup )
__leave;
// Read registry to see if DC tracking is disabled, in which case we'll just
// act like we're in a workgroup. This key is set by the policy manager
// (part of the machine\ntfs policies).
lResult = RegCreateKey(HKEY_LOCAL_MACHINE,
TEXT("System\\CurrentControlSet\\Control\\FileSystem"),
&hkey);
if(ERROR_SUCCESS == lResult)
{
lResult = RegQueryValueEx(hkey,
TEXT("NtfsDisableDomainLinkTracking"),
NULL,
&dwType,
(LPBYTE)&dwValue,
&cbValue);
if(ERROR_SUCCESS == lResult)
{
if(REG_DWORD == dwType)
{
fIsWorkGroup = fIsWorkGroup || dwValue;
if( dwValue )
{
TrkLog((TRKDBG_WKS, TEXT("Domain link tracking disabled by policy")));
}
}
}
}
}
__finally
{
if( NULL != hkey )
RegCloseKey(hkey);
if( NULL != pwszDomain )
NetApiBufferFree(pwszDomain);
}
_configWks._fIsWorkgroup = fIsWorkGroup;
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::OnPortNotification
//
// This method is called when the service receives a message at its
// LPC port from the kernel. This message is always a move notification,
// and its comes here via a CPort object. The message is handled
// off to the CVolumeManager object, which finds the correct CVolume
// object to ultimately handle the notification.
//
//+----------------------------------------------------------------------------
NTSTATUS
CTrkWksSvc::OnPortNotification(const TRKWKS_REQUEST *pRequest)
{
NTSTATUS Status;
Status = STATUS_SUCCESS;
_entropy.Put();
// Test hook: return an error on the port notification rather than
// doing any processing.
if( 0 != _configWks.GetPortNotifyError() )
{
TrkLog(( TRKDBG_PORT, TEXT("Returning explicit error per configuration (0x%x)"),
_configWks.GetPortNotifyError() ));
return( _configWks.GetPortNotifyError() );
}
else if( _configWks.GetIgnoreMovesAndDeletes() )
{
TrkLog(( TRKDBG_PORT, TEXT("Ignoring move due to configuration") ));
return( STATUS_SUCCESS );
}
__try // __except
{
LARGE_INTEGER liDueTime;
// Abort if the service is being stopped.
RaiseIfStopped();
// Verify that the machine ID has a zero in it.
for( int i = 0; i < sizeof(pRequest->MoveMessage.MachineId); i++ )
{
if( '\0' == ((BYTE*)&pRequest->MoveMessage.MachineId)[i] )
break;
}
if( i == sizeof(pRequest->MoveMessage.MachineId) )
TrkRaiseWin32Error( ERROR_INVALID_COMPUTERNAME );
// Append this notification to the end of the appropriate volume log.
switch (pRequest->dwRequest)
{
case TRKWKS_RQ_MOVE_NOTIFY:
CLogMoveMessage lm( pRequest->MoveMessage );
CDomainRelativeObjId droidZero;
// Verify that the IDs are non-zero.
if( droidZero == lm._droidCurrent||
droidZero == lm._droidNew ||
droidZero == lm._droidBirth )
{
TrkLog(( TRKDBG_WKS, TEXT("Invalid ID in move notification: %s %s %s"),
droidZero == lm._droidCurrent ? TEXT("Current") : TEXT(""),
droidZero == lm._droidNew ? TEXT("New") : TEXT(""),
droidZero == lm._droidBirth ? TEXT("Birth") : TEXT("") ));
TrkRaiseWin32Error( ERROR_INVALID_DATA );
}
TrkLog((TRKDBG_PORT | TRKDBG_MOVE,
TEXT("Port:\n Current=%s\n New =%s:%s\n Birth =%s"),
(const TCHAR*)CDebugString(lm._droidCurrent),
(const TCHAR*)CDebugString(lm._mcidNew),
(const TCHAR*)CDebugString(lm._droidNew),
(const TCHAR*)CDebugString(lm._droidBirth) ));
g_ptrkwks->_volumes.Append(
lm._droidCurrent,
lm._droidNew,
lm._mcidNew,
lm._droidBirth
);
// Take this opportunity to cache the volid-to-mcid mapping,
// so we might be able to avoid a DC call later.
_volumeLocCache.AddVolume( lm._droidNew.GetVolumeId(), lm._mcidNew );
break;
}
}
__except(BreakOnDebuggableException())
{
Status = GetExceptionCode();
}
return Status;
}
//+----------------------------------------------------------------------------
//
// GetSvrMessagePriority
//
// This method is used to determine the priority of a message that's going
// to be sent to trksvr (priority 9 is the low, 0 is high). When trksvr
// gets too busy, it uses these priorities to determine which requests
// to reject.
//
// The priority is based on the length of time the caller's activity is
// past due; the further it is past due (relative to the frequency of the
// activity), the higher it's priority.
//
// For example, a once-per-month activity that's one week past due will
// get a moderate priority, while a once-per-week activity that's one
// week past due will get the highest priority.
//
//+----------------------------------------------------------------------------
TRKSVR_MESSAGE_PRIORITY
GetSvrMessagePriority(
LONGLONG llLastDue,
LONGLONG llPeriod ) // pass in in seconds
{
LONGLONG llDiff = CFILETIME() - llLastDue;
TrkAssert( 0 != llLastDue );
llPeriod *= 10000000;
if ( llDiff < 0 )
{
return(PRI_9);
}
else
if ( llDiff >= llPeriod )
{
return(PRI_0);
}
else
{
return (TRKSVR_MESSAGE_PRIORITY) ( 9 - (llDiff * 10) / llPeriod );
}
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::GetDcName
//
// Get the appropriate DC computer name for this domain. If fForce, we'll
// do a domain-rediscovery, otherwise we'll return the cached value (assuming
// it exists).
//
//+----------------------------------------------------------------------------
CMachineId
CTrkWksSvc::GetDcName( BOOL fForce )
{
CMachineId mcid;
if( _rpc.UseCustomDc() )
// The registry specifies which DC to use (and that we shouldn't use Kerberos).
mcid = CMachineId( _rpc.GetCustomDcName() );
else if( _rpc.UseCustomSecureDc() )
// The registry specifies which DC to use
mcid = CMachineId( _rpc.GetCustomSecureDcName() );
else
mcid = CMachineId( fForce ? MCID_DOMAIN_REDISCOVERY : MCID_DOMAIN );
return mcid;
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::OnRefreshTimeout
//
// Called when the refresh timer signals. Upload all volume IDs and
// birth IDs on this system to the DC, so that it can mark them in
// its tables as active. The DC (trksvr) automatically garbage collects
// objects which are not active for a period of time.
//
// The first time this routine is called, it does nothing and restarts the
// timer for a randome amount of time. That way, if a large number
// of machines are booted at once, and they all need to send a refresh,
// they will not all do so at the same time.
//
//+----------------------------------------------------------------------------
PTimerCallback::TimerContinuation
CTrkWksSvc::OnRefreshTimeout( CFILETIME cftOriginalDueTime,
ULONG ulPeriodInSeconds )
{
PTimerCallback::TimerContinuation continuation = PTimerCallback::RETRY_TIMER;
__try
{
TrkLog((TRKDBG_WKS | TRKDBG_GARBAGE_COLLECT, TEXT("CTrkWksSvc::OnRefreshTimeout")));
// We'ave already hesitated. Now is the time to upload all the IDs.
const ULONG cBatch = 128;
CVolumeId *avolid = new CVolumeId[26];
ULONG cVolumes;
CObjId *aobjid = new CObjId[cBatch];
CAvailableDc adc;
int cSources=0;
CDomainRelativeObjId *adroid = new CDomainRelativeObjId[cBatch];
CAllVolumesObjIdEnumerator *pAllSources = new CAllVolumesObjIdEnumerator;
__try
{
// Get an array of all the volume IDs.
cVolumes = _volumes.GetVolumeIds( avolid, 26 );
if( NULL == avolid || NULL == aobjid || NULL == adroid || NULL == pAllSources )
{
TrkLog(( TRKDBG_ERROR, TEXT("Out of memory in OnRefreshTimeout") ));
TrkRaiseWin32Error( ERROR_NOT_ENOUGH_MEMORY );
}
// The AllSources enumerator enums all the files on all the volumes.
if (pAllSources->FindFirst( &_volumes, &aobjid[cSources], &adroid[cSources] ))
{
do // while ( pAllSources->FindNext( &aobjid[cSources], &adroid[cSources]) );
{
RaiseIfStopped();
// If this link source has been in a cross-volume move, then we
// need to upload it. Normalize the value, and increment the count
// (so that we'll keep it).
if (adroid[cSources].GetVolumeId().GetUserBitState()) // if moved across volumes
{
adroid[cSources].GetVolumeId().Normalize();
cSources ++;
}
// If we have enough link sources for a batch, send them up now.
if (cSources == cBatch)
{
TRKSVR_MESSAGE_UNION Msg;
Msg.MessageType = REFRESH;
// Set the priority based on how long we're overdue.
Msg.Priority = GetSvrMessagePriority(
cftOriginalDueTime,
ulPeriodInSeconds );
Msg.Refresh.cSources = cSources;
Msg.Refresh.adroidBirth = adroid;
Msg.Refresh.cVolumes = cVolumes;
Msg.Refresh.avolid = cVolumes == 0 ? NULL : avolid;
TrkLog((TRKDBG_WKS | TRKDBG_GARBAGE_COLLECT,
TEXT("CTrkWksSvc::OnRefreshTimeout calling DC with %d volumes, ")
TEXT("%d sources, %d priority"), cVolumes, cSources, Msg.Priority ));
// If the DC is down we'll get an exception. This will cause the
// timer to go into a retry.
adc.CallAvailableDc(&Msg);
cSources = 0;
cVolumes = 0;
}
} while ( pAllSources->FindNext( &aobjid[cSources], &adroid[cSources]) );
}
// Upload the final block of link sources (which is smaller than a normal
// batch size).
if (cVolumes != 0 || cSources != 0)
{
TRKSVR_MESSAGE_UNION Msg;
Msg.MessageType = REFRESH;
TrkLog(( TRKDBG_WKS | TRKDBG_GARBAGE_COLLECT,
TEXT("Refresh priority based on %I64i"),
static_cast<LONGLONG>( CFILETIME() - cftOriginalDueTime ) ));
Msg.Priority = GetSvrMessagePriority(
cftOriginalDueTime,
ulPeriodInSeconds );
Msg.Refresh.cSources = cSources;
Msg.Refresh.adroidBirth = cSources == 0 ? NULL : adroid;
Msg.Refresh.cVolumes = cVolumes;
Msg.Refresh.avolid = cVolumes == 0 ? NULL : avolid;
TrkLog((TRKDBG_WKS | TRKDBG_GARBAGE_COLLECT,
TEXT("CTrkWksSvc::OnRefreshTimeout calling DC with %d volumes, ")
TEXT("%d sources, %d priority"), cVolumes, cSources, Msg.Priority ));
adc.CallAvailableDc(&Msg);
}
}
__finally
{
pAllSources->UnInitialize();
adc.UnInitialize();
if( NULL != avolid )
delete[] avolid;
if( NULL != aobjid )
delete[] aobjid;
if( NULL != adroid )
delete[] adroid;
if( NULL != pAllSources )
delete pAllSources;
}
// Put the timer back into it's original mode, so that it will go
// off in the next period (one month?).
continuation = PTimerCallback::CONTINUE_TIMER;
TrkLog((TRKDBG_WKS | TRKDBG_GARBAGE_COLLECT,
TEXT("CTrkWksSvc::OnRefreshTimeout successfully refreshed DC")));
}
__except( BreakOnDebuggableException() )
{
TrkLog(( TRKDBG_WARNING,
TEXT("Ignoring exception in CVolumeManager::OnRefreshTimeout (%08x)"),
GetExceptionCode() ));
}
return( continuation );
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::OnEntriesAvailable
//
// Pass this on to the volume manager.
//
//+----------------------------------------------------------------------------
void
CTrkWksSvc::OnEntriesAvailable()
{
_volumes.OnEntriesAvailable();
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::OnMoveBatchTimeout
//
// Called by the _timerNotify when it expires so that we can send all
// move notifications to the DC that haven't been sent.
//
//+----------------------------------------------------------------------------
#define MOVE_BATCH_SIZE 64
PTimerCallback::TimerContinuation
CTrkWksSvc::OnMoveBatchTimeout( EAggressiveness eAggressiveness )
{
HRESULT hr;
BOOL fSuccess = FALSE;
SequenceNumber seqLog;
CAvailableDc adc;
CVolume * pVol = NULL;
ULONG cSendsToServer = 0;
PTimerCallback::TimerContinuation continuation = PTimerCallback::BREAK_TIMER;
TrkLog((TRKDBG_MOVE | TRKDBG_WKS, TEXT("CTrkWksSvc::OnMoveBatchTimeout")));
IFDBG( _testsyncMoveBatch.ReleaseAndWait(); )
// If we found ourselves to be above quota recently, and we're not
// being aggressive, then do nothing.
if( PASSIVE == eAggressiveness && _MoveQuotaReached.IsSet() )
{
TrkLog(( TRKDBG_LOG, TEXT("Skipping OnMoveBatchTimeout, move quota was exceeded before") ));
return( PTimerCallback::BREAK_TIMER );
}
// Ensure that we're the only thread trying to do a MoveNotify.
// If we're not, then simple abort this call; we'll assume
// that the other thread will take care of things.
if( !BeginSingleInstanceTask( &_cOnMoveBatchTimeout ))
{
TrkLog(( TRKDBG_LOG, TEXT("Skipping OnMoveBatchTimeout") ));
return( PTimerCallback::BREAK_TIMER );
}
//
// The move batch timeout has expired. We are in a different thread to
// that which may be concurrently writing the log and starting another
// move batch time period.
// We then get the current range of log entries that need to be sent to
// the DC. The range may be empty because we may have read everything out
// of the log during a thread switch at NoteXXXX in OnPortNotification.
//
__try
{
CVolumeEnumerator VolumeEnum;
ULONG cPerVolumePasses = 0;
// Iterate through an enumeration of the volumes.
VolumeEnum = _volumes.Enum();
while (pVol = VolumeEnum.GetNextVolume())
{
CObjId rgobjidCurrent[MOVE_BATCH_SIZE];
CDomainRelativeObjId rgdroidBirth[MOVE_BATCH_SIZE];
CDomainRelativeObjId rgdroidNew[MOVE_BATCH_SIZE];
// Don't do anything if the volumes isn't owned.
if( CVolume::VOL_STATE_OWNED != pVol->GetState() )
{
TrkLog(( TRKDBG_WKS, TEXT("Skipping MoveNotify on volume %c:; it is not in the owned state"),
VolChar(pVol->GetVolIndex()) ));
// Skip to the next volume.
pVol->Release();
continue;
}
ULONG cNotifications = sizeof(rgobjidCurrent)/sizeof(rgobjidCurrent[0]);
BOOL fForceSeqNumber = FALSE;
__try // __except
{
// Read a batch of move notifications from this volume's log.
pVol->Read(rgobjidCurrent, rgdroidBirth, rgdroidNew, &seqLog, &cNotifications);
// Process entries from the log
#if DBG
if( 0 == cNotifications )
TrkLog(( TRKDBG_LOG, TEXT("Nothing to send for %c:"), VolChar(pVol->GetVolIndex()) ));
#endif
while( cNotifications )
{
// Pass the entries up to the server.
// Abort if the service is stopping
RaiseIfStopped();
// Also abort if we're putting too much strain on the server
if( ++cSendsToServer > _configWks.GetMaxSendsPerMoveNotify() )
{
TrkLog(( TRKDBG_LOG, TEXT("Too many moves are going to the server, aborting for now") ));
TrkRaiseException( TRK_E_SERVER_TOO_BUSY );
}
TRKSVR_MESSAGE_UNION Msg;
CVolumeId volid = pVol->GetVolumeId();
Msg.MessageType = MOVE_NOTIFICATION;
Msg.Priority = PRI_0;
Msg.MoveNotification.cNotifications = cNotifications;
Msg.MoveNotification.seq = seqLog;
Msg.MoveNotification.fForceSeqNumber = fForceSeqNumber;
Msg.MoveNotification.pvolid = &volid;
Msg.MoveNotification.rgobjidCurrent = rgobjidCurrent;
Msg.MoveNotification.rgdroidBirth = rgdroidBirth;
Msg.MoveNotification.rgdroidNew = rgdroidNew;
Msg.MoveNotification.cProcessed = 0;
TrkLog(( TRKDBG_MOVE | TRKDBG_WKS, TEXT("Sending %d move %s for %c: (seq=%d)."),
cNotifications,
cNotifications > 1 ? TEXT("notifications") : TEXT("notification"),
VolChar(pVol->GetVolIndex()), seqLog ));
hr = adc.CallAvailableDc(&Msg);
TrkAssert( SUCCEEDED(hr) );
// If the upload was successful (even if not complete),
// advance the read pointer in the log.
if( S_OK == hr )
{
TrkLog(( TRKDBG_MOVE | TRKDBG_WKS, TEXT("MoveNotify succeeded") ));
_MoveQuotaReached.Clear();
// Advance the read cursor in the log.
pVol->Seek(SEEK_CUR, Msg.MoveNotification.cProcessed );
if( Msg.MoveNotification.cProcessed != cNotifications )
{
// The server is being over-loaded, and not everything
// was uploaded. Try again later to upload the rest.
hr = TRK_E_SERVER_TOO_BUSY;
TrkLog(( TRKDBG_ERROR,
TEXT("OnMoveBatchTimeout server too busy (%d entries processed)"),
Msg.MoveNotification.cProcessed ));
__leave;
}
else
{
// After a good upload, we don't expect the sequence
// numbers to be out of sync.
fForceSeqNumber = FALSE;
}
}
// We had an error. See if it's because we're out
// of sync with the server
else
if ( hr == TRK_S_OUT_OF_SYNC )
{
TrkAssert( seqLog != Msg.MoveNotification.seq );
TrkAssert( !fForceSeqNumber );
// Are we ahead or behind the server?
if( seqLog < Msg.MoveNotification.seq )
{
// We're behind the server (probably because we were restored).
// Just tell the server to take our sequence number.
TrkAssert( !fForceSeqNumber );
fForceSeqNumber = TRUE;
}
else
{
// We're ahead of the server. Let's back up our log
// so that everything the server needs will get uploaded.
// If this sequence number isn't in the log, then just
// force the server to take everything we have.
if( !pVol->Seek( Msg.MoveNotification.seq ))
fForceSeqNumber = TRUE;
}
}
// Or maybe the error is that we don't currently own the volume
// from which this file was moved.
else
if( TRK_S_VOLUME_NOT_FOUND == hr
||
TRK_S_VOLUME_NOT_OWNED == hr
)
{
TrkLog(( TRKDBG_LOG, TEXT("Volume %c: found to be not-owned during MoveNotify"),
TEXT('A')+pVol->GetVolIndex() ));
pVol->SetState( CVolume::VOL_STATE_NOTOWNED );
break; // Move on to the next volume
}
// Or maybe we hit the move notification quota limit
else
if( TRK_S_NOTIFICATION_QUOTA_EXCEEDED == hr )
{
TrkLog(( TRKDBG_MOVE|TRKDBG_WKS, TEXT("Hit move limit after %d entries"),
Msg.MoveNotification.cProcessed ));
_MoveQuotaReached.Set();
// Advance the read cursor in the log.
if( 0 != Msg.MoveNotification.cProcessed )
pVol->Seek(SEEK_CUR, Msg.MoveNotification.cProcessed );
__leave;
}
else
TrkRaiseException(hr);
// Get the next batch of data to be uploaded.
Sleep( 5000 ); // Pause a little to be sure we're not overloading.
cNotifications = sizeof(rgobjidCurrent)/sizeof(rgobjidCurrent[0]);
pVol->Read(rgobjidCurrent, rgdroidBirth, rgdroidNew, &seqLog, &cNotifications);
} // while( cNotifications )
pVol->Flush();
} // __try
__except( IsErrorDueToLockedVolume(GetExceptionCode())
? EXCEPTION_EXECUTE_HANDLER
: EXCEPTION_CONTINUE_SEARCH )
{
// This volume is locked, so there's nothing we can do other
// than just carry on to the next volume.
}
pVol->Release();
pVol = NULL;
// If we're at quota, there's no point in continuing
if( _MoveQuotaReached.IsSet() )
{
TrkLog(( TRKDBG_MOVE|TRKDBG_WKS, TEXT("Stopping move notifications due to quota") ));
break;
}
} // while (pVol = VolumeEnum.GetNextVolume())
} // __try
__except (BreakOnDebuggableException())
{
hr = GetExceptionCode();
// Restart the timer for a retry (with backoff).
continuation = PTimerCallback::RETRY_TIMER;
TrkLog((TRKDBG_MOVE | TRKDBG_WKS, TEXT("Retrying move notify (%08x)"), GetExceptionCode() ));
}
EndSingleInstanceTask( &_cOnMoveBatchTimeout );
if (pVol)
{
pVol->Release();
}
// If we failed because the server is too busy, don't do a normal continuation
if( TRK_E_SERVER_TOO_BUSY == hr )
TrkRaiseException( hr );
return( continuation );
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::ServiceHandler
//
// This method is the service control handler callback function, which is
// called by the SCM. We handle service messages (start/stop/shutdown),
// and PNP messages.
//
// NOTE: In services.exe, this method is called on the one and only ServiceHandler
// thread. So while we execute, no other service in this process can
// receive notifications. Thus it is important that we do nothing
// blocking or time-consuming here.
//
//+----------------------------------------------------------------------------
DWORD
CTrkWksSvc::ServiceHandler(DWORD dwControl,
DWORD dwEventType,
PVOID EventData,
PVOID pData)
{
DWORD dwRet = NO_ERROR;
NTSTATUS status;
switch (dwControl)
{
// ----------------
// Service Messages
// ----------------
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
// Stop receiving move notifications from NTOS
_port.DisableKernelNotifications();
/*
// Run the service cleanup on a worker thread. Run it
// as a long function, so that when we do an LPC connect
// in CPort::UnInitialize, the thread pool will be willing to create
// a thread for CPort::DoWork to process the connect.
status = TrkQueueWorkItem( (PWorkItem*)this, WT_EXECUTELONGFUNCTION );
if( !NT_SUCCESS(status) )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't queue service stop to thread pool") ));
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__,
status,
TRKREPORT_LAST_PARAM );
}
*/
ServiceStopCallback( this, FALSE );
break;
case SERVICE_CONTROL_PAUSE:
break;
case SERVICE_CONTROL_CONTINUE:
break;
case SERVICE_CONTROL_INTERROGATE:
break;
// ------------
// PNP messages
// ------------
case SERVICE_CONTROL_DEVICEEVENT:
switch( dwEventType )
{
// PNP events identified by GUID: Volume lock/unlock/lockfail, plus
// volume mount/dismount.
case DBT_CUSTOMEVENT:
{
PDEV_BROADCAST_HANDLE pbh = reinterpret_cast<PDEV_BROADCAST_HANDLE>(EventData);
if( pbh->dbch_devicetype == DBT_DEVTYP_HANDLE )
{
TrkAssert(pbh->dbch_hdevnotify);
if( pbh->dbch_eventguid == GUID_IO_VOLUME_LOCK )
{
// Never raises
TrkLog(( TRKDBG_WKS, TEXT("Received volume lock notification (%p)"),
pbh->dbch_hdevnotify ));
_volumes.OnVolumeLock( pbh->dbch_hdevnotify );
}
else if( pbh->dbch_eventguid == GUID_IO_VOLUME_UNLOCK )
{
// Doesn't raise or block
TrkLog(( TRKDBG_WKS, TEXT("Received volume unlock notification (%p)"),
pbh->dbch_hdevnotify ));
_volumes.OnVolumeUnlock( pbh->dbch_hdevnotify );
}
else if( pbh->dbch_eventguid == GUID_IO_VOLUME_LOCK_FAILED )
{
// Doesn't raise or block
TrkLog(( TRKDBG_WKS, TEXT("Received volume lock fail notification (%p)"),
pbh->dbch_hdevnotify ));
_volumes.OnVolumeLockFailed(pbh->dbch_hdevnotify);
}
else if( pbh->dbch_eventguid == GUID_IO_VOLUME_DISMOUNT )
{
TrkLog(( TRKDBG_WKS, TEXT("Volume Dismount") ));
_volumes.OnVolumeDismount( pbh->dbch_hdevnotify );
}
else if( pbh->dbch_eventguid == GUID_IO_VOLUME_MOUNT )
{
TrkLog(( TRKDBG_WKS, TEXT("Volume Mount") ));
_volumes.OnVolumeMount( pbh->dbch_hdevnotify );
}
}
}
break;
case DBT_DEVICEQUERYREMOVE:
// We treat this like a dismount and close all of our handles.
TrkLog(( TRKDBG_WKS, TEXT("DBT_DEVICEQUERYREMOVE") ));
{
PDEV_BROADCAST_HANDLE pbh = reinterpret_cast<PDEV_BROADCAST_HANDLE>(EventData);
if( pbh->dbch_devicetype == DBT_DEVTYP_HANDLE )
{
_volumes.OnVolumeDismount( pbh->dbch_hdevnotify );
}
}
break;
case DBT_DEVICEQUERYREMOVEFAILED:
// We can reopen the handles, because someone else made the
// query fail.
TrkLog(( TRKDBG_WKS, TEXT("DBT_DEVICEQUERYREMOVEFAILED") ));
{
PDEV_BROADCAST_HANDLE pbh = reinterpret_cast<PDEV_BROADCAST_HANDLE>(EventData);
if( pbh->dbch_devicetype == DBT_DEVTYP_HANDLE )
{
_volumes.OnVolumeDismountFailed( pbh->dbch_hdevnotify );
}
}
break;
case DBT_DEVICEREMOVECOMPLETE:
// The volume was successfully removed.
TrkLog(( TRKDBG_WKS, TEXT("DBT_DEVICEREMOVECOMPLETE") ));
{
PDEV_BROADCAST_HANDLE pbh = reinterpret_cast<PDEV_BROADCAST_HANDLE>(EventData);
if( pbh->dbch_devicetype == DBT_DEVTYP_HANDLE )
{
// The volume handles should have been closed already
// in the DBT_DEVICEQUERYREMOVE, in which case the following
// call will have no effect.
_volumes.OnVolumeDismount( pbh->dbch_hdevnotify );
}
else
{
PDEV_BROADCAST_DEVICEINTERFACE pintf
= reinterpret_cast<PDEV_BROADCAST_DEVICEINTERFACE>(EventData);
if( MOUNTDEV_MOUNTED_DEVICE_GUID == pintf->dbcc_classguid )
{
TrkLog(( TRKDBG_WKS, TEXT("Received mounted device remove complete") ));
TrkLog(( TRKDBG_WKS, TEXT("DeviceType=%08x, Name=%s"), pintf->dbcc_devicetype, pintf->dbcc_name ));
}
}
break;
}
case DBT_DEVICEARRIVAL:
TrkLog(( TRKDBG_WKS, TEXT("DBT_DEVICEARRIVAL") ));
/* Need to figure out what device-type to check for
{
PDEV_BROADCAST_DEVICEINTERFACE pintf
= reinterpret_cast<PDEV_BROADCAST_DEVICEINTERFACE>(EventData);
if( MOUNTDEV_MOUNTED_DEVICE_GUID == pintf->dbcc_classguid )
{
TrkLog(( TRKDBG_WKS, TEXT("Received mounted device arrival") ));
TrkLog(( TRKDBG_WKS, TEXT("DeviceType=%08x, Name=%s"), pintf->dbcc_devicetype, pintf->dbcc_name ));
}
}
*/
break;
} // switch( dwEventType )
}
return(dwRet);
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::CallDcSyncVolumes
//
// Send a SYNC_VOLUMES request to the DC. There are multiple types if
// SYNC_VOLUMES requests, for example it can be used to create or claim
// volumes, or to verify sequence numbers for volumes.
//
// This implementation is part of CTrkWksSvc, even though it is only
// called from CVolumeManager. This was done because during the request
// we also get information that's used to update the _persistentVolumeMap
// table, which is part of CTrkWksSvc.
//
//+----------------------------------------------------------------------------
void
CTrkWksSvc::CallDcSyncVolumes(ULONG cVolumes, TRKSVR_SYNC_VOLUME rgSyncVolumes[])
{
TRKSVR_MESSAGE_UNION Msg;
CAvailableDc adc;
VolumeMapEntry * pVolumeChanges = NULL;
#ifdef VOL_REPL
CVolumeMap VolumeMapNew;
#endif
__try
{
HRESULT hr;
// Compose the SyncVolumes message buffer
Msg.MessageType = SYNC_VOLUMES;
Msg.Priority = PRI_0;
Msg.SyncVolumes.cVolumes = cVolumes;
Msg.SyncVolumes.pVolumes = rgSyncVolumes;
#ifdef VOL_REPL
// pass in the DC time that we last got volume changes
Msg.SyncVolumes.ftFirstChange = _persistentVolumeMap.GetLastUpdateTime( );
Msg.SyncVolumes.cChanges = 0;
Msg.SyncVolumes.ppVolumeChanges = & pVolumeChanges;
#endif
// Call the DC
adc.CallAvailableDc(&Msg);
#ifdef VOL_REPL
// Process volume table updates
if (Msg.SyncVolumes.cChanges != 0 && pVolumeChanges != NULL)
{
// takes ownership of *pVolumeChanges
VolumeMapNew.Initialize(Msg.SyncVolumes.cChanges, &pVolumeChanges);
// ftFirstChange is now the time that we pass back into the DC next time
_persistentVolumeMap.Merge(&VolumeMapNew);
}
_persistentVolumeMap.SetLastUpdateTime( CFILETIME(Msg.SyncVolumes.ftFirstChange) );
#endif
}
__finally
{
adc.UnInitialize();
#ifdef VOL_REPL
midl_user_free(pVolumeChanges);
VolumeMapNew.UnInitialize();
#endif
}
}
// Always returns a success code (positive number), exception if RPC error or service
// returns a negative number.
//+----------------------------------------------------------------------------
//
// CAvailableDc::CallAvailableDc
//
// Find a DC and call TrkSvr's LnkSvrMessage method with the caller-provided
// message. All communications between the trkwks & trksvr services goes
// through this method. This routine raises if LnkSvrMessage returns an
// error.
//
//+----------------------------------------------------------------------------
HRESULT
CAvailableDc::CallAvailableDc(
TRKSVR_MESSAGE_UNION * pMsg,
RC_AUTHENTICATE auth )
{
HRESULT hr = E_FAIL;
CMachineId mcidLocal( MCID_LOCAL );
TCHAR tszMachineID[ MAX_PATH + 1 ];
CMachineId mcidFirstTry;
// Set the machine ID in the message. Ordinarily this is set to NULL;
// trksvr infers the machine ID by impersonating us. It's non-NULL
// if the registry is configured to use a custom DC.
if( UseCustomDc() )
{
mcidLocal.GetName( tszMachineID, sizeof(tszMachineID) );
pMsg->ptszMachineID = tszMachineID;
}
else
pMsg->ptszMachineID = NULL;
// Try twice to talk to the DC. If it fails the first time, we'll try
// another DC.
for (int tries=0; tries<2; tries++)
{
// If the service is stopping, don't even attempt to make a call that
// could hang indefinitely.
g_ptrkwks->RaiseIfStopped();
// If we don't have an association with the DC, establish it now.
if (! _rcDomain.IsConnected())
{
_mcidDomain = g_ptrkwks->GetDcName( 1 == tries ); // Force on the second try
TrkLog(( TRKDBG_WKS, TEXT("Connecting to DC %s"),
(const TCHAR*)CDebugString(_mcidDomain) ));
_rcDomain.RcInitialize( _mcidDomain,
s_tszTrkSvrRpcProtocol, s_tszTrkSvrRpcEndPoint,
auth );
TrkAssert( _rcDomain.IsConnected() );
}
// If this is the second try, and we're about to try the same DC as
// the first time, then don't bother.
if (tries == 1 && mcidFirstTry == _mcidDomain)
{
break;
}
// Call the DC
__try
{
if (tries == 0)
{
// Remember which DC we try first, so we don't bother to try
// it a second time.
mcidFirstTry = _mcidDomain;
}
TrkLog(( TRKDBG_WKS, TEXT("Calling LnkSvrMessage on %s"),
(const TCHAR*)CDebugString(_mcidDomain) ));
hr = LnkSvrMessage(_rcDomain, pMsg);
}
__except (BreakOnDebuggableException())
{
hr = HRESULT_FROM_WIN32(GetExceptionCode());
TrkLog(( TRKDBG_WKS, TEXT("Couldn't call DC %s (%08x)"),
(const TCHAR*)CDebugString(_mcidDomain),
HRESULT_FROM_WIN32(GetExceptionCode()) ));
}
// If the call succeeded, we're done.
if (SUCCEEDED(hr))
{
break;
}
if( NULL != g_ptrkwks )
g_ptrkwks->RaiseIfStopped();
_rcDomain.UnInitialize();
} // for (int tries=0; tries<2; tries++)
if (FAILED(hr))
{
TrkLog((TRKDBG_WKS, TEXT("CallAvailableDc failed %08X"), hr));
TrkRaiseException(hr);
}
return hr;
} // CAvailableDc::CallAvailableDc
//+----------------------------------------------------------------------------
//
// CAvailableDc::UnInitialize
//
// Uninitialize the RPC association and registry configuration.
//
//+----------------------------------------------------------------------------
void
CAvailableDc::UnInitialize()
{
_rcDomain.UnInitialize();
CTrkRpcConfig::UnInitialize();
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::CallSvrMessage
//
// This method is the implementation within CTrkWksSvc of the
// LnkCallSvrMessage RPC request. This purpose of this request is to
// provide a means for a utility to send a message to trksvr via trkwks,
// no pre- or post-processing is done by trkwks. This is only provided
// for testing purposes, and is disabled unless a flag is set in the
// registry.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::CallSvrMessage( handle_t IDL_handle, TRKSVR_MESSAGE_UNION * pMsg )
{
HRESULT hr = S_OK;
CAvailableDc adc;
BOOL fAllowCall = FALSE;
TrkLog(( TRKDBG_MEND, TEXT("CallSvrMessage request") ));
// Is the special registry flag set that allows us to perform this call?
if( _configWks.GetTestFlags() & TRK_TEST_FLAG_CALL_SERVER )
{
fAllowCall = TRUE;
}
else
{
// Otherwise, see if the client is running as an administrator.
// If so, then it's OK to make this call.
RPC_STATUS rpc_status = RpcImpersonateClient( IDL_handle );
if( S_OK == rpc_status )
{
if( RunningAsAdministratorHack() )
{
fAllowCall = TRUE;
TCHAR tszCurrentUser[ 200 ] = { TEXT("") };
ULONG cchCurrentUser = sizeof(tszCurrentUser);
GetUserName( tszCurrentUser, &cchCurrentUser );
TrkLog(( TRKDBG_MEND, TEXT("CallSvrMessage from %s"), tszCurrentUser ));
}
RpcRevertToSelf();
}
}
if( !fAllowCall )
return( HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED) );
__try
{
// Is this a request to modify our configuration?
if( WKS_CONFIG == pMsg->MessageType )
{
// Yes, this is a trkwks configuration change request. Are we
// attempt to change a dynamic parameter?
if( !_configWks.IsParameterDynamic( pMsg->WksConfig.dwParameter ) )
{
// No, this parameter is static and can't be changed.
TrkLog(( TRKDBG_WARNING, TEXT("Attempt to modify a static parameter (%d)"),
pMsg->WksConfig.dwParameter ));
hr = HRESULT_FROM_WIN32( ERROR_ACCESS_DENIED );
}
// Otherwise, we can change the parameter.
else if( !_configWks.SetParameter( pMsg->WksConfig.dwParameter,
pMsg->WksConfig.dwNewValue ) )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't set parameter %d to %d"),
pMsg->WksConfig.dwParameter, pMsg->WksConfig.dwNewValue ));
hr = E_FAIL;
}
else
{
hr = S_OK;
TrkLog(( TRKDBG_WKS, TEXT("Set parameter %s to %d"),
_configWks.GetParameterName( pMsg->WksConfig.dwParameter ),
pMsg->WksConfig.dwNewValue ));
}
} // if( WKS_CONFIG == pMsg->MessageType )
// Or, is it a request to refresh the volume list (to look for new volumes)?
else if( WKS_VOLUME_REFRESH == pMsg->MessageType )
{
_volumes.RefreshVolumes( (PLogCallback*) this, _svcctrl._ssh
#if DBG
, &_testsyncTunnel
#endif
);
hr = S_OK;
}
else
{
// No, this isn't a request to change trkwks configuration. Just pass
// the request up to trksvr unchanged.
hr = adc.CallAvailableDc(pMsg);
}
}
__finally
{
adc.UnInitialize();
}
return(hr);
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::GetBackup
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
#ifdef VOL_REPL
HRESULT
CTrkWksSvc::GetBackup(DWORD * pcVolumes,
VolumeMapEntry ** ppVolumeChanges,
FILETIME *pft)
{
HRESULT hr = S_OK;
__try
{
_persistentVolumeMap.CopyTo( pcVolumes, ppVolumeChanges );
*pft = _persistentVolumeMap.GetLastUpdateTime();
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
hr = GetExceptionCode();
}
return(hr);
}
#endif
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::SearchMachine
//
// This is the implementation witthin CTrkWksSvc of LnkSearchMachine. This
// request is sent by other instances of CTrkWksSvc (trkwks) on remote
// machines.
//
// Give a link source's last known droid and birth droid, find the file
// on this machine, or a referral to the file from the logs.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::SearchMachine(
RPC_BINDING_HANDLE IDL_handle,
DWORD Restrictions,
const CDomainRelativeObjId &droidBirthLast,
const CDomainRelativeObjId &droidLast,
CDomainRelativeObjId * pdroidBirthNext,
CDomainRelativeObjId * pdroidNext,
CMachineId * pmcidNext,
TCHAR* ptszPath )
{
HRESULT hr = S_OK;
TCHAR tszLocalPath[MAX_PATH+1];
// Abort if the service is being stopped
RaiseIfStopped();
// Show who made the call in the debugger.
#if 1==DBG
{
RPC_STATUS rpc_status = RpcImpersonateClient( IDL_handle );
if( S_OK == rpc_status )
{
TCHAR tszCurrentUser[ 200 ] = { TEXT("") };
ULONG cchCurrentUser = sizeof(tszCurrentUser);
GetUserName( tszCurrentUser, &cchCurrentUser );
TrkLog(( TRKDBG_MEND, TEXT("Searching on behalf of %s, Restrictions = %08x"),
tszCurrentUser, Restrictions ));
RpcRevertToSelf();
}
}
#endif // #if 1==DBG
// Search all the local volumes
hr = g_ptrkwks->_volumes.Search( Restrictions, droidBirthLast, droidLast,
pdroidBirthNext, pdroidNext, pmcidNext,
tszLocalPath );
// Did we find the file?
if( SUCCEEDED(hr) || TRK_E_POTENTIAL_FILE_FOUND == hr )
{
// Yes, we either found the link source, or a potential match for
// the link source (potential means that the objid was right, but the birth
// ID didn't match).
TrkLog((TRKDBG_MEND | TRKDBG_WKS, TEXT("CVolumeManager::Search returned local %spath %s"),
TRK_E_POTENTIAL_FILE_FOUND == hr ? TEXT("potential ") : TEXT(""),
tszLocalPath ));
RPC_STATUS rpc_status;
UINT uiRpcTransportType;
BOOL fPotential = TRK_E_POTENTIAL_FILE_FOUND == hr;
// See if the client is on the local machine. If so, we'll simply
// return this local path (e.g. "C:\path\file"). Otherwise, we have
// to generate a UNC path. We know it's local if the rpc client came to
// us over the LRPC protocol.
rpc_status = I_RpcBindingInqTransportType (IDL_handle, &uiRpcTransportType );
if( RPC_S_OK != rpc_status )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't inq the RPC transport type (%lu)"), rpc_status ));
TrkRaiseWin32Error( rpc_status );
}
if( TRANSPORT_TYPE_LPC != uiRpcTransportType )
{
// It's not local. Map the local path to the "best" UNC path.
hr = MapLocalPathToUNC( IDL_handle, tszLocalPath, ptszPath );
if( SUCCEEDED(hr) && fPotential )
hr = TRK_E_POTENTIAL_FILE_FOUND;
}
else
// Just return this local path.
_tcscpy( ptszPath, tszLocalPath );
} // if (hr == S_OK)
TrkLog(( TRKDBG_MEND | TRKDBG_WKS,
TEXT("LnkSearchMachine returns %s %s"),
GetErrorString(hr),
( (hr == S_OK || hr == TRK_E_POTENTIAL_FILE_FOUND) ? ptszPath : TEXT("")) ));
return(hr);
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::SetVolumeId
//
// Implementation of LnkSetVolumeId RPC request. This is test-only code.
// BUGBUG: Is this used?
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::SetVolumeId(
ULONG iVolume,
const CVolumeId VolId)
{
NTSTATUS status = E_FAIL;
if (g_ptrkwks->_configWks.GetTestFlags() & TRK_TEST_FLAG_SET_VOLUME_ID)
{
CVolumeEnumerator VolumeEnum;
CVolume * pVol = NULL;
// We have to ask the volume to set the ID, otherwise the volid
// protection code will restore the old ID after we set it.
VolumeEnum = _volumes.Enum();
while (pVol = VolumeEnum.GetNextVolume())
{
if( iVolume == pVol->GetVolIndex() )
{
status = pVol->SetVolIdOnVolume( VolId );
pVol->Release();
break;
}
pVol->Release();
}
}
return status;
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::MendLink
//
// Implementation of the LnkMendLink RPC request.
//
// Given the last known droid, machine, and birth droid, this method
// searches for a link source. The client may also specify a time
// limit and certain restrictions on how the search will be performed.
//
// The result returned is the new droid, machine, and path. Also, the new
// birth ID is returned, though it is normally unchanged (it is only changed
// if TRK_E_POTENTIAL_FILE is returned).
//
// The search algorithm is:
//
// - Search the last known machine. The identity of the last known
// machine is as specified by the caller in mcidLast, though if
// the volid in droidLast shows up in our volume cache, we'll use that.
//
// - Contact the DC to find what it believes is the latest droid and
// that droid's host machine ID. Search that machine.
//
// - Starting with the last known machine, search for the file
// by following referrals provided in the logs.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::MendLink(
RPC_BINDING_HANDLE IDL_handle,
DWORD dwTickCountDeadline,
DWORD Restrictions,
IN const CDomainRelativeObjId &droidBirthLast,
IN const CDomainRelativeObjId &droidLast,
IN const CMachineId &mcidLast,
OUT CDomainRelativeObjId *pdroidBirthNew,
OUT CDomainRelativeObjId *pdroidNew,
OUT CMachineId *pmcidNew,
IN OUT ULONG *pcbPath,
OUT WCHAR *pwsz )
{
HRESULT hr = S_OK, hrFirst = S_OK;
// Temp values to be used within this routine
SAllIDs allidsFromLog( droidBirthLast, droidLast, mcidLast );
SAllIDs allidsFromDC = allidsFromLog;
TCHAR tsz[ MAX_PATH + 1 ];
// Temp values to hold a potential match while we continue to look for
// a perfect match.
SAllIDs allidsPotential, allidsResult;
TCHAR tszPotential[ MAX_PATH + 1 ];
BOOL fPotential = FALSE;
wcstotcs(tsz, pwsz);
TrkLog(( TRKDBG_MEND, TEXT("\nMending birth=%s, last=%s"),
(const TCHAR*)CDebugString(droidBirthLast),
(const TCHAR*)CDebugString(droidLast) ));
__try
{
if( GetTickCount() >= dwTickCountDeadline )
{
TrkLog((TRKDBG_MEND, TEXT("Mend: timeout")));
hr = TRK_E_TIMEOUT;
__leave;
}
// -----------------------
// Search the last machine
// -----------------------
TrkLog(( TRKDBG_MEND, TEXT("Mend: search last machine") ));
hrFirst = hr = SearchChain( IDL_handle, 1, dwTickCountDeadline, &Restrictions,
USE_SPECIFIED_MCID,
&allidsFromLog, tsz);
if( SUCCEEDED(hr) || TRK_E_TIMEOUT == hrFirst )
{
allidsResult = allidsFromLog;
// If we succeeded and the droids don't match, then we must
// have been searching all the volumes on the machine (if
// we failed with a timeout, the droids shouldn't have changed).
TrkAssert( !(TRK_MEND_DONT_SEARCH_ALL_VOLUMES & Restrictions)
||
allidsFromLog.droidRevised == droidLast );
__leave;
}
else if( TRK_E_POTENTIAL_FILE_FOUND == hrFirst )
{
// We have a potential hit (the object ID matched, but the birth ID didn't).
fPotential = TRUE;
TrkAssert( allidsFromLog.droidBirth != droidBirthLast );
TrkAssert( 0 < _tcslen(tsz) );
// Save these potential values
allidsPotential = allidsFromLog;
_tcscpy( tszPotential, tsz );
}
// (droidLastT/mcidLastT always contains last referral)
// --------------------------------
// Get an updated droid from the DC
// --------------------------------
if( GetTickCount() >= dwTickCountDeadline )
{
TrkLog((TRKDBG_MEND, TEXT("Mend: timeout")));
hr = TRK_E_TIMEOUT;
__leave;
}
hr = TRK_E_NOT_FOUND;
if( !(TRK_MEND_DONT_USE_DC & Restrictions) )
{
TrkLog(( TRKDBG_MEND, TEXT("Mend: ConnectAndSearchDomain") ));
hr = ConnectAndSearchDomain( droidBirthLast,
&Restrictions,
&allidsFromDC.droidRevised,
&allidsFromDC.mcid );
}
// ---------------------------------
// Search using the info from the DC
// ---------------------------------
if( GetTickCount() >= dwTickCountDeadline )
{
TrkLog((TRKDBG_MEND, TEXT("Mend: timeout")));
hr = TRK_E_TIMEOUT;
__leave;
}
if( SUCCEEDED(hr) )
{
TrkLog(( TRKDBG_MEND, TEXT("Mend: SearchChain using IDs from DC") ));
allidsResult = allidsFromDC;
// Specify USE_SPECIFIED_MCID so that we don't look up the volid
// in the DC; the DC already mapped the volid to the mcid in the
// ConnectAndSearchDomain call.
hr = SearchChain( IDL_handle, -1, dwTickCountDeadline, &Restrictions,
USE_SPECIFIED_MCID,
&allidsResult, tsz );
}
// ---------------------
// Search using the logs
// ---------------------
if( GetTickCount() >= dwTickCountDeadline )
{
TrkLog((TRKDBG_MEND, TEXT("Mend: timeout")));
hr = TRK_E_TIMEOUT;
__leave;
}
if( FAILED(hr) && TRK_E_REFERRAL == hrFirst )
{
TrkLog(( TRKDBG_MEND, TEXT("Mend: SearchChain using IDs from Log") ));
allidsResult = allidsFromLog;
hr = SearchChain( IDL_handle, -1, dwTickCountDeadline, &Restrictions, SEARCH_FLAGS_DEFAULT,
&allidsResult, tsz );
}
// If we still haven't found it, try searching the last known machine
// for potential files. Potential files are ignored if a referral is found
// in the log, so we block usage of the log.
if( GetTickCount() >= dwTickCountDeadline )
{
TrkLog((TRKDBG_MEND, TEXT("Mend: timeout")));
hr = TRK_E_TIMEOUT;
__leave;
}
if( TRK_E_NOT_FOUND == hr && TRK_E_UNAVAILABLE != hrFirst )
{
allidsResult.droidBirth = droidBirthLast;
allidsResult.droidRevised = droidLast;
allidsResult.mcid = mcidLast;
TrkLog(( TRKDBG_MEND, TEXT("Mend: SearchChain using IDs from client, don't use log") ));
Restrictions |= TRK_MEND_DONT_USE_LOG;
hr = SearchChain( IDL_handle, 1, dwTickCountDeadline, &Restrictions, SEARCH_FLAGS_DEFAULT,
&allidsResult, tsz );
}
}
__except(BreakOnDebuggableException())
{
hr = GetExceptionCode();
}
//} while (ft.Redo(hr));
// If the birth ID doesn't look correct, consider this a potential
// hit.
if( SUCCEEDED(hr) )
{
if( CVolumeId() == allidsResult.droidBirth.GetVolumeId()
||
CObjId() == allidsResult.droidBirth.GetObjId() )
{
TrkLog(( TRKDBG_MEND, TEXT("Birth ID doesn't look valid, flagging as potential hit") ));
hr = TRK_E_POTENTIAL_FILE_FOUND;
}
}
// Did the last search step succeed, or return a potential file?
if( SUCCEEDED(hr) || TRK_E_POTENTIAL_FILE_FOUND == hr )
{
TrkAssert( 0 < _tcslen(tsz) );
if( *pcbPath > _tcslen(tsz) * sizeof(WCHAR) )
{
tcstowcs(pwsz, tsz);
*pdroidBirthNew = allidsResult.droidBirth;
*pdroidNew = allidsResult.droidRevised;
*pmcidNew = allidsResult.mcid;
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
*pcbPath = ( _tcslen(tsz) + 1 ) * sizeof(WCHAR);
}
}
// Or, did an earlier search step return a potential file?
else if( fPotential )
{
hr = TRK_E_POTENTIAL_FILE_FOUND;
if( *pcbPath > _tcslen(tszPotential) * sizeof(WCHAR) )
{
tcstowcs(pwsz, tszPotential);
*pdroidBirthNew = allidsPotential.droidBirth;
*pdroidNew = allidsPotential.droidRevised;
*pmcidNew = allidsPotential.mcid;
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW);
*pcbPath = ( _tcslen(tszPotential) + 1 ) * sizeof(WCHAR);
}
}
// Test hook: If requested, pause here to allow timeout testing
if( Restrictions & TRK_MEND_SLEEP_DURING_MEND )
{
TrkLog(( TRKDBG_MEND, TEXT("Mend: sleep 15 seconds (for testing)") ));
Sleep( 15 * 1000 );
}
TrkLog(( TRKDBG_MEND, TEXT("MendLink returned %s(%08x) \"%ws\""),
GetErrorString(hr), hr,
(S_OK == hr || TRK_E_POTENTIAL_FILE_FOUND == hr) ? pwsz : L""
));
return(hr);
} // CTrkWksSvc::MendLink()
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::GetVolumeTrackingInformation
//
// This method is unused (it was being used by a utility that ran on the DC
// and called down to a workstation to get info about its volumes).
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::GetVolumeTrackingInformation( const CVolumeId & volid,
TrkInfoScope scope,
TRK_VOLUME_TRACKING_INFORMATION_PIPE pipeVolInfo )
{
return( E_NOTIMPL );
#if 0
HRESULT hr = S_OK;
CVolumeEnumerator VolEnum;
CVolume *pvol = NULL;
TRK_VOLUME_TRACKING_INFORMATION rgvolinfo[10];
int iVolInfo = -1;
TrkLog(( TRKDBG_WKS, TEXT("Getting volume-tracking information") ));
TrkAssert( (TRKINFOSCOPE_MACHINE == scope) ^ (TRKINFOSCOPE_VOLUME == scope) );
__try
{
// -----------------
// Get *all* volumes
// -----------------
if( TRKINFOSCOPE_MACHINE == scope )
{
// Get an enumerator
VolEnum = _volumes.Enum();
// Get the first volume
pvol = VolEnum.GetNextVolume();
// Loop until we run out of volumes
while( NULL != pvol )
{
// Load the data for this volume
iVolInfo++;
rgvolinfo[iVolInfo].volindex = pvol->GetVolIndex();
rgvolinfo[iVolInfo].volume = pvol->GetVolumeId();
// Get the next volume
pvol->Release();
pvol = VolEnum.GetNextVolume();
// If there are no more volumes, or if we've got a full load,
// then send the data we have in rgvolinfo
if( NULL == pvol
||
sizeof(rgvolinfo)/sizeof(*rgvolinfo) - 1 == iVolInfo )
{
// Send the volume information
pipeVolInfo.push( pipeVolInfo.state, rgvolinfo, iVolInfo + 1 );
// Reset to the start of rgvolinfo.
iVolInfo = -1;
}
}
} // if( NULL == ptszShareName )
// ---------------------
// Get a *single* volume
// ---------------------
else
{
TrkAssert( TRKINFOSCOPE_VOLUME == scope );
TrkAssert( CVolumeId() != volid );
NTSTATUS status = STATUS_SUCCESS;
// Get the CVolume for this volume
pvol = _volumes.FindVolume( volid );
if( NULL == pvol )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't find volid %s"),
(const TCHAR*)CDebugString(volid) ));
TrkRaiseWin32Error( ERROR_FILE_NOT_FOUND );
}
// Send the volume info
rgvolinfo[0].volindex = pvol->GetVolIndex();
rgvolinfo[0].volume = pvol->GetVolumeId();
pipeVolInfo.push( pipeVolInfo.state, rgvolinfo, 1 );
} // if( NULL == ptszShareName ) ... else
// Show that we're done with the pipe
pipeVolInfo.push( pipeVolInfo.state, NULL, 0 );
}
__except( BreakOnDebuggableException() )
{
hr = GetExceptionCode();
}
if (pvol)
pvol->Release();
return( hr );
#endif // #if 0
} // CTrkWksSvc::GetVolumeTrackingInformation()
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::GetFileTrackingInformation
//
// This method is unused (it was being used by a utility that ran on the DC
// and called down to a workstation to get info about its link sources).
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::GetFileTrackingInformation( const CDomainRelativeObjId & droidCurrent,
TrkInfoScope scope,
TRK_FILE_TRACKING_INFORMATION_PIPE pipeFileInfo )
{
return( E_NOTIMPL );
#if 0
HRESULT hr = S_OK;
NTSTATUS status;
CVolumeEnumerator VolEnum;
CVolume *pvol = NULL; // Doesn't need to be freed
HANDLE hFile = NULL;
TRK_FILE_TRACKING_INFORMATION rgfileinfo[10];
int iFileInfo = -1;
TCHAR tszRelativePathBase[ MAX_PATH ];
TrkLog(( TRKDBG_WKS, TEXT("Getting file-tracking information") ));
__try
{
if( TRKINFOSCOPE_ONE_FILE == scope )
{
CDomainRelativeObjId droidT, droidBirth;
pvol = _volumes.FindVolume( droidCurrent.GetVolumeId() );
if( NULL == pvol )
{
TrkLog((TRKDBG_ERROR, TEXT("Couldn't find volid %s"),
(const TCHAR*)CDebugString(droidCurrent.GetVolumeId()) ));
TrkRaiseWin32Error( ERROR_FILE_NOT_FOUND );
}
if( !pvol->OpenFile( droidCurrent.GetObjId(),
SYNCHRONIZE | FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
&hFile ) )
{
hFile = NULL;
TrkLog((TRKDBG_ERROR, TEXT("Couldn't open file")));
TrkRaiseWin32Error( ERROR_FILE_NOT_FOUND );
}
status = QueryVolRelativePath( hFile, &rgfileinfo[0].tszFilePath[2] );
if( !NT_SUCCESS(status) )
{
TrkLog((TRKDBG_ERROR, TEXT("Couldn't query file for vol-relative path")));
TrkRaiseNtStatus( status );
}
rgfileinfo[0].tszFilePath[0] = (TCHAR)(0 <= pvol->GetVolIndex() ? TEXT('A') + pvol->GetVolIndex() : TEXT('?'));
rgfileinfo[0].tszFilePath[1] = TEXT(':');
// BUGBUG P2: Optimize so we don't have to get droidT
status = GetDroids( hFile, &droidT, &droidBirth, RGO_READ_OBJECTID );
if( !NT_SUCCESS(status) )
{
TrkLog((TRKDBG_ERROR, TEXT("Couldn't get droids in GetFileTrkInfo")));
TrkRaiseNtStatus( status );
}
TrkAssert( droidT == droidCurrent );
NtClose( hFile ); hFile = NULL;
rgfileinfo[0].droidBirth = droidBirth;
rgfileinfo[0].droidLast = droidCurrent;
rgfileinfo[0].hr = S_OK;
pipeFileInfo.push( pipeFileInfo.state, rgfileinfo, 1 );
}
else if( TRKINFOSCOPE_DIRECTORY == scope )
{
TrkRaiseException( E_NOTIMPL );
}
else
{
if( TRKINFOSCOPE_VOLUME == scope )
{
// Get the volume object
TrkAssert(!pvol);
pvol = _volumes.FindVolume( droidCurrent.GetVolumeId() );
if( NULL == pvol )
{
TrkLog((TRKDBG_ERROR, TEXT("Couldn't find volid %s"),
(const TCHAR*)CDebugString(droidCurrent.GetVolumeId()) ));
TrkRaiseWin32Error( ERROR_FILE_NOT_FOUND );
}
}
else if( TRKINFOSCOPE_MACHINE == scope )
{
VolEnum = _volumes.Enum();
TrkAssert(!pvol);
pvol = VolEnum.GetNextVolume(); // BUGBUG P1: ref count on enum
if( NULL == pvol )
{
TrkLog((TRKDBG_ERROR, TEXT("Couldn't find first volume in enumerator")));
TrkRaiseWin32Error( ERROR_FILE_NOT_FOUND );
}
}
else
{
TrkRaiseException( E_NOTIMPL );
}
while( NULL != pvol )
{
CObjIdEnumerator objidenum;
CObjId VolRelativeFileTrackingInfoObjId;
CDomainRelativeObjId VolRelativeFileTrackingInfoDroid;
if( !pvol->EnumObjIds( &objidenum ))
{
pvol->Release();
pvol = VolEnum.GetNextVolume();
continue;
}
iFileInfo = -1;
if( objidenum.FindFirst( &VolRelativeFileTrackingInfoObjId,
&VolRelativeFileTrackingInfoDroid))
{
TCHAR tszRelativePathFile[ MAX_PATH ]; // BUGBUG P1: path
do
{
if( !pvol->OpenFile( VolRelativeFileTrackingInfoObjId,
SYNCHRONIZE | FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE, &hFile ))
{
TrkAssert( FALSE && TEXT("File is in object directory but doesn't exist") );
hFile = NULL;
continue;
}
status = QueryVolRelativePath( hFile, &tszRelativePathFile[2] );
NtClose( hFile ); hFile = NULL;
if( !NT_SUCCESS(status) )
{
TrkLog((TRKDBG_ERROR, TEXT("Couldn't get vol-relative path for objid %s"),
(const TCHAR*)CDebugString(VolRelativeFileTrackingInfoObjId) ));
TrkRaiseNtStatus( status );
}
tszRelativePathFile[0] = (TCHAR)(0 <= pvol->GetVolIndex() ? TEXT('A') + pvol->GetVolIndex() : TEXT('?'));
tszRelativePathFile[1] = TEXT(':');
++iFileInfo;
_tcscpy( rgfileinfo[ iFileInfo ].tszFilePath, tszRelativePathFile );
rgfileinfo[ iFileInfo ].droidBirth = VolRelativeFileTrackingInfoDroid;
rgfileinfo[ iFileInfo ].droidLast
= CDomainRelativeObjId( pvol->GetVolumeId(),
VolRelativeFileTrackingInfoObjId );
if( iFileInfo == sizeof(rgfileinfo)/sizeof(*rgfileinfo) - 1)
{
pipeFileInfo.push( pipeFileInfo.state, rgfileinfo, iFileInfo + 1 );
iFileInfo = -1;
}
} while( objidenum.FindNext( &VolRelativeFileTrackingInfoObjId,
&VolRelativeFileTrackingInfoDroid ));
if( iFileInfo >= 0 )
pipeFileInfo.push( pipeFileInfo.state, rgfileinfo, iFileInfo );
} // if( objidenum.FindFirst( ))
if (pvol)
{
pvol->Release();
}
pvol = VolEnum.GetNextVolume();
} // while( NULL != pVol )
} // if( NULL != hFile ) ... else
} // __try
__finally
{
// Show that we're done with the pipe
pipeFileInfo.push( pipeFileInfo.state, NULL, 0 );
if( NULL != hFile )
NtClose( hFile );
if ( NULL != pvol )
pvol->Release();
}
return( hr );
#endif // #if 0
} // CTrkWksSvc::GetFileTrackingInformation()
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::TriggerVolumeClaims
//
// This method is not currently used. (It was being used by a utility run
// on the DC that would trigger volume claim requests after updating
// the DS.)
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::TriggerVolumeClaims( ULONG cVolumes, const CVolumeId *rgvolid )
{
return( E_NOTIMPL );
#if 0
CVolume *pvol = NULL;
CAvailableDc adc;
HRESULT hr = E_FAIL;
ULONG iVol;
TRKSVR_SYNC_VOLUME rgsyncvol[ NUM_VOLUMES ]; // BUGBUG: fix number of volumes
TRKSVR_MESSAGE_UNION Msg;
TrkLog(( TRKDBG_WKS, TEXT("Triggering %d volume claims"), cVolumes ));
if( 0 == cVolumes || NUM_VOLUMES < cVolumes )
{
hr = E_UNEXPECTED;
goto Exit;
}
__try
{
for( iVol = 0; iVol < cVolumes; iVol++ )
{
pvol = _volumes.FindVolume( rgvolid[iVol] );
if( NULL == pvol )
{
// We don't handle the case where a volume is removed during the call
TrkLog(( TRKDBG_ERROR, TEXT("CTrkWksSvc::TriggerVolumeClaims couldn't find volid %s"),
(const TCHAR*)CDebugString(rgvolid[iVol]) ));
hr = TRK_E_NOT_FOUND;
goto Exit;
}
if( !pvol->LoadSyncVolume( /* CLAIM_VOLUME, */ &rgsyncvol[iVol] ) )
{
TrkLog(( TRKDBG_ERROR, TEXT("CTrkWksSvc::TriggerVolumeClaims couldn't load volid %s"),
(const TCHAR*)CDebugString(rgvolid[iVol]) ));
hr = E_FAIL;
goto Exit;
}
pvol->Release();
pvol = NULL;
} // for( iVol = 0; iVol < cVolumes; iVol++ )
Msg.MessageType = SYNC_VOLUMES;
Msg.Priority = PRI_0;
Msg.SyncVolumes.cVolumes = cVolumes;
Msg.SyncVolumes.pVolumes = rgsyncvol;
#ifdef VOL_REPL
Msg.SyncVolumes.cChanges = 0;
Msg.SyncVolumes.ppVolumeChanges = NULL;
#endif
adc.CallAvailableDc(this, &Msg);
for( iVol = 0; iVol < cVolumes; iVol++ )
{
pvol = _volumes.FindVolume( rgvolid[iVol] );
if( NULL == pvol )
{
// We don't handle the case where a volume is removed during this call.
TrkLog(( TRKDBG_ERROR, TEXT("CTrkWksSvc::TriggerVolumeClaims couldn't find volid %s"),
(const TCHAR*)CDebugString(rgvolid[iVol]) ));
hr = TRK_E_NOT_FOUND;
goto Exit;
}
if( !pvol->UnloadSyncVolume( &rgsyncvol[iVol] ))
{
TrkLog(( TRKDBG_ERROR, TEXT("CTrkWksSvc::TriggerVolumeClaims couldn't unload volid %s"),
(const TCHAR*)CDebugString(rgvolid[iVol]) ));
hr = E_FAIL;
goto Exit;
}
pvol->Release();
pvol = NULL;
}
}
__finally
{
if( AbnormalTermination() && NULL != pvol )
pvol->Release();
adc.UnInitialize();
}
hr = S_OK;
Exit:
if (pvol != NULL)
pvol->Release();
return( hr );
#endif // #if 0
} // CTrkWksSvc::TriggerVolumeClaims
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::ConnectAndSearchDomain
//
// This method looks up a birth ID in the DC (trksvr). If it was
// found, it returns the new droid, and the machine that owns that
// droid.
//
// Arguments:
// [droidBirth]
// The ID of the file to look up.
// [pRestrictions]
// The TrkMendRestrictions flags. If we can't talk to the
// DC for some reason, TRK_MEND_DONT_USE_DC will be set.
// [pdroidLast]
// On successful return, holds the file's last known droid.
// [pmcidLast]
// On successful return, identifies the machine that holds
// the volume specified in pdroidLast.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::ConnectAndSearchDomain(IN const CDomainRelativeObjId &droidBirth,
IN OUT DWORD *pRestrictions,
IN OUT CDomainRelativeObjId *pdroidLast,
OUT CMachineId *pmcidLast )
{
TRKSVR_MESSAGE_UNION Msg;
TRK_FILE_TRACKING_INFORMATION TrkFileInfo;
HRESULT hr = TRK_E_UNAVAILABLE;
CAvailableDc adc;
// If the volid in the birth ID isn't specified, then there's nothing
// we can look up.
if( CVolumeId() == droidBirth.GetVolumeId() )
return( TRK_E_NOT_FOUND );
// Also, if there is no DC, then there's no need trying to RPC to it.
else if( _configWks._fIsWorkgroup )
return( TRK_E_UNAVAILABLE );
__try
{
memset( &TrkFileInfo, 0, sizeof(TrkFileInfo) );
TrkFileInfo.droidBirth = droidBirth;
TrkFileInfo.droidLast = *pdroidLast;
TrkFileInfo.mcidLast = CMachineId();
Msg.MessageType = SEARCH;
Msg.Priority = PRI_0;
Msg.Search.cSearch = 1;
Msg.Search.pSearches = &TrkFileInfo;
// Send the search request to trksvr.
adc.CallAvailableDc(&Msg);
// Was it found?
if( TrkFileInfo.hr == S_OK )
{
// Get the last known droid & mcid for return.
*pdroidLast = TrkFileInfo.droidLast;
*pmcidLast = TrkFileInfo.mcidLast;
hr = S_OK;
_volumeLocCache.AddVolume( TrkFileInfo.droidLast.GetVolumeId(), TrkFileInfo.mcidLast );
}
else
{
// Either the last/birth DROIDs weren't found, or they mapped
// to a volume that didn't exist.
hr = TRK_E_NOT_FOUND;
if( TRK_E_NOT_FOUND_BUT_LAST_VOLUME_FOUND == TrkFileInfo.hr
||
TRK_E_NOT_FOUND_AND_LAST_VOLUME_NOT_FOUND == TrkFileInfo.hr )
{
// The last/birth DROIDs weren't found. If the error was
// TRK_E_NOT_FOUND_BUT_LAST_VOLUME_FOUND, then the volume
// for droidLast did exist as was looked up. If the error
// was just TRK_E_NOT_FOUND, then the volume for droidLast
// couldn't be found. In either case, take this opportunity
// to add it to the volume cache, because we're probably about
// to use it in a fallback search.
_volumeLocCache.AddVolume( TrkFileInfo.droidLast.GetVolumeId(), TrkFileInfo.mcidLast );
}
}
}
__except (BreakOnDebuggableException())
{
hr = TRK_E_UNAVAILABLE;
if( HRESULT_FROM_WIN32(RPC_S_INVALID_TAG) == GetExceptionCode() )
{
// We get this error when we talk to a beta2 DC. Retry
// the request using the old two-call mechanism.
TrkLog(( TRKDBG_MEND, TEXT("Trying downlevel ConnectAndSearchDomain") ));
hr = OldConnectAndSearchDomain( droidBirth, pdroidLast, pmcidLast );
}
else
{
// Something's wrong with the DC and there's no point
// trying to call it again during this mend operation.
*pRestrictions |= TRK_MEND_DONT_USE_DC;
}
}
TrkLog((TRKDBG_MEND, TEXT("ConnectAndSearchDomain returning %s"), GetErrorString(hr)));
TrkAssert(hr == S_OK ||
hr == TRK_E_NOT_FOUND ||
hr == TRK_E_UNAVAILABLE);
return(hr);
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::OldConnectAndSearchDomain
//
// This method is functionally equivalent to ConnectAndSearchDomain.
// The difference is that it uses an older interface, it makes
// an old_SEARCH request followed by a FIND_VOLUME request (the
// modern SEARCH request returns the volume, making the FIND_VOLUME
// request unecessary).
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::OldConnectAndSearchDomain(IN const CDomainRelativeObjId & droidBirth,
IN OUT CDomainRelativeObjId *pdroidLast,
OUT CMachineId *pmcidLast )
{
HRESULT hr = S_OK;
CAvailableDc adc;
__try
{
TRKSVR_MESSAGE_UNION Msg;
old_TRK_FILE_TRACKING_INFORMATION OldTrkFileInfo;
TRKSVR_SYNC_VOLUME SyncVolume;
// Search for the the latest droid.
OldTrkFileInfo.droidBirth = droidBirth;
OldTrkFileInfo.droidLast = *pdroidLast;
Msg.MessageType = old_SEARCH;
Msg.Priority = PRI_0;
Msg.old_Search.cSearch = 1;
Msg.old_Search.pSearches = &OldTrkFileInfo;
adc.CallAvailableDc(&Msg);
if( S_OK != OldTrkFileInfo.hr )
{
hr = TRK_E_NOT_FOUND;
__leave;
}
// Search for the location of the volume in the droid just returned.
SyncVolume.hr = S_OK;
SyncVolume.SyncType = FIND_VOLUME;
SyncVolume.volume = OldTrkFileInfo.droidLast.GetVolumeId();
Msg.MessageType = SYNC_VOLUMES;
Msg.Priority = PRI_0;
Msg.SyncVolumes.cVolumes = 1;
Msg.SyncVolumes.pVolumes = &SyncVolume;
hr = adc.CallAvailableDc(&Msg);
if( S_OK != hr || S_OK != SyncVolume.hr )
{
hr = TRK_E_NOT_FOUND;
__leave;
}
// We found both the droid and the machine.
TrkLog(( TRKDBG_MEND, TEXT("Downlevel ConnectAndSearchDomain finds %s, %s"),
(const TCHAR*)CDebugString(OldTrkFileInfo.droidLast),
(const TCHAR*)CDebugString(SyncVolume.machine) ));
*pdroidLast = OldTrkFileInfo.droidLast;
*pmcidLast = SyncVolume.machine;
}
__except( BreakOnDebuggableException() )
{
}
return( hr );
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::ConnectAndSearchMachine
//
// RPC to the machine specified by the mcid parameter, and execute the
// LnkSearchMachine method. If the target is actually the local machine,
// this method just calls StubLnkSearchMachine directly.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::ConnectAndSearchMachine(RPC_BINDING_HANDLE IDL_handle,
const CMachineId &mcid,
IN OUT DWORD *pRestrictions,
IN OUT CDomainRelativeObjId *pdroidBirthLast,
IN OUT CDomainRelativeObjId *pdroidLast,
OUT CMachineId *pmcidLast,
OUT TCHAR *ptsz)
{
CRpcClientBinding rc;
HRESULT hr;
CDomainRelativeObjId droidBirthNext, droidNext;
CMachineId mcidNext;
RPC_STATUS rpc_status = S_OK;
BOOL fImpersonating = FALSE;
__try
{
//FAILTEST();
// Are we calling the local machine?
if( CMachineId(MCID_LOCAL) == mcid )
{
// Yes, don't bother going through RPC.
// (Actually, this isn't just for performance; this is also so that
// a local path may be returned.)
hr = StubLnkSearchMachine( IDL_handle, *pRestrictions,
pdroidBirthLast, pdroidLast,
&droidBirthNext, &droidNext, &mcidNext, ptsz );
}
// Or, is this an unservicable request?
else if( CMachineId() == mcid )
hr = TRK_E_UNAVAILABLE;
// Otherwise, RPC to mcid.
else
{
// Impersonate the client during this call, so that the target
// can determine what UNC path is best for this user.
if( RpcSecurityEnabled() ) // Normal case
{
rpc_status = RpcImpersonateClient( IDL_handle );
if( STATUS_SUCCESS != rpc_status )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't impersonate client") ));
TrkRaiseWin32Error( rpc_status );
}
fImpersonating = TRUE;
}
else // Test case
{
if( !ImpersonateSelf( SecurityImpersonation ))
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't impersonate self") ));
TrkRaiseLastError();
}
fImpersonating = TRUE;
}
//
// Set up the client binding after the impersonation so that RPC
// picks up the right user security info - but specify no Rpc auth
// so that we get named pipes auth
//
for( int cRetries = 0; cRetries < 2; cRetries++ )
{
BOOL fContinue = FALSE;
// We'll try the normal endpoint name (trkwks) first. If that gives
// us rpc_s_server_unavailable, we'll try the Win2K name (ntsvcs).
// (This change happened when we moved from services.exe to svchost.)
rc.RcInitialize(mcid,
s_tszTrkWksRemoteRpcProtocol,
0 == cRetries
? s_tszTrkWksRemoteRpcEndPoint
: s_tszTrkWksRemoteRpcEndPointOld,
NO_AUTHENTICATION);
TrkLog(( TRKDBG_MEND, TEXT("Attempting LnkSearchMachine on %s"),
0 == cRetries
? s_tszTrkWksRemoteRpcEndPoint
: s_tszTrkWksRemoteRpcEndPointOld ));
__try
{
hr = LnkSearchMachine(rc, *pRestrictions,
const_cast<const CDomainRelativeObjId*>(pdroidBirthLast),
const_cast<const CDomainRelativeObjId*>(pdroidLast),
&droidBirthNext, &droidNext, &mcidNext, ptsz );
}
__except( (0 == cRetries && RPC_S_SERVER_UNAVAILABLE == GetExceptionCode())
? EXCEPTION_EXECUTE_HANDLER
: EXCEPTION_CONTINUE_SEARCH )
{
// On the first attempt, we got an error consistent with calling
// a Win2K box. Try again (and this time we'll use the endpoint name
// that was used back then).
rc.UnInitialize();
fContinue = TRUE;
}
if( !fContinue )
break;
}
if( FAILED(hr) )
{
TrkLog(( TRKDBG_MEND, TEXT("LnkSearchMachine(%s) returns %08x"),
(const TCHAR*)CDebugString(mcid), hr ));
}
} // if( CMachineId( MCID_LOCAL ) == mcid ) ... else
// Did we find the file?
if( SUCCEEDED(hr) || TRK_E_REFERRAL == hr || TRK_E_POTENTIAL_FILE_FOUND == hr )
{
*pdroidBirthLast = droidBirthNext;
*pdroidLast = droidNext;
*pmcidLast = mcidNext;
}
else
if (hr != S_OK && hr != TRK_E_NOT_FOUND && hr != TRK_S_VOLUME_NOT_FOUND)
{
hr = TRK_E_UNAVAILABLE;
}
}
__except(BreakOnDebuggableException())
{
hr = TRK_E_UNAVAILABLE;
}
// Revert to self
if( fImpersonating )
{
if( RpcSecurityEnabled() )
RpcRevertToSelf();
else
RevertToSelf();
}
TrkLog((TRKDBG_MEND, TEXT("ConnectAndSearchMachine returning %s"), GetErrorString(hr)));
TrkAssert(hr == S_OK ||
hr == TRK_E_REFERRAL ||
hr == TRK_E_NOT_FOUND ||
hr == TRK_E_UNAVAILABLE ||
hr == TRK_S_VOLUME_NOT_FOUND ||
hr == TRK_E_POTENTIAL_FILE_FOUND );
return(hr);
}
/*
CMachineId::CMachineId(handle_t ClientBinding)
{
TrkAssert( !TEXT("CMachineId(handle_t)") );
}
*/
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::FindAndSearchVolume
//
// Find the location of a volume, and send a search request to that
// machine. The machine is located by using either the volume ID
// in pdroidLast, or by using the machine ID in pmcidLast, depending
// on what works, what the client specified in pRestrictions, and
// depending on what the caller specified in SearchFlags.
//
// Assuming no special Restrictions or SearchFlags, the algorithm for
// locating a volume is:
//
// - Search the local machine.
//
// - Search the local cache that maps volumes to machines. If
// that fails, or the subsequent call to the machine fails
// with a volume error, continue to the next step.
//
// - Call to the DC and ask it to map the volume ID to the
// current machine ID.
//
// If a search of a remote machine is successful, we add the volid->mcid
// mapping to the local cache for later use.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::FindAndSearchVolume(RPC_BINDING_HANDLE IDL_handle,
IN OUT DWORD *pRestrictions,
IN SEARCH_FLAGS SearchFlags,
IN OUT CDomainRelativeObjId *pdroidBirthLast,
IN OUT CDomainRelativeObjId *pdroidLast,
IN OUT CMachineId *pmcidLast,
TCHAR *ptsz)
{
HRESULT hr = TRK_E_NOT_FOUND;
HRESULT hrFromSearchUsingCachedVolId = TRK_E_NOT_FOUND;
BOOL fFoundVolumeOnThisMachine = FALSE;
BOOL fRecentVolCacheEntryFound = FALSE;
CMachineId mcidSearch;
CMachineId mcidFromVolumeCache;
CAvailableDc adc;
CVolume * pVol = NULL;
CVolumeId volid;
__try
{
// ------------------------------------------------------
// Determine what machine to search and put in mcidSearch
// ------------------------------------------------------
// If this isn't a meaningfull volid, or we don't have a DC in which to
// look up volids, then just use the last machine ID.
if( CVolumeId() == pdroidLast->GetVolumeId()
||
_configWks._fIsWorkgroup
||
(*pRestrictions & TRK_MEND_DONT_USE_VOLIDS)
||
(USE_SPECIFIED_MCID & SearchFlags) )
{
mcidSearch = *pmcidLast;
hr = TRK_E_NOT_FOUND;
TrkLog(( TRKDBG_MEND, TEXT("Didn't search for %s, using machine %s"),
_configWks._fIsWorkgroup ? TEXT("volume in workgroup") : TEXT("volume"),
(const TCHAR*)CDebugString(mcidSearch) ));
}
// Try to find the volume locally
else if( !(TRK_MEND_DONT_SEARCH_ALL_VOLUMES & *pRestrictions)
&&
NULL != (pVol = _volumes.FindVolume( pdroidLast->GetVolumeId()) ))
{
// found the volume on this machine
fFoundVolumeOnThisMachine = TRUE;
mcidSearch = CMachineId(MCID_LOCAL);
hr = S_OK;
TrkLog((TRKDBG_MEND, TEXT("Found volume %s on THIS (%s) machine."),
(const TCHAR*)CDebugString(pdroidLast->GetVolumeId()),
(const TCHAR*)CDebugString(mcidSearch) ));
}
else
{
// The volume isn't on the local machine. See if we can find it in the
// local volume cache.
if( TRK_MEND_DONT_SEARCH_ALL_VOLUMES & *pRestrictions )
hr = TRK_E_NOT_FOUND;
else
hr = _volumeLocCache.FindVolume( pdroidLast->GetVolumeId(),
&mcidFromVolumeCache,
&fRecentVolCacheEntryFound )
? S_OK
: TRK_E_NOT_FOUND;
if (hr == S_OK)
{
// Yes, the volid-to-mcid mapping is in the local cache.
CDomainRelativeObjId droidBirthLast = *pdroidBirthLast;
CDomainRelativeObjId droidLast = *pdroidLast;
CMachineId mcidLast = *pmcidLast;
TCHAR tsz[ MAX_PATH + 1 ];
TrkLog((TRKDBG_MEND, TEXT("LocalCache--> %s (%s)"),
(const TCHAR*)CDebugString(mcidFromVolumeCache),
fRecentVolCacheEntryFound
? TEXT("young cache entry")
: TEXT("old cache entry") ));
mcidSearch = mcidFromVolumeCache;
volid = pdroidLast->GetVolumeId();
// Search using temporaries, so that we can ignore the result if
// we just get a TRK_E_POTENTIAL_FILE_FOUND.
hr = ConnectAndSearchMachine(IDL_handle, mcidSearch, pRestrictions,
&droidBirthLast, &droidLast, &mcidLast, tsz);
// If the volume is good, put it back into the cache. This
// refreshes it so that it's least likely to be removed in a trim.
if (hr != TRK_S_VOLUME_NOT_FOUND
&&
hr != TRK_E_UNAVAILABLE)
{
TrkLog((TRKDBG_MEND, TEXT("%s --> %s"),
(const TCHAR*)CDebugString(mcidSearch),
GetErrorString(hr) ));
_volumeLocCache.AddVolume(volid, mcidSearch);
}
if( SUCCEEDED(hr) )
{
// We found the file and we're done.
*pdroidBirthLast = droidBirthLast;
*pdroidLast = droidLast;
*pmcidLast = mcidLast;
_tcscpy( ptsz, tsz );
__leave;
}
// We didn't find the file. Save this result.
// We might look up the volid in the DC to handle
// the case where the cache is out of date. But if the DC agrees on
// where that volume lives, we won't bother to search again.
hrFromSearchUsingCachedVolId = hr;
} // if (hr == S_OK)
#ifdef VOL_REPL
if (hr != S_OK)
{
hr = _persistentVolumeMap.FindVolume(pdroidLast->GetVolumeId(), &mcidSearch) ? S_OK : TRK_E_NOT_FOUND;
if (hr == S_OK)
{
TrkLog((TRKDBG_MEND, TEXT("FindAndSearchVolume: Volume on machine %s, (found in local persist volume map)"),
CDebugString(mcidSearch)._tsz));
}
}
#endif
// The volume isn't local, or wasn't in the local cache, or if it was in the
// local cache the cache is out of date. So, we'll ask the TrkSvr (DC).
if( hr != S_OK )
{
BOOL fSearchedDC = FALSE;
TRKSVR_SYNC_VOLUME SyncVolume;
SyncVolume.hr = TRK_S_VOLUME_NOT_FOUND;
// Not found on this machine ... go look in the DC for the volume.
// Don't look in the DC, however, if restricted to avoid it,
// or if we had a good (recent) entry for it in the volume cache.
if( !fRecentVolCacheEntryFound
&&
!(TRK_MEND_DONT_USE_DC & *pRestrictions)
&&
!(DONT_USE_DC & SearchFlags) )
{
TRKSVR_MESSAGE_UNION Msg;
VolumeMapEntry * pVolumeChanges = NULL;
SyncVolume.hr = S_OK;
SyncVolume.SyncType = FIND_VOLUME;
SyncVolume.volume = pdroidLast->GetVolumeId();
SyncVolume.machine = CMachineId();
Msg.MessageType = SYNC_VOLUMES;
Msg.Priority = PRI_0;
Msg.SyncVolumes.cVolumes = 1;
Msg.SyncVolumes.pVolumes = &SyncVolume;
#ifdef VOL_REPL
Msg.SyncVolumes.ppVolumeChanges = &pVolumeChanges;
Msg.SyncVolumes.cChanges = 0;
Msg.SyncVolumes.ftFirstChange = CFILETIME(-1);
#endif
__try
{
hr = adc.CallAvailableDc(&Msg);
fSearchedDC = TRUE;
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
hr = GetExceptionCode();
// Something's wrong with the DC and there's no point
// trying to call it again during this mend operation.
*pRestrictions |= TRK_MEND_DONT_USE_DC;
}
} // if( !(TRK_MEND_DONT_USE_DC & *pRestrictions) )
#if DBG
else
{
TrkLog(( TRKDBG_MEND, TEXT("Not searching for volume on DC because of %s, %s, %s"),
fRecentVolCacheEntryFound ? TEXT("VolCache") : TEXT(""),
(TRK_MEND_DONT_USE_DC & *pRestrictions) ? TEXT("Restrictions") : TEXT(""),
(DONT_USE_DC & SearchFlags) ? TEXT("SearchFlags") : TEXT("") ));
}
#endif
// Did we successfully get a mcid back from the DC
// that's different than the one we found in the volume cache?
if( S_OK == hr && S_OK == SyncVolume.hr )
{
// We got an mcid back from the DC
if( SyncVolume.machine != mcidFromVolumeCache )
{
// And the mcid from the DC differs from the one in the
// volume cache (the volume has moved since the time we cached it).
mcidSearch = SyncVolume.machine;
hr = S_OK;
TrkLog((TRKDBG_MEND, TEXT("Found volume %s in DC on %s"),
(const TCHAR*)CDebugString(pdroidLast->GetVolumeId()),
(const TCHAR*)CDebugString(mcidSearch) ));
}
else
{
// We've already searched this volume.
TrkLog((TRKDBG_MEND, TEXT("DC matches volume cache") ));
hr = hrFromSearchUsingCachedVolId;
__leave;
}
}
else
{
// We couldn't find the volume in the DC.
#if DBG
if( fSearchedDC )
{
TrkLog((TRKDBG_MEND, TEXT("DC--> %s -> %s,%s."),
(const TCHAR*)CDebugString(pdroidLast->GetVolumeId()),
GetErrorString(hr),
GetErrorString(SyncVolume.hr) ));
}
#endif
mcidSearch = *pmcidLast;
hr = TRK_E_NOT_FOUND;
}
// Save this result in the volume cache. If we didn't find the volume,
// then we'll be putting a null machine ID into the cache as a way
// of remembering not to ask the DC again in the near future.
if( fSearchedDC )
_volumeLocCache.AddVolume( SyncVolume.volume, SyncVolume.machine );
} // if (hr != S_OK)
} // if (pVol != NULL)
// -------------------------------------------------
// We've found a machine. Connect to it and search.
// -------------------------------------------------
// Save the volid from pdroidLast before it gets overwritten.
volid = pdroidLast->GetVolumeId();
if( !(TRK_MEND_DONT_SEARCH_LAST_MACHINE & *pRestrictions)
||
mcidSearch != *pmcidLast )
{
hr = ConnectAndSearchMachine(IDL_handle, mcidSearch, pRestrictions,
pdroidBirthLast, pdroidLast, pmcidLast, ptsz);
}
else
hr = TRK_E_NOT_FOUND;
// Take advantage of our work to find the owner of this volume, and
// add it to the cache.
if( S_OK == hr && !fFoundVolumeOnThisMachine )
_volumeLocCache.AddVolume(volid, mcidSearch);
// S_OK || TRK_E_REFERRAL || TRK_E_NOT_FOUND || TRK_E_UNAVAILABLE
}
__finally
{
if (pVol != NULL)
{
pVol->Release();
}
if (AbnormalTermination())
{
TrkLog((TRKDBG_MEND, TEXT("FindAndSearchVolume: abnormal termination")));
}
adc.UnInitialize();
}
TrkLog((TRKDBG_MEND, TEXT("Call to %s to FindAndSearchVolume returned %s"),
(const TCHAR*)CDebugString(mcidSearch),
GetErrorString(hr) ));
return(hr);
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::SearchChain
//
// Search for a link source, possibly searching a chain of moves using
// referrals from the log. The caller can specify how many referrals
// (links in the chain) to follow. The search starts at the location
// specified by the IDs in the pallidsLast parameter.
//
//+----------------------------------------------------------------------------
HRESULT
CTrkWksSvc::SearchChain(RPC_BINDING_HANDLE IDL_handle,
int cMaxReferrals,
DWORD dwTickCountDeadline,
IN OUT DWORD *pRestrictions,
IN SEARCH_FLAGS SearchFlags,
IN OUT SAllIDs *pallidsLast,
OUT TCHAR *ptsz)
{
int cReferrals = 0;
HRESULT hr;
IFDBG( CDomainRelativeObjId droidBirthOriginal = pallidsLast->droidBirth );
struct CDroidList
{
CDomainRelativeObjId droid;
CDroidList *pNext;
};
CDroidList *pdroidList = NULL;
// As a sanity check, never search over (100) places.
if( -1 == cMaxReferrals )
cMaxReferrals = _configWks.GetMaxReferrals();
__try
{
while (TRUE)
{
CDroidList *pdroidNode = NULL;
// Abort if the service has been requested to stop.
RaiseIfStopped();
if( GetTickCount() >= dwTickCountDeadline )
{
TrkLog((TRKDBG_MEND, TEXT("Mend: timeout")));
hr = TRK_E_TIMEOUT;
__leave;
}
// Have we searched this droid before?
for( pdroidNode = pdroidList; NULL != pdroidNode; pdroidNode = pdroidNode->pNext )
{
if( pdroidNode->droid == pallidsLast->droidRevised )
{
// Yes, we've see this droid before. Abort.
TrkLog(( TRKDBG_MEND | TRKDBG_WKS,
TEXT("Aborting SearchChain; cycle found at %s"),
(const TCHAR*)CDebugString( pdroidNode->droid ) ));
hr = TRK_E_NOT_FOUND;
goto Exit;
}
}
// Add a new node to the list for this volume (this is used above
// for cycle detection).
pdroidNode = new CDroidList;
if( NULL == pdroidNode )
TrkRaiseWin32Error( ERROR_NOT_ENOUGH_MEMORY );
pdroidNode->droid = pallidsLast->droidRevised;
pdroidNode->pNext = pdroidList;
pdroidList = pdroidNode;
pdroidNode = NULL;
// Now find the volume and search it for the file.
hr = FindAndSearchVolume( IDL_handle, pRestrictions, SearchFlags,
&pallidsLast->droidBirth, &pallidsLast->droidRevised,
&pallidsLast->mcid, ptsz);
// If we got anything other than a referral (including S_OK) we're done.
if( TRK_E_REFERRAL != hr )
{
TrkLog((TRKDBG_MEND | TRKDBG_WKS, TEXT("SearchChain - %s != TRK_E_REFERRAL so returning (%s)"),
GetErrorString(hr),
droidBirthOriginal == pallidsLast->droidBirth
? TEXT("birth IDs match")
: TEXT("birth IDs don't match")
));
goto Exit;
}
// We got a referral. Either return the referral, or follow it.
if( ++cReferrals >= cMaxReferrals )
{
// Return the referral.
TrkLog((TRKDBG_MEND, TEXT("SearchChain: Reached chain limit.")));
goto Exit;
}
}
}
__finally
{
while( NULL != pdroidList )
{
CDroidList *pdroidNext = pdroidList->pNext;
delete pdroidList;
pdroidList = pdroidNext;
}
}
Exit:
TrkAssert( NULL == pdroidList );
return( hr );
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::OnDomainNameChange
//
// This method is called when we receive a notification that the domain
// name has changed (which also happens if we move between a workgroup
// and domain). We handle this by putting all the volumes in the
// not-owned state.
//
//+----------------------------------------------------------------------------
void
CTrkWksSvc::OnDomainNameChange()
{
BOOL fWasWorkgroup;
TrkLog(( TRKDBG_WKS, TEXT("Domain name change notification") ));
_csDomainNameChangeNotify.Enter();
__try
{
RaiseIfStopped();
fWasWorkgroup = _configWks._fIsWorkgroup;
CheckForDomainOrWorkgroup(); // Sets _configWks._fIsWorkgroup
// Workgroup => Domain
if( fWasWorkgroup && !_configWks._fIsWorkgroup )
{
_volumes.InitializeDomainObjects();
StartDomainTimers();
_volumes.StartDomainTimers();
}
// Domain => Workgroup
else if( !fWasWorkgroup && _configWks._fIsWorkgroup )
{
_volumes.UnInitializeDomainObjects();
}
// If we switched into a domain, or between domains, claim
// our volumes to get in sync with the DC or begin the process
// of re-creating the volume.
if( !_configWks._fIsWorkgroup )
_volumes.ForceVolumeClaims();
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
TrkLog(( TRKDBG_ERROR, TEXT("Ignoring exception %08x in OnDomainNameChange"),
GetExceptionCode() ));
}
_csDomainNameChangeNotify.Leave();
}
//+----------------------------------------------------------------------------
//
// CTrkWksSvc::DoWork
//
// This is an override of the PWorkItem base class. This method is called
// on a thread pool thread, and is queued when the service needs to stop.
//
//+----------------------------------------------------------------------------
void
CTrkWksSvc::DoWork()
{
ServiceStopCallback( this, FALSE );
}
//+----------------------------------------------------------------------------
//
// CTestSync::Initialize
//
// Open the test sync semaphores.
//
//+----------------------------------------------------------------------------
#if DBG
void
CTestSync::Initialize(const TCHAR * ptszBaseName)
{
TCHAR tsz[MAX_PATH];
TCHAR * ptszSuffix;
_tcscpy(tsz, ptszBaseName);
ptszSuffix = _tcschr(tsz, 0);
_tcscat(ptszSuffix, TEXT("Reached"));
_hSemReached = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, tsz);
_tcscat(ptszSuffix, TEXT("Wait"));
_hSemWait = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, tsz);
_tcscat(ptszSuffix, TEXT("Flag"));
_hSemFlag = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, tsz);
if (_hSemFlag != NULL && _hSemWait != NULL && _hSemReached != NULL)
{
Beep(2000,500);
Sleep(500);
Beep(2000,500);
}
}
#endif // #if DBG
//+----------------------------------------------------------------------------
//
// CTestSync::UnInitialize
//
// Close down the semaphores.
//
//+----------------------------------------------------------------------------
#if DBG
void
CTestSync::UnInitialize()
{
if (_hSemFlag != NULL)
{
CloseHandle(_hSemFlag);
_hSemFlag = NULL;
}
if (_hSemWait != NULL)
{
CloseHandle(_hSemWait);
_hSemWait = NULL;
}
if (_hSemReached != NULL)
{
CloseHandle(_hSemReached);
_hSemReached = NULL;
}
}
#endif // #if DBG
//+----------------------------------------------------------------------------
//
// CTestSync::ReleaseAndWait
//
// Wait for "Flag", release "Reached", then wait for "Wait".
//
//+----------------------------------------------------------------------------
#if DBG
void
CTestSync::ReleaseAndWait()
{
if (_hSemFlag != NULL && _hSemWait != NULL && _hSemReached != NULL)
{
TrkLog(( TRKDBG_WARNING, TEXT("About to wait for test sync") ));
DWORD dw;
if ((dw = WaitForSingleObject(_hSemFlag, 0)) == WAIT_OBJECT_0)
{
TrkVerify(ReleaseSemaphore(_hSemReached, 1, NULL));
TrkVerify(WAIT_OBJECT_0 == WaitForSingleObject(_hSemWait, INFINITE));
}
else
{
TrkVerify(dw == WAIT_TIMEOUT);
}
}
}
#endif // #if DBG
//+----------------------------------------------------------------------------
//
// CTrkWksRpcServer::Initialize
//
// Register the interface with RPC.
//+----------------------------------------------------------------------------
void
CTrkWksRpcServer::Initialize( SVCHOST_GLOBAL_DATA * pSvcsGlobalData, CTrkWksConfiguration *pTrkWksConfig )
{
RPC_STATUS rpcstatus;
NET_API_STATUS netstatus;
// Register the ncacn_np protocol sequence with RPC (used when we're
// called by another trkwks) as well as ncalrpc (used when we're called
// by CTracker::Search in shell32).
rpcstatus = RpcServerUseProtseqEp( const_cast<TCHAR*>(s_tszTrkWksRemoteRpcProtocol), // ncacn_np
pTrkWksConfig->GetWksMaxRpcCalls(),
const_cast<TCHAR*>(s_tszTrkWksRemoteRpcEndPoint),
NULL );
if( RPC_S_OK != rpcstatus && RPC_S_DUPLICATE_ENDPOINT != rpcstatus )
{
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__,
HRESULT_FROM_WIN32(rpcstatus), s_tszTrkWksRemoteRpcProtocol );
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't register %s/%s(%lu)"),
s_tszTrkWksRemoteRpcProtocol,
s_tszTrkWksRemoteRpcEndPoint,
rpcstatus ));
TrkRaiseWin32Error( rpcstatus );
}
TrkLog(( TRKDBG_RPC, TEXT("UseProtseqEp on %s, %s"),
s_tszTrkWksRemoteRpcProtocol,
s_tszTrkWksRemoteRpcEndPoint ));
rpcstatus = RpcServerUseProtseqEp( const_cast<TCHAR*>(s_tszTrkWksLocalRpcProtocol), // ncalrpc
pTrkWksConfig->GetWksMaxRpcCalls(),
const_cast<TCHAR*>(s_tszTrkWksLocalRpcEndPoint),
NULL );
if( RPC_S_OK != rpcstatus && RPC_S_DUPLICATE_ENDPOINT != rpcstatus )
{
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__,
HRESULT_FROM_WIN32(rpcstatus), s_tszTrkWksLocalRpcProtocol );
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't register %s/%s (%lu)"),
s_tszTrkWksLocalRpcProtocol,
s_tszTrkWksLocalRpcEndPoint,
rpcstatus ));
TrkRaiseWin32Error( rpcstatus );
}
TrkLog(( TRKDBG_RPC, TEXT("UseProtseqEp on %s, %s"),
s_tszTrkWksLocalRpcProtocol,
s_tszTrkWksLocalRpcEndPoint ));
// If we don't have a pSvcsGlobalData (we're not running in services.exe),
// tell RpcServerRegisterIfEx to automatically set up a listen thread
// (by specifying RPC_IF_AUTOLISTEN). Also, since we use static endpoints,
// we don't need to register with the endpoint mapper.
CRpcServer::Initialize( Stubtrkwks_v1_2_s_ifspec,
NULL == pSvcsGlobalData ? RPC_IF_AUTOLISTEN : 0,
pTrkWksConfig->GetWksMaxRpcCalls(),
FALSE, // fSetAuthInfo
NULL ); // Don't register with the endpoint mapper
TrkLog(( TRKDBG_RPC, TEXT("Registered TrkWks RPC server (%d)"), pTrkWksConfig->GetWksMaxRpcCalls() ));
}
//+----------------------------------------------------------------------------
//
// CTrkWksRpcServer::UnInitialize
//
// Unregister the server interface.
//
//+----------------------------------------------------------------------------
void
CTrkWksRpcServer::UnInitialize( SVCHOST_GLOBAL_DATA * pSvcsGlobalData )
{
TrkLog(( TRKDBG_RPC, TEXT("Unregistering TrkWks RPC server") ));
CRpcServer::UnInitialize( );
TrkLog(( TRKDBG_RPC, TEXT("Unregistered TrkWks RPC server") ));
}
//+----------------------------------------------------------------------------
//
// CMountManager::Initialize
//
// Not currently implemented
//
//+----------------------------------------------------------------------------
#if 0
void
CMountManager::Initialize(CTrkWksSvc * pTrkWksSvc, CVolumeManager *pVolMgr )
{
LONG lErr;
UNICODE_STRING ustrMountManagerDriverName;
IO_STATUS_BLOCK IoStatusBlock;
OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS status = STATUS_SUCCESS;
_pTrkWksSvc = pTrkWksSvc;
_pVolMgr = pVolMgr;
_hMountManager = NULL;
_hRegisterWaitForSingleObjectEx = NULL;
_hCompletionEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
if( NULL == _hCompletionEvent )
TrkRaiseLastError();
_info.EpicNumber = 0;
// Open the MountManager device driver
RtlInitUnicodeString( &ustrMountManagerDriverName, MOUNTMGR_DEVICE_NAME );
InitializeObjectAttributes( &ObjectAttributes,
&ustrMountManagerDriverName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
status = NtCreateFile( &_hMountManager,
FILE_READ_ATTRIBUTES|FILE_READ_DATA|SYNCHRONIZE,
&ObjectAttributes,
&IoStatusBlock, NULL,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
FILE_OPEN_IF,
FILE_CREATE_TREE_CONNECTION,
NULL,
0 );
if( !NT_SUCCESS(status) )
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't open the mount manager") ));
TrkRaiseNtStatus(status);
}
_hRegisterWaitForSingleObjectEx
= TrkRegisterWaitForSingleObjectEx( _hCompletionEvent, ThreadPoolCallbackFunction,
static_cast<PWorkItem*>(this), INFINITE,
WT_EXECUTEDEFAULT );
if( NULL == _hRegisterWaitForSingleObjectEx )
{
TrkLog(( TRKDBG_ERROR, TEXT("Failed RegisterWaitForSingleObjectEx in CDomainNameChangeNotify (%lu)"),
GetLastError() ));
TrkRaiseLastError();
}
AsyncListen();
}
#endif // #if 0
//+----------------------------------------------------------------------------
//
// CMountManager::UnInitialize
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
#if 0
void
CMountManager::UnInitialize()
{
if( NULL != _hRegisterWaitForSingleObjectEx )
{
if( !TrkUnregisterWait( _hRegisterWaitForSingleObjectEx ))
{
TrkLog(( TRKDBG_ERROR, TEXT("Failed UnregisterWait for CMountManager (%lu)"),
GetLastError() ));
}
_hRegisterWaitForSingleObjectEx = NULL;
}
if( NULL != _hCompletionEvent )
{
CloseHandle( _hCompletionEvent );
_hCompletionEvent = NULL;
}
if( NULL != _hMountManager )
{
NtClose( _hMountManager );
_hMountManager = NULL;
}
}
#endif // #if 0
//+----------------------------------------------------------------------------
//
// CMountManager::DoWork
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
#if 0
void
CMountManager::DoWork()
{
Raise If Stopped
TrkLog((TRKDBG_WKS, TEXT("CMountManager received a notification (Epic=%d)"), _info.EpicNumber ));
__try
{
// Update drive letters if they've changed, pick up any new volumes,
// and delete the CVolume objects for volumes that have gone away.
//_pVolMgr->RefreshVolumes();
}
__except( BreakOnDebuggableException() )
{
TrkLog(( TRKDBG_ERROR, TEXT("Exception in CMountManager::DoWork (%08x)"), GetExceptionCode() ));
}
AsyncListen();
}
#endif // #if 0
//+----------------------------------------------------------------------------
//
// CMountManager::AsyncListen
//
// Not currently implemented.
//
//+----------------------------------------------------------------------------
#if 0
void
CMountManager::AsyncListen( )
{
NTSTATUS status = STATUS_SUCCESS;
IO_STATUS_BLOCK IoStatusBlock;
MOUNTMGR_CHANGE_NOTIFY_INFO infoIn = _info;
for( int i = 0; i < 2; i++ )
{
TrkAssert( 0 == i || 0 != infoIn.EpicNumber );
status = NtDeviceIoControlFile(
_hMountManager,
_hCompletionEvent, // Event
NULL, // ApcRoutine
NULL, // ApcContext
&IoStatusBlock,
IOCTL_MOUNTMGR_CHANGE_NOTIFY,
&infoIn, // InputBuffer
sizeof(infoIn), // InputBufferLength
&_info, // OutputBuffer
sizeof(_info) // OutputBufferLength
);
if( STATUS_SUCCESS == status )
{
// The MountManager is at a newer EpicNumber than we are. This means that
// changes have occurred for which we didn't receive a notification
// (i.e., we were processing one notification when another was sent).
// This is always the case, though, during service initialization.
if( 0 == infoIn.EpicNumber )
{
// We must be in service initialization. Just resend the ioctl
// with the latest EpicNumber.
infoIn = _info;
TrkAssert( 0 != _info.EpicNumber );
}
else
{
// Fire the event as if it came from an ioctl completion
if( !SetEvent( _hCompletionEvent ))
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't fire mount manager completion event") ));
TrkRaiseLastError();
}
break; // for
}
}
// Ordinarily, we'll get status_pending
else if( STATUS_PENDING )
break;
else
{
TrkLog(( TRKDBG_ERROR, TEXT("Couldn't send mount manager notify ioctl") ));
TrkRaiseNtStatus(status);
}
} // for( int i = 0; i < 2; i++ )
return;
}
#endif
/*
HRESULT
GetTCharsFromPipe( TCHAR_PIPE *ppipe, TCHAR *ptsz, ULONG *pcb )
{
return( E_FAIL );
#if 0
ULONG cbActual = 0;
TCHAR tszVerify[ 1 ];
ppipe->pull( ppipe->state, ptsz, *pcb, &cbActual );
*pcb = cbActual;
if( 0 == cbActual )
return( HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME) );
ppipe->pull( ppipe->state, tszVerify, sizeof(tszVerify), &cbActual );
if( 0 != cbActual )
return( HRESULT_FROM_WIN32(ERROR_BUFFER_OVERFLOW) );
return( S_O );
#endif // #if 0
}
*/
//+----------------------------------------------------------------------------
//
// CDomainNameChangeNotify::Initialize
//
// Call NetRegisterDomainNameChangeNotification, and then register that
// handle with the NTDLL thread pool.
//
//+----------------------------------------------------------------------------
void
CDomainNameChangeNotify::Initialize()
{
NET_API_STATUS NetStatus;
_fInitialized = TRUE;
_hDomainNameChangeNotification = INVALID_HANDLE_VALUE;
__try
{
// Register for domain name change notification
NetStatus = NetRegisterDomainNameChangeNotification(&_hDomainNameChangeNotification);
if(NetStatus != NO_ERROR)
{
_hDomainNameChangeNotification = INVALID_HANDLE_VALUE;
TrkReportInternalError( THIS_FILE_NUMBER, __LINE__, NetStatus, TRKREPORT_LAST_PARAM );
TrkLog((TRKDBG_ERROR, TEXT("Can't register domain name change notification, %08x"), NetStatus));
TrkRaiseWin32Error( NetStatus );
}
else
{
// Register the change handle with the thread pool.
TrkLog((TRKDBG_LOG, TEXT("NetRegisterDomainNameChangeNotification succeeded")));
TrkAssert(_hDomainNameChangeNotification != INVALID_HANDLE_VALUE);
_hRegisterWaitForSingleObjectEx
= TrkRegisterWaitForSingleObjectEx( _hDomainNameChangeNotification, ThreadPoolCallbackFunction,
static_cast<PWorkItem*>(this), INFINITE,
WT_EXECUTEDEFAULT );
if( NULL == _hRegisterWaitForSingleObjectEx )
{
TrkLog(( TRKDBG_ERROR, TEXT("Failed RegisterWaitForSingleObjectEx in CDomainNameChangeNotify (%lu)"),
GetLastError() ));
TrkRaiseLastError();
}
}
}
__except(BreakOnDebuggableException())
{
if(_hDomainNameChangeNotification != INVALID_HANDLE_VALUE)
{
NetUnregisterDomainNameChangeNotification(_hDomainNameChangeNotification);
_hDomainNameChangeNotification = INVALID_HANDLE_VALUE;
}
_fInitialized = FALSE;
}
}
//+----------------------------------------------------------------------------
//
// CDomainNameChangeNotify::UnInitialize
//
// Unregister with the thread pool, then unregister the change notify.
//
//+----------------------------------------------------------------------------
void
CDomainNameChangeNotify::UnInitialize()
{
if( _fInitialized )
{
if( NULL != _hRegisterWaitForSingleObjectEx )
{
if( !TrkUnregisterWait( _hRegisterWaitForSingleObjectEx ))
{
TrkLog(( TRKDBG_ERROR, TEXT("Failed UnregisterWait for CDomainNameChangeNotify (%lu)"),
GetLastError() ));
}
else
TrkLog(( TRKDBG_WKS, TEXT("Unregistered wait for CDomainNameChangeNotify") ));
_hRegisterWaitForSingleObjectEx = NULL;
}
if( INVALID_HANDLE_VALUE != _hDomainNameChangeNotification )
NetUnregisterDomainNameChangeNotification(_hDomainNameChangeNotification);
_hDomainNameChangeNotification = INVALID_HANDLE_VALUE;
_fInitialized = FALSE;
}
}
//+----------------------------------------------------------------------------
//
// CDomainNameChangeNotify::DoWork
//
// This is called when we move into a new domain. Just calls CTrkWksSvc
// to do the work.
//
//+----------------------------------------------------------------------------
void
CDomainNameChangeNotify::DoWork()
{
g_ptrkwks->OnDomainNameChange();
}
Reference in a new issue View git blame Copy permalink