You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
380 lines
9.2 KiB
380 lines
9.2 KiB
// FrcOwn.h : Declaration of the CForceOwnership
|
|
|
|
#ifndef __FRCOWN_H_
|
|
#define __FRCOWN_H_
|
|
|
|
#include "resource.h" // main symbols
|
|
#include <trkwks.hxx>
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CForceOwnership
|
|
class ATL_NO_VTABLE CTrkForceOwnership :
|
|
public CComObjectRootEx<CComSingleThreadModel>,
|
|
public CComCoClass<CTrkForceOwnership, &CLSID_TrkForceOwnership>,
|
|
public IDispatchImpl<ITrkForceOwnership, &IID_ITrkForceOwnership, &LIBID_ITRKADMNLib>
|
|
{
|
|
public:
|
|
CTrkForceOwnership() :
|
|
_idt(_dbc, &_refreshSequenceStorage),
|
|
_voltab(_dbc, &_refreshSequenceStorage),
|
|
_refreshSequenceStorage( &_voltab )
|
|
{
|
|
__try
|
|
{
|
|
_dbc.Initialize(NULL);
|
|
_voltab.Initialize(NULL,0,0);
|
|
_idt.Initialize();
|
|
}
|
|
__except( BreakOnDebuggableException() )
|
|
{
|
|
}
|
|
}
|
|
|
|
DECLARE_REGISTRY_RESOURCEID(IDR_FRCOWN)
|
|
|
|
BEGIN_COM_MAP(CTrkForceOwnership)
|
|
COM_INTERFACE_ENTRY(ITrkForceOwnership)
|
|
COM_INTERFACE_ENTRY(IDispatch)
|
|
END_COM_MAP()
|
|
|
|
// ITrkForceOwnership
|
|
public:
|
|
STDMETHOD(FileStatus)(BSTR bstrUncPath, long lScope, VARIANT *pvarrgbstrFileName, VARIANT* pvarrgbstrFileId, VARIANT* pvarrglongStatus);
|
|
STDMETHOD(VolumeStatus)(BSTR bstrUncPath, long lScope, VARIANT *pvarlongVolIndex,
|
|
VARIANT *pvarbstrVolId, VARIANT *pvarlongStatus);
|
|
STDMETHOD(Files)(BSTR bstrUncPath, long lScope);
|
|
STDMETHOD(Volumes)(BSTR bstrUncPath, long lScope );
|
|
|
|
private:
|
|
|
|
CDbConnection _dbc;
|
|
CVolumeTable _voltab;
|
|
CIntraDomainTable _idt;
|
|
CRefreshSequenceStorage _refreshSequenceStorage;
|
|
};
|
|
|
|
|
|
//
|
|
// This class is used on the client side of an RPC pipe parameter that passes
|
|
// volume tracking information. The client provides a derived class which
|
|
// overrides the push/pull methods as appropriate.
|
|
//
|
|
|
|
class PVolInfoPipeCallback : public TPRpcPipeCallback<TRK_VOLUME_TRACKING_INFORMATION>
|
|
{
|
|
public:
|
|
|
|
virtual void Pull( TRK_VOLUME_TRACKING_INFORMATION *pVolInfo, unsigned long cbBuffer, unsigned long * pcElems ) = 0;
|
|
virtual void Push( TRK_VOLUME_TRACKING_INFORMATION *pVolInfo, unsigned long cElems ) = 0;
|
|
|
|
virtual void Alloc( unsigned long cbRequested, TRK_VOLUME_TRACKING_INFORMATION **ppVolInfo, unsigned long * pcbActual )
|
|
{
|
|
if( cbRequested > sizeof(_rgVolInfo) )
|
|
*pcbActual = sizeof(_rgVolInfo);
|
|
else
|
|
*pcbActual = cbRequested;
|
|
|
|
*ppVolInfo = _rgVolInfo;
|
|
|
|
return;
|
|
}
|
|
|
|
private:
|
|
|
|
TRK_VOLUME_TRACKING_INFORMATION _rgVolInfo[ 26 ];
|
|
|
|
};
|
|
|
|
|
|
//
|
|
// This class is used on the client side of an RPC pipe parameter that passes
|
|
// file tracking information. The client provides a derived class which
|
|
// overrides the push/pull methods as appropriate.
|
|
//
|
|
|
|
class PFileInfoPipeCallback : public TPRpcPipeCallback<TRK_FILE_TRACKING_INFORMATION>
|
|
{
|
|
public:
|
|
|
|
virtual void Pull( TRK_FILE_TRACKING_INFORMATION *pVolInfo, unsigned long cbBuffer, unsigned long * pcElems ) = 0;
|
|
virtual void Push( TRK_FILE_TRACKING_INFORMATION *pFileInfo, unsigned long cElems ) = 0;
|
|
|
|
virtual void Alloc( unsigned long cbRequested, TRK_FILE_TRACKING_INFORMATION **ppFileInfo, unsigned long * pcbActual )
|
|
{
|
|
if( cbRequested > sizeof(_rgFileInfo) )
|
|
*pcbActual = sizeof(_rgFileInfo);
|
|
else
|
|
*pcbActual = cbRequested;
|
|
|
|
*ppFileInfo = _rgFileInfo;
|
|
|
|
return;
|
|
}
|
|
|
|
protected:
|
|
|
|
TRK_FILE_TRACKING_INFORMATION _rgFileInfo[ 32 ];
|
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
// This class is used on the client side of an RPC pipe parameter that passes
|
|
// a path from the client to the server.
|
|
//
|
|
|
|
class CPCPath : public TPRpcPipeCallback<TCHAR>
|
|
{
|
|
public:
|
|
|
|
CPCPath( TCHAR *ptszPath )
|
|
{
|
|
_iPath = 0;
|
|
_tcscpy( _tszPath, ptszPath );
|
|
_cchPath = _tcslen(_tszPath) + 1;
|
|
}
|
|
|
|
public:
|
|
|
|
void Pull( TCHAR *ptszPath, unsigned long cbBuffer, unsigned long * pcElems )
|
|
{
|
|
if( 0 > _iPath )
|
|
{
|
|
*pcElems = 0;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if( sizeof(TCHAR) * (_cchPath - _iPath) > cbBuffer )
|
|
*pcElems = cbBuffer / sizeof(TCHAR);
|
|
else
|
|
*pcElems = _cchPath - _iPath;
|
|
|
|
memcpy( ptszPath, &_tszPath[ _iPath ], *pcElems * sizeof(TCHAR) );
|
|
|
|
if( _iPath + *pcElems >= _cchPath )
|
|
_iPath = -1;
|
|
else
|
|
_iPath += *pcElems;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
void Push( TCHAR *ptszPath, unsigned long cElems )
|
|
{
|
|
TrkAssert( !TEXT("CGetPathPipeCallback::push shouldn't be called") );
|
|
return;
|
|
}
|
|
|
|
void Alloc( unsigned long cbRequested, TCHAR **pptszPath, unsigned long * pcbActual )
|
|
{
|
|
if( cbRequested > sizeof(_tszBuffer) )
|
|
*pcbActual = sizeof(_tszBuffer);
|
|
else
|
|
*pcbActual = cbRequested;
|
|
|
|
*pptszPath = _tszBuffer;
|
|
|
|
return;
|
|
}
|
|
|
|
private:
|
|
|
|
TCHAR _tszPath[ MAX_PATH + 1 ]; // BUGBUG P2: Path
|
|
TCHAR _tszBuffer[ MAX_PATH + 1 ];
|
|
LONG _iPath;
|
|
ULONG _cchPath;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class CPCVolumeStatus : public PVolInfoPipeCallback
|
|
{
|
|
public:
|
|
|
|
CPCVolumeStatus( CVolumeTable *pvoltab ) : _fInitialized(FALSE), _pvoltab(pvoltab) {};
|
|
|
|
public:
|
|
|
|
void Initialize( CMachineId *pmcid, VARIANT *pvarlongVolIndex, VARIANT *pvarbstrVolId, VARIANT *pvarlongStatus );
|
|
void UnInitialize();
|
|
|
|
void Pull( TRK_VOLUME_TRACKING_INFORMATION *pVolInfo, unsigned long cbBuffer, unsigned long * pcElems )
|
|
{
|
|
TrkAssert( !TEXT("CPCVolumeStatus should not be pulled") );
|
|
*pcElems = 0;
|
|
return;
|
|
}
|
|
|
|
void Push( TRK_VOLUME_TRACKING_INFORMATION *pVolInfo, unsigned long cElems );
|
|
|
|
public:
|
|
|
|
HRESULT GetHResult()
|
|
{
|
|
return( _hr );
|
|
}
|
|
|
|
void Compact();
|
|
|
|
private:
|
|
|
|
HRESULT _hr;
|
|
BOOL _fInitialized;
|
|
|
|
CMachineId *_pmcid;
|
|
CVolumeTable *_pvoltab;
|
|
VARIANT *_pvarlongVolIndex;
|
|
VARIANT *_pvarbstrVolId;
|
|
VARIANT *_pvarlongStatus;
|
|
|
|
SAFEARRAYBOUND _sabound;
|
|
LONG _iArrays;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class CPCVolumes : public PVolInfoPipeCallback
|
|
{
|
|
public:
|
|
|
|
CPCVolumes( CMachineId *pmcid,
|
|
CVolumeTable *pvoltab,
|
|
CRefreshSequenceStorage *pRefreshSequenceStorage ) :
|
|
_pmcid(pmcid),
|
|
_pvoltab(pvoltab),
|
|
_pRefreshSequenceStorage(pRefreshSequenceStorage)
|
|
{
|
|
_cVolIds = 0;
|
|
_hr = S_OK;
|
|
};
|
|
|
|
public:
|
|
|
|
void Pull( TRK_VOLUME_TRACKING_INFORMATION *pVolInfo, unsigned long cbBuffer, unsigned long * pcElems )
|
|
{
|
|
TrkAssert( !TEXT("CPCVolumes should not be pulled") );
|
|
*pcElems = 0;
|
|
return;
|
|
}
|
|
|
|
void Push( TRK_VOLUME_TRACKING_INFORMATION *pVolInfo, unsigned long cElems );
|
|
|
|
public:
|
|
|
|
HRESULT GetHResult()
|
|
{
|
|
return( _hr );
|
|
}
|
|
|
|
ULONG Count()
|
|
{
|
|
return( _cVolIds );
|
|
}
|
|
|
|
CVolumeId * GetVolIds()
|
|
{
|
|
return( _rgvolid );
|
|
}
|
|
|
|
|
|
private:
|
|
|
|
HRESULT _hr;
|
|
CMachineId *_pmcid;
|
|
CVolumeTable *_pvoltab;
|
|
CRefreshSequenceStorage *_pRefreshSequenceStorage;
|
|
ULONG _cVolIds;
|
|
CVolumeId _rgvolid[ NUM_VOLUMES ]; // BUGBUG: Fixed # volumes
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class CPCFileStatus : public PFileInfoPipeCallback
|
|
{
|
|
public:
|
|
|
|
CPCFileStatus( CIntraDomainTable *pidt ) : _fInitialized(FALSE), _pidt(pidt) {};
|
|
|
|
public:
|
|
|
|
void Initialize( CMachineId *pmcid, VARIANT *pvarrgbstrFileName, VARIANT *pvarrgbstrFileId, VARIANT *pvarrglongStatus );
|
|
void UnInitialize()
|
|
{
|
|
// Nothing to do, the Variants are cleaned by the caller
|
|
return;
|
|
}
|
|
|
|
void Pull( TRK_FILE_TRACKING_INFORMATION *pFileInfo, unsigned long cbBuffer, unsigned long * pcElems )
|
|
{
|
|
TrkAssert( !TEXT("CPCFileStatus should not be pulled") );
|
|
*pcElems = 0;
|
|
return;
|
|
}
|
|
|
|
void Push( TRK_FILE_TRACKING_INFORMATION *pFileInfo, unsigned long cElems );
|
|
|
|
public:
|
|
|
|
HRESULT GetHResult()
|
|
{
|
|
return( _hr );
|
|
}
|
|
|
|
void Compact();
|
|
|
|
private:
|
|
|
|
HRESULT _hr;
|
|
BOOL _fInitialized;
|
|
|
|
CMachineId *_pmcid;
|
|
CIntraDomainTable
|
|
*_pidt;
|
|
VARIANT *_pvarrgbstrFileName;
|
|
VARIANT *_pvarrgbstrFileId;
|
|
VARIANT *_pvarrglongStatus;
|
|
|
|
SAFEARRAYBOUND _sabound;
|
|
long _iArrays;
|
|
|
|
};
|
|
|
|
class CPCFiles : public PFileInfoPipeCallback
|
|
{
|
|
public:
|
|
|
|
CPCFiles( CIntraDomainTable *pidt )
|
|
{
|
|
_pidt = pidt;
|
|
}
|
|
|
|
public:
|
|
|
|
void Pull( TRK_FILE_TRACKING_INFORMATION *pVolInfo, unsigned long cbBuffer, unsigned long * pcElems )
|
|
{
|
|
TrkAssert( !TEXT("CPCFiles should not be pulled") );
|
|
*pcElems = 0;
|
|
return;
|
|
}
|
|
|
|
void Push( TRK_FILE_TRACKING_INFORMATION *pFileInfo, unsigned long cElems );
|
|
|
|
private:
|
|
|
|
CIntraDomainTable *_pidt;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#endif //__FRCOWN_H_
|