2421 lines
60 KiB
C++
2421 lines
60 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
|
|
|
|
Revision History:
|
|
|
|
See iis\svcs\w3\server\ssinc.cxx for prior log
|
|
|
|
--*/
|
|
|
|
#include "ssinc.hxx"
|
|
#include "ssicgi.hxx"
|
|
#include "ssibgi.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_CMDECHO,
|
|
SSI_TAG_CMDPREFIX,
|
|
SSI_TAG_CMDPOSTFIX,
|
|
|
|
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
|
|
};
|
|
|
|
//
|
|
// Gateway types
|
|
//
|
|
|
|
enum SSI_GATEWAY_TYPE
|
|
{
|
|
SSI_GATEWAY_CGI,
|
|
SSI_GATEWAY_CMD,
|
|
SSI_GATEWAY_ISA,
|
|
|
|
SSI_GATEWAY_UNKNOWN
|
|
};
|
|
|
|
//
|
|
// 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,
|
|
OUT BOOL * pfAccessDenied
|
|
);
|
|
|
|
BOOL
|
|
SSISend(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL
|
|
);
|
|
|
|
BOOL
|
|
ParseSSITag(
|
|
IN OUT CHAR * * ppchFilePos,
|
|
IN CHAR * pchEOF,
|
|
OUT BOOL * pfValidTag,
|
|
OUT SSI_COMMANDS * pCommandType,
|
|
OUT SSI_TAGS * pTagType,
|
|
OUT CHAR * pszTagString
|
|
);
|
|
|
|
void
|
|
FreeSELBlob(
|
|
VOID * pvCacheBlob
|
|
);
|
|
|
|
CHAR *
|
|
SSISkipTo(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR ch,
|
|
IN CHAR * pchEOF
|
|
);
|
|
|
|
CHAR *
|
|
SSISkipWhite(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR * pchEOF
|
|
);
|
|
|
|
SSI_FILE * SSICreateFile(
|
|
IN STR * pstrFilename,
|
|
IN HANDLE hUser
|
|
);
|
|
|
|
VOID SSICloseFile(
|
|
IN SSI_FILE * pssiFile
|
|
);
|
|
|
|
BOOL SSICreateFileMapping(
|
|
IN SSI_FILE * pssiFile
|
|
);
|
|
|
|
BOOL SSICloseMapHandle(
|
|
IN SSI_FILE * pssiFile
|
|
);
|
|
|
|
BOOL SSIMapViewOfFile(
|
|
IN SSI_FILE * pssiFile
|
|
);
|
|
|
|
BOOL SSIUnmapViewOfFile(
|
|
IN SSI_FILE * pssiFile
|
|
);
|
|
|
|
DWORD SSIGetFileAttributes(
|
|
IN SSI_FILE * pssiFile
|
|
);
|
|
|
|
BOOL SSIGetFileSize(
|
|
IN SSI_FILE * pssiFile,
|
|
OUT DWORD * pdwLowWord,
|
|
OUT DWORD * pdwHighWord
|
|
);
|
|
|
|
BOOL SSIGetLastModTime(
|
|
IN SSI_FILE * pssiFile,
|
|
OUT FILETIME * ftTime
|
|
);
|
|
|
|
//
|
|
// Class Definitions
|
|
//
|
|
|
|
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; }
|
|
|
|
};
|
|
|
|
//
|
|
// 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
|
|
{
|
|
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( SSI_REQUEST * pRequest )
|
|
: _Signature ( SIGNATURE_SEL ),
|
|
_pssiFile( NULL ),
|
|
_cRefCount( 0 )
|
|
{
|
|
InitializeListHead( &_ListHead );
|
|
InitializeCriticalSection( &_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 )
|
|
{
|
|
SSICloseFile( _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 ))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AppendItem( pSEI );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID AppendItem( IN SSI_ELEMENT_ITEM * pSEI )
|
|
{
|
|
InsertTailList( &_ListHead,
|
|
&pSEI->_ListEntry );
|
|
}
|
|
|
|
CHAR * QueryData( VOID ) const
|
|
{ return (CHAR *) _pssiFile->_pvMappedBase; }
|
|
|
|
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( SSIUnmapViewOfFile( _pssiFile ) );
|
|
TCP_REQUIRE( SSICloseMapHandle( _pssiFile ) );
|
|
}
|
|
UnLock();
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL Map( VOID )
|
|
{
|
|
Lock();
|
|
if ( _cRefCount++ == 0 )
|
|
{
|
|
if ( !SSICreateFileMapping( _pssiFile ) )
|
|
{
|
|
UnLock();
|
|
return FALSE;
|
|
}
|
|
if ( !SSIMapViewOfFile( _pssiFile ) )
|
|
{
|
|
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() );
|
|
}
|
|
|
|
VOID SendErrMsg( IN SSI_REQUEST *,
|
|
IN DWORD,
|
|
IN LPCTSTR * );
|
|
BOOL Send( SSI_REQUEST * );
|
|
|
|
BOOL GetFullPath( IN SSI_REQUEST *,
|
|
IN SSI_ELEMENT_ITEM *,
|
|
IN OUT STR *,
|
|
IN DWORD );
|
|
BOOL SendDate( IN SSI_REQUEST *,
|
|
IN SYSTEMTIME *,
|
|
IN STR * );
|
|
BOOL FindInternalVariable( IN OUT STR *,
|
|
IN OUT DWORD * );
|
|
|
|
// methods for performing #ECHOs
|
|
|
|
BOOL DoEchoISAPIVariable( IN SSI_REQUEST *,
|
|
IN STR * );
|
|
BOOL DoEchoDateLocal( IN SSI_REQUEST *,
|
|
IN STR * );
|
|
BOOL DoEchoDateGMT( IN SSI_REQUEST *,
|
|
IN STR * );
|
|
BOOL DoEchoDocumentName( IN SSI_REQUEST * );
|
|
BOOL DoEchoDocumentURI( IN SSI_REQUEST * );
|
|
BOOL DoEchoQueryStringUnescaped( IN SSI_REQUEST * );
|
|
BOOL DoEchoLastModified( IN SSI_REQUEST *,
|
|
IN STR * );
|
|
|
|
// methods for performing other commands
|
|
|
|
BOOL DoFLastMod( IN SSI_REQUEST *,
|
|
IN STR *,
|
|
IN STR * );
|
|
BOOL DoFSize( IN SSI_REQUEST *,
|
|
IN STR *,
|
|
IN BOOL );
|
|
BOOL DoProcessGateway( IN SSI_REQUEST *,
|
|
IN STR *,
|
|
IN SSI_GATEWAY_TYPE );
|
|
};
|
|
|
|
//
|
|
// Global Data
|
|
//
|
|
|
|
DECLARE_DEBUG_PRINTS_OBJECT()
|
|
DECLARE_DEBUG_VARIABLE();
|
|
|
|
|
|
//
|
|
// This is used to access cache/virtual root mapping code
|
|
//
|
|
|
|
#ifdef DO_CACHE
|
|
TSVC_CACHE * g_ptsvcCache;
|
|
#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,
|
|
"cmdecho", 7, SSI_TAG_CMDECHO,
|
|
"cmdprefix",9, SSI_TAG_CMDPREFIX,
|
|
"cmdpostfix",10,SSI_TAG_CMDPOSTFIX,
|
|
"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
|
|
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
|
|
|
|
--*/
|
|
{
|
|
TCP_PRINT(( DBG_CONTEXT,
|
|
"[ProcessSSI] about to process %s\n",
|
|
_strFilename.QueryStr() ));
|
|
|
|
return SSISend( this, &_strFilename, &_strURL );
|
|
}
|
|
|
|
BOOL
|
|
SSISend(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL
|
|
)
|
|
/*++
|
|
|
|
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
|
|
|
|
Return Value:
|
|
|
|
TRUE on success, FALSE on failure
|
|
|
|
--*/
|
|
{
|
|
SSI_ELEMENT_LIST * pSEL;
|
|
BOOL fRet = TRUE;
|
|
BOOL fAccessDenied = FALSE;
|
|
|
|
#ifdef DO_CACHE
|
|
SSI_ELEMENT_LIST ** ppSELBlob;
|
|
DWORD cbBlob;
|
|
BOOL fCached = TRUE;
|
|
BOOL fMustFree = FALSE;
|
|
|
|
//
|
|
// Check if we've already processed the file and its in cache
|
|
//
|
|
if ( TsCheckOutCachedBlob( *g_ptsvcCache,
|
|
pstrFile->QueryStr(),
|
|
SSI_DEMUX,
|
|
(VOID**) &ppSELBlob,
|
|
&cbBlob ) )
|
|
{
|
|
//
|
|
// found it! Send a response header if processing base file
|
|
//
|
|
|
|
if ( pRequest->_fBaseFile )
|
|
{
|
|
pRequest->_fBaseFile = FALSE;
|
|
pRequest->SendResponseHeader( NULL );
|
|
}
|
|
|
|
pSEL = *ppSELBlob;
|
|
|
|
goto SendSSI;
|
|
}
|
|
#endif
|
|
//
|
|
// This file hasn't been processed yet so go process it
|
|
//
|
|
|
|
pSEL = SSIParse( pRequest, pstrFile, pstrURL, &fAccessDenied );
|
|
|
|
if ( pRequest->_fBaseFile )
|
|
{
|
|
pRequest->_fBaseFile = FALSE;
|
|
if ( !pSEL && fAccessDenied )
|
|
{
|
|
pRequest->SendResponseHeader( SSI_ACCESS_DENIED_HEADER );
|
|
return FALSE;
|
|
}
|
|
//
|
|
// Send the response header now even though we do not know for sure
|
|
// whether all of the included files exist. If we find a file that
|
|
// doesn't exist then we'll just include an error message in the document
|
|
//
|
|
|
|
if ( !pRequest->SendResponseHeader( NULL ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !pSEL )
|
|
{
|
|
//
|
|
// ParseSSI failed and has already sent the error to the client,
|
|
// we return TRUE so processing may continue on the parent
|
|
// include files
|
|
//
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
#ifdef DO_CACHE
|
|
ppSELBlob = &pSEL;
|
|
|
|
//
|
|
// In case allocation/caching fails, initialize ppSELBlob
|
|
//
|
|
|
|
if ( !TsAllocateEx( *g_ptsvcCache,
|
|
sizeof( PVOID ),
|
|
(VOID**) &ppSELBlob,
|
|
(PUSER_FREE_ROUTINE) FreeSELBlob ) )
|
|
{
|
|
fCached = FALSE;
|
|
goto SendSSI;
|
|
}
|
|
|
|
*ppSELBlob = pSEL;
|
|
|
|
if ( !TsCacheDirectoryBlob( *g_ptsvcCache,
|
|
pstrFile->QueryStr(),
|
|
SSI_DEMUX,
|
|
ppSELBlob,
|
|
sizeof( PVOID ),
|
|
TRUE ) )
|
|
{
|
|
// remember to free the blob
|
|
fMustFree= TRUE;
|
|
fCached = FALSE;
|
|
goto SendSSI;
|
|
}
|
|
|
|
#endif
|
|
goto SendSSI;
|
|
|
|
SendSSI:
|
|
|
|
TCP_ASSERT( pSEL->CheckSignature() );
|
|
|
|
if ( !pSEL->Send( pRequest ) )
|
|
{
|
|
//
|
|
// Send a failure message
|
|
//
|
|
|
|
LPCTSTR apszParms[ 2 ];
|
|
CHAR pszNumBuf[ SSI_MAX_NUMBER_STRING ];
|
|
_ultoa( GetLastError(), pszNumBuf, 10 );
|
|
apszParms[ 0 ] = pstrFile->QueryStr();
|
|
apszParms[ 1 ] = pszNumBuf;
|
|
|
|
pRequest->SSISendError( SSINCMSG_ERROR_HANDLING_FILE,
|
|
apszParms );
|
|
fRet = FALSE;
|
|
}
|
|
|
|
#ifdef DO_CACHE
|
|
if ( fCached )
|
|
{
|
|
TCP_REQUIRE( TsCheckInCachedBlob( *g_ptsvcCache,
|
|
ppSELBlob ) );
|
|
}
|
|
else
|
|
{
|
|
if ( fMustFree )
|
|
{
|
|
TCP_REQUIRE( TsFree( *g_ptsvcCache,
|
|
ppSELBlob ) );
|
|
}
|
|
else
|
|
{
|
|
delete *ppSELBlob;
|
|
}
|
|
}
|
|
#else
|
|
delete pSEL;
|
|
#endif
|
|
return fRet;
|
|
}
|
|
|
|
SSI_ELEMENT_LIST *
|
|
SSIParse(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFile,
|
|
IN STR * pstrURL,
|
|
OUT BOOL * pfAccessDenied
|
|
)
|
|
/*++
|
|
|
|
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
|
|
pfAccessDenied - Was .STM file access denied?
|
|
|
|
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( pRequest );
|
|
|
|
if ( pSEL == NULL )
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
//
|
|
// Set the URL (to be used in calculating FILE="xxx" paths
|
|
//
|
|
|
|
pSEL->SetURL( pstrURL );
|
|
|
|
//
|
|
// Open the file
|
|
//
|
|
|
|
pssiFile = SSICreateFile( pstrFile, pRequest->_hUser );
|
|
if ( !pssiFile )
|
|
{
|
|
*pfAccessDenied = ( GetLastError() == ERROR_ACCESS_DENIED );
|
|
goto ErrorExit;
|
|
}
|
|
|
|
pSEL->SetFile( pssiFile );
|
|
|
|
//
|
|
// Make sure a parent doesn't try and include a directory
|
|
//
|
|
|
|
if ( SSIGetFileAttributes( pssiFile ) & FILE_ATTRIBUTE_DIRECTORY )
|
|
{
|
|
// SetLastError( SSINCMSG_CANT_INCLUDE_DIR );
|
|
goto ErrorExit;
|
|
}
|
|
|
|
if ( !SSIGetFileSize( pssiFile, &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 >= 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( pchBeginRange - pchBeginFile,
|
|
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( pchBeginRange - pchBeginFile,
|
|
pchFilePos - pchBeginRange ))
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
pSEL->UnMap();
|
|
|
|
return pSEL;
|
|
|
|
ErrorExit:
|
|
|
|
if ( pssiFile != NULL )
|
|
{
|
|
SSICloseFile( pssiFile );
|
|
}
|
|
|
|
if ( pSEL != NULL )
|
|
{
|
|
delete pSEL;
|
|
}
|
|
|
|
LPCTSTR apszParms[ 2 ];
|
|
CHAR pszNumBuf[ SSI_MAX_NUMBER_STRING ];
|
|
_ultoa( GetLastError(), pszNumBuf, 10 );
|
|
apszParms[ 0 ] = pstrFile->QueryStr();
|
|
apszParms[ 1 ] = pszNumBuf;
|
|
|
|
pRequest->SSISendError( SSINCMSG_ERROR_HANDLING_FILE,
|
|
apszParms );
|
|
|
|
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( (pchEndQuote - pchFilePos), SSI_MAX_PATH );
|
|
|
|
memcpy( pszTagString,
|
|
pchFilePos,
|
|
cbToCopy );
|
|
|
|
pszTagString[cbToCopy] = '\0';
|
|
|
|
*pfValidTag = TRUE;
|
|
|
|
*ppchFilePos = pchEOT + cbJumpLen;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::Send(
|
|
SSI_REQUEST * pRequest
|
|
)
|
|
/*++
|
|
|
|
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;
|
|
STR strPath;
|
|
SSI_ELEMENT_ITEM * pSEI;
|
|
|
|
STR strTimeFmt( SSI_DEF_TIMEFMT );
|
|
STR strCmdPrefix( SSI_DEF_CMDPREFIX );
|
|
STR strCmdPostfix( SSI_DEF_CMDPOSTFIX );
|
|
BOOL bSizeFmtBytes( SSI_DEF_SIZEFMT );
|
|
BOOL bCmdEcho( SSI_DEF_CMDECHO );
|
|
|
|
TCP_ASSERT( CheckSignature() );
|
|
|
|
if ( !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() );
|
|
|
|
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:
|
|
if ( !GetFullPath( pRequest,
|
|
pSEI,
|
|
&strPath,
|
|
VROOT_MASK_READ ) ||
|
|
!SSISend( pRequest,
|
|
&strPath,
|
|
pSEI->QueryTagValue() ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = strPath.QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_ERROR_HANDLING_FILE,
|
|
apszParms );
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_FLASTMOD:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_FILE:
|
|
case SSI_TAG_VIRTUAL:
|
|
if ( !GetFullPath( pRequest,
|
|
pSEI,
|
|
&strPath,
|
|
0 ) ||
|
|
!DoFLastMod( pRequest,
|
|
&strPath,
|
|
&strTimeFmt ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = strPath.QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_DO_FLASTMOD,
|
|
apszParms );
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_CONFIG:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_ERRMSG:
|
|
pRequest->SetUserErrorMessage( pSEI->QueryTagValue() );
|
|
break;
|
|
case SSI_TAG_TIMEFMT:
|
|
strTimeFmt.Copy( pSEI->QueryTagValue()->QueryStr() );
|
|
break;
|
|
case SSI_TAG_SIZEFMT:
|
|
if ( _strnicmp( SSI_DEF_BYTES,
|
|
pSEI->QueryTagValue()->QueryStr(),
|
|
SSI_DEF_BYTES_LEN + 1 ) == 0 )
|
|
{
|
|
bSizeFmtBytes = TRUE;
|
|
}
|
|
else if ( _strnicmp( SSI_DEF_ABBREV,
|
|
pSEI->QueryTagValue()->QueryStr(),
|
|
SSI_DEF_ABBREV_LEN + 1 ) == 0 )
|
|
{
|
|
bSizeFmtBytes = FALSE;
|
|
}
|
|
else
|
|
{
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
}
|
|
break;
|
|
case SSI_TAG_CMDECHO:
|
|
if ( _strnicmp( SSI_DEF_ON,
|
|
pSEI->QueryTagValue()->QueryStr(),
|
|
SSI_DEF_ON_LEN + 1 ) == 0 )
|
|
{
|
|
bCmdEcho = TRUE;
|
|
}
|
|
else if ( _strnicmp( SSI_DEF_OFF,
|
|
pSEI->QueryTagValue()->QueryStr(),
|
|
SSI_DEF_OFF_LEN + 1) == 0 )
|
|
{
|
|
bCmdEcho = FALSE;
|
|
}
|
|
else
|
|
{
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
}
|
|
break;
|
|
case SSI_TAG_CMDPREFIX:
|
|
strCmdPrefix.Copy( pSEI->QueryTagValue()->QueryStr() );
|
|
break;
|
|
case SSI_TAG_CMDPOSTFIX:
|
|
strCmdPostfix.Copy( pSEI->QueryTagValue()->QueryStr() );
|
|
break;
|
|
default:
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_FSIZE:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_FILE:
|
|
case SSI_TAG_VIRTUAL:
|
|
if ( !GetFullPath( pRequest,
|
|
pSEI,
|
|
&strPath,
|
|
0 ) ||
|
|
!DoFSize( pRequest,
|
|
&strPath,
|
|
bSizeFmtBytes ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = strPath.QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_DO_FSIZE,
|
|
apszParms );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case SSI_CMD_ECHO:
|
|
if ( pSEI->QueryTag() == SSI_TAG_VAR )
|
|
{
|
|
// First let ISAPI try to evaluate variable.
|
|
if ( DoEchoISAPIVariable( pRequest,
|
|
pSEI->QueryTagValue() ) )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwVar;
|
|
BOOL fEchoError = FALSE;
|
|
|
|
// if ISAPI couldn't resolve var, try internal list
|
|
if ( !FindInternalVariable( pSEI->QueryTagValue(),
|
|
&dwVar ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_FIND_VARIABLE,
|
|
apszParms );
|
|
break;
|
|
}
|
|
switch( dwVar )
|
|
{
|
|
case SSI_VAR_DOCUMENT_NAME:
|
|
if ( !DoEchoDocumentName( pRequest ) )
|
|
{
|
|
fEchoError = TRUE;
|
|
}
|
|
break;
|
|
case SSI_VAR_DOCUMENT_URI:
|
|
if ( !DoEchoDocumentURI( pRequest ) )
|
|
{
|
|
fEchoError = TRUE;
|
|
}
|
|
break;
|
|
case SSI_VAR_QUERY_STRING_UNESCAPED:
|
|
if ( !DoEchoQueryStringUnescaped( pRequest ) )
|
|
{
|
|
fEchoError = TRUE;
|
|
}
|
|
break;
|
|
case SSI_VAR_DATE_LOCAL:
|
|
if ( !DoEchoDateLocal( pRequest, &strTimeFmt ) )
|
|
{
|
|
fEchoError = TRUE;
|
|
}
|
|
break;
|
|
case SSI_VAR_DATE_GMT:
|
|
if ( !DoEchoDateGMT( pRequest, &strTimeFmt ) )
|
|
{
|
|
fEchoError = TRUE;
|
|
}
|
|
break;
|
|
case SSI_VAR_LAST_MODIFIED:
|
|
if ( !DoEchoLastModified( pRequest, &strTimeFmt ) )
|
|
{
|
|
fEchoError = TRUE;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_FIND_VARIABLE,
|
|
apszParms );
|
|
break;
|
|
}
|
|
}
|
|
if ( fEchoError )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_EVALUATE_VARIABLE,
|
|
apszParms );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
}
|
|
break;
|
|
case SSI_CMD_EXEC:
|
|
switch( pSEI->QueryTag() )
|
|
{
|
|
case SSI_TAG_CMD:
|
|
if ( !DoProcessGateway( pRequest,
|
|
pSEI->QueryTagValue(),
|
|
SSI_GATEWAY_CMD ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_EXEC_CMD,
|
|
apszParms );
|
|
}
|
|
break;
|
|
case SSI_TAG_CGI:
|
|
if ( !DoProcessGateway( pRequest,
|
|
pSEI->QueryTagValue(),
|
|
SSI_GATEWAY_CGI ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_EXEC_CGI,
|
|
apszParms );
|
|
}
|
|
break;
|
|
case SSI_TAG_ISA:
|
|
if ( !DoProcessGateway( pRequest,
|
|
pSEI->QueryTagValue(),
|
|
SSI_GATEWAY_ISA ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = pSEI->QueryTagValue()->QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_CANT_EXEC_ISA,
|
|
apszParms );
|
|
}
|
|
break;
|
|
default:
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_INVALID_TAG,
|
|
NULL );
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_NOT_SUPPORTED,
|
|
NULL );
|
|
break;
|
|
}
|
|
}
|
|
|
|
UnMap();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID
|
|
SSI_ELEMENT_LIST::SendErrMsg(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN DWORD dwMessageID,
|
|
IN LPCTSTR apszParms[]
|
|
)
|
|
{
|
|
pRequest->SSISendError( dwMessageID,
|
|
apszParms );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::GetFullPath(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN SSI_ELEMENT_ITEM * pSEI,
|
|
OUT STR * pstrPath,
|
|
IN DWORD dwPermission
|
|
)
|
|
{
|
|
CHAR * pszValue;
|
|
STR * pstrValue;
|
|
DWORD dwMask;
|
|
DWORD cbBufLen;
|
|
CHAR achPath[ SSI_MAX_PATH + 1 ];
|
|
TSVC_CACHE tsvcCache( INET_HTTP_SVC_ID );
|
|
|
|
//
|
|
// We recalc the virtual root each time in case the root
|
|
// to directory mapping has changed
|
|
//
|
|
|
|
pstrValue = pSEI->QueryTagValue();
|
|
pszValue = pstrValue->QueryStr();
|
|
|
|
if ( *pszValue == '/' )
|
|
strcpy( achPath, pszValue );
|
|
else if ( (int)pSEI->QueryTag() == (int)SSI_TAG_FILE )
|
|
{
|
|
strcpy( achPath, _strURL.QueryStr() );
|
|
LPSTR pL = achPath + lstrlen( achPath );
|
|
while ( pL > achPath && pL[-1] != '/' )
|
|
--pL;
|
|
if ( pL == achPath )
|
|
*pL++ = '/';
|
|
strcpy( pL, pszValue );
|
|
}
|
|
else
|
|
{
|
|
achPath[0] = '/';
|
|
strcpy( achPath+1, pszValue );
|
|
}
|
|
|
|
//
|
|
// Map to a physical directory
|
|
//
|
|
|
|
if ( !pstrPath->Resize( SSI_MAX_PATH + 1 ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
cbBufLen = SSI_MAX_PATH + 1;
|
|
|
|
if ( !TsLookupVirtualRoot( tsvcCache,
|
|
achPath,
|
|
pstrPath->QueryStr(),
|
|
&cbBufLen,
|
|
&dwMask ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( dwPermission && !( dwMask & dwPermission ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = achPath;
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_ACCESS_DENIED,
|
|
apszParms );
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoFLastMod(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFilename,
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
{
|
|
SSI_FILE * pssiFile;
|
|
FILETIME ftTime;
|
|
SYSTEMTIME sysTime;
|
|
SYSTEMTIME sysLocal;
|
|
|
|
pssiFile = SSICreateFile( pstrFilename, pRequest->_hUser );
|
|
if ( !pssiFile )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !SSIGetLastModTime( pssiFile, &ftTime ) )
|
|
{
|
|
SSICloseFile( pssiFile );
|
|
return FALSE;
|
|
}
|
|
SSICloseFile( pssiFile );
|
|
|
|
if ( !::FileTimeToSystemTime( &ftTime, &sysTime ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !::SystemTimeToTzSpecificLocalTime( NULL,
|
|
&sysTime,
|
|
&sysLocal ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return SendDate( pRequest,
|
|
&sysLocal,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::SendDate(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN SYSTEMTIME * psysTime,
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
{
|
|
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;
|
|
|
|
cbBufLen = strftime( achBuffer,
|
|
SSI_MAX_TIME_SIZE + 1,
|
|
pstrTimeFmt->QueryStr(),
|
|
&tm );
|
|
|
|
if ( cbBufLen == 0 )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return pRequest->WriteToClient( achBuffer,
|
|
cbBufLen,
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoISAPIVariable(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrVariable
|
|
)
|
|
{
|
|
STR strVar;
|
|
DWORD cbBufLen;
|
|
|
|
if ( !pRequest->GetVariable( pstrVariable->QueryStr(),
|
|
&strVar ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return pRequest->WriteToClient( strVar.QueryStrA(),
|
|
strVar.QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoDateLocal(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
{
|
|
SYSTEMTIME sysTime;
|
|
|
|
::GetLocalTime( &sysTime );
|
|
return SendDate( pRequest,
|
|
&sysTime,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoDateGMT(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
{
|
|
SYSTEMTIME sysTime;
|
|
|
|
::GetSystemTime( &sysTime );
|
|
return SendDate( pRequest,
|
|
&sysTime,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoDocumentName(
|
|
IN SSI_REQUEST * pRequest
|
|
)
|
|
{
|
|
DWORD cbBufLen;
|
|
|
|
return pRequest->WriteToClient( _pssiFile->_strFilename.QueryStrA(),
|
|
_pssiFile->_strFilename.QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoDocumentURI(
|
|
IN SSI_REQUEST * pRequest
|
|
)
|
|
{
|
|
DWORD cbBufLen;
|
|
|
|
return pRequest->WriteToClient( _strURL.QueryStrA(),
|
|
_strURL.QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoQueryStringUnescaped(
|
|
IN SSI_REQUEST * pRequest
|
|
)
|
|
{
|
|
DWORD cbBufLen;
|
|
STR strVar;
|
|
|
|
if ( !pRequest->GetVariable( "QUERY_STRING",
|
|
&strVar ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
strVar.Unescape();
|
|
|
|
return pRequest->WriteToClient( strVar.QueryStrA(),
|
|
strVar.QueryCB(),
|
|
&cbBufLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoEchoLastModified(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrTimeFmt
|
|
)
|
|
{
|
|
return DoFLastMod( pRequest,
|
|
&_pssiFile->_strFilename,
|
|
pstrTimeFmt );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::DoFSize(
|
|
IN SSI_REQUEST * pRequest,
|
|
IN STR * pstrFilename,
|
|
IN BOOL bSizeFmtBytes
|
|
)
|
|
{
|
|
BOOL bRet;
|
|
DWORD cbSizeLow;
|
|
DWORD cbSizeHigh;
|
|
SSI_FILE * pssiFile;
|
|
CHAR achInputNumber[ SSI_MAX_NUMBER_STRING + 1 ];
|
|
CHAR achOutputNumber[ SSI_MAX_NUMBER_STRING + 1 ];
|
|
NUMBERFMT nfNumberFormat;
|
|
int iOutputSize;
|
|
DWORD dwActualLen;
|
|
|
|
pssiFile = SSICreateFile( pstrFilename, pRequest->_hUser );
|
|
if ( pssiFile == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
bRet = SSIGetFileSize( pssiFile,
|
|
&cbSizeLow,
|
|
&cbSizeHigh );
|
|
if ( !bRet )
|
|
{
|
|
SSICloseFile( pssiFile );
|
|
return FALSE;
|
|
}
|
|
|
|
if ( cbSizeHigh )
|
|
{
|
|
SSICloseFile( pssiFile );
|
|
return FALSE;
|
|
}
|
|
|
|
SSICloseFile( pssiFile );
|
|
|
|
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 pRequest->WriteToClient( achOutputNumber,
|
|
iOutputSize,
|
|
&dwActualLen );
|
|
}
|
|
|
|
BOOL
|
|
SSI_ELEMENT_LIST::FindInternalVariable(
|
|
IN STR * pstrVariable,
|
|
OUT PDWORD pdwID
|
|
)
|
|
{
|
|
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
|
|
SSI_ELEMENT_LIST::DoProcessGateway(
|
|
SSI_REQUEST * pRequest,
|
|
STR * pstrPath,
|
|
SSI_GATEWAY_TYPE sgtType
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Handles #EXEC CMD=,CGI=,ISA=
|
|
|
|
Arguments:
|
|
|
|
pRequest - SSI_REQUEST class used to send data to client
|
|
pstrPath - Command specified in #EXEC call
|
|
sgtType - Type of gateway
|
|
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE on error
|
|
|
|
--*/
|
|
{
|
|
BOOL fRet = TRUE;
|
|
|
|
switch ( sgtType )
|
|
{
|
|
case SSI_GATEWAY_CGI:
|
|
case SSI_GATEWAY_ISA:
|
|
{
|
|
STR strURLParams;
|
|
STR strWorkingDir;
|
|
STR strFull;
|
|
STR strPathCopy;
|
|
TCHAR * pch;
|
|
DWORD cbBufLen = SSI_MAX_PATH + 1;
|
|
DWORD cbDirSize;
|
|
TSVC_CACHE tsvcCache( INET_HTTP_SVC_ID );
|
|
DWORD dwMask;
|
|
|
|
//
|
|
// Need to separate any params specified in URL
|
|
//
|
|
|
|
strPathCopy.Copy( pstrPath->QueryStr() );
|
|
|
|
pch = strchr( strPathCopy.QueryStr(), TEXT('?') );
|
|
|
|
if ( pch != NULL )
|
|
{
|
|
*pch = TEXT('\0');
|
|
}
|
|
|
|
strURLParams.Copy( pch != NULL ? pch + 1 : "" );
|
|
|
|
strFull.Resize( SSI_MAX_PATH + 1 );
|
|
|
|
//
|
|
// We need to the working directory of the path
|
|
// TsLookupVirtualRoot() appears to be the only way for this DLL
|
|
// to get the working directory of a CGI script (for now?)
|
|
//
|
|
|
|
if ( !TsLookupVirtualRoot( tsvcCache,
|
|
strPathCopy.QueryStr(),
|
|
strFull.QueryStr(),
|
|
&cbBufLen,
|
|
&dwMask,
|
|
&cbDirSize ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !( dwMask & VROOT_MASK_EXECUTE ) )
|
|
{
|
|
LPCTSTR apszParms[ 1 ];
|
|
apszParms[ 0 ] = strFull.QueryStr();
|
|
|
|
SendErrMsg( pRequest,
|
|
SSINCMSG_NO_EXECUTE_PERMISSION,
|
|
apszParms );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if ( sgtType == SSI_GATEWAY_CGI )
|
|
{
|
|
if ( !strWorkingDir.Resize( ( cbBufLen + 1 ) * sizeof( CHAR ) ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
strWorkingDir.Copy( strFull.QueryStr() );
|
|
*( strWorkingDir.QueryStr() + cbDirSize ) = TEXT('\0');
|
|
|
|
fRet = ProcessCGI( pRequest,
|
|
&strFull,
|
|
&strURLParams,
|
|
&strWorkingDir,
|
|
NULL );
|
|
}
|
|
else
|
|
{
|
|
fRet = ProcessBGI( pRequest,
|
|
&strFull,
|
|
&strURLParams );
|
|
}
|
|
break;
|
|
}
|
|
case SSI_GATEWAY_CMD:
|
|
fRet = ProcessCGI( pRequest,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
pstrPath );
|
|
break;
|
|
default:
|
|
TCP_ASSERT( 0 );
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
VOID
|
|
FreeSELBlob(
|
|
VOID * pvCacheBlob
|
|
)
|
|
{
|
|
if ( pvCacheBlob )
|
|
{
|
|
TCP_ASSERT( (*((SSI_ELEMENT_LIST **)pvCacheBlob))->CheckSignature() );
|
|
delete *((SSI_ELEMENT_LIST **)pvCacheBlob);
|
|
}
|
|
}
|
|
|
|
CHAR *
|
|
SSISkipTo(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR ch,
|
|
IN CHAR * pchEOF
|
|
)
|
|
{
|
|
while ( pchFilePos < pchEOF )
|
|
{
|
|
if ( *pchFilePos == ch )
|
|
return pchFilePos;
|
|
|
|
pchFilePos++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CHAR *
|
|
SSISkipWhite(
|
|
IN CHAR * pchFilePos,
|
|
IN CHAR * pchEOF
|
|
)
|
|
{
|
|
while ( pchFilePos < pchEOF )
|
|
{
|
|
if ( !isspace( *pchFilePos ) )
|
|
return pchFilePos;
|
|
|
|
pchFilePos++;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// SSI_FILE utilities
|
|
//
|
|
|
|
SSI_FILE * SSICreateFile( IN STR * pstrFilename,
|
|
IN HANDLE hUser )
|
|
// Opens a file to be read. For now use Win32, later may use ISAPI
|
|
// Returns SSI_FILE structure to be used throughout access of file
|
|
{
|
|
SSI_FILE * pssiFile;
|
|
|
|
pssiFile = new SSI_FILE;
|
|
if ( pssiFile == NULL )
|
|
{
|
|
return NULL;
|
|
}
|
|
#ifdef DO_CACHE
|
|
TS_OPEN_FILE_INFO * hHandle;
|
|
|
|
hHandle = TsCreateFile( *g_ptsvcCache,
|
|
pstrFilename->QueryStr(),
|
|
hUser,
|
|
TS_CACHING_DESIRED );
|
|
#else
|
|
HANDLE hHandle;
|
|
|
|
hHandle = ::CreateFile( pstrFilename->QueryStr(),
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL );
|
|
if ( hHandle == INVALID_HANDLE_VALUE )
|
|
{
|
|
hHandle = NULL;
|
|
}
|
|
#endif
|
|
if ( hHandle == NULL )
|
|
{
|
|
delete pssiFile;
|
|
return NULL;
|
|
}
|
|
pssiFile->_hHandle = hHandle;
|
|
pssiFile->_strFilename.Copy( pstrFilename->QueryStr() );
|
|
return pssiFile;
|
|
}
|
|
|
|
VOID SSICloseFile( IN SSI_FILE * pssiFile )
|
|
// Closes file and destructs SSI_FILE structure
|
|
{
|
|
if ( pssiFile->_pvMappedBase != NULL )
|
|
{
|
|
SSIUnmapViewOfFile( pssiFile );
|
|
}
|
|
if ( pssiFile->_hMapHandle != NULL )
|
|
{
|
|
SSICloseMapHandle( pssiFile );
|
|
}
|
|
if ( pssiFile->_hHandle != NULL )
|
|
{
|
|
#ifdef DO_CACHE
|
|
TsCloseHandle( *g_ptsvcCache,
|
|
pssiFile->_hHandle );
|
|
#else
|
|
::CloseHandle( pssiFile->_hHandle );
|
|
#endif
|
|
}
|
|
delete pssiFile;
|
|
}
|
|
|
|
BOOL SSICreateFileMapping( IN SSI_FILE * pssiFile )
|
|
// Creates a mapping to a file
|
|
{
|
|
HANDLE hHandle;
|
|
|
|
#ifdef DO_CACHE
|
|
hHandle = pssiFile->_hHandle->QueryFileHandle();
|
|
#else
|
|
hHandle = pssiFile->_hHandle;
|
|
#endif
|
|
if ( pssiFile->_hMapHandle != NULL )
|
|
{
|
|
if ( !SSICloseMapHandle( pssiFile ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
pssiFile->_hMapHandle = ::CreateFileMapping( hHandle,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
0,
|
|
0,
|
|
NULL );
|
|
|
|
return pssiFile->_hMapHandle != NULL;
|
|
}
|
|
|
|
BOOL SSICloseMapHandle( IN SSI_FILE * pssiFile )
|
|
// Closes mapping to a file
|
|
{
|
|
if ( pssiFile->_hMapHandle != NULL )
|
|
{
|
|
::CloseHandle( pssiFile->_hMapHandle );
|
|
pssiFile->_hMapHandle = NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL SSIMapViewOfFile( IN SSI_FILE * pssiFile )
|
|
// Maps file to address
|
|
{
|
|
if ( pssiFile->_pvMappedBase != NULL )
|
|
{
|
|
if ( !UnmapViewOfFile( pssiFile ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
pssiFile->_pvMappedBase = ::MapViewOfFile( pssiFile->_hMapHandle,
|
|
FILE_MAP_READ,
|
|
0,
|
|
0,
|
|
0 );
|
|
return pssiFile->_pvMappedBase != NULL;
|
|
}
|
|
|
|
BOOL SSIUnmapViewOfFile( IN SSI_FILE * pssiFile )
|
|
// Unmaps file
|
|
{
|
|
if ( pssiFile->_pvMappedBase != NULL )
|
|
{
|
|
::UnmapViewOfFile( pssiFile->_pvMappedBase );
|
|
pssiFile->_pvMappedBase = NULL;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD SSIGetFileAttributes( IN SSI_FILE * pssiFile )
|
|
// Gets the attributes of a file
|
|
{
|
|
#ifdef DO_CACHE
|
|
return pssiFile->_hHandle->QueryAttributes();
|
|
#else
|
|
return ::GetFileAttributes( pssiFile->_strFilename.QueryStr() );
|
|
#endif
|
|
}
|
|
|
|
BOOL SSIGetFileSize( IN SSI_FILE * pssiFile,
|
|
OUT DWORD * pdwLowWord,
|
|
OUT DWORD * pdwHighWord )
|
|
// Gets the size of the file.
|
|
{
|
|
#ifdef DO_CACHE
|
|
return pssiFile->_hHandle->QuerySize( pdwLowWord,
|
|
pdwHighWord );
|
|
#else
|
|
*pdwLowWord = ::GetFileSize( pssiFile->_hHandle,
|
|
pdwHighWord );
|
|
return *pdwLowWord != 0xfffffff;
|
|
#endif
|
|
}
|
|
|
|
BOOL SSIGetLastModTime( IN SSI_FILE * pssiFile,
|
|
OUT FILETIME * ftTime )
|
|
// Gets the Last modification time of a file.
|
|
{
|
|
HANDLE hHandle;
|
|
|
|
#ifdef DO_CACHE
|
|
hHandle = pssiFile->_hHandle->QueryFileHandle();
|
|
#else
|
|
hHandle = pssiFile->_hHandle;
|
|
#endif
|
|
return ::GetFileTime( hHandle,
|
|
NULL,
|
|
NULL,
|
|
ftTime );
|
|
}
|
|
|
|
//
|
|
// ISAPI DLL Required Entry Points
|
|
//
|
|
|
|
DWORD
|
|
WINAPI
|
|
HttpExtensionProc(
|
|
EXTENSION_CONTROL_BLOCK * pecb
|
|
)
|
|
{
|
|
STR strLogMessage;
|
|
BOOL bRet;
|
|
DWORD dwStringID;
|
|
LPCTSTR apsz[ 1 ];
|
|
|
|
TCP_PRINT(( DBG_CONTEXT,
|
|
"HttpExtensionProc() entry point called\n" ));
|
|
|
|
SSI_REQUEST ssiReq = pecb;
|
|
bRet = ssiReq.ProcessSSI();
|
|
|
|
apsz[ 0 ] = pecb->lpszPathInfo;
|
|
strLogMessage.FormatString( bRet ? SSINCMSG_LOG_SUCCESS : SSINCMSG_LOG_ERROR,
|
|
apsz,
|
|
SSI_DLL_NAME );
|
|
|
|
|
|
strncpy( pecb->lpszLogData,
|
|
strLogMessage.QueryStr(),
|
|
HSE_LOG_BUFFER_LEN );
|
|
|
|
return bRet ? HSE_STATUS_SUCCESS : HSE_STATUS_ERROR;
|
|
}
|
|
|
|
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
|
|
)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
WINAPI
|
|
DLLEntry(
|
|
HINSTANCE hDll,
|
|
DWORD dwReason,
|
|
LPVOID lpvReserved
|
|
)
|
|
{
|
|
switch ( dwReason )
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
CREATE_DEBUG_PRINT_OBJECT( SSI_DLL_NAME );
|
|
SET_DEBUG_FLAGS( 0 );
|
|
|
|
if ( InitializeCGI() != NO_ERROR )
|
|
{
|
|
return FALSE;
|
|
}
|
|
if ( InitializeBGI() != NO_ERROR )
|
|
{
|
|
return FALSE;
|
|
}
|
|
#ifdef DO_CACHE
|
|
g_ptsvcCache = new TSVC_CACHE( SSINC_SVC_ID );
|
|
if ( g_ptsvcCache == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
DisableThreadLibraryCalls( hDll );
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
TerminateCGI();
|
|
#ifdef DO_CACHE
|
|
TsCacheFlush( SSINC_SVC_ID );
|
|
delete g_ptsvcCache;
|
|
#endif
|
|
DELETE_DEBUG_PRINT_OBJECT();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|