windows-xp/Source/XPSP1/NT/inetsrv/iis/inc/oplock/tsunami.hxx

/*++

   Copyright    (c)    1995    Microsoft Corporation

   Module  Name :

       tsunami.hxx

   Abstract:

      Declares the constants, data strutcures and function prototypes
        available for common use for Services from Tsunami.lib

   Author:

       Murali R. Krishnan    ( MuraliK )   2-March-1995
       [ Originally  partly done by t-heathh]

   Project:

       Internet Services Common Functionality ( Tsunami Library)

   Revision History:

--*/

# ifndef _TSUNAMI_HXX_
# define _TSUNAMI_HXX_

/************************************************************
 *     Include Headers
 ************************************************************/

# if defined ( __cplusplus)
extern "C" {
# endif

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <basetyps.h>
#include <lmcons.h>

# include <inetinfo.h>

# include "fsconst.h"       // Defines symbolic constants for FileSystems

# if defined ( __cplusplus)
};
# endif

#include <tscache.hxx>

/************************************************************
 *   Symbolic Constants
 ************************************************************/

#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_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")

//
// 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 SIZE_PRIVILEGE_SET                      128

#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 )

// 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

/************************************************************
 *   Type Definitions
 ************************************************************/


/************************************************************
 *   Global Tsunami variables
 ************************************************************/

extern GENERIC_MAPPING g_gmFile;
extern BYTE g_psFile[SIZE_PRIVILEGE_SET];
extern BOOL g_fCacheSecDesc;
extern BOOL g_fW3OnlyNoAuth;
extern BOOL g_fAlwaysCheckForDuplicateLogon;
extern BOOL g_fUseAdvapi32Logon;
extern BOOL g_fCertCheckForRevocation;


/************************************************************
 *   Function Prototypes
 ************************************************************/

//
// General Functions
//

extern
BOOL Tsunami_Initialize( VOID );

extern
VOID Tsunami_Terminate( VOID );

extern
VOID TsDumpCacheToHtml(IN OUT CHAR * pchBuffer, IN OUT LPDWORD lpcbSize);

# if defined( __cplusplus)
extern "C" {
# endif

//
// Blob Memory management functions : Allocate, Reallocate and Free.
//

typedef BOOL ( *PUSER_FREE_ROUTINE )( PVOID pvOldBlock );

extern
BOOL TsAllocate
(
    IN const TSVC_CACHE     &TSvcCache,
    IN      ULONG           cbSize,
    IN OUT  PVOID *         ppvNewBlock
);

extern
BOOL TsAllocateEx
(
    IN const TSVC_CACHE     &TSvcCache,
    IN      ULONG           cbSize,
    IN OUT  PVOID *         ppvNewBlock,
    OPTIONAL PUSER_FREE_ROUTINE pfnFreeRoutine
);


extern
BOOL TsReallocate
(
    IN const TSVC_CACHE     &TSvcCache,
    IN      ULONG           cbSize,
    IN      PVOID           pvOldBlock,
    IN OUT  PVOID *         ppvNewBlock
);

extern
BOOL TsFree
(
    IN const TSVC_CACHE     &TSvcCache,
    IN      PVOID           pvOldBlock
);

extern
BOOL TsCheckInOrFree
(
    IN      PVOID           pvOldBlock
);



//
//  Cache Manager Functions:  cache, decache, checkout and checkins of blobs
//

extern
BOOL
TsCacheDirectoryBlob(
    IN const TSVC_CACHE     &TSvcCache,
    IN      PCSTR           pszDirectoryName,
    IN      ULONG           iDemultiplexor,
    IN      PVOID           pvBlob,
    IN      BOOLEAN         bKeepCheckedOut,
    IN      PSECURITY_DESCRIPTOR    pSecDesc = NULL
);

extern
BOOL
TsCheckOutCachedBlob(
    IN const TSVC_CACHE             &TSvcCache,
    IN      PCSTR                   pszDirectoryName,
    IN      ULONG                   iDemultiplexor,
    IN      PVOID *                 ppvBlob,
    IN      HANDLE                  hAccessToken = NULL,
    IN      BOOL                    fMayCacheAccessToken = FALSE,
    OUT     PSECURITY_DESCRIPTOR*   ppSecDesc = NULL
);

extern
BOOL
TsCheckInCachedBlob(
    IN      PVOID           pvBlob
);

extern
BOOL
TsExpireCachedBlob(
    IN const TSVC_CACHE     &TSvcCache,
    IN      PVOID           pvBlob
    );

extern
BOOL
TsAdjustCachedBlobSize(
    IN PVOID              pvBlob,
    IN INT                cbSize
    );

extern
BOOL
TsCacheQueryStatistics(
    IN  DWORD       Level,
    IN  DWORD       dwServerMask,
    IN  INETA_CACHE_STATISTICS * pCacheCtrs
    );

extern
BOOL
TsCacheClearStatistics(
    IN  DWORD       dwServerMask
    );

extern
BOOL
TsCacheFlushDemux(
    IN  ULONG       iDemux
    );

extern
BOOL
TsCacheFlush(
    IN  DWORD       dwServerMask
    );

extern
BOOL
TsCacheFlushUser(
    IN  HANDLE      hUserToken,
    IN  BOOL        fDefer
    );

extern
VOID
TsFlushTimedOutCacheObjects(
    VOID
    );

extern
VOID
TsCacheSetSize(
    DWORD cbMemoryCacheSize
    );

extern
DWORD
TsCacheQueryMaxSize(
    VOID
    );

extern
DWORD
TsCacheQuerySize(
    VOID
    );

extern
dllexp
VOID
TsDecreaseFileHandleCount(
    VOID
    );

extern
VOID
TsIncreaseFileHandleCount(
    BOOL
    );

extern
dllexp
BOOL
TsDeCacheCachedBlob(
    PVOID
    );

extern
dllexp
BOOL
TsAddRefCachedBlob(
    PVOID
    );

# if defined( __cplusplus)
};
# endif


//
// defines the DIRECTORY_INFO class and functions to
//   obtain and cache the directory information for a given directory.
//

//
// forwards
//
class TS_DIRECTORY_HEADER;

//
//  Following function  compares the two given pFileInfo and returns
//    0  if pFileInfo1  is == pfFileInfo2
//    -1 if pFileInfo1  is < pFileInfo2
//    +1 if pFileInfo1  is > pFileInfo2
//
typedef int  ( __cdecl * PFN_CMP_WIN32_FIND_DATA)
     (IN const void * /* PWIN32_FIND_DATA *  */  pvFileInfo1,
      IN const void * /* PWIN32_FIND_DATA *  */  pvFileInfo2);

//
// Following function AlphaCompareFileBothDirInfo() compares the filenames,
//   of the two given FileInfo present in (**pvFileInfo)
//
dllexp
int __cdecl
AlphaCompareFileBothDirInfo(
   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);

//
//  Following function RegExpressionMatchFileInfo() assumes that the
//    context passed in is a pointer to null-terminated string and
//    uses regular expression based comparison for matching against
//    file name in WIN32_FIND_DATA passed in.
//
dllexp
int __cdecl
RegExpressionMatchFileInfo(
    IN const WIN32_FIND_DATA * pFileInfo,
    IN LPVOID     pContext);


//
// Checks to see if the given name can be generated using the
// regular expression embedded in the pszExpression.
//
dllexp
BOOL _cdecl
IsNameInRegExpressionA(
    IN LPCSTR   pszExpression,
    IN LPCSTR   pszName,
    IN BOOL     fIgnoreCase);


/*++

  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:

    dllexp
    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()
      }

    dllexp
      ~TS_DIRECTORY_INFO( VOID)
        { CleanupThis(); }

    dllexp
      VOID CleanupThis( VOID);

    dllexp
      BOOL IsValid( VOID) const
        { return ( m_fValid); }

    dllexp
      BOOL
        GetDirectoryListingA(
           IN  LPCSTR          pszDirectoryName,
           IN  HANDLE          hListingUser);

    dllexp
      int  QueryFilesCount( VOID) const
        { return ( m_cFilesInDirectory); }


    dllexp
      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
    dllexp
      BOOL
        GetDirectoryListingW(
           IN  LPCWSTR         pwszDirectoryName,
           IN  HANDLE          hListingUser);


# define GetDirectoryListing         GetDirectoryListingW

# else

# define GetDirectoryListing         GetDirectoryListingA
# endif // UNICODE


# if DBG
    dllexp
    VOID Print( VOID) const;
#else
    dllexp
    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;

    dllexp
      PWIN32_FIND_DATA
        GetFileInfoPointerFromIdx( IN int idx) const
          { return ( m_prgFileInfo[idx]);  }

}; // class TS_DIRECTORY_INFO

typedef   TS_DIRECTORY_INFO  * PTS_DIRECTORY_INFO;

//
// The structure of Physical Open File Information. This structure
// is used to access a file opened by TSCreateFile or TsCreateFileFromURI.
//

typedef struct _PHYS_OPEN_FILE_INFO {
    DWORD                       Signature;
    HANDLE                      hOpenFile;
    HANDLE                      hOpenEvent;
    LIST_ENTRY                  OpenReferenceList;
    BOOL                        fSecurityDescriptor;
    BOOL                        fIsCached;
    DWORD                       dwLastError;
    DWORD                       cbSecDescMaxSize;
    PSECURITY_DESCRIPTOR        abSecurityDescriptor;
    struct _OPLOCK_OBJECT *     pOplock;
} PHYS_OPEN_FILE_INFO, *PPHYS_OPEN_FILE_INFO;

#define PHYS_OBJ_SIGNATURE      ((DWORD)'SYHP')
#define PHYS_OBJ_SIGNATURE_X    ((DWORD)'yhpX')

/*++
  Class TS_OPEN_FILE_INFO

    This class maintains the raw information related to open file handles
     that are possibly cached within user-space.
    In addition to the file handles themselves, the file attribute information
     and handle for the opening user are both cached.

    Presently both constructor and destructor are both dummy to keep in
    tune with original "C" APIs for TsCreateFile() and TsCloseFile() written
    by Heath.
--*/
class  TS_OPEN_FILE_INFO {

#ifndef CHICAGO
  private:
#else
  public:
#endif

    HANDLE   m_hOpeningUser;
    PPHYS_OPEN_FILE_INFO m_PhysFileInfo;
    BY_HANDLE_FILE_INFORMATION  m_FileInfo;
    __int64  m_CastratedLastWriteTime;          // Reduced to 1 second granularity
    CHAR     m_achHttpInfo[MAX_SIZE_HTTP_INFO];
    int      m_cchHttpInfo;
    CHAR     m_achETag[MAX_ETAG_BUFFER_LENGTH];
    DWORD    m_cchETag;
    BOOL     m_ETagIsWeak;
    BOOL     m_fIsCached;

  public:
    TS_OPEN_FILE_INFO( VOID)
      : m_PhysFileInfo( NULL),
        m_hOpeningUser( INVALID_HANDLE_VALUE),
        m_fIsCached( FALSE ),
        m_cchHttpInfo( 0 ),
        m_ETagIsWeak(TRUE)
          { }

    ~TS_OPEN_FILE_INFO( VOID) {}

    dllexp PSECURITY_DESCRIPTOR GetSecurityDescriptor( VOID )
        { return (PSECURITY_DESCRIPTOR)m_PhysFileInfo->abSecurityDescriptor; }

    dllexp DWORD GetSecurityDescriptorMaxLength( VOID )
        { return m_PhysFileInfo->cbSecDescMaxSize; }

    dllexp BOOL IsSecurityDescriptorValid( VOID )
        { return m_PhysFileInfo->fSecurityDescriptor != 0; }

    dllexp VOID SetSecurityDescriptorValid( BOOL fV )
        { m_PhysFileInfo->fSecurityDescriptor = fV; }

    dllexp VOID SetCachedFlag( BOOL flag )
            { m_fIsCached = flag; }

    dllexp BOOL QueryCachedFlag( VOID )
            { return m_fIsCached; }

    BOOL
      SetFileInfo( IN PPHYS_OPEN_FILE_INFO lpPhysFileInfo,
                   IN HANDLE hOpeningUser,
                   IN BOOL   fAtRoot,
                   IN DWORD  cbSecDescCacheSize = 0,
                   IN DWORD  dwAttributes = 0 );

    //
    //  Returns TRUE if info was cached, FALSE if not cached
    //

    dllexp BOOL
      SetHttpInfo( IN PSTR pszDate, int cL );

    dllexp HANDLE
      QueryFileHandle( VOID) const
        { return ( m_PhysFileInfo->hOpenFile); }

    dllexp PPHYS_OPEN_FILE_INFO
      QueryPhysFileInfo( VOID) const
        { ASSERT( m_PhysFileInfo->Signature == PHYS_OBJ_SIGNATURE );
          return ( m_PhysFileInfo); }

    dllexp HANDLE
      QueryOpeningUser( VOID) const
        { return ( m_hOpeningUser); }

    dllexp BOOL
      IsValid( VOID) const
        { return ( m_PhysFileInfo->hOpenFile != INVALID_HANDLE_VALUE); }

    dllexp BOOL
      RetrieveHttpInfo( PSTR pS, int *pcHttpInfo )
        {
            if ( m_cchHttpInfo )
            {
                memcpy( pS, m_achHttpInfo, m_cchHttpInfo+1 );
                *pcHttpInfo = m_cchHttpInfo;
                return TRUE;
            }
            else
                return FALSE;
        }

    dllexp BOOL
      QuerySize( IN LARGE_INTEGER & liSize) const
        {
            if ( IsValid()) {
                liSize.LowPart = m_FileInfo.nFileSizeLow;
                liSize.HighPart= m_FileInfo.nFileSizeHigh;
                return (TRUE);
            } else {
                SetLastError( ERROR_INVALID_PARAMETER);
                return ( FALSE);
            }
        }

    dllexp BOOL
      QuerySize( IN LPDWORD  lpcbFileSizeLow,
                 IN LPDWORD  lpcbFileSizeHigh = NULL) const
        {
            if ( IsValid()) {
                if ( lpcbFileSizeLow != NULL) {
                    *lpcbFileSizeLow = m_FileInfo.nFileSizeLow;
                }

                if ( lpcbFileSizeHigh != NULL) {
                    *lpcbFileSizeHigh = m_FileInfo.nFileSizeHigh;
                }

                return ( TRUE);
            } else {

                SetLastError( ERROR_INVALID_PARAMETER);
                return ( FALSE);
            }

        } // QuerySize()

    dllexp DWORD
      QueryAttributes( VOID) const
        {  return ( IsValid()) ?
             ( m_FileInfo.dwFileAttributes) : 0xFFFFFFFF; }

    //
    //  This returns the time with a one second resolution (at best)
    //

    dllexp BOOL
      QueryLastWriteTime( OUT LPFILETIME  lpFileTime) const
        {
            if ( lpFileTime != NULL && IsValid()) {
                *((__int64 * UNALIGNED) lpFileTime) = m_CastratedLastWriteTime;
                return ( TRUE);
            } else {
                SetLastError( ERROR_INVALID_PARAMETER);
                return ( FALSE);
            }
        } // QueryLastWriteTime()

    //
    //  This returns the time with full resolution from the file system
    //

    dllexp BOOL
      QueryFileSystemLastWriteTime( OUT __int64 UNALIGNED * lpNTTime) const
        {
            if ( lpNTTime != NULL && IsValid()) {
                *((FILETIME * UNALIGNED) lpNTTime) = m_FileInfo.ftLastWriteTime;
                return ( TRUE);
            } else {
                SetLastError( ERROR_INVALID_PARAMETER);
                return ( FALSE);
            }
        } // QueryFileSystemLastWriteTime()


    dllexp BOOL
      WeakETag( void ) const
      { return ( m_ETagIsWeak ); }

    dllexp PCHAR
      QueryETag( void ) const
      { return ( (PCHAR)m_achETag ); }

    dllexp DWORD
      QueryETagLength( void ) const
      { return ( m_cchETag ); }

    dllexp VOID
        MakeStrongETag( void );

# if DBG

    VOID Print( VOID) const;

# endif // DBG

};  // class TS_OPEN_FILE_INFO

typedef  TS_OPEN_FILE_INFO * LPTS_OPEN_FILE_INFO;

#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

//
// 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)

#define TS_PWS_VALID_FLAGS      (TS_NOT_IMPERSONATED | \
                                 TS_USE_WIN32_CANON)



//
// 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.
//

typedef struct _W3_URI_INFO {

    DWORD               bFileInfoValid;
    BOOL                bIsCached;
    HANDLE              hFileEvent;
    LPTS_OPEN_FILE_INFO pOpenFileInfo;
    DWORD               dwFileOpenError;
    UINT                cchName;
    PCHAR               pszName;
    PCHAR               pszUnmappedName;
    class W3_METADATA   *pMetaData;

} W3_URI_INFO, *PW3_URI_INFO;

extern
dllexp
LPTS_OPEN_FILE_INFO
TsCreateFile(
    IN const TSVC_CACHE     &TSvcCache,
    IN      LPCSTR          lpszName,
    IN      HANDLE          OpeningUser,
    IN      DWORD           dwOptions
    );

extern
dllexp
PSECURITY_DESCRIPTOR
TsGetFileSecDesc(
    IN LPTS_OPEN_FILE_INFO  pFile
    );

extern
dllexp
BOOL TsCloseHandle(
    IN const TSVC_CACHE           &TSvcCache,
    IN       LPTS_OPEN_FILE_INFO  pOpenFile
    );


extern
dllexp
LPTS_OPEN_FILE_INFO
TsCreateFileFromURI(
    IN const TSVC_CACHE     &TSvcCache,
    IN      PW3_URI_INFO    pURIInfo,
    IN      HANDLE          OpeningUser,
    IN      DWORD           dwOptions,
    IN      DWORD           *dwError
    );

extern
dllexp
BOOL TsCloseURIFile(
    IN       LPTS_OPEN_FILE_INFO  pOpenFile
    );

extern
dllexp
BOOL TsCreateETagFromHandle(
    IN      HANDLE          hFile,
    IN      PCHAR           ETag,
    IN      BOOL            *bWeakETag
    );

extern
dllexp
BOOL TsLastWriteTimeFromHandle(
    IN      HANDLE          hFile,
    IN      FILETIME        *tm
    );

extern
dllexp
VOID
TsFlushURL(
    IN const TSVC_CACHE     &TSvcCache,
    IN      LPCSTR          pszURL,
    IN      DWORD           dwURLLength,
    IN      DWORD           dwDemux
    );

# endif // _TSUNAMI_HXX_

/************************ End of File ***********************/