2644 lines
64 KiB
C++
2644 lines
64 KiB
C++
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ssinc.cxx
|
|
|
|
Abstract:
|
|
|
|
This module contains the server side include processing code. We aim
|
|
for support as specified by iis\spec\ssi.doc. The code is based on
|
|
existing SSI support done in iis\svcs\w3\server\ssinc.cxx.
|
|
|
|
Author:
|
|
|
|
Bilal Alam (t-bilala) 20-May-1996
|
|
|
|
--*/
|
|
|
|
#include "ssinc.hxx"
|
|
|
|
//
|
|
// These are available SSI commands
|
|
//
|
|
|
|
enum SSI_COMMANDS
|
|
{
|
|
SSI_CMD_INCLUDE = 0,
|
|
SSI_CMD_ECHO,
|
|
SSI_CMD_FSIZE, // File size of specified file
|
|
SSI_CMD_FLASTMOD, // Last modified date of specified file
|
|
SSI_CMD_CONFIG, // Configure options
|
|
|
|
SSI_CMD_EXEC, // Execute CGI or CMD script
|
|
|
|
SSI_CMD_BYTERANGE, // Custom commands, not defined by NCSA
|
|
|
|
SSI_CMD_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// These tags are essentially subcommands for the various SSI_COMMAND values
|
|
//
|
|
|
|
enum SSI_TAGS
|
|
{
|
|
SSI_TAG_FILE, // Used with include, fsize & flastmod
|
|
SSI_TAG_VIRTUAL,
|
|
|
|
SSI_TAG_VAR, // Used with echo
|
|
|
|
SSI_TAG_CMD, // Used with Exec
|
|
SSI_TAG_CGI,
|
|
SSI_TAG_ISA,
|
|
|
|
SSI_TAG_ERRMSG, // Used with Config
|
|
SSI_TAG_TIMEFMT,
|
|
SSI_TAG_SIZEFMT,
|
|
|
|
SSI_TAG_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// Variables available to #ECHO VAR = "xxx" but not available in ISAPI
|
|
//
|
|
|
|
enum SSI_VARS
|
|
{
|
|
SSI_VAR_DOCUMENT_NAME = 0,
|
|
SSI_VAR_DOCUMENT_URI,
|
|
SSI_VAR_QUERY_STRING_UNESCAPED,
|
|
SSI_VAR_DATE_LOCAL,
|
|
SSI_VAR_DATE_GMT,
|
|
SSI_VAR_LAST_MODIFIED,
|
|
|
|
SSI_VAR_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// SSI Exec types
|
|
//
|
|
|
|
enum SSI_EXEC_TYPE
|
|
{
|
|
SSI_EXEC_CMD = 1,
|
|
SSI_EXEC_CGI = 2,
|
|
SSI_EXEC_ISA = 4,
|
|
|
|
SSI_EXEC_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
|
|
UINT g_MonthToDayCount[] = {
|
|
0,
|
|
31,
|
|
31 + 28,
|
|
31 + 28 + 31,
|
|
31 + 28 + 31 + 30,
|
|
31 + 28 + 31 + 30 + 31,
|
|
31 + 28 + 31 + 30 + 31 + 30,
|
|
31 + 28 + 31 + 30 + 31 + 30 + 31,
|
|
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
|
|
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
|
|
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
|
|
31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30,
|
|
} ;
|
|
|
|
BOOL g_fIsDBCS = FALSE;
|
|
|
|
//
|
|
// Prototypes
|
|
//
|
|
|
|
extern "C" {
|
|
|
|
BOOL
|
|
WINAPI
|
|
DLLEntry(
|
|
HINSTANCE hDll,
|
|
DWORD dwReason,
|
|
LPVOID lpvReserved
|
|
);
|
|
}
|
|
|
|
class SSI_ELEMENT_LIST;
|
|
|
|
SSI_ELEMENT_LIST *
|
|
SSIParse(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL,
|
|
IN TS_OPEN_FILE_INFO* pOpenFile,
|
|
IN TSVC_CACHE * pTsCache
|
|
);
|
|
|
|
BOOL
|
|
SSISend(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL,
|
|
IN SSI_INCLUDE_FILE * pParent
|
|
);
|
|
|
|
BOOL
|
|
ParseSSITag(
|
|
IN OUT CHAR * * ppchFilePos,
|
|
IN CHAR * pchEOF,
|
|
OUT BOOL * pfValidTag,
|
|
OUT SSI_COMMANDS * pCommandType,
|
|
OUT SSI_TAGS * pTagType,
|
|
OUT CHAR * pszTagString
|
|
);
|
|
|
|
BOOL
|
|
FreeSELBlob(
|
|
VOID * pvCacheBlob
|
|
);
|
|
|
|
CHAR *
|
|
SSISkipTo(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR ch,
|
|
IN CHAR * pchEOF
|
|
);
|
|
|
|
CHAR *
|
|
SSISkipWhite(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR * pchEOF
|
|
);
|
|
|
|
VOID
|
|
InitializeSSIGlobals( VOID );
|
|
|
|
//
|
|
// Global Data
|
|
//
|
|
|
|
DECLARE_DEBUG_PRINTS_OBJECT()
|
|
#ifndef _NO_TRACING_
|
|
#include <initguid.h>
|
|
DEFINE_GUID(IisSSIncGuid,
|
|
0x784d891A, 0xaa8c, 0x11d2, 0x92, 0x5e, 0x00, 0xc0, 0x4f, 0x72, 0xd9, 0x0e);
|
|
#else
|
|
DECLARE_DEBUG_VARIABLE();
|
|
#endif
|
|
|
|
//
|
|
// This is the list of supported commands
|
|
//
|
|
|
|
struct _SSI_CMD_MAP
|
|
{
|
|
CHAR * pszCommand;
|
|
DWORD cchCommand;
|
|
SSI_COMMANDS ssiCmd;
|
|
}
|
|
SSICmdMap[] =
|
|
{
|
|
"#include ", 9, SSI_CMD_INCLUDE,
|
|
"#echo ", 6, SSI_CMD_ECHO,
|
|
"#fsize ", 7, SSI_CMD_FSIZE,
|
|
"#flastmod ",10, SSI_CMD_FLASTMOD,
|
|
"#config ", 8, SSI_CMD_CONFIG,
|
|
"#exec ", 6, SSI_CMD_EXEC,
|
|
NULL, 0, SSI_CMD_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// This is the list of supported tags
|
|
//
|
|
|
|
struct _SSI_TAG_MAP
|
|
{
|
|
CHAR * pszTag;
|
|
DWORD cchTag;
|
|
SSI_TAGS ssiTag;
|
|
}
|
|
SSITagMap[] =
|
|
{
|
|
"var", 3, SSI_TAG_VAR,
|
|
"file", 4, SSI_TAG_FILE,
|
|
"virtual", 7, SSI_TAG_VIRTUAL,
|
|
"errmsg", 6, SSI_TAG_ERRMSG,
|
|
"timefmt", 7, SSI_TAG_TIMEFMT,
|
|
"sizefmt", 7, SSI_TAG_SIZEFMT,
|
|
"cmd", 3, SSI_TAG_CMD,
|
|
"cgi", 3, SSI_TAG_CGI,
|
|
"isa", 3, SSI_TAG_ISA,
|
|
NULL, 0, SSI_TAG_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// This is a list of #ECHO variables not supported by ISAPI
|
|
//
|
|
|
|
struct _SSI_VAR_MAP
|
|
{
|
|
CHAR * pszMap;
|
|
DWORD cchMap;
|
|
SSI_VARS ssiMap;
|
|
}
|
|
SSIVarMap[] =
|
|
{
|
|
"DOCUMENT_NAME", 13, SSI_VAR_DOCUMENT_NAME,
|
|
"DOCUMENT_URI", 12, SSI_VAR_DOCUMENT_URI,
|
|
"QUERY_STRING_UNESCAPED", 22, SSI_VAR_QUERY_STRING_UNESCAPED,
|
|
"DATE_LOCAL", 10, SSI_VAR_DATE_LOCAL,
|
|
"DATE_GMT", 8, SSI_VAR_DATE_GMT,
|
|
"LAST_MODIFIED", 13, SSI_VAR_LAST_MODIFIED,
|
|
NULL, 0, SSI_VAR_UNKNOWN
|
|
};
|
|
|
|
BOOL fEnableCmdDirective = FALSE;
|
|
|
|
//
|
|
// Class Definitions
|
|
//
|
|
|
|
// class SSI_FILE
|
|
//
|
|
// File structure. All high level functions should use this
|
|
// structure instead of dealing with handle specifics themselves.
|
|
|
|
class SSI_FILE
|
|
{
|
|
private:
|
|
STR _strFilename;
|
|
TSVC_CACHE * _pTsCache;
|
|
TS_OPEN_FILE_INFO * _hHandle;
|
|
HANDLE _hMapHandle;
|
|
PVOID _pvMappedBase;
|
|
BOOL _fValid;
|
|
BOOL _fCloseOnDestroy;
|
|
|
|
//
|
|
// Track the current number of open handles for this file.
|
|
//
|
|
|
|
DWORD _cRefCount;
|
|
CRITICAL_SECTION _csRef;
|
|
|
|
public:
|
|
|
|
SSI_FILE( IN STR * pstrFilename,
|
|
IN TS_OPEN_FILE_INFO * pOpenFile,
|
|
IN TSVC_CACHE * pTsCache )
|
|
:
|
|
_hHandle ( pOpenFile ),
|
|
_hMapHandle ( NULL ),
|
|
_pvMappedBase ( NULL ),
|
|
_pTsCache ( pTsCache ),
|
|
_fValid ( FALSE ),
|
|
_cRefCount ( 0),
|
|
_fCloseOnDestroy( FALSE )
|
|
{
|
|
InitializeCriticalSection( &_csRef );
|
|
|
|
if ( !_strFilename.Copy( pstrFilename->QueryStr() ) )
|
|
{
|
|
return;
|
|
}
|
|
_fValid = TRUE;
|
|
}
|
|
|
|
SSI_FILE( IN STR * pstrFilename,
|
|
IN TSVC_CACHE * pTsCache,
|
|
IN HANDLE hUser)
|
|
:
|
|
_hHandle ( NULL ),
|
|
_hMapHandle ( NULL ),
|
|
_pvMappedBase ( NULL ),
|
|
_pTsCache ( pTsCache ),
|
|
_fValid ( FALSE ),
|
|
_cRefCount ( 0),
|
|
_fCloseOnDestroy( TRUE )
|
|
{
|
|
InitializeCriticalSection( &_csRef );
|
|
|
|
if ( !_strFilename.Copy( pstrFilename->QueryStr() ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
_hHandle = TsCreateFile( *_pTsCache,
|
|
_strFilename.QueryStr(),
|
|
hUser,
|
|
TS_CACHING_DESIRED );
|
|
if ( !_hHandle )
|
|
{
|
|
return;
|
|
}
|
|
_fValid = TRUE;
|
|
}
|
|
|
|
~SSI_FILE( VOID )
|
|
{
|
|
if ( _fCloseOnDestroy )
|
|
{
|
|
if ( _hHandle )
|
|
{
|
|
TsCloseHandle( *_pTsCache, _hHandle );
|
|
}
|
|
}
|
|
DeleteCriticalSection( &_csRef );
|
|
}
|
|
|
|
VOID Lock( VOID )
|
|
{ EnterCriticalSection( &_csRef ); }
|
|
|
|
VOID UnLock( VOID )
|
|
{ LeaveCriticalSection( &_csRef ); }
|
|
|
|
BOOL IsValid( VOID ) const
|
|
{
|
|
return _fValid;
|
|
}
|
|
|
|
PSECURITY_DESCRIPTOR GetSecDesc() const
|
|
{
|
|
return _hHandle->QuerySecDesc();
|
|
}
|
|
|
|
BOOL SSICreateFileMapping( VOID )
|
|
// Creates a mapping to a file
|
|
{
|
|
HANDLE hHandle;
|
|
|
|
if ( _hHandle->QueryFileBuffer() )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
hHandle = _hHandle->QueryFileHandle();
|
|
if ( _hMapHandle != NULL )
|
|
{
|
|
if ( !SSICloseMapHandle() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
_hMapHandle = ::CreateFileMapping( hHandle,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
0,
|
|
0,
|
|
NULL );
|
|
|
|
if ( _hMapHandle == NULL )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"CreateFileMapping failed with %d\n",
|
|
GetLastError() ));
|
|
}
|
|
|
|
return _hMapHandle != NULL;
|
|
}
|
|
|
|
BOOL SSICloseMapHandle( VOID )
|
|
// Closes mapping to a file
|
|
{
|
|
if ( _hMapHandle != NULL )
|
|
{
|
|
::CloseHandle( _hMapHandle );
|
|
_hMapHandle = NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL SSIMapViewOfFile( VOID )
|
|
// Maps file to address
|
|
{
|
|
if ( _hHandle->QueryFileBuffer() )
|
|
{
|
|
_pvMappedBase = _hHandle->QueryFileBuffer();
|
|
return TRUE;
|
|
}
|
|
|
|
if ( _pvMappedBase != NULL )
|
|
{
|
|
if ( !SSIUnmapViewOfFile() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
_pvMappedBase = ::MapViewOfFile( _hMapHandle,
|
|
FILE_MAP_READ,
|
|
0,
|
|
0,
|
|
0 );
|
|
if ( _pvMappedBase == NULL )
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"MapViewOfFile() failed with %d\n",
|
|
GetLastError() ));
|
|
}
|
|
return _pvMappedBase != NULL;
|
|
}
|
|
|
|
BOOL SSIUnmapViewOfFile( VOID )
|
|
// Unmaps file
|
|
{
|
|
if ( !_hHandle->QueryFileBuffer() && _pvMappedBase != NULL )
|
|
{
|
|
::UnmapViewOfFile( _pvMappedBase );
|
|
_pvMappedBase = NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD SSIGetFileAttributes( VOID )
|
|
// Gets the attributes of a file
|
|
{
|
|
if ( _hHandle == NULL )
|
|
{
|
|
return 0;
|
|
}
|
|
return _hHandle->QueryAttributes();
|
|
}
|
|
|
|
BOOL SSIGetFileSize( OUT DWORD * pdwLowWord,
|
|
OUT DWORD * pdwHighWord )
|
|
// Gets the size of the file.
|
|
{
|
|
if ( _hHandle == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
return _hHandle->QuerySize( pdwLowWord,
|
|
pdwHighWord );
|
|
}
|
|
|
|
BOOL SSIGetLastModTime( OUT FILETIME * ftTime )
|
|
// Gets the Last modification time of a file.
|
|
{
|
|
if ( _hHandle == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
return _hHandle->QueryLastWriteTime( ftTime );
|
|
}
|
|
|
|
PVOID GetMappedBase( VOID )
|
|
{
|
|
return _pvMappedBase;
|
|
}
|
|
|
|
STR & GetFilename( VOID )
|
|
{
|
|
return _strFilename;
|
|
}
|
|
};
|
|
|
|
// Class SSI_ELEMENT_ITEM
|
|
//
|
|
// Represents a SSI command in the document
|
|
|
|
class SSI_ELEMENT_ITEM
|
|
{
|
|
private:
|
|
DWORD _Signature;
|
|
SSI_COMMANDS _ssiCmd;
|
|
SSI_TAGS _ssiTag;
|
|
STR * _pstrTagValue;
|
|
|
|
DWORD _cbBegin; // Only used for Byte range command
|
|
DWORD _cbLength; // Only used for Byte range command
|
|
public:
|
|
|
|
LIST_ENTRY _ListEntry;
|
|
|
|
SSI_ELEMENT_ITEM( VOID )
|
|
: _ssiCmd ( SSI_CMD_UNKNOWN ),
|
|
_ssiTag ( SSI_TAG_UNKNOWN ),
|
|
_Signature( SIGNATURE_SEI ),
|
|
_pstrTagValue( NULL )
|
|
{
|
|
_ListEntry.Flink = NULL;
|
|
}
|
|
|
|
~SSI_ELEMENT_ITEM( VOID )
|
|
{
|
|
if ( _pstrTagValue != NULL )
|
|
{
|
|
delete _pstrTagValue;
|
|
}
|
|
TCP_ASSERT( _ListEntry.Flink == NULL );
|
|
_Signature = SIGNATURE_SEI_FREE;
|
|
}
|
|
|
|
VOID SetByteRange( IN DWORD cbBegin,
|
|
IN DWORD cbLength )
|
|
{
|
|
_ssiCmd = SSI_CMD_BYTERANGE;
|
|
_cbBegin = cbBegin;
|
|
_cbLength = cbLength;
|
|
}
|
|
|
|
BOOL SetCommand( IN SSI_COMMANDS ssiCmd,
|
|
IN SSI_TAGS ssiTag,
|
|
IN CHAR * achTag )
|
|
{
|
|
_ssiCmd = ssiCmd;
|
|
_ssiTag = ssiTag;
|
|
_pstrTagValue = new STR( achTag );
|
|
return _pstrTagValue != NULL;
|
|
}
|
|
|
|
SSI_COMMANDS QueryCommand( VOID ) const
|
|
{ return _ssiCmd; }
|
|
|
|
SSI_TAGS QueryTag( VOID ) const
|
|
{ return _ssiTag; }
|
|
|
|
STR * QueryTagValue( VOID ) const
|
|
{ return _pstrTagValue; }
|
|
|
|
BOOL CheckSignature( VOID ) const
|
|
{ return _Signature == SIGNATURE_SEI; }
|
|
|
|
DWORD QueryBegin( VOID ) const
|
|
{ return _cbBegin; }
|
|
|
|
DWORD QueryLength( VOID ) const
|
|
{ return _cbLength; }
|
|
};
|
|
|
|
// Class SSI_ELEMENT_LIST
|
|
//
|
|
// This object sits as a cache blob under a file to be processed as a
|
|
// server side include. It represents an interpreted list of data elements
|
|
// that make up the file itself.
|
|
//
|
|
|
|
class SSI_ELEMENT_LIST : public BLOB_HEADER
|
|
{
|
|
private:
|
|
DWORD _Signature;
|
|
LIST_ENTRY _ListHead;
|
|
|
|
//
|
|
// These are for tracking the memory mapped file
|
|
//
|
|
|
|
DWORD _cRefCount;
|
|
CRITICAL_SECTION _csRef;
|
|
|
|
//
|
|
// Provides the utilities needed to open/manipulate files
|
|
//
|
|
|
|
SSI_FILE * _pssiFile;
|
|
|
|
//
|
|
// Name of URL. Used to resolve FILE="xxx" filenames
|
|
//
|
|
|
|
STR _strURL;
|
|
|
|
|
|
public:
|
|
SSI_ELEMENT_LIST( VOID )
|
|
: _Signature ( SIGNATURE_SEL ),
|
|
_pssiFile( NULL ),
|
|
_cRefCount( 0 )
|
|
{
|
|
InitializeListHead( &_ListHead );
|
|
INITIALIZE_CRITICAL_SECTION( &_csRef );
|
|
}
|
|
|
|
~SSI_ELEMENT_LIST( VOID )
|
|
{
|
|
SSI_ELEMENT_ITEM * pSEI;
|
|
|
|
while ( !IsListEmpty( &_ListHead ))
|
|
{
|
|
pSEI = CONTAINING_RECORD( _ListHead.Flink,
|
|
SSI_ELEMENT_ITEM,
|
|
_ListEntry );
|
|
|
|
RemoveEntryList( &pSEI->_ListEntry );
|
|
pSEI->_ListEntry.Flink = NULL;
|
|
delete pSEI;
|
|
}
|
|
UnMap();
|
|
|
|
if( _pssiFile != NULL )
|
|
{
|
|
delete _pssiFile;
|
|
}
|
|
|
|
DeleteCriticalSection( &_csRef );
|
|
_Signature = SIGNATURE_SEL_FREE;
|
|
|
|
}
|
|
|
|
BOOL AppendByteRange( IN DWORD cbStart,
|
|
IN DWORD cbLength )
|
|
{
|
|
SSI_ELEMENT_ITEM * pSEI;
|
|
|
|
pSEI = new SSI_ELEMENT_ITEM;
|
|
|
|
if ( !pSEI )
|
|
{
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
return FALSE;
|
|
}
|
|
|
|
pSEI->SetByteRange( cbStart,
|
|
cbLength );
|
|
AppendItem( pSEI );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL AppendCommand( IN SSI_COMMANDS ssiCmd,
|
|
IN SSI_TAGS ssiTag,
|
|
IN CHAR * pszTag )
|
|
{
|
|
SSI_ELEMENT_ITEM * pSEI;
|
|
|
|
pSEI = new SSI_ELEMENT_ITEM;
|
|
|
|
if ( !pSEI )
|
|
{
|
|
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !pSEI->SetCommand( ssiCmd,
|
|
ssiTag,
|
|
pszTag ))
|
|
{
|
|
delete pSEI;
|
|
return FALSE;
|
|
}
|
|
|
|
AppendItem( pSEI );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID AppendItem( IN SSI_ELEMENT_ITEM * pSEI )
|
|
{
|
|
InsertTailList( &_ListHead,
|
|
&pSEI->_ListEntry );
|
|
}
|
|
|
|
CHAR * QueryData( VOID ) const
|
|
{ return (CHAR *) _pssiFile->GetMappedBase(); }
|
|
|
|
|
|
PSECURITY_DESCRIPTOR QuerySecDesc( VOID )
|
|
{ return _pssiFile->GetSecDesc(); }
|
|
|
|
BOOL CheckSignature( VOID ) const
|
|
{ return _Signature == SIGNATURE_SEL; }
|
|
|
|
VOID Lock( VOID )
|
|
{ EnterCriticalSection( &_csRef ); }
|
|
|
|
VOID UnLock( VOID )
|
|
{ LeaveCriticalSection( &_csRef ); }
|
|
|
|
BOOL UnMap( VOID )
|
|
{
|
|
Lock();
|
|
if ( _cRefCount && !--_cRefCount )
|
|
{
|
|
TCP_REQUIRE( _pssiFile->SSIUnmapViewOfFile() );
|
|
TCP_REQUIRE( _pssiFile->SSICloseMapHandle() );
|
|
}
|
|
UnLock();
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL Map( VOID )
|
|
{
|
|
Lock();
|
|
if ( _cRefCount++ == 0 )
|
|
{
|
|
if ( !_pssiFile->SSICreateFileMapping() )
|
|
{
|
|
UnLock();
|
|
return FALSE;
|
|
}
|
|
if ( !_pssiFile->SSIMapViewOfFile() )
|
|
{
|
|
UnMap();
|
|
UnLock();
|
|
return FALSE;
|
|
}
|
|
}
|
|
UnLock();
|
|
return TRUE;
|
|
}
|
|
|
|
VOID SetFile( IN SSI_FILE * pssiFile )
|
|
{ _pssiFile = pssiFile; }
|
|
|
|
SSI_FILE * GetFile( VOID )
|
|
{ return _pssiFile; }
|
|
|
|
VOID SetURL( IN STR * pstrURL )
|
|
{
|
|
_strURL.Copy( pstrURL->QueryStr() );
|
|
}
|
|
|
|
BOOL Send( IN SSI_REQUEST *,
|
|
IN SSI_INCLUDE_FILE *,
|
|
IN STR * );
|
|
|
|
BOOL FindInternalVariable( IN OUT STR *,
|
|
IN OUT DWORD * );
|
|
BOOL GetFullPath( IN SSI_REQUEST *,
|
|
IN SSI_ELEMENT_ITEM *,
|
|
OUT STR *,
|
|
IN DWORD,
|
|
IN STR *,
|
|
OUT STR * pstrURL = NULL );
|
|
|
|
};
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::Send(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN SSI_INCLUDE_FILE * pParent,
|
|
IN STR * pstrURL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This method walks the element list sending the appropriate chunks of
|
|
data
|
|
|
|
Arguments:
|
|
|
|
pRequest - Request context
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on any failures
|
|
|
|
--*/
|
|
{
|
|
LIST_ENTRY * pEntry;
|
|
DWORD cbSent;
|
|
STACK_STR( strPath, MAX_PATH);
|
|
SSI_ELEMENT_ITEM * pSEI;
|
|
|
|
DWORD dwID;
|
|
LPCTSTR apszParms[ 2 ];
|
|
CHAR achNumberBuffer[ SSI_MAX_NUMBER_STRING ];
|
|
|
|
BOOL bSizeFmtBytes = SSI_DEF_SIZEFMT;
|
|
STACK_STR( strTimeFmt, 64);
|
|
|
|
TCP_ASSERT( CheckSignature() );
|
|
|
|
if ( !strTimeFmt.Copy( SSI_DEF_TIMEFMT ) ||
|
|
!Map() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Loop through each element and take the appropriate action
|
|
//
|
|
|
|
for ( pEntry = _ListHead.Flink;
|
|
pEntry != &_ListHead;
|
|
pEntry = pEntry->Flink )
|
|
{
|
|
pSEI = CONTAINING_RECORD( pEntry, SSI_ELEMENT_ITEM, _ListEntry );
|
|
|
|
TCP_ASSERT( pSEI->CheckSignature() );
|
|
|
|
dwID = 0;
|
|
|
|
switch ( pSEI->QueryCommand() )
|
|
{
|
|
case SSI_CMD_BYTERANGE:
|
|
if ( !pRequest->WriteToClient( QueryData() + pSEI->QueryBegin(),
|
|
pSEI->QueryLength(),
|
|
&cbSent ) )
|
|
{
|
|
UnMap();
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_INCLUDE:
|
|
switch ( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_FILE:
|
|
case SSI_TAG_VIRTUAL:
|
|
{
|
|
STACK_STR( strFullURL, MAX_PATH );
|
|
|
|
if ( !GetFullPath( pRequest,
|
|
pSEI,
|
|
&strPath,
|
|
HSE_URL_FLAGS_READ,
|
|
pstrURL,
|
|
&strFullURL ) )
|
|
{
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
dwID = SSINCMSG_ERROR_HANDLING_FILE;
|
|
break;
|
|
}
|
|
|
|
SSI_INCLUDE_FILE Child( strPath, pParent );
|
|
|
|
if ( !Child.IsValid() )
|
|
{
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
dwID = SSINCMSG_ERROR_HANDLING_FILE;
|
|
break;
|
|
}
|
|
|
|
if ( pParent->IsRecursiveInclude( strPath ) )
|
|
{
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
dwID = SSINCMSG_ERROR_RECURSIVE_INCLUDE;
|
|
break;
|
|
}
|
|
|
|
if ( !SSISend( pRequest,
|
|
&strPath,
|
|
&strFullURL,
|
|
&Child ) )
|
|
{
|
|
// apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
// dwID = SSINCMSG_ERROR_HANDLING_FILE;
|
|
}
|
|
|
|
break;
|
|
}
|
|
default:
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
if ( dwID )
|
|
{
|
|
pRequest->SSISendError( dwID, apszParms );
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_FLASTMOD:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_FILE:
|
|
case SSI_TAG_VIRTUAL:
|
|
if ( !GetFullPath( pRequest,
|
|
pSEI,
|
|
&strPath,
|
|
0,
|
|
pstrURL ) ||
|
|
!pRequest->DoFLastMod( &strPath,
|
|
&strTimeFmt,
|
|
this) )
|
|
{
|
|
_ultoa( GetLastError(), achNumberBuffer, 10 );
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
apszParms[ 1 ] = achNumberBuffer;
|
|
dwID = SSINCMSG_CANT_DO_FLASTMOD;
|
|
}
|
|
break;
|
|
default:
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
if ( dwID )
|
|
{
|
|
pRequest->SSISendError( dwID, apszParms );
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_CONFIG:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_ERRMSG:
|
|
if ( !pRequest->SetUserErrorMessage( pSEI->QueryTagValue() ) )
|
|
{
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
break;
|
|
case SSI_TAG_TIMEFMT:
|
|
if ( !strTimeFmt.Copy( pSEI->QueryTagValue()->QueryStr() ) )
|
|
{
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
break;
|
|
case SSI_TAG_SIZEFMT:
|
|
if ( _strnicmp( SSI_DEF_BYTES,
|
|
pSEI->QueryTagValue()->QueryStr(),
|
|
SSI_DEF_BYTES_LEN ) == 0 )
|
|
{
|
|
bSizeFmtBytes = TRUE;
|
|
}
|
|
else if ( _strnicmp( SSI_DEF_ABBREV,
|
|
pSEI->QueryTagValue()->QueryStr(),
|
|
SSI_DEF_ABBREV_LEN ) == 0 )
|
|
{
|
|
bSizeFmtBytes = FALSE;
|
|
}
|
|
else
|
|
{
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
break;
|
|
default:
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
if ( dwID )
|
|
{
|
|
pRequest->SSISendError( dwID, NULL );
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_FSIZE:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_FILE:
|
|
case SSI_TAG_VIRTUAL:
|
|
if ( !GetFullPath( pRequest,
|
|
pSEI,
|
|
&strPath,
|
|
0,
|
|
pstrURL ) ||
|
|
!pRequest->DoFSize( &strPath,
|
|
bSizeFmtBytes,
|
|
this) )
|
|
{
|
|
_ultoa( GetLastError(), achNumberBuffer, 10 );
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
apszParms[ 1 ] = achNumberBuffer;
|
|
dwID = SSINCMSG_CANT_DO_FSIZE;
|
|
}
|
|
break;
|
|
default:
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
if ( dwID )
|
|
{
|
|
pRequest->SSISendError( dwID, apszParms );
|
|
}
|
|
|
|
break;
|
|
|
|
case SSI_CMD_ECHO:
|
|
if ( pSEI->QueryTag() == SSI_TAG_VAR )
|
|
{
|
|
// First let ISAPI try to evaluate variable.
|
|
if ( pRequest->DoEchoISAPIVariable( pSEI->QueryTagValue() ) )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwVar;
|
|
BOOL fEchoSuccess = FALSE;
|
|
|
|
// if ISAPI couldn't resolve var, try internal list
|
|
if ( !FindInternalVariable( pSEI->QueryTagValue(),
|
|
&dwVar ) )
|
|
{
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
dwID = SSINCMSG_CANT_FIND_VARIABLE;
|
|
}
|
|
else
|
|
{
|
|
switch( dwVar )
|
|
{
|
|
case SSI_VAR_DOCUMENT_NAME:
|
|
fEchoSuccess = pRequest->DoEchoDocumentName( &_pssiFile->GetFilename() );
|
|
break;
|
|
case SSI_VAR_DOCUMENT_URI:
|
|
fEchoSuccess = pRequest->DoEchoDocumentURI( &_strURL );
|
|
break;
|
|
case SSI_VAR_QUERY_STRING_UNESCAPED:
|
|
fEchoSuccess = pRequest->DoEchoQueryStringUnescaped();
|
|
break;
|
|
case SSI_VAR_DATE_LOCAL:
|
|
fEchoSuccess = pRequest->DoEchoDateLocal( &strTimeFmt );
|
|
break;
|
|
case SSI_VAR_DATE_GMT:
|
|
fEchoSuccess = pRequest->DoEchoDateGMT( &strTimeFmt );
|
|
break;
|
|
case SSI_VAR_LAST_MODIFIED:
|
|
fEchoSuccess = pRequest->DoEchoLastModified( &_pssiFile->GetFilename(),
|
|
&strTimeFmt, this );
|
|
break;
|
|
default:
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
dwID = SSINCMSG_CANT_FIND_VARIABLE;
|
|
}
|
|
if ( !fEchoSuccess )
|
|
{
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
dwID = SSINCMSG_CANT_EVALUATE_VARIABLE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
|
|
if ( dwID )
|
|
{
|
|
pRequest->SSISendError( dwID,
|
|
apszParms );
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_EXEC:
|
|
{
|
|
SSI_EXEC_TYPE ssiExecType = SSI_EXEC_UNKNOWN;
|
|
|
|
if ( pRequest->IsExecDisabled() )
|
|
{
|
|
dwID = SSINCMSG_EXEC_DISABLED;
|
|
}
|
|
else if ( pSEI->QueryTag() == SSI_TAG_CMD )
|
|
{
|
|
if ( !fEnableCmdDirective )
|
|
{
|
|
dwID = SSINCMSG_CMD_NOT_ENABLED;
|
|
}
|
|
else
|
|
{
|
|
ssiExecType = SSI_EXEC_CMD;
|
|
}
|
|
}
|
|
else if ( pSEI->QueryTag() == SSI_TAG_CGI )
|
|
{
|
|
ssiExecType = SSI_EXEC_CGI;
|
|
}
|
|
else if ( pSEI->QueryTag() == SSI_TAG_ISA )
|
|
{
|
|
ssiExecType = SSI_EXEC_ISA;
|
|
}
|
|
else
|
|
{
|
|
dwID = SSINCMSG_INVALID_TAG;
|
|
}
|
|
|
|
if ( ssiExecType != SSI_EXEC_UNKNOWN )
|
|
{
|
|
DWORD dwFlags = HSE_EXEC_NO_HEADERS | HSE_EXEC_REDIRECT_ONLY;
|
|
if (ssiExecType == SSI_EXEC_CMD)
|
|
dwFlags |= HSE_EXEC_COMMAND;
|
|
|
|
BOOL fOk = pRequest->_pECB->ServerSupportFunction
|
|
(
|
|
pRequest->_pECB->ConnID,
|
|
HSE_REQ_EXECUTE_CHILD,
|
|
(LPVOID) pSEI->QueryTagValue()->QueryStr(),
|
|
NULL,
|
|
&dwFlags
|
|
);
|
|
|
|
if ( !fOk )
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
|
|
_ultoa( dwError, achNumberBuffer, 10 );
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
apszParms[ 1 ] = achNumberBuffer;
|
|
|
|
if ( dwError == ERROR_INVALID_FLAGS )
|
|
{
|
|
dwID = SSINCMSG_NO_EXECUTE_PERMISSION;
|
|
}
|
|
else
|
|
{
|
|
dwID = SSINCMSG_CANT_EXEC_CGI;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( dwID )
|
|
{
|
|
pRequest->SSISendError( dwID, apszParms );
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
pRequest->SSISendError( SSINCMSG_NOT_SUPPORTED,
|
|
NULL );
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnMap();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::GetFullPath(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN SSI_ELEMENT_ITEM * pSEI,
|
|
OUT STR * pstrPath,
|
|
IN DWORD dwPermission,
|
|
IN STR * pstrCurrentURL,
|
|
OUT STR * pstrURL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Used to resolve FILE= and VIRTUAL= references. Fills in the physical
|
|
path of such file references and optionally checks the permissions
|
|
of the virtual directory.
|
|
|
|
Arguments:
|
|
|
|
pRequest - SSI_REQUEST
|
|
pSEI - Element item ( either FILE or VIRTUAL )
|
|
pstrPath - Filled in with physical path of file
|
|
dwPermission - Contains permissions that the virtual
|
|
path must satisfy. For example HSE_URL_FLAGS_READ.
|
|
If 0, then no permissions are checked
|
|
pstrCurrentURL - Current .STM URL being parsed
|
|
pstrURL - Full URL filled in here
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
CHAR * pszValue;
|
|
STR * pstrValue;
|
|
DWORD dwMask;
|
|
DWORD cbBufLen;
|
|
CHAR achPath[ SSI_MAX_PATH + 1 ];
|
|
|
|
//
|
|
// We recalc the virtual root each time in case the root
|
|
// to directory mapping has changed
|
|
//
|
|
|
|
pstrValue = pSEI->QueryTagValue();
|
|
pszValue = pstrValue->QueryStr();
|
|
|
|
if ( *pszValue == '/' )
|
|
{
|
|
achPath[ SSI_MAX_PATH ] = '\0';
|
|
strncpy( achPath, pszValue, SSI_MAX_PATH + 1 );
|
|
if ( achPath[ SSI_MAX_PATH ] != '\0' )
|
|
{
|
|
//
|
|
// buffer size has been exceeded
|
|
//
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if ( (int)pSEI->QueryTag() == (int)SSI_TAG_FILE )
|
|
{
|
|
achPath[ SSI_MAX_PATH ] = '\0';
|
|
strncpy( achPath, pstrCurrentURL->QueryStr(), SSI_MAX_PATH + 1 );
|
|
if ( achPath[ SSI_MAX_PATH ] != '\0' )
|
|
{
|
|
//
|
|
// buffer size has been exceeded
|
|
//
|
|
return FALSE;
|
|
}
|
|
// find last '/'
|
|
LPSTR pL = (PCHAR) _mbsrchr( (PUCHAR) achPath, '/' );
|
|
if ( pL == NULL )
|
|
{
|
|
pL = achPath;
|
|
}
|
|
|
|
if ( pL == achPath )
|
|
{
|
|
*pL = '/';
|
|
}
|
|
pL ++;
|
|
strncpy( pL, pszValue, SSI_MAX_PATH + 1 - DIFF( pL - achPath ) );
|
|
if ( achPath[ SSI_MAX_PATH ] != '\0' )
|
|
{
|
|
//
|
|
// buffer size has been exceeded
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
achPath[0] = '/';
|
|
achPath[ SSI_MAX_PATH ] = '\0';
|
|
strncpy( achPath + 1, pszValue, SSI_MAX_PATH + 1 - 1 ); // decrement one because we copy starting with index 1
|
|
if ( achPath[ SSI_MAX_PATH ] != '\0' )
|
|
{
|
|
//
|
|
// buffer size has been exceeded
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// First canonicalize the URL to be #included
|
|
//
|
|
|
|
CanonURL( achPath, g_fIsDBCS );
|
|
|
|
//
|
|
// Map to a physical directory
|
|
//
|
|
|
|
if ( !pRequest->LookupVirtualRoot( achPath,
|
|
pstrPath,
|
|
dwPermission ) )
|
|
{
|
|
if ( GetLastError() == ERROR_ACCESS_DENIED )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = achPath;
|
|
|
|
pRequest->SSISendError( SSINCMSG_ACCESS_DENIED,
|
|
apszParms );
|
|
}
|
|
else
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = achPath;
|
|
|
|
pRequest->SSISendError( SSINCMSG_CANT_RESOLVE_PATH,
|
|
apszParms );
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
return pstrURL ? pstrURL->Copy( achPath ) : TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::FindInternalVariable(
|
|
IN STR * pstrVariable,
|
|
OUT PDWORD pdwID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Lookup internal list of SSI variables that aren't supported by ISAPI.
|
|
These include "DOCUMENT_NAME", "DATE_LOCAL", etc.
|
|
|
|
Arguments:
|
|
|
|
pstrVariable - Variable to check
|
|
pdwID - Variable ID (or SSI_VAR_UNKNOWN if not found)
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
DWORD dwCounter = 0;
|
|
|
|
while ( ( SSIVarMap[ dwCounter ].pszMap != NULL ) &&
|
|
_strnicmp( SSIVarMap[ dwCounter ].pszMap,
|
|
pstrVariable->QueryStr(),
|
|
SSIVarMap[ dwCounter ].cchMap ) )
|
|
{
|
|
dwCounter++;
|
|
}
|
|
if ( SSIVarMap[ dwCounter ].pszMap != NULL )
|
|
{
|
|
*pdwID = SSIVarMap[ dwCounter ].ssiMap;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pdwID = SSI_VAR_UNKNOWN;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
SSIFreeContextRoutine(
|
|
VOID * pvContext
|
|
)
|
|
{
|
|
delete (SSI_ELEMENT_LIST*) pvContext;
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// SSI_REQUEST methods
|
|
//
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoFLastMod(
|
|
IN STR * pstrFilename,
|
|
IN STR * pstrTimeFmt,
|
|
IN SSI_ELEMENT_LIST * pList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Send the LastModTime of file to HTML stream
|
|
|
|
Arguments:
|
|
|
|
pstrFilename - Filename
|
|
pstrTimeFmt - Format of time -> follows strftime() convention
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
FILETIME ftTime;
|
|
FILETIME ftLocalTime;
|
|
SYSTEMTIME sysLocal;
|
|
|
|
if ( (NULL == pList) ||
|
|
strcmp(pstrFilename->QueryStr(), (pList->GetFile()->GetFilename().QueryStr())) )
|
|
{
|
|
SSI_FILE ssiFile( pstrFilename, _pTsCache, GetUser() );
|
|
|
|
if ( !ssiFile.IsValid() ||
|
|
(!ssiFile.SSIGetLastModTime( &ftTime))
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pList->GetFile()->SSIGetLastModTime( &ftTime);
|
|
}
|
|
|
|
if ((!FileTimeToLocalFileTime( &ftTime, &ftLocalTime ) ) ||
|
|
(!FileTimeToSystemTime( &ftLocalTime, &sysLocal ) ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return SendDate( &sysLocal,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::SendDate(
|
|
IN SYSTEMTIME * psysTime,
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends a SYSTEMTIME in appropriate format to HTML stream
|
|
|
|
Arguments:
|
|
|
|
psysTime - SYSTEMTIME containing time to send
|
|
pstrTimeFmt - Format of time (follows strftime() convention)
|
|
fCalcDays - TRUE if days since the beginning of the year should be
|
|
calculated
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
struct tm tm;
|
|
CHAR achBuffer[ SSI_MAX_TIME_SIZE + 1 ];
|
|
DWORD cbBufLen;
|
|
|
|
// Convert SYSTEMTIME to 'struct tm'
|
|
|
|
tm.tm_sec = psysTime->wSecond;
|
|
tm.tm_min = psysTime->wMinute;
|
|
tm.tm_hour = psysTime->wHour;
|
|
tm.tm_mday = psysTime->wDay;
|
|
tm.tm_mon = psysTime->wMonth - 1;
|
|
tm.tm_year = psysTime->wYear - 1900;
|
|
tm.tm_wday = psysTime->wDayOfWeek;
|
|
tm.tm_yday = g_MonthToDayCount[tm.tm_mon] + tm.tm_mday - 1;
|
|
|
|
//
|
|
// Adjust for leap year - note that we do not handle 2100
|
|
//
|
|
|
|
if ( (tm.tm_mon) > 1 && !(psysTime->wYear&3) )
|
|
{
|
|
++tm.tm_yday;
|
|
}
|
|
|
|
tm.tm_isdst = -1; // Daylight savings time flag - have crt compute
|
|
|
|
cbBufLen = strftime( achBuffer,
|
|
SSI_MAX_TIME_SIZE + 1,
|
|
pstrTimeFmt->QueryStr(),
|
|
&tm );
|
|
|
|
if ( cbBufLen == 0 )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return WriteToClient( achBuffer,
|
|
cbBufLen,
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::LookupVirtualRoot( IN CHAR * pszVirtual,
|
|
OUT STR * pstrPhysical,
|
|
IN DWORD dwAccess )
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Lookup the given virtual path. Optionally ensure that its access
|
|
flags are valid for the require request.
|
|
|
|
Arguments:
|
|
|
|
pszVirtual = Virtual path to lookup
|
|
pstrPhysical = Contains the physical path
|
|
dwAccess = Access flags required for a valid request
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, else FALSE
|
|
|
|
--*/
|
|
{
|
|
HSE_URL_MAPEX_INFO URLMap;
|
|
DWORD dwMask;
|
|
|
|
if ( !_pECB->ServerSupportFunction( _pECB->ConnID,
|
|
HSE_REQ_MAP_URL_TO_PATH_EX,
|
|
pszVirtual,
|
|
NULL,
|
|
(PDWORD) &URLMap ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
dwMask = URLMap.dwFlags;
|
|
|
|
if ( dwAccess & HSE_URL_FLAGS_READ )
|
|
{
|
|
if ( !(dwMask & HSE_URL_FLAGS_READ ) ||
|
|
((dwMask & HSE_URL_FLAGS_SSL ) && !_pReq->IsSecurePort()) )
|
|
{
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return pstrPhysical->Copy( URLMap.lpszPath );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoISAPIVariable(
|
|
IN STR * pstrVariable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get ISAPI variable and if successful, send it to HTML stream
|
|
|
|
Arguments:
|
|
|
|
pstrVariable - Variable
|
|
|
|
Return Value:
|
|
|
|
TRUE on variable found and sent success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
STACK_STR( strVar, MAX_PATH);
|
|
DWORD cbBufLen;
|
|
|
|
if ( !GetVariable( pstrVariable->QueryStr(),
|
|
&strVar ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return WriteToClient( strVar.QueryStrA(),
|
|
strVar.QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoDateLocal(
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends local time (#ECHO VAR="DATE_LOCAL")
|
|
|
|
Arguments:
|
|
|
|
pstrTimefmt - Format of time (follows strftime() convention)
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
SYSTEMTIME sysTime;
|
|
|
|
::GetLocalTime( &sysTime );
|
|
return SendDate( &sysTime,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoDateGMT(
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends GMT time (#ECHO VAR="DATE_GMT")
|
|
|
|
Arguments:
|
|
|
|
pstrTimefmt - Format of time (follows strftime() convention)
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
SYSTEMTIME sysTime;
|
|
|
|
::GetSystemTime( &sysTime );
|
|
return SendDate( &sysTime,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoDocumentName(
|
|
IN STR * pstrFilename
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends filename of current SSI document (#ECHO VAR="DOCUMENT_NAME")
|
|
|
|
Arguments:
|
|
|
|
pstrFilename - filename to print
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
DWORD cbBufLen;
|
|
|
|
return WriteToClient( pstrFilename->QueryStr(),
|
|
pstrFilename->QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoDocumentURI(
|
|
IN STR * pstrURL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends URL of current SSI document (#ECHO VAR="DOCUMENT_URI")
|
|
|
|
Arguments:
|
|
|
|
pstrURL - URL to print
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
DWORD cbBufLen;
|
|
|
|
return WriteToClient( pstrURL->QueryStr(),
|
|
pstrURL->QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoQueryStringUnescaped(
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends unescaped querystring to HTML stream (#ECHO VAR="QUERY_STRING_UNESCAPED")
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
DWORD cbBufLen;
|
|
STACK_STR( strVar, MAX_PATH);
|
|
|
|
if ( !strVar.Copy( _pECB->lpszQueryString ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !strVar.Unescape() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return WriteToClient( strVar.QueryStr(),
|
|
strVar.QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoEchoLastModified(
|
|
IN STR * pstrFilename,
|
|
IN STR * pstrTimeFmt,
|
|
IN SSI_ELEMENT_LIST *pList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends LastModTime of current document (#ECHO VAR="LAST_MODIFIED")
|
|
|
|
Arguments:
|
|
|
|
pstrFilename - Filename of current SSI document
|
|
pstrTimeFmt - Time format (follows strftime() convention)
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
return DoFLastMod( pstrFilename,
|
|
pstrTimeFmt,
|
|
pList);
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::DoFSize(
|
|
IN STR * pstrFilename,
|
|
IN BOOL bSizeFmtBytes,
|
|
IN SSI_ELEMENT_LIST *pList
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sends file size of file to HTML stream
|
|
|
|
Arguments:
|
|
|
|
pstrfilename - Filename
|
|
bSizeFmtBytes - TRUE if count is in Bytes, FALSE if in KBytes
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
BOOL bRet;
|
|
DWORD cbSizeLow;
|
|
DWORD cbSizeHigh;
|
|
CHAR achInputNumber[ SSI_MAX_NUMBER_STRING + 1 ];
|
|
CHAR achOutputNumber[ SSI_MAX_NUMBER_STRING + 1 ];
|
|
NUMBERFMT nfNumberFormat;
|
|
int iOutputSize;
|
|
DWORD dwActualLen;
|
|
|
|
if ( (NULL == pList) ||
|
|
strcmp(pstrFilename->QueryStr(), (pList->GetFile()->GetFilename().QueryStr())) )
|
|
{
|
|
SSI_FILE ssiFile( pstrFilename, _pTsCache, GetUser() );
|
|
|
|
if ( !ssiFile.IsValid() ||
|
|
(!ssiFile.SSIGetFileSize( &cbSizeLow,
|
|
&cbSizeHigh ))
|
|
)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!pList->GetFile()->SSIGetFileSize( &cbSizeLow,
|
|
&cbSizeHigh ))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if ( cbSizeHigh )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !bSizeFmtBytes )
|
|
{
|
|
// express in terms of KB
|
|
cbSizeLow /= 1000;
|
|
}
|
|
|
|
nfNumberFormat.NumDigits = 0;
|
|
nfNumberFormat.LeadingZero = 0;
|
|
nfNumberFormat.Grouping = 3;
|
|
nfNumberFormat.lpThousandSep = ",";
|
|
nfNumberFormat.lpDecimalSep = ".";
|
|
nfNumberFormat.NegativeOrder = 2;
|
|
|
|
_snprintf( achInputNumber,
|
|
SSI_MAX_NUMBER_STRING + 1,
|
|
"%ld",
|
|
cbSizeLow );
|
|
|
|
iOutputSize = GetNumberFormat( LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
achInputNumber,
|
|
&nfNumberFormat,
|
|
achOutputNumber,
|
|
SSI_MAX_NUMBER_STRING + 1 );
|
|
if ( !iOutputSize )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
iOutputSize--;
|
|
|
|
return WriteToClient( achOutputNumber,
|
|
iOutputSize,
|
|
&dwActualLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_REQUEST::ProcessSSI( VOID )
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the top level routine for retrieving a server side include
|
|
file.
|
|
|
|
Arguments:
|
|
|
|
none
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"[ProcessSSI] about to process %s\n",
|
|
_strFilename.QueryStr() ));
|
|
|
|
SSI_INCLUDE_FILE Parent( _strFilename, NULL );
|
|
|
|
if ( !Parent.IsValid() )
|
|
{
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
return SSISend( this, &_strFilename, &_strURL, &Parent );
|
|
}
|
|
}
|
|
|
|
// Standalone functions
|
|
|
|
BOOL
|
|
SSISend(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL,
|
|
IN SSI_INCLUDE_FILE * pParent
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This method builds the Server Side Include Element List the first time
|
|
a .stm file is sent. Subsequently, the element list is checked out from
|
|
the associated cache blob.
|
|
|
|
Note: The HTTP headers have already been sent at this point so for any
|
|
subsequent non-catastrophic errors, we have to insert them into the output
|
|
stream.
|
|
|
|
Arguments:
|
|
|
|
pRequest - SSI Request
|
|
pstrFile - File to send
|
|
pstrURL - URL (from root) of this file
|
|
pParent - Parent SSI include file
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
SSI_ELEMENT_LIST * pSEL = NULL;
|
|
BOOL fRet = TRUE;
|
|
BOOL fSELCached = FALSE;
|
|
BOOL fFileCached = FALSE;
|
|
BOOL fMustFree = FALSE;
|
|
TS_OPEN_FILE_INFO * pOpenFile = NULL;
|
|
DWORD dwError;
|
|
LPCTSTR apszParms[ 2 ];
|
|
CHAR pszNumBuf[ SSI_MAX_NUMBER_STRING ];
|
|
|
|
pOpenFile = TsCreateFile( *(pRequest->_pTsCache),
|
|
pstrFile->QueryStr(),
|
|
pRequest->GetUser(), // WinSE 5597
|
|
TS_CACHING_DESIRED );
|
|
if ( pOpenFile )
|
|
{
|
|
//
|
|
// The source file is in the cache. Check whether we have associated
|
|
// a SSI_ELEMENT_LIST with it.
|
|
//
|
|
|
|
fFileCached = pOpenFile->QueryFileBuffer() != NULL;
|
|
|
|
pSEL = (SSI_ELEMENT_LIST*) pOpenFile->QueryContext();
|
|
if ( pSEL )
|
|
{
|
|
fSELCached = TRUE;
|
|
}
|
|
else
|
|
{
|
|
pSEL = SSIParse( pRequest,
|
|
pstrFile,
|
|
pstrURL,
|
|
pOpenFile,
|
|
pRequest->_pTsCache );
|
|
}
|
|
}
|
|
|
|
if ( !pOpenFile || !pSEL )
|
|
{
|
|
fRet = FALSE;
|
|
|
|
if ( pRequest->IsBaseFile() )
|
|
{
|
|
dwError = GetLastError();
|
|
switch( dwError )
|
|
{
|
|
case ERROR_ACCESS_DENIED:
|
|
pRequest->SendResponseHeader( SSI_ACCESS_DENIED,
|
|
SSI_HEADER
|
|
"<body><h1>"
|
|
SSI_ACCESS_DENIED
|
|
"</h1></body>" );
|
|
break;
|
|
case ERROR_FILE_NOT_FOUND:
|
|
case ERROR_PATH_NOT_FOUND:
|
|
default: // treat all other failures as 404
|
|
pRequest->SendResponseHeader( SSI_OBJECT_NOT_FOUND,
|
|
SSI_HEADER
|
|
"<body><h1>"
|
|
SSI_OBJECT_NOT_FOUND
|
|
"</h1></body>" );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// do not send back file names
|
|
pRequest->SendResponseHeader( SSI_OBJECT_NOT_FOUND,
|
|
SSI_HEADER
|
|
"<body><h1>"
|
|
SSI_OBJECT_NOT_FOUND
|
|
"</h1></body>" );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Only bother to cache SEL if the file is cached
|
|
//
|
|
|
|
if ( fRet && !fSELCached && fFileCached )
|
|
{
|
|
if ( !pOpenFile->SetContext( pSEL, SSIFreeContextRoutine ) )
|
|
{
|
|
delete pSEL;
|
|
pSEL = (SSI_ELEMENT_LIST*) pOpenFile->QueryContext();
|
|
if ( !pSEL )
|
|
{
|
|
DBG_ASSERT( FALSE );
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
fSELCached = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fSELCached = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we got this far and this is the base file, we can send the 200 OK
|
|
//
|
|
|
|
if ( fRet && pRequest->IsBaseFile() )
|
|
{
|
|
pRequest->SetNotBaseFile();
|
|
|
|
pRequest->SendResponseHeader( NULL,
|
|
SSI_HEADER );
|
|
|
|
}
|
|
|
|
if ( pSEL != NULL )
|
|
{
|
|
DBG_ASSERT( pSEL->CheckSignature() );
|
|
}
|
|
|
|
//
|
|
// Send response body only if it's not the HEAD request
|
|
//
|
|
|
|
if ( fRet &&
|
|
_stricmp(pRequest->_pECB->lpszMethod, "HEAD" ) != 0 )
|
|
{
|
|
if ( !pSEL->Send( pRequest,
|
|
pParent,
|
|
pstrURL ) )
|
|
{
|
|
//
|
|
// Send a failure message
|
|
//
|
|
|
|
LPCTSTR apszParms[ 2 ];
|
|
CHAR pszNumBuf[ SSI_MAX_NUMBER_STRING ];
|
|
_ultoa( GetLastError(), pszNumBuf, 10 );
|
|
apszParms[ 0 ] = pstrURL->QueryStr();
|
|
apszParms[ 1 ] = pszNumBuf;
|
|
|
|
pRequest->SSISendError( SSINCMSG_ERROR_HANDLING_FILE,
|
|
apszParms );
|
|
fRet = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cleanup SEL if necessary
|
|
//
|
|
|
|
if ( !fSELCached )
|
|
{
|
|
if ( pSEL )
|
|
{
|
|
delete pSEL;
|
|
}
|
|
}
|
|
|
|
if ( pOpenFile )
|
|
{
|
|
TsCloseHandle( *(pRequest->_pTsCache), pOpenFile );
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
SSI_ELEMENT_LIST *
|
|
SSIParse(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL,
|
|
IN TS_OPEN_FILE_INFO* pOpenFile,
|
|
IN TSVC_CACHE * pTsCache
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This method opens and parses the specified server side include file.
|
|
|
|
Note: The HTTP headers have already been sent at this point so for any
|
|
subsequent non-catastrophic errors, we have to insert them into the output
|
|
stream.
|
|
|
|
We keep the file open but that's ok because if a change dir notification
|
|
occurs, the cache blob will get decached at which point we will close
|
|
all of our open handles.
|
|
|
|
Arguments:
|
|
|
|
pRequest - Request context
|
|
pstrFile - File to open and parse
|
|
pstrURL - The URL path of this file
|
|
pOpenFile - Cached file descriptor
|
|
pTsCache - Cache handle
|
|
|
|
Return Value:
|
|
|
|
Created Server Side Include File on success, NULL on failure.
|
|
|
|
--*/
|
|
{
|
|
SSI_FILE * pssiFile = NULL;
|
|
SSI_ELEMENT_LIST * pSEL = NULL;
|
|
CHAR * pchBeginRange = NULL;
|
|
CHAR * pchFilePos = NULL;
|
|
CHAR * pchBeginFile = NULL;
|
|
CHAR * pchEOF = NULL;
|
|
DWORD cbSizeLow, cbSizeHigh;
|
|
|
|
//
|
|
// Create the element list
|
|
//
|
|
|
|
pSEL = new SSI_ELEMENT_LIST;
|
|
|
|
if ( pSEL == NULL )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
//
|
|
// Set the URL (to be used in calculating FILE="xxx" paths
|
|
//
|
|
|
|
pSEL->SetURL( pstrURL );
|
|
|
|
//
|
|
// Open the file
|
|
//
|
|
|
|
pssiFile = new SSI_FILE( pstrFile, pOpenFile, pTsCache );
|
|
if ( !pssiFile || !pssiFile->IsValid() )
|
|
{
|
|
if (pssiFile)
|
|
{
|
|
delete pssiFile;
|
|
pssiFile = NULL;
|
|
}
|
|
goto ErrorExit;
|
|
}
|
|
|
|
pSEL->SetFile( pssiFile );
|
|
|
|
//
|
|
// Make sure a parent doesn't try and include a directory
|
|
//
|
|
|
|
if ( pssiFile->SSIGetFileAttributes() & FILE_ATTRIBUTE_DIRECTORY )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if ( !pssiFile->SSIGetFileSize( &cbSizeLow, &cbSizeHigh ) )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if ( cbSizeHigh )
|
|
{
|
|
SetLastError( ERROR_NOT_SUPPORTED );
|
|
goto ErrorExit;
|
|
}
|
|
|
|
//
|
|
// Create a file mapping, we shouldn't need to impersonate as we already
|
|
// have the file open
|
|
//
|
|
|
|
if ( !pSEL->Map() )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
pchFilePos = pchBeginFile = pchBeginRange = pSEL->QueryData();
|
|
pchEOF = pchFilePos + cbSizeLow;
|
|
|
|
//
|
|
// Scan for "<!--" or "<%"
|
|
//
|
|
|
|
while ( TRUE )
|
|
{
|
|
while ( pchFilePos < pchEOF && *pchFilePos != '<' )
|
|
{
|
|
pchFilePos++;
|
|
}
|
|
|
|
if ( pchFilePos + 4 >= pchEOF )
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Is this one of our tags?
|
|
//
|
|
|
|
if ( pchFilePos[1] == '%' ||
|
|
!strncmp( pchFilePos, "<!--", 4 ))
|
|
{
|
|
CHAR * pchBeginTag = pchFilePos;
|
|
SSI_COMMANDS CommandType;
|
|
SSI_TAGS TagType;
|
|
CHAR achTagString[SSI_MAX_PATH + 1];
|
|
BOOL fValidTag;
|
|
|
|
//
|
|
// Get the tag info. The file position will be advanced to the
|
|
// first character after the tag
|
|
//
|
|
|
|
if ( !ParseSSITag( &pchFilePos,
|
|
pchEOF,
|
|
&fValidTag,
|
|
&CommandType,
|
|
&TagType,
|
|
achTagString ))
|
|
{
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If it's a tag we don't recognize then ignore it
|
|
//
|
|
|
|
if ( !fValidTag )
|
|
{
|
|
pchFilePos++;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Add the data up to the tag as a byte range
|
|
//
|
|
|
|
if ( pchBeginRange != pchBeginTag )
|
|
{
|
|
if ( !pSEL->AppendByteRange( DIFF(pchBeginRange - pchBeginFile),
|
|
DIFF(pchBeginTag - pchBeginRange) ))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
pchBeginRange = pchFilePos;
|
|
|
|
//
|
|
// Add the tag
|
|
//
|
|
|
|
if ( !pSEL->AppendCommand( CommandType,
|
|
TagType,
|
|
achTagString ))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Not one of our tags, skip the openning angle bracket
|
|
//
|
|
|
|
pchFilePos++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Tack on the last byte range
|
|
//
|
|
|
|
if ( pchFilePos > pchBeginRange )
|
|
{
|
|
if ( !pSEL->AppendByteRange( DIFF(pchBeginRange - pchBeginFile),
|
|
DIFF(pchFilePos - pchBeginRange) ))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
pSEL->UnMap();
|
|
|
|
return pSEL;
|
|
|
|
ErrorExit:
|
|
|
|
if ( pSEL != NULL )
|
|
{
|
|
delete pSEL; // also deletes pssiFile if SetFile has been called.
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL
|
|
ParseSSITag(
|
|
IN OUT CHAR * * ppchFilePos,
|
|
IN CHAR * pchEOF,
|
|
OUT BOOL * pfValidTag,
|
|
OUT SSI_COMMANDS * pCommandType,
|
|
OUT SSI_TAGS * pTagType,
|
|
OUT CHAR * pszTagString
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function picks apart an NCSA style server side include expression
|
|
|
|
The general form of a server side include directive is:
|
|
|
|
<[!-- or %]#[command] [tag]="[value]"[-- or %]>
|
|
|
|
For example:
|
|
|
|
<!--#include file="myfile.txt"-->
|
|
<%#echo var="HTTP_USER_AGENT"%>
|
|
<!--#fsize virtual="/dir/bar.htm"-->
|
|
|
|
For valid commands and tags see \iis\specs\ssi.doc
|
|
|
|
Arguments:
|
|
|
|
ppchFilePos - Pointer to first character of tag on way in, pointer
|
|
to first character after tag on way out if the tag is valid
|
|
pchEOF - Points to first byte beyond the end of the file
|
|
pfValidTag - Set to TRUE if this is a tag we support and all of the
|
|
parameters have been supplied
|
|
pCommandType - Receives SSI command
|
|
pTagType - Receives SSI tag
|
|
pszTagString - Receives value of pTagType. Must be > SSI_MAX_PATH.
|
|
|
|
Return Value:
|
|
|
|
TRUE if no errors occurred.
|
|
|
|
--*/
|
|
{
|
|
CHAR * pchFilePos = *ppchFilePos;
|
|
CHAR * pchEOT;
|
|
CHAR * pchEndQuote;
|
|
DWORD i;
|
|
DWORD cbToCopy;
|
|
DWORD cbJumpLen = 0;
|
|
BOOL fNewStyle; // <% format
|
|
|
|
TCP_ASSERT( *pchFilePos == '<' );
|
|
|
|
//
|
|
// Assume this is bad tag
|
|
//
|
|
|
|
*pfValidTag = FALSE;
|
|
|
|
if ( !strncmp( pchFilePos, "<!--", 4 ) )
|
|
{
|
|
fNewStyle = FALSE;
|
|
}
|
|
else if ( !strncmp( pchFilePos, "<%", 2 ) )
|
|
{
|
|
fNewStyle = TRUE;
|
|
}
|
|
else
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Find the closing comment token (either --> or %>). The reason
|
|
// why we shouldn't simply look for a > is because we want to allow
|
|
// the user to embed HTML <tags> in the directive
|
|
// (ex. <!--#CONFIG ERRMSG="<B>ERROR!!!</B>-->)
|
|
//
|
|
|
|
pchEOT = strstr( pchFilePos, fNewStyle ? "%>" : "-->" );
|
|
if ( !pchEOT )
|
|
{
|
|
return FALSE;
|
|
}
|
|
cbJumpLen = fNewStyle ? 2 : 3;
|
|
|
|
//
|
|
// Find the '#' that prefixes the command
|
|
//
|
|
|
|
pchFilePos = SSISkipTo( pchFilePos, '#', pchEOT );
|
|
|
|
if ( !pchFilePos )
|
|
{
|
|
//
|
|
// No command, bail for this tag
|
|
//
|
|
// CODEWORK - Check for if expression here
|
|
//
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Lookup the command
|
|
//
|
|
|
|
i = 0;
|
|
while ( SSICmdMap[i].pszCommand )
|
|
{
|
|
if ( *SSICmdMap[i].pszCommand == tolower( *pchFilePos ) &&
|
|
!_strnicmp( SSICmdMap[i].pszCommand,
|
|
pchFilePos,
|
|
SSICmdMap[i].cchCommand ))
|
|
{
|
|
*pCommandType = SSICmdMap[i].ssiCmd;
|
|
|
|
//
|
|
// Note the space after the command is included in cchCommand
|
|
//
|
|
|
|
pchFilePos += SSICmdMap[i].cchCommand;
|
|
goto FoundCommand;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
//
|
|
// Unrecognized command, bail
|
|
//
|
|
|
|
return TRUE;
|
|
|
|
FoundCommand:
|
|
|
|
//
|
|
// Next, find the tag name
|
|
//
|
|
|
|
pchFilePos = SSISkipWhite( pchFilePos, pchEOT );
|
|
|
|
if ( !pchFilePos )
|
|
return TRUE;
|
|
|
|
i = 0;
|
|
while ( SSITagMap[i].pszTag )
|
|
{
|
|
if ( *SSITagMap[i].pszTag == tolower( *pchFilePos ) &&
|
|
!_strnicmp( SSITagMap[i].pszTag,
|
|
pchFilePos,
|
|
SSITagMap[i].cchTag ))
|
|
{
|
|
*pTagType = SSITagMap[i].ssiTag;
|
|
pchFilePos += SSITagMap[i].cchTag;
|
|
goto FoundTag;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
//
|
|
// Tag not found, bail
|
|
//
|
|
|
|
return TRUE;
|
|
|
|
FoundTag:
|
|
|
|
//
|
|
// Skip to the quoted tag value, then find the close quote
|
|
//
|
|
|
|
pchFilePos = SSISkipTo( pchFilePos, '"', pchEOT );
|
|
|
|
if ( !pchFilePos )
|
|
return TRUE;
|
|
|
|
pchEndQuote = SSISkipTo( ++pchFilePos, '"', pchEOT );
|
|
|
|
if ( !pchEndQuote )
|
|
return TRUE;
|
|
|
|
cbToCopy = min( DIFF(pchEndQuote - pchFilePos), SSI_MAX_PATH );
|
|
|
|
memcpy( pszTagString,
|
|
pchFilePos,
|
|
cbToCopy );
|
|
|
|
pszTagString[cbToCopy] = '\0';
|
|
|
|
*pfValidTag = TRUE;
|
|
|
|
*ppchFilePos = pchEOT + cbJumpLen;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
CHAR *
|
|
SSISkipTo(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR ch,
|
|
IN CHAR * pchEOF
|
|
)
|
|
{
|
|
return (CHAR*) memchr( pchFilePos, ch, DIFF(pchEOF - pchFilePos) );
|
|
}
|
|
|
|
CHAR *
|
|
SSISkipWhite(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR * pchEOF
|
|
)
|
|
{
|
|
while ( pchFilePos < pchEOF )
|
|
{
|
|
if ( !isspace( (UCHAR)(*pchFilePos) ) )
|
|
return pchFilePos;
|
|
|
|
pchFilePos++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
VOID
|
|
InitializeSSIGlobals( VOID )
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize global variables
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
HKEY hKeyParam;
|
|
|
|
if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
W3_PARAMETERS_KEY,
|
|
0,
|
|
KEY_READ,
|
|
&hKeyParam ) == NO_ERROR )
|
|
{
|
|
fEnableCmdDirective = !!ReadRegistryDword( hKeyParam,
|
|
"SSIEnableCmdDirective",
|
|
fEnableCmdDirective );
|
|
RegCloseKey( hKeyParam );
|
|
}
|
|
|
|
WORD wPrimaryLangID = PRIMARYLANGID( GetSystemDefaultLangID() );
|
|
|
|
g_fIsDBCS = ((wPrimaryLangID == LANG_JAPANESE) ||
|
|
(wPrimaryLangID == LANG_CHINESE) ||
|
|
(wPrimaryLangID == LANG_KOREAN) );
|
|
}
|
|
|
|
//
|
|
// ISAPI DLL Required Entry Points
|
|
//
|
|
|
|
DWORD
|
|
WINAPI
|
|
HttpExtensionProc(
|
|
EXTENSION_CONTROL_BLOCK * pecb
|
|
)
|
|
{
|
|
BOOL bRet;
|
|
|
|
DBGPRINTF(( DBG_CONTEXT,
|
|
"HttpExtensionProc() entry point called\n" ));
|
|
|
|
SSI_REQUEST ssiReq = pecb;
|
|
if ( !ssiReq.IsValid() || !ssiReq.ProcessSSI() )
|
|
{
|
|
LPCTSTR apsz[ 1 ];
|
|
STR strLogMessage;
|
|
|
|
apsz[ 0 ] = pecb->lpszPathInfo;
|
|
strLogMessage.FormatString( SSINCMSG_LOG_ERROR,
|
|
apsz,
|
|
SSI_DLL_NAME );
|
|
|
|
strncpy( pecb->lpszLogData,
|
|
strLogMessage.QueryStr(),
|
|
HSE_LOG_BUFFER_LEN );
|
|
|
|
pecb->lpszLogData[HSE_LOG_BUFFER_LEN-1] = 0;
|
|
|
|
return HSE_STATUS_ERROR;
|
|
}
|
|
else
|
|
{
|
|
return HSE_STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
GetExtensionVersion(
|
|
HSE_VERSION_INFO * pver
|
|
)
|
|
{
|
|
pver->dwExtensionVersion = MAKELONG( 0, 1 );
|
|
strcpy( pver->lpszExtensionDesc,
|
|
"Server Side Include Extension DLL" );
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
TerminateExtension(
|
|
DWORD dwFlags
|
|
)
|
|
{
|
|
//
|
|
// Flush Tsunami file associated with this extension
|
|
//
|
|
|
|
TsFlushFilesWithContext();
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
DLLEntry(
|
|
HINSTANCE hDll,
|
|
DWORD dwReason,
|
|
LPVOID lpvReserved
|
|
)
|
|
{
|
|
switch ( dwReason )
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
#ifdef _NO_TRACING_
|
|
CREATE_DEBUG_PRINT_OBJECT( SSI_DLL_NAME );
|
|
SET_DEBUG_FLAGS( 0 );
|
|
#else
|
|
CREATE_DEBUG_PRINT_OBJECT( SSI_DLL_NAME, IisSSIncGuid );
|
|
#endif
|
|
DisableThreadLibraryCalls( hDll );
|
|
InitializeSSIGlobals();
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
DELETE_DEBUG_PRINT_OBJECT();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|