/**********************************************************************/ /** Microsoft Windows NT **/ /** Copyright(c) Microsoft Corp., 1994 **/ /**********************************************************************/ /*++ tsunami.hxx Declares constants, types, and functions for the Core Cache. FILE HISTORY: MCourage 10-Dec-1997 Created --*/ # ifndef _TSUNAMI_HXX_ # define _TSUNAMI_HXX_ extern "C" { #include #include #include #include # include # include }; #include /* * Class and struct declarations */ class TSVC_CACHE; class STR; typedef struct _INETA_CACHE_STATISTICS INETA_CACHE_STATISTICS; class CFileKey; /* * Ref trace support */ // // Setting TSUNAMI_REF_DEBUG to a non-zero value will enable reference // count logging. // #if DBG #define TSUNAMI_REF_DEBUG 1 #else // !DBG #define TSUNAMI_REF_DEBUG 0 #endif // DBG #if TSUNAMI_REF_DEBUG extern PTRACE_LOG g_pFileRefTraceLog; extern PTRACE_LOG g_pBlobRefTraceLog; #define TS_FILE_TRACE( refcount ) \ if( g_pFileRefTraceLog != NULL ) { \ WriteRefTraceLog( \ g_pFileRefTraceLog, \ (refcount), \ (this) \ ); \ } #define TS_FILE_TRACE_EX( refcount, c1, c2, c3 ) \ if( g_pFileRefTraceLog != NULL ) { \ WriteRefTraceLogEx( \ g_pFileRefTraceLog, \ (refcount), \ (this), \ (c1), \ (c2), \ (c3) \ ); \ } #define TS_BLOB_TRACE( refcount ) \ if( g_pBlobRefTraceLog != NULL ) { \ WriteRefTraceLog( \ g_pBlobRefTraceLog, \ (refcount), \ (this) \ ); \ } #define TS_BLOB_TRACE_EX( refcount, c1, c2, c3 ) \ if( g_pBlobRefTraceLog != NULL ) { \ WriteRefTraceLogEx( \ g_pBlobRefTraceLog, \ (refcount), \ (this), \ (c1), \ (c2), \ (c3) \ ); \ } #else // !TSUNAMI_REF_DEBUG #define TS_FILE_TRACE( refcount ) #define TS_FILE_TRACE_EX( refcount, c1, c2, c3 ) #define TS_BLOB_TRACE( refcount ) #define TS_BLOB_TRACE_EX( refcount, c1, c2, c3 ) #endif // TSUNAMI_REF_DEBUG // // Here we define some "magic" context values to more // easily read the ref logs. // #define TS_MAGIC_TIMEOUT ((PVOID)((ULONG_PTR) 0x77770001)) // timeout #define TS_MAGIC_DELETE ((PVOID)((ULONG_PTR) 0x777700dc)) // delete cached item #define TS_MAGIC_DELETE_NC ((PVOID)((ULONG_PTR) 0x777700d0)) // delete non-cached item #define TS_MAGIC_CLOSE ((PVOID)((ULONG_PTR) 0x7777000c)) // Close Handle #define TS_MAGIC_OPLOCK_2 ((PVOID)((ULONG_PTR) 0x777700b2)) // Oplock break to level 2 #define TS_MAGIC_OPLOCK_0 ((PVOID)((ULONG_PTR) 0x777700b0)) // Oplock break to none #define TS_MAGIC_OPLOCK_FAIL ((PVOID)((ULONG_PTR) 0x7777008f)) // Couldn't oplock a file #define TS_MAGIC_ALLOCATE ((PVOID)((ULONG_PTR) 0x7777000a)) // allocate cache object #define TS_MAGIC_CREATE ((PVOID)((ULONG_PTR) 0x7777008c)) // Create cached file #define TS_MAGIC_CREATE_NC ((PVOID)((ULONG_PTR) 0x77770080)) // Create non-cached file #define TS_MAGIC_ACCESS_CHECK ((PVOID)((ULONG_PTR) 0x777700ac)) // Access check /* * Symbolic constants */ #define TS_FILE_INFO_SIGNATURE ((DWORD)'IFST') #define TS_FREE_FILE_INFO_SIGNATURE ((DWORD)'IFSX') #define TS_BLOB_SIGNATURE ((DWORD)'BOLB') #define TS_FREE_BLOB_SIGNATURE ((DWORD)'BOLX') #define MAX_LENGTH_VIRTUAL_ROOT ( MAX_PATH + 1) #define MAX_LENGTH_ROOT_ADDR ( 50) #define INETA_MAX_OPEN_FILE TEXT("OpenFileInCache") #define INETA_DISABLE_TSUNAMI_CACHING TEXT("DisableMemoryCache") #define INETA_MAX_CACHED_FILE_SIZE TEXT("MaxCachedFileSize") #define INETA_MEM_CACHE_SIZE TEXT("MemCacheSize") #define INETA_ENABLE_SEQUENTIAL_READ TEXT("EnableSequentialRead") #define INETA_DISABLE_TSUNAMI_SPUD TEXT("DisableCacheOplocks") #define INETA_ALWAYS_CHECK_FOR_DUPLICATE_LOGON TEXT("AlwaysCheckForDuplicateLogon") #define INETA_USE_ADVAPI32_LOGON TEXT("UseAdvapi32Logon") #define INETA_CHECK_CERT_REVOCATION TEXT("CheckCertRevocation") #define TS_FILE_CACHE_SHUTDOWN_TIMEOUT (10 * 1000) // // Modifications to this name should also be made in exe\main.c // #define INETA_W3ONLY_NO_AUTH TEXT("W3OnlyNoAuth") #define INETA_MIN_DEF_FILE_HANDLE 300 #define MAX_SIZE_HTTP_INFO 170 #define INETA_CACHE_USE_ACCESS_CHECK TEXT("CacheSecurityDescriptor") #define INETA_DEF_CACHE_USE_ACCESS_CHECK TRUE #define INETA_DEF_MAX_CACHED_FILE_SIZE (256 * 1024) #define INETA_DEF_MEM_CACHE_SIZE ((DWORDLONG)-1) #define INETA_DEF_ENABLE_SEQUENTIAL_READ (0) #define SIZE_PRIVILEGE_SET 128 #define TS_DEFAULT_PATH_SIZE 64 #define SECURITY_DESC_DEFAULT_SIZE 256 #define SECURITY_DESC_GRANULARITY 128 #define RESERVED_DEMUX_START 0x80000000 #define RESERVED_DEMUX_DIRECTORY_LISTING ( RESERVED_DEMUX_START + 1 ) #define RESERVED_DEMUX_ATOMIC_DIRECTORY_GUARD ( RESERVED_DEMUX_START + 2 ) #define RESERVED_DEMUX_OPEN_FILE ( RESERVED_DEMUX_START + 3 ) #define RESERVED_DEMUX_URI_INFO ( RESERVED_DEMUX_START + 4 ) #define RESERVED_DEMUX_PHYSICAL_OPEN_FILE ( RESERVED_DEMUX_START + 5 ) #define RESERVED_DEMUX_FILE_DATA ( RESERVED_DEMUX_START + 6 ) #define RESERVED_DEMUX_QUERY_CACHE ( RESERVED_DEMUX_START + 7 ) #define RESERVED_DEMUX_SSI ( RESERVED_DEMUX_START + 8 ) // The maxium length of an ETag is 16 bytes for the last modified time plus // one byte for the colon plus 2 bytes for the quotes plus 8 bytes for the // system change notification number plus one for the trailing NULL, for a // total of 28 bytes. #define MAX_ETAG_BUFFER_LENGTH 28 #define TS_CACHING_DESIRED 0x00000001 #define TS_NOT_IMPERSONATED 0x00000002 #define TS_NO_ACCESS_CHECK 0x00000004 #define TS_DONT_CACHE_ACCESS_TOKEN 0x00000008 #define TS_USE_WIN32_CANON 0x00000010 #define TS_FORBID_SHORT_NAMES 0x00000020 // // Flags applicable to the different servers // #define TS_IIS_VALID_FLAGS (TS_CACHING_DESIRED | \ TS_NO_ACCESS_CHECK | \ TS_DONT_CACHE_ACCESS_TOKEN | \ TS_NOT_IMPERSONATED | \ TS_USE_WIN32_CANON | \ TS_FORBID_SHORT_NAMES) #define TS_PWS_VALID_FLAGS (TS_NOT_IMPERSONATED | \ TS_USE_WIN32_CANON | \ TS_FORBID_SHORT_NAMES) /* * Global variables */ extern BOOL g_fW3OnlyNoAuth; extern BOOL g_fAlwaysCheckForDuplicateLogon; extern BOOL g_fUseAdvapi32Logon; extern BOOL g_fCertCheckForRevocation; extern BOOL DisableTsunamiCaching; /* * Types */ enum FI_STATE { FI_UNINITIALIZED, FI_OPEN, FI_FLUSHED, FI_FLUSHED_UNINIT, FI_CLOSED }; /*++ Class CFileKey Contains the hashtable key information for a TS_OPEN_FILE_INFO. --*/ class CFileKey { public: CHAR * m_pszFileName; // The file name in upper-case DWORD m_cbFileName; // The number of bytes in the file name // We put the path name here if it fits CHAR m_achFileNameBuf[TS_DEFAULT_PATH_SIZE]; }; typedef BOOL ( *PCONTEXT_FREE_ROUTINE )( PVOID pvOldBlock ); /*++ Class TS_OPEN_FILE_INFO This class maintains the raw information related to open file handles that are cached. In addition to the file handles themselves, the file attribute information and handle for the opening user are both cached. --*/ class TS_OPEN_FILE_INFO { public: TS_OPEN_FILE_INFO(); ~TS_OPEN_FILE_INFO( VOID); BOOL CheckSignature( VOID ) const { return (m_Signature == TS_FILE_INFO_SIGNATURE); } BOOL SetFileName(const CHAR * pszFileName); dllexp BOOL SetHttpInfo( IN PSTR pszDate, int cL ); dllexp BOOL RetrieveHttpInfo( PSTR pS, int *pcHttpInfo ) { CheckSignature(); if ( m_cchHttpInfo ) { memcpy( pS, m_achHttpInfo, m_cchHttpInfo+1 ); *pcHttpInfo = m_cchHttpInfo; return TRUE; } else { return FALSE; } } dllexp HANDLE QueryFileHandle( VOID); PBYTE QueryFileBuffer( VOID) const { return m_pFileBuffer; } HANDLE QueryUser( VOID) const { return m_hUser; } dllexp BOOL IsValid( VOID) const { return (m_hFile != INVALID_HANDLE_VALUE); } dllexp BOOL QuerySize( IN LARGE_INTEGER & liSize) const { liSize.LowPart = m_nFileSizeLow; liSize.HighPart= m_nFileSizeHigh; return (TRUE); } dllexp BOOL QuerySize( IN LPDWORD lpcbFileSizeLow, IN LPDWORD lpcbFileSizeHigh = NULL) const { if ( lpcbFileSizeLow != NULL) { *lpcbFileSizeLow = m_nFileSizeLow; } if ( lpcbFileSizeHigh != NULL) { *lpcbFileSizeHigh = m_nFileSizeHigh; } return ( TRUE); } // QuerySize() dllexp DWORD QueryAttributes( VOID) const { return m_FileAttributes; } PSECURITY_DESCRIPTOR QuerySecDesc(VOID) const { return m_pSecurityDescriptor; } // // This returns the time with a one second resolution (at best) // dllexp BOOL QueryLastWriteTime( OUT LPFILETIME lpFileTime) const { if ( lpFileTime != NULL ) { *((__int64 *) lpFileTime) = m_CastratedLastWriteTime; return ( TRUE); } else { SetLastError( ERROR_INVALID_PARAMETER); return ( FALSE); } } // QueryLastWriteTime() dllexp BOOL WeakETag( void ) const { return ( m_ETagIsWeak ); } dllexp PCHAR QueryETag( void ) const { return ( (PCHAR)m_achETag ); } dllexp VOID MakeStrongETag( void ); dllexp VOID Print( VOID) const; // // Cache only functions // const CFileKey * GetKey( void ) const { return &m_FileKey; } DWORD GetTTL( void ) const { return m_TTL; } VOID DecrementTTL( void ) { DBG_ASSERT(m_TTL != 0); m_TTL--; } VOID SetFileInfo( HANDLE hFile, HANDLE hUser, PSECURITY_DESCRIPTOR pSecDesc, DWORD dwSecDescSize ); VOID SetFileInfo( PBYTE pFileBuff, HANDLE hCopyFile, HANDLE hFile, HANDLE hUser, PSECURITY_DESCRIPTOR pSecDesc, DWORD dwSecDescSize, PSPUD_FILE_INFORMATION pFileInfo ); dllexp BOOL AccessCheck( HANDLE hUser, BOOL bCache ); // // CloseHandle should NOT be called with the lock held. // dllexp VOID CloseHandle( void ); VOID AddRef( VOID ) { LONG cRef = InterlockedIncrement(&m_lRefCount); TS_FILE_TRACE( cRef ); } LONG Deref( VOID ) { TS_FILE_TRACE( m_lRefCount - 1 ); return InterlockedDecrement(&m_lRefCount); } // // As a general rule you should hold the structure // lock when check these properties, however in // some situations you can get away without it. // // Cached, Flushed, and Initialized are stable. Once they // are TRUE they will never be FALSE (although // they can obviously move from FALSE to TRUE). // BOOL IsCached( void ) const { return m_bIsCached; } BOOL IsFlushed( void ) const { return ((m_state != FI_UNINITIALIZED) && (m_state != FI_OPEN)); } BOOL IsInitialized( void ) const { return ((m_state != FI_UNINITIALIZED) && (m_state != FI_FLUSHED_UNINIT)); } // // Unlike the other properties, IsCloseable is not // stable so you ALWAYS have to hold the structure // lock when you call this function. // BOOL IsCloseable( void ) const { return ((m_state == FI_FLUSHED) && (m_dwIORefCount == 0)); } // // The following functions should only be called when // the structure has been Locked. // DWORD AddRefIO( VOID ) { m_dwIORefCount++; m_TTL = 1; return m_dwIORefCount; } DWORD DerefIO( VOID ) { m_dwIORefCount--; return m_dwIORefCount; } DWORD GetIORefCount( VOID ) const { return m_dwIORefCount; } VOID SetCached( VOID ) { m_bIsCached = TRUE; } VOID ClearCached( VOID ) { m_bIsCached = FALSE; } VOID SetFlushed( VOID ) { ASSERT( (m_state == FI_UNINITIALIZED) || (m_state == FI_OPEN) ); if (m_state == FI_UNINITIALIZED) { m_state = FI_FLUSHED_UNINIT; } else if (m_state == FI_OPEN) { m_state = FI_FLUSHED; } } VOID SetInitialized( VOID ) { ASSERT( (m_state == FI_UNINITIALIZED) || (m_state == FI_FLUSHED_UNINIT) ); if (m_state == FI_UNINITIALIZED) { m_state = FI_OPEN; } else { m_state = FI_FLUSHED; } } dllexp BOOL SetContext( VOID * pvContext, PCONTEXT_FREE_ROUTINE pfnContextFree ); dllexp PVOID QueryContext( VOID ) const; VOID FreeContext( VOID ); // // static methods // static BOOL Initialize( DWORD dwMaxFiles ); static VOID Cleanup( void ); static VOID Lock( void ); static VOID Unlock( void ); static void * operator new (size_t s); static void operator delete(void * psi); private: // // member variables // ULONG m_Signature; // // File info data // HANDLE m_hFile; HANDLE m_hCopyFile; PBYTE m_pFileBuffer; HANDLE m_hUser; __int64 m_ftLastWriteTime; __int64 m_CastratedLastWriteTime; ULONG m_FileAttributes; ULONG m_nFileSizeLow; ULONG m_nFileSizeHigh; DWORD m_cbSecDescMaxSize; BYTE m_abSecDesc[SECURITY_DESC_DEFAULT_SIZE]; PSECURITY_DESCRIPTOR m_pSecurityDescriptor; BOOL m_fSecurityDescriptor; CHAR m_achHttpInfo[MAX_SIZE_HTTP_INFO]; DWORD m_cchHttpInfo; CHAR m_achETag[MAX_ETAG_BUFFER_LENGTH]; DWORD m_cchETag; BOOL m_ETagIsWeak; // // Cache state // CFileKey m_FileKey; BOOL m_bIsCached; FI_STATE m_state; DWORD m_dwIORefCount; LONG m_lRefCount; DWORD m_TTL; // // SSI hooks // PVOID m_pvContext; PCONTEXT_FREE_ROUTINE m_pfnFreeRoutine; VOID TS_OPEN_FILE_INFO::SetFileInfoHelper( HANDLE hFile, HANDLE hUser, PSECURITY_DESCRIPTOR pSecDesc, DWORD dwSecDescSize ); // // Static members // static ALLOC_CACHE_HANDLER * sm_pachFileInfos; static CRITICAL_SECTION sm_cs; public: LIST_ENTRY FlushList; VOID TraceCheckpoint(VOID) { TS_FILE_TRACE( -m_lRefCount ); } VOID TraceCheckpointEx(PVOID c1, PVOID c2, PVOID c3) { TS_FILE_TRACE_EX( -m_lRefCount, c1, c2, c3 ); } }; // class TS_OPEN_FILE_INFO typedef TS_OPEN_FILE_INFO * LPTS_OPEN_FILE_INFO; class CBlobKey; typedef BOOL ( *PUSER_FREE_ROUTINE )( PVOID pvOldBlock ); class BLOB_HEADER { public: ULONG Signature; BOOL IsCached; BOOL IsFlushed; PUSER_FREE_ROUTINE pfnFreeRoutine; CBlobKey * pBlobKey; LIST_ENTRY FlushList; LONG lRefCount; DWORD TTL; VOID AddRef( VOID ) { LONG cRef = InterlockedIncrement(&lRefCount); TS_BLOB_TRACE( cRef ); } LONG Deref( VOID ) { TS_BLOB_TRACE( lRefCount - 1 ); return InterlockedDecrement(&lRefCount); } // // NOTE: I don't think I need these for URI's and dirlists // PSECURITY_DESCRIPTOR pSecDesc; HANDLE hLastSuccessAccessToken; VOID TraceCheckpoint(VOID) { TS_BLOB_TRACE( -lRefCount ); } VOID TraceCheckpointEx(PVOID c1, PVOID c2, PVOID c3) { TS_BLOB_TRACE_EX( -lRefCount, c1, c2, c3 ); } }; typedef BLOB_HEADER * PBLOB_HEADER; /*++ Class W3_URI_INFO The structure of URI Object information. This stucture contains pointers to cached meta information about a URI as well as information about the actual file to which the URI is mapped. The file information may be extracted with TsCreateFileFromURI. --*/ #define EXTMAP_UNKNOWN_PTR ((PVOID)( ~0 )) class W3_URI_INFO : public BLOB_HEADER { public: BOOL bIsCached; DWORD dwFileOpenError; UINT cchName; PCHAR pszName; PCHAR pszUnmappedName; class W3_METADATA *pMetaData; BOOL bInProcOnly; // The next 2 BOOL are used to check BOOL bUseAppPathChecked; // when an URI request is runnable only // in inproc. // // private - should not be used outside of cache functions // LPTS_OPEN_FILE_INFO pOpenFileInfo; PVOID pvExtMapInfo; // cache extmap info }; typedef W3_URI_INFO * PW3_URI_INFO; typedef int ( __cdecl * PFN_CMP_WIN32_FIND_DATA) (IN const void * /* PWIN32_FIND_DATA * */ pvFileInfo1, IN const void * /* PWIN32_FIND_DATA * */ pvFileInfo2); // // Following function is to be used by filter function for filtering // of the files requested. The criteria for matching is user supplied. // Arguments: // pFileInfo1 pointer to File Info object under consideration // pContext user supplied context for the Filter Function // Return values: // 0 indicates that there is no match of context to FileInfo ==> filter // 1 indicates that there is a match and hence dont filter // typedef int ( __cdecl * PFN_IS_MATCH_WIN32_FIND_DATA) (IN const WIN32_FIND_DATA * pFileInfo, IN LPVOID pContext); class TS_DIRECTORY_HEADER; // // Following function AlphaCompareFileBothDirInfo() compares the filenames, // of the two given FileInfo present in (**pvFileInfo) // int __cdecl AlphaCompareFileBothDirInfo( IN const void * /* PWIN32_FIND_DATA * */ pvFileInfo1, IN const void * /* PWIN32_FIND_DATA * */ pvFileInfo2); /*++ Class TS_DIRECTORY_INFO This class provides a method to obtain directory listings. The directory listing may be optionally cached transparently. In addition this class provides methods for 1) accessing the information about files in indexed fashion 2) Sort the information about files using a generic sort function given the compare funtion 3) Filters the listing applying filters the list of files available. The strings in the File information obtained are stored as ANSI strings. --*/ class TS_DIRECTORY_INFO : public BLOB_HEADER { public: TS_DIRECTORY_INFO( const TSVC_CACHE & tsCache) : m_cFilesInDirectory ( 0), m_fValid ( FALSE), m_tsCache ( tsCache), m_pTsDirectoryHeader( NULL), m_prgFileInfo ( NULL) { // the data stored may be valid after user calls GetDirectoryListing() } ~TS_DIRECTORY_INFO( VOID) { CleanupThis(); } dllexp VOID CleanupThis( VOID); BOOL IsValid( VOID) const { return ( m_fValid); } dllexp BOOL GetDirectoryListingA( IN LPCSTR pszDirectoryName, IN HANDLE hListingUser); int QueryFilesCount( VOID) const { return ( m_cFilesInDirectory); } const WIN32_FIND_DATA * operator [] ( IN int idx) const { return ( 0 <= idx && idx < QueryFilesCount()) ? GetFileInfoPointerFromIdx( idx) : NULL; } dllexp BOOL SortFileInfoPointers( IN PFN_CMP_WIN32_FIND_DATA pfnCompare); BOOL AlphabeticallySortFileInfo( VOID) { return SortFileInfoPointers( AlphaCompareFileBothDirInfo); } // // Filter functions are used to eliminate some of the file // pointers to be used in scanning ( using operator []). // // // This function uses the pfnMatch to identify the items that dont match // and filters them away from the directory listing generated. // The filter function returns TRUE on success and FALSE if any errors. // dllexp BOOL FilterFiles(IN PFN_IS_MATCH_WIN32_FIND_DATA pfnMatch, IN LPVOID pContext); # ifdef UNICODE BOOL GetDirectoryListingW( IN LPCWSTR pwszDirectoryName, IN HANDLE hListingUser); # define GetDirectoryListing GetDirectoryListingW # else # define GetDirectoryListing GetDirectoryListingA # endif // UNICODE # if DBG VOID Print( VOID) const; #else VOID Print( VOID) const { ; } # endif // DBG private: int m_cFilesInDirectory; BOOL m_fValid; const TSVC_CACHE & m_tsCache; TS_DIRECTORY_HEADER * m_pTsDirectoryHeader; // ptr to dir listing PWIN32_FIND_DATA * m_prgFileInfo; PWIN32_FIND_DATA GetFileInfoPointerFromIdx( IN int idx) const { return ( m_prgFileInfo[idx]); } }; // class TS_DIRECTORY_INFO typedef TS_DIRECTORY_INFO * PTS_DIRECTORY_INFO; /* * Function Prototypes */ /* * Create and Close TS_OPEN_FILE_INFO objects. */ LPTS_OPEN_FILE_INFO TsCreateFile( IN const TSVC_CACHE &TSvcCache, IN LPCSTR lpszName, IN HANDLE OpeningUser, IN DWORD dwOptions ); LPTS_OPEN_FILE_INFO TsCreateFileFromURI( IN const TSVC_CACHE &TSvcCache, IN PW3_URI_INFO pURIInfo, IN HANDLE OpeningUser, IN DWORD dwOptions, IN DWORD *dwError ); BOOL TsCloseHandle( IN const TSVC_CACHE &TSvcCache, IN LPTS_OPEN_FILE_INFO pOpenFile ); BOOL TsCloseURIFile( IN LPTS_OPEN_FILE_INFO pOpenFile ); BOOL TsDerefURIFile( IN LPTS_OPEN_FILE_INFO pOpenFile ); /* * Other file info operations */ BOOL TsDeleteOnClose( IN PW3_URI_INFO pURIInfo, IN HANDLE OpeningUser, OUT BOOL *fDeleted ); PSECURITY_DESCRIPTOR TsGetFileSecDesc( IN LPTS_OPEN_FILE_INFO pFile ); VOID TsFlushFilesWithContext( VOID ); BOOL TsCreateETagFromHandle( IN HANDLE hFile, IN PCHAR ETag, IN BOOL *bWeakETag ); BOOL TsLastWriteTimeFromHandle( IN HANDLE hFile, IN FILETIME *tm ); /* * Create/Close URI functions */ class W3_SERVER_INSTANCE; class W3_METADATA; /* * Cache Setup and Shutdown */ BOOL Tsunami_Initialize( VOID ); VOID Tsunami_Terminate( VOID ); BOOL InitializeCacheScavenger( VOID ); VOID TerminateCacheScavenger( VOID ); /* * Cache Blob Memory Management */ BOOL TsAllocate ( IN const TSVC_CACHE &TSvcCache, IN ULONG cbSize, IN OUT PVOID * ppvNewBlock ); BOOL TsAllocateEx ( IN const TSVC_CACHE &TSvcCache, IN ULONG cbSize, IN OUT PVOID * ppvNewBlock, OPTIONAL PUSER_FREE_ROUTINE pfnFreeRoutine ); BOOL TsFree ( IN const TSVC_CACHE &TSvcCache, IN PVOID pvOldBlock ); /* * Cache/decache */ BOOL TsCacheDirectoryBlob( IN const TSVC_CACHE &TSvcCache, IN PCSTR pszDirectoryName, IN ULONG cchDirectoryName, IN ULONG iDemultiplexor, IN PVOID pvBlob, IN BOOLEAN bKeepCheckedOut, IN PSECURITY_DESCRIPTOR pSecDesc = NULL ); BOOL TsDeCacheCachedBlob( PVOID pvBlob ); /* * Check in/out */ BOOL TsCheckOutCachedBlob( IN const TSVC_CACHE &TSvcCache, IN PCSTR pszDirectoryName, IN ULONG cchDirectoryName, IN ULONG iDemultiplexor, OUT PVOID * ppvBlob, IN HANDLE hAccessToken = NULL, IN BOOL fMayCacheAccessToken = FALSE, OUT PSECURITY_DESCRIPTOR* ppSecDesc = NULL ); BOOL TsCheckInCachedBlob( IN PVOID pvBlob ); BOOL TsCheckInOrFree ( IN PVOID pvOldBlock ); /* * Flush */ BOOL TsCacheFlushDemux( IN ULONG iDemux ); BOOL TsCacheFlush( IN DWORD dwServerMask ); BOOL TsCacheFlushUser( IN HANDLE hUserToken, IN BOOL fDefer ); VOID TsFlushURL( IN const TSVC_CACHE &TSvcCache, IN LPCSTR pszURL, IN DWORD dwURLLength, IN DWORD dwDemux ); BOOL TsExpireCachedBlob( IN const TSVC_CACHE &TSvcCache, IN PVOID pvBlob ); /* * Misc Cache Management */ BOOL TsCacheQueryStatistics( IN DWORD Level, IN DWORD dwServerMask, IN INETA_CACHE_STATISTICS * pCacheCtrs ); BOOL TsCacheClearStatistics( IN DWORD dwServerMask ); typedef int ( __cdecl * PFN_CMP_WIN32_FIND_DATA) (IN const void * /* PWIN32_FIND_DATA * */ pvFileInfo1, IN const void * /* PWIN32_FIND_DATA * */ pvFileInfo2); dllexp BOOL __cdecl IsNameInRegExpressionA( IN LPCSTR pszExpression, IN LPCSTR pszName, IN BOOL fIgnoreCase); // // Utility function for checking to see if a short filename has a longfile // name equivalent. // dllexp DWORD CheckIfShortFileName( IN CONST UCHAR * pszName, IN HANDLE hImpersonation, OUT BOOL * pfShort ); # endif _TSUNAMI_HXX_