141 lines
4.6 KiB
C++
141 lines
4.6 KiB
C++
#ifndef _SHLKMGR_H_
|
|
#define _SHLKMGR_H_
|
|
|
|
|
|
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
|
//
|
|
// SHLKMGR.H
|
|
//
|
|
// Declaration of the CSharedLockMgr class which inherits from ILockCache
|
|
// and is used in place of CLockCache for httpext. It wraps the shared
|
|
// memory lock cache, needed to support recycling and multiple processes
|
|
// handling dav requests.
|
|
//
|
|
// Copyright 2000 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
|
|
#include <smh.h>
|
|
#include <shlkcache.h>
|
|
#include <singlton.h>
|
|
#include "_fslock.h"
|
|
|
|
/**********************************
|
|
* Class CSharedLockMgr
|
|
*
|
|
***********************************/
|
|
class CSharedLockMgr : private Singleton<CSharedLockMgr>
|
|
{
|
|
// Friend declarations required by Singleton template
|
|
//
|
|
friend class Singleton<CSharedLockMgr>;
|
|
|
|
// Since this is a singleton object we do not want anyone
|
|
// being able to create or destruct this object without
|
|
// going through the CreateInstance or DestroyInstance calls.
|
|
//
|
|
CSharedLockMgr();
|
|
~CSharedLockMgr();
|
|
|
|
// Shared Ptrs to the cache representing the key cache and the
|
|
// cache representing the name cache for this lock object.
|
|
//
|
|
SharedPtr<CInShLockCache> m_spSharedCache;
|
|
SharedPtr<CInShCacheStatic> m_spSharedStatic;
|
|
|
|
// Handle to DAVProc process, used for duplicating handles
|
|
// so that we can use file handles held by DAVProc.
|
|
//
|
|
HANDLE m_hDavProc;
|
|
|
|
// Flag lets us know that the shared memory has been initalized
|
|
// if it has not than we will try to initalize it again.
|
|
//
|
|
BOOL m_fSharedMemoryInitalized;
|
|
|
|
// Critical section to serialize the initialization
|
|
//
|
|
CCriticalSection m_cs;
|
|
|
|
// Uses the m_fSharedMemoryInitalized flag to determine if
|
|
// we need to initalize the shared memory and if we do it does
|
|
// the work to set everything up.
|
|
//
|
|
BOOL SharedMemoryInitalized();
|
|
|
|
// Generate a new lock token ID. This is done here because
|
|
// we need to use the static shared memory data to make sure
|
|
// that the ids are unique across process.
|
|
//
|
|
HRESULT GetNewLockTokenId(__int64* pi64LockID);
|
|
|
|
// Used to get the DAVProcessID that is needed for opening the
|
|
// the handle to the dav process that we need for duplicating handles.
|
|
//
|
|
DWORD GetDAVProcessId()
|
|
{ return (m_spSharedStatic->GetDAVProcessId()); }
|
|
|
|
|
|
// NOT IMPLEMENTED
|
|
//
|
|
CSharedLockMgr& operator=( const CSharedLockMgr& );
|
|
CSharedLockMgr( const CSharedLockMgr& );
|
|
|
|
public:
|
|
|
|
enum
|
|
{ // 3 minutes (in seconds) (until I get this debugged!)
|
|
//
|
|
DWSEC_TIMEOUT_DEFAULT = 60 * 3
|
|
};
|
|
|
|
// Instance creating/destroying routines provided
|
|
// by the Singleton template.
|
|
//=================================
|
|
using Singleton<CSharedLockMgr>::CreateInstance;
|
|
using Singleton<CSharedLockMgr>::DestroyInstance;
|
|
using Singleton<CSharedLockMgr>::Instance;
|
|
|
|
BOOL FLock (CLockFS& lock, DWORD dwsecTimeout = DWSEC_TIMEOUT_DEFAULT);
|
|
HRESULT HrGetLock( LPMETHUTIL pmu, __int64 i64LockId, CLockFS * * pplock );
|
|
BOOL FGetLockNoAuth( __int64 i64LockId, CLockFS * * pplock );
|
|
VOID DeleteLock(__int64 i64LockId);
|
|
LPCWSTR WszGetGuid();
|
|
BOOL FGetLockOnError( IMethUtil * pmu,
|
|
LPCWSTR wszResource,
|
|
DWORD dwLockType,
|
|
BOOL fEmitXML = FALSE,
|
|
CXMLEmitter * pemitter = NULL,
|
|
CXNode * pxnParent = NULL);
|
|
|
|
// CLockCache has an implementation only for Debug mode for this.
|
|
// I am not copying that implemenation for CSharedLockMgr.
|
|
//virtual DWORD GetDefaultTimeoutSeconds();
|
|
|
|
// CSharedLockMgr specific classes
|
|
//=================================
|
|
// Used to generate a new shared data lock token with
|
|
// the appropriate information stored it. Has to be
|
|
// generated from here because of the need to get to the
|
|
// new lock token ID, and to access the lock token guid.
|
|
HRESULT GetNewLockData(LPCWSTR wszResource
|
|
, HANDLE hfile
|
|
, DWORD dwAccess
|
|
, DWORD dwLockType
|
|
, DWORD dwLockScope
|
|
, DWORD dwTimeout
|
|
, LPCWSTR wszOwnerComment
|
|
, HANDLE hit
|
|
, CLockFS& lock);
|
|
|
|
// Used instead of GetHandle because it has the side
|
|
// affect of duplicating the handle and the handle must
|
|
// be closed afterwards. Functions using this implementation
|
|
// of ILockCache should not call GetHandle, but instead just call
|
|
// this function.
|
|
HRESULT GetDAVProcessHandle(HANDLE* phDavProc);
|
|
|
|
};
|
|
|
|
|
|
#endif // end _SHLKMGR_H_ define
|