/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
httpfilt.cxx
Abstract:
This module contains the Microsoft HTTP server filter module
Author:
John Ludeman (johnl) 31-Jan-1995
Revision History:
--*/
#include "w3p.hxx"
//
// Maximum allowable cached buffer
//
#define MAX_CACHED_FILTER_BUFFER (8 * 1024)
//
// Maximum number of filters we allow (per-instance - includes global filters)
//
#define MAX_FILTERS 50
//
// Private globals.
//
BOOL
WINAPI
ServerFilterCallback(
struct _HTTP_FILTER_CONTEXT * pfc,
enum SF_REQ_TYPE se,
void * pData,
ULONG_PTR ul,
ULONG_PTR ul2
);
BOOL
WINAPI
GetServerVariable(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszVariableName,
LPVOID lpvBuffer,
LPDWORD lpdwSize
);
BOOL
WINAPI
WriteFilterClient(
struct _HTTP_FILTER_CONTEXT * pfc,
LPVOID Buffer,
LPDWORD lpdwBytes,
DWORD dwReserved
);
VOID *
WINAPI
AllocFilterMem(
struct _HTTP_FILTER_CONTEXT * pfc,
DWORD cbSize,
DWORD dwReserved
);
BOOL
WINAPI
ServerSupportFunction(
struct _HTTP_FILTER_CONTEXT * pfc,
enum SF_REQ_TYPE sfReq,
PVOID pData,
ULONG_PTR ul1,
ULONG_PTR ul2
);
BOOL
WINAPI
AddFilterResponseHeaders(
HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszHeaders,
DWORD dwReserved
);
VOID
FilterAtqCompletion(
PVOID Context,
DWORD BytesWritten,
DWORD CompletionStatus,
OVERLAPPED * lpo
);
VOID
ContinueRawRead(
PVOID Context,
DWORD BytesWritten,
DWORD CompletionStatus,
OVERLAPPED * lpo
);
BOOL
WINAPI
CompressionFilterCheck(
HTTP_FILTER_CONTEXT *pfc,
LPVOID lpszEncodingString,
ULONG_PTR lpszVerbString,
ULONG_PTR sizesForBuffers
);
/*****************************************************************/
BOOL
HTTP_FILTER::NotifyRequestSecurityContextClose(
HTTP_FILTER_DLL * pFilterDLL,
CtxtHandle * pCtxt
)
{
HTTP_FILTER_REQUEST_CLOSE_SECURITY_CONTEXT hfcc;
HTTP_FILTER_CONTEXT * phfc;
HTTP_FILTER_DLL * pFilt;
FILTER_LIST * pFilterList;
SF_STATUS_TYPE sfStatus = SF_STATUS_REQ_HANDLED_NOTIFICATION;
DWORD i;
hfcc.pCtxt = (PVOID)pCtxt;
phfc = QueryContext();
phfc->fIsSecurePort = QueryReq()->IsSecurePort();
pFilterList = QueryFilterList();
//
// If this filter doesn't support this type of notification
// then ignore it
//
if ( !pFilterDLL->IsNotificationNeeded(
SF_NOTIFY_REQUEST_SECURITY_CONTEXT_CLOSE,
phfc->fIsSecurePort ))
{
//
// This filter doesn't support this type of notification.
//
return FALSE;
}
//
// This request is targetted at a particular DLL so find the filter
// context in the filter list
//
for ( i = 0; i < pFilterList->QueryFilterCount(); i++ )
{
if ( pFilterDLL == pFilterList->QueryDll( i ) )
{
phfc->pFilterContext = QueryClientContext( i );
sfStatus = (SF_STATUS_TYPE)
pFilterDLL->QueryEntryPoint()( phfc,
SF_NOTIFY_REQUEST_SECURITY_CONTEXT_CLOSE,
&hfcc );
SetClientContext( i, phfc->pFilterContext );
}
break;
}
return sfStatus == SF_STATUS_REQ_HANDLED_NOTIFICATION;
}
BOOL
HTTP_FILTER::NotifyRawReadDataFilters(
VOID * pvInData,
DWORD cbInData,
DWORD cbInBuffer,
VOID * * ppvOutData,
DWORD * pcbOutData,
BOOL * pfRequestFinished,
BOOL * pfReadAgain
)
/*++
Routine Description:
This method handles notification of all filters that handle the
raw data notifications.
Note this is the only routine that needs to save phfc->pFilterContext
because this is the only notification that can get occur while we're
in another notification.
Arguments:
pvInData - Raw data
cbInData - count of bytes of raw data
cbInBuffer - Size of input buffer
ppvOutData - Receives pointer to buffer of translated data
pcbOutData - Number of bytes of translated data
pfRequestFinished - Set to TRUE if the filter completed request processing
pfReadAgain - Set to TRUE if the caller should issue another read and
call this routine again
Return Value:
TRUE if successful, FALSE on error
--*/
{
HTTP_FILTER_RAW_DATA hfrd;
HTTP_FILTER_CONTEXT * phfc;
HTTP_FILTER_DLL * pFilterDLL;
FILTER_LIST * pFilterList;
SF_STATUS_TYPE sfStatus;
VOID * pvClientContext;
DWORD CurrentDll;
DWORD i;
PVOID pvtmp;
//
// Don't notify on zero length writes
//
if ( !cbInData )
{
*ppvOutData = pvInData;
*pcbOutData = cbInData;
return TRUE;
}
//
// Fill out the raw read structure
//
hfrd.pvInData = pvInData;
hfrd.cbInData = cbInData;
hfrd.cbInBuffer = cbInBuffer;
//
// Increment the nested notification level
//
_cRawNotificationLevel++;
//
// Initialize items specific to this request
//
phfc = QueryContext();
phfc->fIsSecurePort = QueryReq()->IsSecurePort();
//
// Save the current client context in the filter structure and the
// current dll because we may be in the middle of another filter
// notification
//
pvClientContext = phfc->pFilterContext;
CurrentDll = QueryCurrentDll();
pFilterList = QueryFilterList();
//
// If a filter needs to do a WriteClient in the middle of a raw data
// notification, we only notify the filters down (or up) the chain
//
i = (CurrentDll == INVALID_DLL ? 0 : CurrentDll);
//
// For recv operations, walk the list in order so encryption filters
// are at the front of the list
//
for ( ; i < pFilterList->QueryFilterCount(); i++ )
{
pFilterDLL = pFilterList->QueryDll( i );
//
// Notification flags are cached in the HTTP_FILTER object, but they're
// only copied from the actual HTTP_FILTER_DLL object if a filter dll
// disables a particular notification [sort of a copy-on-write scheme].
// If a filter dll disables/changes a notification, we need to check the flags
// in the HTTP_FILTER object, not those in the HTTP_FILTER_DLL object
//
// NOTE : This code is also executed in the functions
// HTTP_FILTER::NotifyRawSendDataFilters and HTTP_FILTER::NotifyFilters, so
// any changes/corrections need to be made there as well. The reason it wasn't
// broken out into a function is that this code is on the main-line code path
// for each request and making a function call for each filter loaded would
// be an efficiency hit.
//
if ( !QueryNotificationChanged() )
{
if (! pFilterDLL->IsNotificationNeeded(SF_NOTIFY_READ_RAW_DATA,
phfc->fIsSecurePort ))
{
//
// This filter doesn't support this type of notification.
//
continue;
}
}
else
{
if ( !IsDisableNotificationNeeded( i,
SF_NOTIFY_READ_RAW_DATA,
phfc->fIsSecurePort ))
{
//
// This filter doesn't support this type of notification.
//
continue;
}
}
SetCurrentDll( i );
pvtmp = phfc->pFilterContext = QueryClientContext( i );
sfStatus = (SF_STATUS_TYPE)
pFilterDLL->QueryEntryPoint()( phfc,
SF_NOTIFY_READ_RAW_DATA,
&hfrd );
if ( pvtmp != phfc->pFilterContext )
SetClientContext( i, phfc->pFilterContext );
switch ( sfStatus )
{
default:
DBGPRINTF((DBG_CONTEXT,
"[NotifyRawReadDataFilters] Unknown status code from filter %d\n",
sfStatus ));
//
// Fall through
//
case SF_STATUS_REQ_NEXT_NOTIFICATION:
continue;
case SF_STATUS_REQ_ERROR:
SetCurrentDll( CurrentDll );
_cRawNotificationLevel--;
phfc->pFilterContext = pvClientContext;
return FALSE;
case SF_STATUS_REQ_FINISHED:
case SF_STATUS_REQ_FINISHED_KEEP_CONN: // Not supported for raw data
QueryReq()->Disconnect();
*pfRequestFinished = TRUE;
goto Exit;
case SF_STATUS_REQ_HANDLED_NOTIFICATION:
//
// Don't notify any other filters
//
goto Exit;
case SF_STATUS_REQ_READ_NEXT:
*pfReadAgain = TRUE;
goto Exit;
}
}
Exit:
*ppvOutData = hfrd.pvInData;
*pcbOutData = hfrd.cbInData;
phfc->pFilterContext = pvClientContext;
_cRawNotificationLevel--;
SetCurrentDll( CurrentDll );
return TRUE;
}
BOOL
HTTP_FILTER::NotifyRawSendDataFilters(
VOID * pvInData,
DWORD cbInData,
DWORD cbInBuffer,
VOID * * ppvOutData,
DWORD * pcbOutData,
BOOL * pfRequestFinished
)
/*++
Routine Description:
This method handles notification of all filters that handle the
raw data notifications.
Note this is the only routine that needs to save phfc->pFilterContext
because this is the only notification that can get occur while we're
in another notification.
Arguments:
pvInData - Raw data
cbInData - count of bytes of raw data
cbInBuffer - Size of input buffer
ppvOutData - Receives pointer to buffer of translated data
pcbOutData - Number of bytes of translated data
pfRequestFinished - Set to TRUE if the filter completed request processing
Return Value:
TRUE if successful, FALSE on error
--*/
{
HTTP_FILTER_RAW_DATA hfrd;
HTTP_FILTER_CONTEXT * phfc;
HTTP_FILTER_DLL * pFilterDLL;
FILTER_LIST * pFilterList;
DWORD err;
SF_STATUS_TYPE sfStatus;
VOID * pvClientContext;
DWORD CurrentDll;
DWORD i;
PVOID pvtmp;
//
// Don't notify on zero length writes
//
if ( !cbInData )
{
*ppvOutData = pvInData;
*pcbOutData = cbInData;
return TRUE;
}
pFilterList = QueryFilterList();
//
// Fill out the raw send structure
//
hfrd.pvInData = pvInData;
hfrd.cbInData = cbInData;
hfrd.cbInBuffer = cbInBuffer;
//
// Increment the nested notification level
//
_cRawNotificationLevel++;
//
// Initialize items specific to this request
//
phfc = QueryContext();
phfc->fIsSecurePort = QueryReq()->IsSecurePort();
//
// Save the current client context in the filter structure and the
// current dll in the because we may be in the middle of another filter
// notification
//
pvClientContext = phfc->pFilterContext;
CurrentDll = QueryCurrentDll();
pFilterList = QueryFilterList();
//
// If a filter needs to do a WriteClient in the middle of a raw data
// notification, we only notify the filters up the chain
//
i = (CurrentDll == INVALID_DLL ? pFilterList->QueryFilterCount() - 1
: CurrentDll) ;
//
// For send operations, walk the list in reverse so encryption filters
// are at the end of the list
//
do {
pFilterDLL = pFilterList->QueryDll( i );
//
// Notification flags are cached in the HTTP_FILTER object, but they're
// only copied from the actual HTTP_FILTER_DLL object if a filter dll
// disables a particular notification [sort of a copy-on-write scheme].
// If a filter dll disables/changes a notification, we need to check the flags
// in the HTTP_FILTER object, not those in the HTTP_FILTER_DLL object
//
// NOTE : This code is also executed in the functions
// HTTP_FILTER::NotifyRawReadDataFilters and HTTP_FILTER::NotifyFilters, so
// any changes/corrections need to be made there as well. The reason it wasn't
// broken out into a function is that this code is on the main-line code path
// for each request and making a function call for each filter loaded would
// be an efficiency hit.
//
if ( !QueryNotificationChanged() )
{
if (! pFilterDLL->IsNotificationNeeded(SF_NOTIFY_SEND_RAW_DATA,
phfc->fIsSecurePort ))
{
//
// This filter doesn't support this type of notification.
//
continue;
}
}
else
{
if ( !IsDisableNotificationNeeded( i,
SF_NOTIFY_SEND_RAW_DATA,
phfc->fIsSecurePort ))
{
//
// This filter doesn't support this type of notification.
//
continue;
}
}
SetCurrentDll( i );
pvtmp = phfc->pFilterContext = QueryClientContext( i );
sfStatus = (SF_STATUS_TYPE)
pFilterDLL->QueryEntryPoint()( phfc,
SF_NOTIFY_SEND_RAW_DATA,
&hfrd );
if ( pvtmp != phfc->pFilterContext )
SetClientContext( i, phfc->pFilterContext );
switch ( sfStatus )
{
default:
DBGPRINTF((DBG_CONTEXT,
"[NotifyRawSendDataFilters] Unknown status code from filter %d\n",
sfStatus ));
//
// Fall through
//
case SF_STATUS_REQ_NEXT_NOTIFICATION:
continue;
case SF_STATUS_REQ_ERROR:
SetCurrentDll( CurrentDll );
_cRawNotificationLevel--;
phfc->pFilterContext = pvClientContext;
return FALSE;
case SF_STATUS_REQ_FINISHED:
case SF_STATUS_REQ_FINISHED_KEEP_CONN: // Not supported for raw data
QueryReq()->Disconnect();
*pfRequestFinished = TRUE;
goto Exit;
case SF_STATUS_REQ_HANDLED_NOTIFICATION:
//
// Don't notify any other filters
//
goto Exit;
}
} while ( i-- > 0 );
Exit:
*ppvOutData = hfrd.pvInData;
*pcbOutData = hfrd.cbInData;
phfc->pFilterContext = pvClientContext;
_cRawNotificationLevel--;
SetCurrentDll( CurrentDll );
return TRUE;
}
BOOL
HTTP_FILTER::NotifyRequestRenegotiate(
HTTP_FILTER * pFilter,
LPBOOL pfAccepted,
BOOL fMapCert
)
/*++
Routine Description:
Arguments:
pFilter - Pointer to filter object
pAccepted - updated with TRUE if request accepted
Return Value:
TRUE if successful, FALSE on error
--*/
{
HTTP_FILTER_CONTEXT * phfc;
HTTP_FILTER_DLL * pFilterDLL;
SF_STATUS_TYPE sfStatus;
HTTP_FILTER_REQUEST_CERT hfrc;
DWORD i;
FILTER_LIST * pFilterList;
PVOID pvtmp;
//
// Increment the nested notification level
//
pFilter->_cRawNotificationLevel++;
//
// Initialize items specific to this request
//
phfc = pFilter->QueryContext();
phfc->fIsSecurePort = pFilter->QueryReq()->IsSecurePort();
phfc->ulReserved = 0;
pFilterList = QueryFilterList();
hfrc.fMapCert = fMapCert;
hfrc.dwReserved = 0;
for ( i = 0; i < pFilterList->QueryFilterCount(); i++ )
{
pFilterDLL = pFilterList->QueryDll( i );
//
// Skip this DLL if it doesn't want this notification
//
if ( !pFilterDLL->IsNotificationNeeded( SF_NOTIFY_RENEGOTIATE_CERT,
phfc->fIsSecurePort ))
{
continue;
}
pFilter->SetCurrentDll( i );
pvtmp = phfc->pFilterContext = pFilter->QueryClientContext( i );
sfStatus = (SF_STATUS_TYPE)
pFilterDLL->QueryEntryPoint()( phfc,
SF_NOTIFY_RENEGOTIATE_CERT,
&hfrc );
if ( pvtmp != phfc->pFilterContext )
pFilter->SetClientContext( i, phfc->pFilterContext );
switch ( sfStatus )
{
default:
DBGPRINTF((DBG_CONTEXT,
"[NotifyRenegoCert] Unknown status code from filter %d\n",
sfStatus ));
//
// Fall through
//
case SF_STATUS_REQ_NEXT_NOTIFICATION:
continue;
case SF_STATUS_REQ_ERROR:
pFilter->SetCurrentDll( INVALID_DLL );
pFilter->_cRawNotificationLevel--;
return FALSE;
case SF_STATUS_REQ_FINISHED: // not supported
case SF_STATUS_REQ_FINISHED_KEEP_CONN: // Not supported at this point
pFilter->QueryReq()->SetKeepConn( FALSE );
goto Exit;
case SF_STATUS_REQ_HANDLED_NOTIFICATION:
//
// Don't notify any other filters
//
*pfAccepted = hfrc.fAccepted;
goto Exit;
}
}
Exit:
pFilter->SetCurrentDll( INVALID_DLL );
pFilter->_cRawNotificationLevel--;
return TRUE;
}
BOOL
HTTP_FILTER::NotifyAccessDenied(
const CHAR * pszURL,
const CHAR * pszPhysicalPath,
BOOL * pfFinished
)
/*++
Routine Description:
This method handles notification of all filters that handle the
access denied notification
Arguments:
pszURL - URL that was target of request
pszPath - Physical path the URL mapped to
pfFinished - Set to TRUE if no further processing is required
Return Value:
TRUE if successful, FALSE on error
--*/
{
HTTP_FILTER_ACCESS_DENIED hfad;
HTTP_FILTER_CONTEXT * phfc;
BOOL fRet;
//
// If these flags are not set, then somebody hasn't indicated the reason
// for denying the user access
//
DBG_ASSERT( QueryDeniedFlags() != 0 );
//
// Ignore the notification of a send "401 ..." if this notification
// generated it
//
if ( _fInAccessDeniedNotification )
{
return TRUE;
}
_fInAccessDeniedNotification = TRUE;
//
// Fill out the url map structure
//
hfad.pszURL = pszURL;
hfad.pszPhysicalPath = pszPhysicalPath;
hfad.dwReason = QueryDeniedFlags();
//
// Initialize items specific to this request
//
phfc = QueryContext();
phfc->fIsSecurePort = QueryReq()->IsSecurePort();
fRet = NotifyFilters(
SF_NOTIFY_ACCESS_DENIED,
phfc,
&hfad,
pfFinished,
FALSE );
_fInAccessDeniedNotification = FALSE;
return fRet;
}
BOOL
HTTP_FILTER::NotifySendHeaders( const CHAR * pszHeaderList,
BOOL * pfFinished,
BOOL * pfAnyChanges,
BUFFER * pChangeBuff )
{
HTTP_FILTER_SEND_RESPONSE hfph;
BOOL fRet;
DWORD cbJump;
hfph.GetHeader = GetSendHeader;
hfph.SetHeader = SetSendHeader;
hfph.AddHeader = AddSendHeader;
_pchSendHeaders = pszHeaderList;
// When parsing out the status code, beware of bad response buffers:
// - empty buffers (in case of HTTP 0.x requests)
// - buffers not starting with HTTP/X.X
//
// first line is the status
cbJump = sizeof( "HTTP/X.X" );
if ( strlen( pszHeaderList ) > ( cbJump - 1 ) )
{
pszHeaderList += cbJump;
}
while ( *pszHeaderList != '\0' &&
*pszHeaderList != '\r' &&
*pszHeaderList != '\n' &&
!isdigit( (UCHAR)(*pszHeaderList) ))
{
pszHeaderList++;
}
// If for some reason, there was no version in string,
// atoi() returns 0 on the empty string, which I guess is OK.
hfph.HttpStatus = atoi( pszHeaderList );
fRet = NotifyFilters( SF_NOTIFY_SEND_RESPONSE,
QueryContext(),
&hfph,
pfFinished,
FALSE );
if ( pfAnyChanges )
{
*pfAnyChanges = _fSendHeadersChanged;
}
if ( fRet && _fSendHeadersChanged )
{
fRet = BuildNewSendHeaders( pChangeBuff );
}
//
// Make sure we reparse the headers
//
SetSendHeadersParsed(FALSE);
_SendHeaders.Reset();
return fRet;
}
BOOL
FILTER_LIST::NotifyFilters(
HTTP_FILTER * pFilter,
DWORD NotificationType,
HTTP_FILTER_CONTEXT * phfc,
PVOID NotificationData,
BOOL * pfFinished,
BOOL fNotifyAll
)
/*++
Routine Description:
Notifies all registered filters on this filter list for the specified
notification type
Arguments:
pFilter - Pointer to filter making this request
NotificationType - SF_NOTIFY_ flag indicating the notification type
pfc - Pointer to filter context
NotificationData - Pointer to notification specific structure
fNotifyAll - If TRUE, always notify all filters regardless of return code
from filter
Return Value:
TRUE on success, FALSE on failure (call GetLastError)
--*/
{
HTTP_FILTER_DLL * pFilterDLL;
DWORD err;
SF_STATUS_TYPE sfStatus;
DWORD i;
PVOID pvtmp;
PVOID pvCurrentClientContext;
//
// In certain cases, we can send a notification to a filter while we're still
// processing another filter's notification. In that case, we need to make sure
// we restore the current filter's context when we're done with the notifications
//
pvCurrentClientContext = phfc->pFilterContext;
phfc->fIsSecurePort = pFilter->QueryReq()->IsSecurePort();
for ( i = 0; i < m_cFilters; i++ )
{
pFilterDLL = QueryDll( i );
//
// Notification flags are cached in the HTTP_FILTER object, but they're
// only copied from the actual HTTP_FILTER_DLL object if a filter dll
// disables a particular notification [sort of a copy-on-write scheme].
// If a filter dll disables/changes a notification, we need to check the flags
// in the HTTP_FILTER object, not those in the HTTP_FILTER_DLL object
//
// NOTE : This code is also executed in the functions
// HTTP_FILTER::NotifyRawSendDataFilters and HTTP_FILTER::NotifyRawReadDataFilters, so
// any changes/corrections need to be made there as well. The reason it wasn't
// broken out into a function is that this code is on the main-line code path
// for each request and making a function call for each filter loaded would
// be an efficiency hit.
//
if ( !pFilter->QueryNotificationChanged() )
{
if ( !pFilterDLL->IsNotificationNeeded( NotificationType,
phfc->fIsSecurePort ))
{
//
// This filter doesn't support this type of notification.
//
continue;
}
}
else
{
if ( !pFilter->IsDisableNotificationNeeded( i,
NotificationType,
phfc->fIsSecurePort ) )
{
continue;
}
}
pFilter->SetCurrentDll( i );
pvtmp = phfc->pFilterContext = pFilter->QueryClientContext( i );
sfStatus = (SF_STATUS_TYPE)
pFilterDLL->QueryEntryPoint()( phfc,
NotificationType,
NotificationData );
if ( pvtmp != phfc->pFilterContext )
pFilter->SetClientContext( i, phfc->pFilterContext );
switch ( sfStatus )
{
default:
DBGPRINTF((DBG_CONTEXT,
"[NotifyFilters] Unknown status code from filter %d\n",
sfStatus ));
//
// Fall through
//
case SF_STATUS_REQ_NEXT_NOTIFICATION:
continue;
case SF_STATUS_REQ_ERROR:
phfc->pFilterContext = pvCurrentClientContext;
pFilter->SetCurrentDll( INVALID_DLL );
return FALSE;
case SF_STATUS_REQ_FINISHED:
case SF_STATUS_REQ_FINISHED_KEEP_CONN: // Not supported at this point
pFilter->QueryReq()->SetKeepConn( FALSE );
*pfFinished = TRUE;
goto Exit;
case SF_STATUS_REQ_HANDLED_NOTIFICATION:
//
// Don't notify any other filters
//
goto Exit;
}
}
Exit:
//
// Reset the filter context we came in with
//
phfc->pFilterContext = pvCurrentClientContext;
pFilter->SetCurrentDll( INVALID_DLL );
return TRUE;
}
VOID FILTER_LIST::SetNotificationFlags(
DWORD i,
HTTP_FILTER_DLL * pFilterDll
)
/*++
Routine Description:
Adjusts the filter flags in the filter list. Note this is only safe on
global filters, not per website filters.
Arguments:
i - index of filter dll that is being adjusted
pFilterDll - Pointer to filter dll that contains the updated list
Return Value:
--*/
{
DWORD dwSec = 0;
DWORD dwNonSec = 0;
//
// Reset the flags in the array then rebuild the set of flags for
// the filter list. Build the set in a temporary so the filter list
// gets updated in a single action so other filters won't be impacted
//
((DWORD*) m_buffSecureArray.QueryPtr())[i] = pFilterDll->QuerySecureFlags();
((DWORD*) m_buffNonSecureArray.QueryPtr())[i] = pFilterDll->QueryNonsecureFlags();
for (DWORD j = 0; j < m_cFilters; j++)
{
dwSec |= QueryDll(j)->QuerySecureFlags();
dwNonSec |= QueryDll(j)->QueryNonsecureFlags();
}
m_SecureNotifications = dwSec;
m_NonSecureNotifications = dwNonSec;
}
HTTP_FILTER_DLL* FILTER_LIST::HasFilterDll(
HTTP_FILTER_DLL *pFilterDll
)
/*++
Routine Description:
Checks whether this filter list contains a specific filter dll
Arguments:
pFilterDll - filter dll to look for
Return Value:
Pointer to matching HTTP_FILTER_DLL object if found, NULL otherwise.
[This is probably redundant, since HTTP_FILTER_DLL objects are unique ...]
--*/
{
HTTP_FILTER_DLL **apFilterDll = (HTTP_FILTER_DLL **)(m_buffFilterArray.QueryPtr());
for ( DWORD i = 0; i < m_cFilters; i++ )
{
if ( apFilterDll[i] == pFilterDll )
{
return pFilterDll;
}
}
return NULL;
}
HTTP_FILTER::HTTP_FILTER(
HTTP_REQ_BASE * pRequest
)
/*++
Routine Description:
Copies the filter context
Arguments:
pRequest - Pointer to HTTP request this filter should be applied to
Return Value:
--*/
: _fIsValid ( FALSE ),
_pRequest ( pRequest ),
_apvContexts ( NULL ),
_pFilterList ( NULL ),
_pGlobalFilterList( NULL ),
_fSendHeadersChanged( FALSE ),
_fSendHeadersParsed( FALSE ),
_dwSecureNotifications( 0 ),
_dwNonSecureNotifications( 0 ),
_fNotificationsDisabled( FALSE )
{
InitializeListHead( &_PoolHead );
_hfc.cbSize = sizeof( _hfc );
_hfc.Revision = HTTP_FILTER_REVISION;
_hfc.ServerContext = (void *) this;
_hfc.ulReserved = 0;
_hfc.ServerSupportFunction = ServerFilterCallback;
_hfc.GetServerVariable = GetServerVariable;
_hfc.AddResponseHeaders = AddFilterResponseHeaders;
_hfc.WriteClient = WriteFilterClient;
_hfc.AllocMem = AllocFilterMem;
_Overlapped.hEvent = NULL;
_CurrentFilter = INVALID_DLL;
//
// Allocate the array of contexts for this request
//
_apvContexts = new PVOID[MAX_FILTERS];
if ( !_apvContexts )
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return;
}
//
// Initialize the array of filter contexts
//
memset( _apvContexts, 0, MAX_FILTERS * sizeof(PVOID) );
//Reset(); We Assume Reset will be called when initializing the session
SetGlobalFilterList( GLOBAL_FILTER_LIST() );
_fIsValid = TRUE;
}
VOID
HTTP_FILTER::Reset(
VOID
)
/*++
Routine Description:
Resets the state of this filter. Called between net sessions.
--*/
{
FILTER_POOL_ITEM * pfpi;
_cbRecvRaw = 0;
_cbRecvTrans = 0;
_hFile = NULL;
_pFilterGetFile = NULL;
_cbFileReadSize = 4096;
_cRawNotificationLevel = 0;
_dwDeniedFlags = 0;
_fInAccessDeniedNotification = FALSE;
_pchSendHeaders = NULL;
_fNotificationsDisabled = FALSE;
if ( _fSendHeadersParsed )
{
_SendHeaders.Reset();
}
_fSendHeadersChanged = FALSE;
_fSendHeadersParsed = FALSE;
}
VOID
HTTP_FILTER::Cleanup(
VOID
)
/*++
Routine Description:
Cleans up this filter. Called after a session terminates.
--*/
{
FILTER_POOL_ITEM * pfpi;
//
// Reset the array of filter contexts
//
memset( _apvContexts, 0, MAX_FILTERS * sizeof(PVOID) );
//
// Clean up the allocated buffers
//
if ( _bufRecvRaw.QuerySize( ) > MAX_CACHED_FILTER_BUFFER ) {
_bufRecvRaw.FreeMemory();
}
_bufRecvTrans.Resize( 0 );
//
// Free pool items
//
while ( !IsListEmpty( &_PoolHead )) {
pfpi = CONTAINING_RECORD( _PoolHead.Flink,
FILTER_POOL_ITEM,
_ListEntry );
RemoveEntryList( &pfpi->_ListEntry );
delete pfpi;
}
if ( _pFilterList )
{
FILTER_LIST::Dereference( _pFilterList );
_pFilterList = NULL;
}
_fNotificationsDisabled = FALSE;
} // Cleanup
HTTP_FILTER::~HTTP_FILTER(
VOID
)
/*++
Routine Description:
Destructor for HTTP filter class
Arguments:
Return Value:
--*/
{
if ( _Overlapped.hEvent )
CloseHandle( _Overlapped.hEvent );
if ( _pFilterList )
{
DBGPRINTF(( DBG_CONTEXT,
"[~HTTP_FILTER] Dereferencing _pFilterList at %lx\n",
_pFilterList ));
FILTER_LIST::Dereference( _pFilterList );
_pFilterList = NULL;
}
#if 0 // Global filter lists are not dynamic so they're not counted
if ( _pGlobalFilterList )
{
DBGPRINTF(( DBG_CONTEXT,
"[~HTTP_FILTER] Dereferencing _pGlobalFilterList at %lx\n",
_pGlobalFilterList ));
FILTER_LIST::Dereference( _pGlobalFilterList );
_pGlobalFilterList = NULL;
}
#endif
delete [] _apvContexts;
}
BOOL
HTTP_FILTER::ReadData(
LPVOID lpBuffer,
DWORD nBytesToRead,
DWORD *pcbBytesRead,
DWORD dwFlags
)
/*++
Routine Description:
This method reads data from the network and calls the
filter dlls. It also handles data tracking on data overflow
or underflow. The number of bytes read are translated
bytes, which may be more or less then actual bytes transferred
on the network.
The user's buffer is used for the initial receive. If a filter comes
back indicating it needs more data (got the first 8k of a 32k SSL message
for example) then we switch to using the _bufRecvRaw buffers.
Arguments:
lpBuffer - Destination buffer
nBytesToRead - Number of bytes to read
*pcbBytesRead - Number of bytes read
dwFlags - IO_FLAG values
Return Value:
TRUE on success, FALSE on failure (call GetLastError)
--*/
{
DWORD cbBytesRead = 0;
DWORD cbToCopy;
if ( pcbBytesRead )
{
*pcbBytesRead = 0;
}
_pbReadBuff = _pbClientBuff = (BYTE *) lpBuffer;
_cbReadBuff = _cbClientBuff = nBytesToRead;
_cbReadBuffUsed = 0;
//
// If there is old translated data that we need to give
// to the client, copy that now
//
if ( _cbRecvTrans )
{
cbToCopy = min( _cbRecvTrans, nBytesToRead );
memcpy( lpBuffer,
_bufRecvTrans.QueryPtr(),
cbToCopy );
if ( pcbBytesRead )
{
*pcbBytesRead = cbToCopy;
}
if ( _cbRecvTrans > cbToCopy )
{
_cbRecvTrans -= cbToCopy;
//
// This should be very rare this happens, so flag it and if
// it does happen often then add an offset counter
//
DBGPRINTF(( DBG_CONTEXT,
"[HTTP_FILTER::ReadData] PERF WARNING! In place buffer copy (%d bytes)!\n",
_cbRecvTrans ));
memmove( (BYTE *) _bufRecvTrans.QueryPtr(),
(BYTE *) _bufRecvTrans.QueryPtr() + cbToCopy,
_cbRecvTrans );
}
else
{
_cbRecvTrans = 0;
}
nBytesToRead -= cbToCopy;
_cbReadBuffUsed += cbToCopy;
//
// If there were any bytes from the previous request, just complete
// the request now. This prevents potentially blocking on a recv()
// with no data.
//
if ( dwFlags & IO_FLAG_ASYNC )
{
DBGPRINTF(( DBG_CONTEXT,
"[ReadData] Posting dummy completion\n" ));
if ( !_pRequest->PostCompletionStatus( cbToCopy ))
{
return FALSE;
}
}
return TRUE;
}
if ( dwFlags & IO_FLAG_SYNC )
{
BOOL fRet;
//
// Get the raw data, put it after any old raw data. We temporarily
// bump up the thread pool count so we don't eat all of the threads.
//
AtqSetInfo( AtqIncMaxPoolThreads, 0 );
fRet = TcpSockRecv(_pRequest->QueryClientConn()->QuerySocket(),
(char *) _pbReadBuff + _cbReadBuffUsed,
nBytesToRead,
&cbBytesRead,
60 // 60s timeout
);
AtqSetInfo( AtqDecMaxPoolThreads, 0 );
if ( !fRet || (cbBytesRead == 0) )
{
return FALSE;
}
if ( !ContinueRawRead( cbBytesRead,
NO_ERROR,
NULL,
pcbBytesRead ))
{
return FALSE;
}
}
else
{
DBG_ASSERT( dwFlags & IO_FLAG_ASYNC );
//
// Hook the Atq IO completion routine so reads complete through
// ContinueRawRead
//
_OldAtqCompletion = (ATQ_COMPLETION) AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION,
(ULONG_PTR) ::ContinueRawRead );
_OldAtqContext = (PVOID) AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION_CONTEXT,
(ULONG_PTR) this );
if ( !_pRequest->ReadFile( _pbReadBuff + _cbReadBuffUsed,
nBytesToRead,
NULL,
IO_FLAG_ASYNC | IO_FLAG_NO_FILTER ))
{
AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION,
(ULONG_PTR) _OldAtqCompletion );
AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION_CONTEXT,
(ULONG_PTR) _OldAtqContext );
return FALSE;
}
}
return TRUE;
} // HTTP_FILTER::ReadData
VOID
ContinueRawRead(
PVOID Context,
DWORD BytesWritten,
DWORD CompletionStatus,
OVERLAPPED * lpo
)
{
HTTP_FILTER * pFilter;
pFilter = (HTTP_FILTER *) Context;
((HTTP_FILTER *)Context)->ContinueRawRead( BytesWritten,
CompletionStatus,
lpo );
}
BOOL
HTTP_FILTER::ContinueRawRead(
DWORD cbBytesRead,
DWORD CompletionStatus,
OVERLAPPED * lpo,
DWORD * pcbRead
)
/*++
Routine Description:
This method is the completion routine for an async (or sync) read.
Note : It's a sync read if the overlapped structure [lpo] is null and
a completion status [CompletionStatus] of NO_ERROR
Arguments:
cbBytesRead - Number of bytes read
CompletionStatus - status code of read operation
lpo - Pointer to overlapped structure
Return Value:
TRUE on success, FALSE on failure (call GetLastError)
--*/
{
PVOID pvOutData;
DWORD cbOutData;
BOOL fReadAgain;
BOOL fRequestFinished = FALSE;
DWORD cbToCopy;
BOOL fSyncRead = (lpo == NULL && CompletionStatus == NO_ERROR);
//
// Don't update _cbReadBuffUsed until we get the data translated
//
if ( lpo )
{
_pRequest->Dereference();
//
// If the socket has been closed get out. It's the responsibility of the
// caller to detect this
//
if ( cbBytesRead == 0 )
{
goto CompleteRequest;
}
}
if ( CompletionStatus )
{
goto CompleteRequest;
}
ReadAgain:
//
// Keeps track of the number of bytes the filter has *not* seen
//
_cbRecvRaw += cbBytesRead;
//
// Call the filters to translate the raw data. No need to check for
// any filters that need this notification as we wouldn't be here otherwise
//
// _cbReadBuffUsed is translated bytes, _cbRecvRaw is untranslated bytes
//
fReadAgain = FALSE;
if ( !NotifyRawReadDataFilters( _pbReadBuff + _cbReadBuffUsed,
_cbRecvRaw,
_cbReadBuff - _cbReadBuffUsed,
&pvOutData,
&cbOutData,
&fRequestFinished,
&fReadAgain ))
{
CompletionStatus = GetLastError();
goto CompleteRequest;
}
//
// If the filter indicated this connection should be finished, force
// a tear down of our connection state
//
if ( fRequestFinished )
{
CompletionStatus = WSAECONNRESET;
goto CompleteRequest;
}
if ( fReadAgain )
{
//
// If we need to read the next chunk, make sure it will fit in
// our read buffer. If it won't, then switch to our own buffer
// and issue the read from there
//
if ( QueryNextReadSize() > (_cbReadBuff - _cbRecvRaw ) )
{
if ( !_bufRecvRaw.Resize( _cbRecvRaw + QueryNextReadSize() ))
{
CompletionStatus = GetLastError();
goto CompleteRequest;
}
memcpy( _bufRecvRaw.QueryPtr(),
_pbReadBuff,
_cbRecvRaw );
_pbReadBuff = (BYTE *) _bufRecvRaw.QueryPtr();
_cbReadBuff = _bufRecvRaw.QuerySize();
}
if ( !_pRequest->ReadFile( _pbReadBuff + _cbRecvRaw,
QueryNextReadSize(),
pcbRead,
(lpo ? (IO_FLAG_ASYNC | IO_FLAG_NO_FILTER) :
(IO_FLAG_SYNC | IO_FLAG_NO_FILTER)) ))
{
CompletionStatus = GetLastError();
goto CompleteRequest;
}
//
// Operation aborted, set error and return
//
if ( pcbRead && *pcbRead == 0 )
{
SetLastError( ERROR_OPERATION_ABORTED );
return FALSE;
}
//
// If this is a sync request process the additional bytes now
//
if ( !lpo )
{
cbBytesRead = *pcbRead;
goto ReadAgain;
}
return TRUE;
}
//
// Adjust the byte counts for the bytes just translated.
//
_pRequest->IncrementBytesSeenByRawReadFilter( cbOutData );
_cbReadBuffUsed += cbOutData;
_cbRecvRaw = 0;
//
// If we weren't able to use the original client buffer, copy as many
// bytes as possible to the client's buffer now. We only hit this case
// if a filter indicated we need to read again.
//
if ( _pbReadBuff != _pbClientBuff )
{
cbToCopy = min( cbOutData, _cbClientBuff );
memcpy( _pbClientBuff,
pvOutData,
cbToCopy );
_cbReadBuffUsed = cbToCopy;
//
// If more bytes were translated then what the client
// requested us to read, save those away for the next
// read request
//
if ( cbOutData > _cbClientBuff )
{
_cbRecvTrans = cbOutData - _cbClientBuff;
if ( !_bufRecvTrans.Resize( _cbRecvTrans ))
{
CompletionStatus = GetLastError();
goto CompleteRequest;
}
memcpy( _bufRecvTrans.QueryPtr(),
(BYTE *) pvOutData + cbToCopy,
_cbRecvTrans );
}
}
if ( pcbRead )
{
*pcbRead = _cbReadBuffUsed;
}
//
// If this was an async request, reset the Atq information and complete
// the receive with _cbReadBuffUsed
//
CompleteRequest:
if (!fSyncRead)
{
//
// This is an async completion, the return is not used
//
AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION,
(ULONG_PTR) _OldAtqCompletion );
AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION_CONTEXT,
(ULONG_PTR) _OldAtqContext );
_OldAtqCompletion( _OldAtqContext,
_cbReadBuffUsed,
CompletionStatus,
NULL );
return TRUE;
}
return (CompletionStatus == NO_ERROR);
}
BOOL
HTTP_FILTER::SendData(
LPVOID lpBuffer,
DWORD nBytesToSend,
DWORD * pnBytesSent,
DWORD dwFlags
)
/*++
Routine Description:
This method calls the interested filters to do the appropriate data
transformation then sends the data.
Arguments:
lpBuffer - Destination buffer
nBytesToRead - Number of bytes to read
*pcbBytesRead - Number of bytes read
dwFlags - IO_FLAG values
Return Value:
TRUE on success, FALSE on failure (call GetLastError)
--*/
{
PVOID pvOutData;
DWORD cbOutData;
DWORD cbToCopy;
BOOL fRequestFinished = FALSE;
//
// We buffer any unsent data so indicate all the data was sent
//
if ( pnBytesSent )
*pnBytesSent = nBytesToSend;
pvOutData = lpBuffer;
cbOutData = nBytesToSend;
if ( IsNotificationNeeded( SF_NOTIFY_SEND_RAW_DATA,
QueryReq()->IsSecurePort() ) &&
!NotifyRawSendDataFilters( lpBuffer,
nBytesToSend,
nBytesToSend,
&pvOutData,
&cbOutData,
&fRequestFinished ))
{
DBGPRINTF(( DBG_CONTEXT,
"[SendData] NotifyRawDataFilters failed with %d\n",
GetLastError()));
return FALSE;
}
if ( fRequestFinished )
{
//
// We have to return an error so the client doesn't think
// they will receive an IO completion. This may have odd
// manifestations
//
SetLastError( ERROR_OPERATION_ABORTED );
return FALSE;
}
if ( !_pRequest->WriteFile( pvOutData,
cbOutData,
&nBytesToSend,
dwFlags | IO_FLAG_NO_FILTER ))
{
DBGPRINTF(( DBG_CONTEXT,
"[SendData] Send failed with %d\n",
GetLastError()));
if ( pnBytesSent )
{
*pnBytesSent = (DWORD)SOCKET_ERROR;
}
return FALSE;
}
return TRUE;
}
BOOL
HTTP_FILTER::SendFile(
TS_OPEN_FILE_INFO * pGetFile,
HANDLE hFile,
DWORD dwOffset,
DWORD nBytesToWrite,
DWORD dwFlags,
PVOID pHead,
DWORD HeadLength,
PVOID pTail,
DWORD TailLength
)
/*++
Routine Description:
This method simulates Winsock's TransmitFile with the addition
of running the data through the interested filters. This only
supports async IO.
Arguments:
pGetFile - Cached TS_OPEN_FILE_INFO to send
hFile - Overlapped IO file to send (if NULL, pGetFile used to get handle)
dwOffset - Offset from start of file
nBytesToWrite - Bytes of file to send, note zero (meaning send the whole
file) is not supported
dwFlags - IO_FLAGs
pHead - Optional pre-data to send
HeadLength - Number of bytes of pHead
pTail - Optional post data to send
TailLength - Number of bytes of pTail
Return Value:
TRUE on success, FALSE on failure (call GetLastError)
--*/
{
HANDLE hEvent;
DBG_ASSERT( (dwFlags & IO_FLAG_ASYNC) );
//
// We assume pHead points to header data. Send it synchronously, then
// we'll do chunk async sends for the file
//
if ( HeadLength )
{
DWORD cbSent;
if ( !SendData( pHead,
HeadLength,
&cbSent,
(dwFlags & ~IO_FLAG_ASYNC) | IO_FLAG_SYNC ))
{
DBGPRINTF(( DBG_CONTEXT,
"[SendFile] SendData failed with %d\n",
GetLastError()));
return FALSE;
}
}
if ( !nBytesToWrite )
{
if ( hFile )
{
BY_HANDLE_FILE_INFORMATION hfi;
if ( !GetFileInformationByHandle( hFile, &hfi ))
{
return FALSE;
}
if ( hfi.nFileSizeHigh )
{
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
}
nBytesToWrite = hfi.nFileSizeLow;
}
else if ( pGetFile )
{
LARGE_INTEGER liSize;
if ( !pGetFile->QuerySize( liSize ) )
{
return FALSE;
}
nBytesToWrite = liSize.LowPart;
}
// else -- We are doing a file-less transmit
}
//
// Set up variables for doing the file transmit
//
_hFile = hFile;
_pFilterGetFile = pGetFile;
_cbFileBytesToWrite = nBytesToWrite;
_cbFileBytesSent = 0;
_cbFileData = 0;
_dwCompletionStatus = NO_ERROR;
_pTail = pTail;
_cbTailLength = TailLength;
_dwFlags = dwFlags;
//
// Save the event handle if we previously created one
//
if ( _Overlapped.hEvent )
{
hEvent = _Overlapped.hEvent;
}
else
{
if ( !_Overlapped.hEvent )
{
hEvent = IIS_CREATE_EVENT(
"HTTP_FILTER::_Overlapped::hEvent",
this,
TRUE,
FALSE
);
if ( !hEvent )
{
return FALSE;
}
}
}
memset( &_Overlapped, 0, sizeof( _Overlapped ));
_Overlapped.hEvent = hEvent;
_Overlapped.Offset = dwOffset;
if ( !_bufFileData.Resize( 8192 ))
{
return FALSE;
}
//
// Hook the ATQ completion routine so the caller only sees a single
// completion since we have to chunk the sends for the filters
//
// NOTE: If multiple requests over the same TCP session are being
// handled at once (not currently supported by protocol, but may
// eventually be) then there is a potential race condition between
// setting the context and setting the completion on the ATQ context
//
_OldAtqCompletion = (ATQ_COMPLETION) AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION,
(ULONG_PTR) FilterAtqCompletion );
_OldAtqContext = (PVOID) AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION_CONTEXT,
(ULONG_PTR) this );
//
// Kick off the first send
//
OnAtqCompletion( 0, NO_ERROR, NULL );
return TRUE;
}
VOID
FilterAtqCompletion(
PVOID Context,
DWORD BytesWritten,
DWORD CompletionStatus,
OVERLAPPED * lpo
)
/*++
Routine Description:
This function substitutes for the normal request's ATQ completion. It
is used to simulate an Async transmit file that passes all data through
the interested filters.
Arguments:
Context - Pointer to filter object
BytesWritten - Number of bytes written on last completion
CompletionStatus - Status of last send
lpo - Overlapped structure. NULL if error completion, non-null if IO comp.
--*/
{
HTTP_FILTER * pFilter;
pFilter = (HTTP_FILTER *) Context;
((HTTP_FILTER *)Context)->OnAtqCompletion( BytesWritten,
CompletionStatus,
lpo );
}
VOID
HTTP_FILTER::OnAtqCompletion(
DWORD BytesWritten,
DWORD CompletionStatus,
OVERLAPPED * lpo
)
/*++
Routine Description:
This method handles ATQ completions. It is used to simulate an Async
transmit file that passes all data through the interested filters.
Arguments:
BytesWritten - Number of bytes written on last completion
CompletionStatus - Status of last send
lpo - !NULL if this is a completion from an async IO
--*/
{
DWORD dwIoFlag;
DWORD BytesRead;
DWORD dwToRead;
IF_DEBUG( CONNECTION )
{
DBGPRINTF(( DBG_CONTEXT,
"HTTP_FILTER::OnAtqCompletion: Last IO error %lu Bytes = %d IsIO = %s\n",
CompletionStatus,
BytesWritten,
lpo != NULL ? "TRUE" : "FALSE" ));
}
//
// Decrement the outstanding IO count
//
if ( lpo )
_pRequest->Dereference();
//
// If an error occurred on the completion and we haven't previous recorded
// an error, then record this one. This prevents overwriting the real
// status code from a cancelled IO error.
//
if ( CompletionStatus && !_dwCompletionStatus )
{
_dwCompletionStatus = CompletionStatus;
}
//
// If an error occurred, restore the old ATQ information and forward
// the error
//
if ( _dwCompletionStatus ||
_cbFileBytesSent >= _cbFileBytesToWrite )
{
// In the file-less case _cbFileBytesSent ==
// _cbFileBytesToWrite == 0, so we will send the tail
// if there is no error.
if ( !_dwCompletionStatus && _cbTailLength )
{
DWORD cbSent;
if ( !SendData( _pTail,
_cbTailLength,
&cbSent,
(_dwFlags & ~IO_FLAG_ASYNC) | IO_FLAG_SYNC ))
{
DBGPRINTF(( DBG_CONTEXT,
"[SendFile] SendData failed with %d\n",
GetLastError()));
CompletionStatus = GetLastError();
if ( CompletionStatus && !_dwCompletionStatus )
_dwCompletionStatus = CompletionStatus;
}
}
goto ErrorExit;
}
//
// Read the next chunk of data from the file
//
dwToRead = _bufFileData.QuerySize();
if ( dwToRead > _cbFileBytesToWrite - _cbFileBytesSent ) {
dwToRead = _cbFileBytesToWrite - _cbFileBytesSent;
}
DBG_ASSERT(_dwCompletionStatus == NO_ERROR);
if ( _pFilterGetFile && _pFilterGetFile->QueryFileBuffer() )
{
// Fast path. We already have a buffer with the file contents, so
// read from the buffer directly.
memcpy( (PCHAR) _bufFileData.QueryPtr(),
_pFilterGetFile->QueryFileBuffer() + _Overlapped.Offset,
dwToRead );
BytesRead = dwToRead;
}
else
{
if ( !DoSynchronousReadFile(
_pFilterGetFile ?
_pFilterGetFile->QueryFileHandle() : _hFile,
(PCHAR)_bufFileData.QueryPtr(),
dwToRead,
&BytesRead,
&_Overlapped ))
{
_dwCompletionStatus = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"[Filter AtqCompletion] ReadFile failed with %d\n",
_dwCompletionStatus ));
goto ErrorExit;
}
}
//
// Now send the data through the filters
//
dwIoFlag = IO_FLAG_ASYNC;
_cbFileBytesSent += BytesRead;
_Overlapped.Offset += BytesRead;
if ( !SendData( _bufFileData.QueryPtr(),
BytesRead,
NULL,
dwIoFlag ))
{
_dwCompletionStatus = GetLastError();
DBGPRINTF(( DBG_CONTEXT,
"[Filter AtqCompletion] SendData failed with %d\n",
CompletionStatus ));
goto ErrorExit;
}
return;
ErrorExit:
IF_DEBUG( CONNECTION )
{
DBGPRINTF(( DBG_CONTEXT,
"HTTP_FILTER::OnAtqCompletion: Restoring AtqContext, "
"Bytes Sent = %d, Status = %d, IsIO = %s\n",
_cbFileBytesSent,
_dwCompletionStatus,
(lpo == NULL ? "FALSE" : "TRUE")));
}
AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION,
(ULONG_PTR) _OldAtqCompletion );
AtqContextSetInfo( QueryAtqContext(),
ATQ_INFO_COMPLETION_CONTEXT,
(ULONG_PTR) _OldAtqContext );
//
// Forward the error onto the old ATQ completion handler. We always
// pass an lpo of NULL because we've already decremented the IO
// ref count.
//
// NOTE: 'this' may be deleted in this callback!
//
_OldAtqCompletion( _OldAtqContext,
_cbFileBytesSent,
CompletionStatus,
NULL );
return;
}
BOOL
HTTP_FILTER::DisableNotification(
IN DWORD dwNotification
)
/*++
Routine Description:
Called when a filter wants to disable one/more of its own notifications
for the given request.
Arguments:
dwNotification - Mask of notifications to disable for this request
--*/
{
DBG_ASSERT( _pFilterList || _pGlobalFilterList );
if ( !_fNotificationsDisabled )
{
//
// All subsequent calls to IsNotificationNeeded() and NotifyFilter() must
// use local copy of flags to determine action.
//
_fNotificationsDisabled = TRUE;
//
// Copy notification tables created in the FILTER_LIST objects
//
if ( !_BuffSecureArray.Resize( QueryFilterList()->QuerySecureArray()->QuerySize() ) ||
!_BuffNonSecureArray.Resize( QueryFilterList()->QueryNonSecureArray()->QuerySize() ) )
{
return FALSE;
}
memcpy( _BuffSecureArray.QueryPtr(),
QueryFilterList()->QuerySecureArray()->QueryPtr(),
QueryFilterList()->QuerySecureArray()->QuerySize() );
memcpy( _BuffNonSecureArray.QueryPtr(),
QueryFilterList()->QueryNonSecureArray()->QueryPtr(),
QueryFilterList()->QueryNonSecureArray()->QuerySize() );
}
//
// Disable the appropriate filter in our local table
//
((DWORD*)_BuffSecureArray.QueryPtr())[ QueryCurrentDll() ] &=
~dwNotification;
((DWORD*)_BuffNonSecureArray.QueryPtr())[ QueryCurrentDll() ] &=
~dwNotification;
//
// Calculate the aggregate notification status for our local scenario
// NYI: Might want to defer this operation?
//
_dwSecureNotifications = 0;
_dwNonSecureNotifications = 0;
for( DWORD i = 0; i < QueryFilterList()->QueryFilterCount(); i++ )
{
_dwSecureNotifications |= ((DWORD*)_BuffSecureArray.QueryPtr())[i];
_dwNonSecureNotifications |= ((DWORD*)_BuffNonSecureArray.QueryPtr())[i];
}
return TRUE;
}
BOOL
HTTP_FILTER::SetFilterList(
IN FILTER_LIST *pFilterList
)
/*++
Routine Description:
Sets the filter list associated with this object
Arguments :
pFilterList - new filter list
Returns:
Nothing
--*/
{
DBG_ASSERT( !_pFilterList );
FILTER_LIST *pOldList = _pFilterList;
if ( pFilterList )
{
//
// This function is called during HTTP_REQUEST::Parse, when a -global- filter
// may already have disabled some notifications during READ_RAW processing
// and thus set the _fNotificationsDisabled flag, so we'll leave the flag
// as-is [it's reset at the end of each request and connection, so we're
// not going to be using a stale value].
//
// The first time a notification is disabled, we make a local copy
// of the notification flag arrays from the filter list and make the modifications
// to our local copy. Hence, when the filter list is (re)set, the notification
// arrays of the new filter list and the local copies have to be merged, since we
// want to keep our old flags as well as picking up the flags for the new filters
// that might be in the list.
//
//_fNotificationsDisabled = FALSE; //intentionally commented out !
pFilterList->Reference();
if ( _fNotificationsDisabled )
{
if ( !MergeNotificationArrays( pFilterList,
TRUE ) ||
!MergeNotificationArrays( pFilterList,
FALSE ) )
{
pFilterList->Dereference( pFilterList );
return FALSE;
}
}
_pFilterList = pFilterList;
}
return TRUE;
}
BOOL
HTTP_FILTER::MergeNotificationArrays(
FILTER_LIST *pFilterList,
BOOL fSecure
)
/*++
Routine Description:
This is called when the filter list for this HTTP_FILTER object needs to be replaced
with a new list and we need to merge the arrays holding the notification flags. See
comments in HTTP_FILTER::SetFilterList
Arguments:
pFilterList - filter list whose notification flags need to be incorporated
fSecure - flag indicating whether secure/nonsecure arrays are to be merged
Returns:
Nothing
--*/
{
DWORD dwNotifications = 0;
DWORD *adwOldNotifArray = NULL;
DWORD *adwMergedArray = NULL;
DWORD *adwNewNotifArray = NULL;
DWORD iOldFilterPos = 0;
HTTP_FILTER_DLL *pFilterDll = NULL;
BUFFER BuffMergedArray;
if ( !BuffMergedArray.Resize( fSecure ? pFilterList->QuerySecureArray()->QuerySize() :
pFilterList->QueryNonSecureArray()->QuerySize() ) )
{
return FALSE;
}
if ( fSecure )
{
if ( !_BuffSecureArray.Resize( pFilterList->QuerySecureArray()->QuerySize() ) )
{
return FALSE;
}
}
else
{
if ( !_BuffNonSecureArray.Resize( pFilterList->QueryNonSecureArray()->QuerySize() ) )
{
return FALSE;
}
}
adwNewNotifArray = (DWORD *) (fSecure ? pFilterList->QuerySecureArray()->QueryPtr() :
pFilterList->QueryNonSecureArray()->QueryPtr() );
adwMergedArray = (DWORD *) BuffMergedArray.QueryPtr();
//
// This gets a little tricky : we have to walk through the present
// notification arrays and the notification array for the new filter list
// and merge them - all the notification flags for the filters in the old
// list should be preserved, and the notifications for the new filters
// need to be added to the notification array
//
for ( DWORD i = 0; i < pFilterList->QueryFilterCount(); i++ )
{
//
// If the old filter list had an entry for this filter, we want to
// preserve those notification flags
//
if ( ( pFilterDll = QueryFilterList()->HasFilterDll( pFilterList->QueryDll( i ) ) ) )
{
adwMergedArray[i] = QueryFilterNotifications( pFilterDll,
fSecure );
}
//
// New filter
//
else
{
adwMergedArray[i] = adwNewNotifArray[i];
}
}
//
// Copy merged array
//
memcpy( (fSecure ? _BuffSecureArray.QueryPtr() :
_BuffNonSecureArray.QueryPtr() ),
BuffMergedArray.QueryPtr(),
BuffMergedArray.QuerySize() );
return TRUE;
}
BOOL
HTTP_FILTER::ParseSendHeaders(
VOID
)
/*++
Routine Description:
Parses the list of headers the server is about to send and places them
in the _SendHeaders parameter list for subsequent retrieval by the ISAPI
Filter
--*/
{
const CHAR * pch;
CHAR ch;
DWORD cbHeaders = strlen( _pchSendHeaders );
const CHAR * pchEnd = _pchSendHeaders + cbHeaders;
const CHAR * pchHeader;
const CHAR * pchEndHeader;
const CHAR * pchValue;
const CHAR * pchEndValue;
const CHAR * pchNext;
DBG_ASSERT( !_fSendHeadersParsed );
//
// We don't want the PARAM_LIST to canon the headers because it
// will collapse the WWW-Authenticate: headers to a comma separated
// list which will mess up clients even though technically this is allowed
// by the HTTP spec
//
_SendHeaders.SetIsCanonicalized( TRUE );
//
// Grab the first line and add it as a special value "status"
//
pch = pchNext = (const CHAR *) memchr( _pchSendHeaders, '\n', cbHeaders );
if ( !pch )
return TRUE;
if ( pch > _pchSendHeaders && pch[-1] == '\r' )
{
pch--;
}
if ( !_SendHeaders.AddEntry( "status",
6,
_pchSendHeaders,
DIFF(pch - _pchSendHeaders) ))
{
return FALSE;
}
//
// Now deal with the rest of the headers
//
pchHeader = pchNext + 1;
cbHeaders = DIFF(pchEnd - pchHeader);
while ( pchNext = (LPSTR)memchr( pchHeader, '\n', cbHeaders ) )
{
if ( pchValue = (LPSTR)memchr( pchHeader, ':', DIFF(pchNext - pchHeader) ) )
{
UINT ch = *(PBYTE)++pchValue;
pchEndHeader = pchValue;
int cName = DIFF(pchValue - pchHeader);
if ( _HTTP_IS_LINEAR_SPACE( (CHAR)ch ) )
{
while ( _HTTP_IS_LINEAR_SPACE( *(PBYTE)++pchValue ) )
;
}
if ( (pchNext > pchValue) && (pchNext[-1] == '\r') )
{
pchEndValue = pchNext - 1;
}
else
{
pchEndValue = pchNext;
}
if ( !_SendHeaders.AddEntry( pchHeader,
DIFF(pchEndHeader - pchHeader),
pchValue,
DIFF(pchEndValue - pchValue) ))
{
return FALSE;
}
}
else
{
if ( (*pchHeader == '\r') || (*pchHeader == '\n') )
{
pchHeader = pchNext + 1;
//
// If a body was specified, add it as a special value
//
if ( pchEnd - pchHeader > 1 )
{
if ( !_SendHeaders.AddEntry( "body",
sizeof("body") - 1,
pchHeader,
DIFF(pchEnd - pchHeader) ))
{
return FALSE;
}
}
break;
}
}
pchHeader = pchNext + 1;
cbHeaders = DIFF(pchEnd - pchHeader);
}
_fSendHeadersParsed = TRUE;
return TRUE;
}
BOOL
HTTP_FILTER::BuildNewSendHeaders(
BUFFER * pHeaderBuff
)
/*++
Routine Description:
Takes the set of send headers and builds up an HTTP response, only used
when a header has been changed
Arguments:
pHeaderBuff - Receives HTTP response headers
Return Value:
TRUE on success, FALSE on failure
--*/
{
PVOID Cookie = NULL;
CHAR * pch;
CHAR * pszTail;
CHAR * pszField;
DWORD cbField;
CHAR * pszValue;
DWORD cbValue;
pszTail = (CHAR *) pHeaderBuff->QueryPtr();
*pszTail = '\0';
pch = _SendHeaders.FindValue( "status", NULL, &cbValue );
if ( !pch )
{
//
// Somebody deleted the status or this is a point nine request
// Supply a default and assume the filter really wanted to send a
// header response
//
if (!g_ReplyWith11)
{
pch = "HTTP/1.0 200 Ok";
}
else
{
pch = "HTTP/1.1 200 Ok";
}
cbValue = sizeof( "HTTP/1.0 200 Ok" ) - sizeof(CHAR);
}
if ( !pHeaderBuff->Resize( cbValue + 1, 512 ))
{
return FALSE;
}
pszTail = (CHAR *) pHeaderBuff->QueryPtr();
CopyMemory( pszTail, pch, cbValue + 1 );
pszTail += cbValue;
*pszTail = '\r';
pszTail++;
*pszTail = '\n';
pszTail++;
while ( Cookie = _SendHeaders.NextPair( Cookie,
&pszField,
&cbField,
&pszValue,
&cbValue ))
{
//
// Ignore "status" and "body"
//
if ( !memcmp( pszField, "status", sizeof("status") ) ||
!memcmp( pszField, "body", sizeof("body") ))
{
continue;
}
//
// Make sure there's room for the space, plus two '\r\n'
//
pch = (CHAR *) pHeaderBuff->QueryPtr();
if ( !pHeaderBuff->Resize( DIFF(pszTail - pch) + cbValue + cbField + 6, 128 ))
{
return FALSE;
}
//
// Watch for pointer shift
//
if ( pch != pHeaderBuff->QueryPtr() )
{
pszTail = (CHAR *) pHeaderBuff->QueryPtr() + (pszTail - pch);
}
CopyMemory( pszTail, pszField, cbField + 1 );
pszTail += cbField;
*pszTail = ' ';
pszTail++;
CopyMemory( pszTail, pszValue, cbValue + 1 );
pszTail += cbValue;
*pszTail = '\r';
pszTail++;
*pszTail = '\n';
pszTail++;
}
*pszTail = '\r';
pszTail++;
*pszTail = '\n';
pszTail++;
//
// Add the body if one was specified
//
pszValue = _SendHeaders.FindValue( "body", NULL, &cbValue );
if ( pszValue )
{
pch = (CHAR *) pHeaderBuff->QueryPtr();
if ( !pHeaderBuff->Resize( DIFF(pszTail - pch) + cbValue + 1 ))
{
return FALSE;
}
if ( pch != pHeaderBuff->QueryPtr() )
{
pszTail = (CHAR *) pHeaderBuff->QueryPtr() + (pszTail - pch);
}
CopyMemory( pszTail, pszValue, cbValue + 1 );
}
else
{
*pszTail = '\0';
}
return TRUE;
}
DWORD
HTTP_FILTER::QueryFilterNotifications( HTTP_FILTER_DLL *pFilterDll,
BOOL fSecure )
/*++
Routine Description:
Retrieves the notification flags for a given filter dll
Arguments:
pFilterDll - filter dll whose notifications are to be retrieved
fSecure - flag indicating whether secure/insecure port notifications are to be retrieved
Return Value:
Notification flags for filter; zero if filter isn't found
--*/
{
FILTER_LIST *pFilterList = QueryFilterList();
DWORD cFilterCount = pFilterList->QueryFilterCount();
for ( DWORD i = 0; i < cFilterCount ; i++ )
{
if ( pFilterList->QueryDll( i ) == pFilterDll )
{
if ( _fNotificationsDisabled )
{
return (((DWORD *) (fSecure ? _BuffSecureArray.QueryPtr() :
_BuffNonSecureArray.QueryPtr()))[i]);
}
else
{
return (fSecure ? pFilterDll->QuerySecureFlags() :
pFilterDll->QueryNonsecureFlags() );
}
}
}
return 0;
}
/*****************************************************************/
BOOL
WINAPI
ServerFilterCallback(
HTTP_FILTER_CONTEXT * pfc,
enum SF_REQ_TYPE sf,
void * pData,
ULONG_PTR ul1,
ULONG_PTR ul2
)
/*++
Routine Description:
This method handles a gateway request to a server extension DLL
Arguments:
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_REQ_BASE * pRequest;
HTTP_FILTER * pFilter;
STACK_STR( str, MAX_PATH);;
STACK_STR( strResp, MAX_PATH);;
STACK_STR( strURL, MAX_PATH);
UINT cb;
int n;
DWORD CurrentDll;
HTTP_FILTER_DLL * pFilterDll;
DWORD dwAuth;
BOOL fFinished;
DWORD Status;
DWORD Win32Status;
W3_SERVER_INSTANCE* pInst;
DWORD dwIOFlags;
//
// Check for valid parameters
//
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[ServerExtensionCallback: Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
pRequest = pFilter->QueryReq();
//
// Handle the server extension's request
//
switch ( sf )
{
case SF_REQ_SEND_RESPONSE_HEADER:
//
// Save the client context context because the client may call
// Send headers just after changing the context and we're about to
// write over it when we do the raw send notifications
//
CurrentDll = pFilter->QueryCurrentDll();
DBG_ASSERT( CurrentDll != INVALID_DLL );
pFilter->SetClientContext( CurrentDll, pfc->pFilterContext );
//
// If we're doing a send header from a Raw data notification then we need
// to notify only the filters down the food chain so save the current
// filter and set the start point in the list to the next filter (remember
// raw sends walk the list backwards so encryption filters are last)
//
dwIOFlags = IO_FLAG_SYNC;
if ( pFilter->IsInRawNotification() )
{
//
// If this is the first filter in the list, then there's nobody that
// needs to be notified
//
if ( pFilter->IsFirstFilter( CurrentDll ) )
{
dwIOFlags |= IO_FLAG_NO_FILTER;
}
else
{
pFilter->SetCurrentDll( CurrentDll - 1 );
}
}
if ( pData )
{
Status = atoi( (PCSTR)pData );
if ( Status == HT_DENIED )
{
//
// Only set the reason as denied_filter if we're not doing
// denied access filter processing.
//
if ( !pFilter->ProcessingAccessDenied() )
{
pRequest->SetDeniedFlags( SF_DENIED_FILTER );
}
Win32Status = ERROR_ACCESS_DENIED;
pRequest->SetAuthenticationRequested( TRUE );
//
// If we do not have Metadata yet but we have an instance
// then read metadata so that WWW authentication headers can
// be properly generated
//
if ( pRequest->QueryW3Instance() &&
!pRequest->QueryMetaData() &&
pRequest->QueryHeaderList()->FastMapQueryValue( HM_URL ) )
{
((HTTP_REQUEST*)pRequest)->OnURL( (LPSTR)pRequest->QueryHeaderList()
->FastMapQueryValue( HM_URL ) );
}
}
else
{
Win32Status = NO_ERROR;
}
}
else
{
Status = HT_OK;
Win32Status = NO_ERROR;
}
pRequest->SetState( pRequest->QueryState(),
Status,
Win32Status );
if ( !pRequest->SendHeader( (CHAR *) pData,
(((CHAR *) ul1) ? ((CHAR *) ul1) : "\r\n"),
dwIOFlags,
&fFinished ))
{
pFilter->SetCurrentDll( CurrentDll );
return FALSE;
}
//
// CODEWORK - need general method of handling an early finish
// indication (have flag and drop subsequent sends in bit bucket?
// return an error to filter?)
//
DBG_ASSERT( !fFinished );
pFilter->SetCurrentDll( CurrentDll );
break;
case SF_REQ_ADD_HEADERS_ON_DENIAL:
{
BOOL fOK = TRUE;
DWORD cb = 0;
CHAR *pchHeaders = NULL;
if ( !pData )
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
fOK = pRequest->QueryDenialHeaders()->Append( (CHAR *) pData );
if ( fOK )
{
//
// Need to make sure that the header ends with a CR-LF
//
cb = pRequest->QueryDenialHeaders()->QueryCCH();
pchHeaders = pRequest->QueryDenialHeaders()->QueryStr();
if ( cb < 2 ||
( !(pchHeaders[cb - 2] == '\r' && pchHeaders[cb - 1] == '\n' ) ) )
{
fOK = pRequest->QueryDenialHeaders()->Append( (CHAR *) "\r\n" );
}
}
return fOK;
}
case SF_REQ_SET_NEXT_READ_SIZE:
if ( (ul1 == 0) || (ul1 > 0x8000000) )
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter->SetNextReadSize( (DWORD) ul1 );
return TRUE;
case SF_REQ_SET_PROXY_INFO:
//
// ul1 contains the proxy flags to set for this request (which right
// now is only On or Off).
//
pRequest->SetProxyRequest( (DWORD) ul1 & 0x00000001 );
break;
case SF_REQ_SET_CERTIFICATE_INFO:
pFilterDll = pFilter->QueryFilterList()->QueryDll(
pFilter->QueryCurrentDll() );
return pRequest->SetCertificateInfo(
(PHTTP_FILTER_CERTIFICATE_INFO)pData,
(CtxtHandle*)ul1,
(HANDLE)ul2,
pFilterDll );
case SF_REQ_GET_PROPERTY:
pInst = pRequest->QueryW3InstanceAggressively();
dwAuth = pRequest->QueryMetaData() ? pRequest->QueryAuthentication() : 0;
switch ( ul1 )
{
case SF_PROPERTY_GET_INSTANCE_ID:
*(LPVOID*)pData = (LPVOID)pInst;
break;
#if 0 // Unused
case SF_PROPERTY_CLIENT_CERT_ENABLED:
*(LPBOOL)pData = !!(dwAuth & INET_INFO_AUTH_CERT_AUTH);
break;
#endif
case SF_PROPERTY_MD5_ENABLED:
*(LPBOOL)pData = !!(dwAuth & INET_INFO_AUTH_MD5_AUTH);
break;
#if 0 // Unused
case SF_PROPERTY_DIR_MAP_CERT:
*(LPBOOL)pData = !!(dwAuth & INET_INFO_CERT_MAP);
break;
#endif
case SF_PROPERTY_DIGEST_SSP_ENABLED:
if ( pRequest->QueryMetaData() )
{
*(LPBOOL)pData = pRequest->QueryMetaData()->QueryUseDigestSSP();
}
else
{
*(LPBOOL)pData = FALSE;
}
break;
case SF_PROPERTY_GET_CERT11_MAPPER:
if ( pInst )
{
*(LPVOID*)pData = pInst->QueryMapper( MT_CERT11 );
}
else
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
break;
case SF_PROPERTY_GET_RULE_MAPPER:
if ( pInst )
{
*(LPVOID*)pData = pInst->QueryMapper( MT_CERTW );
}
else
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
break;
case SF_PROPERTY_GET_MD5_MAPPER:
if ( pInst )
{
*(LPVOID*)pData = pInst->QueryMapper( MT_MD5 );
}
else
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
break;
case SF_PROPERTY_GET_ITA_MAPPER:
if ( pInst )
{
*(LPVOID*)pData = pInst->QueryMapper( MT_ITA );
}
else
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
break;
case SF_PROPERTY_MD_IF:
*(LPVOID*)pData = (LPVOID) g_pInetSvc->QueryMDObject();
break;
case SF_PROPERTY_SSL_CTXT:
*(LPVOID*)pData = pRequest->QueryAuthenticationObj()->QuerySslCtxtHandle();
break;
case SF_PROPERTY_INSTANCE_NUM_ID:
*(DWORD*)pData = pInst ? pInst->QueryInstanceId() : 0;
break;
case SF_PROPERTY_MD_PATH:
*(const CHAR**)pData = pInst ? pInst->QueryMDPath() :
g_pInetSvc->QueryMDPath();
break;
default:
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
return TRUE;
case SF_REQ_NORMALIZE_URL:
return ((HTTP_REQUEST * )pRequest)->NormalizeUrl( (LPSTR)pData );
case SF_REQ_DONE_RENEGOTIATE:
((HTTP_REQUEST * )pRequest)->DoneRenegotiate( *(LPBOOL)pData );
break;
case SF_REQ_SET_NOTIFY:
switch ( ul1 )
{
case SF_NOTIFY_MAPPER_MD5_CHANGED:
case SF_NOTIFY_MAPPER_ITA_CHANGED:
case SF_NOTIFY_MAPPER_CERT11_CHANGED:
case SF_NOTIFY_MAPPER_CERTW_CHANGED:
return SetFlushMapperNotify( (SF_NOTIFY_TYPE)ul1, (PFN_SF_NOTIFY)pData );
case SF_NOTIFY_MAPPER_SSLKEYS_CHANGED:
return SetSllKeysNotify( (PFN_SF_NOTIFY)pData );
}
return FALSE;
case SF_REQ_DISABLE_NOTIFICATIONS:
return pFilter->DisableNotification( (DWORD) ul1 );
case SF_REQ_COMPRESSION_FILTER_CHECK:
return CompressionFilterCheck(pfc,pData,ul1,ul2);
case HSE_REQ_GET_CERT_INFO_EX: {
//
// Descrption:
// Returns the first cert in the request's cert-chain,
// only used if using an SSPI package
//
// Input:
// pData - ISA-provided struct
// NOTE ISA must allocate buffer within struct
//
// Notes:
// Works in-proc or out-of-proc
//
//
// cast ISA-provided ptr to our cert struct
//
CERT_CONTEXT_EX * pCertContextEx = reinterpret_cast
<CERT_CONTEXT_EX *>
( pData );
if ( pData == NULL ) {
DBG_ASSERT( FALSE );
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
//
// pass struct members as individual parameters
//
return pRequest->QueryAuthenticationObj()->GetClientCertBlob(
pCertContextEx->cbAllocated,
&( pCertContextEx->CertContext.dwCertEncodingType ),
pCertContextEx->CertContext.pbCertEncoded,
&( pCertContextEx->CertContext.cbCertEncoded ),
&( pCertContextEx->dwCertificateFlags ) );
} // case HSE_REQ_GET_CERT_INFO_EX:
default:
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
return TRUE;
}
BOOL
WINAPI
GetServerVariable(
HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszVariableName,
LPVOID lpvBuffer,
LPDWORD lpdwSize
)
/*++
Routine Description:
Callback for a filter retrieving a server variable. These are mostly
CGI type varaibles
Arguments:
pfc - Pointer to http filter context
lpszVariableName - Variable to retrieve
lpvBuffer - Receives value or '\0' if not found
lpdwSize - Specifies the size of lpvBuffer, gets set to the number of
bytes transferred including the '\0'
Return Value:
TRUE on success, FALSE on failure
--*/
{
BOOL fReturn = TRUE; // fast path value
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[GetServerVariable] Filter sent invalid parameters\n"));
SetLastError( ERROR_INVALID_PARAMETER );
fReturn = FALSE;
} else {
HTTP_FILTER * pFilter = (HTTP_FILTER *) pfc->ServerContext;
HTTP_REQ_BASE * pRequest = pFilter->QueryReq();
CHAR tmpStr[MAX_PATH];
STR str(tmpStr, MAX_PATH);
BOOL fFound;
//
// Get the requested variable and copy it into the supplied buffer
//
if ( fReturn = pRequest->GetInfo( lpszVariableName,
&str,
&fFound ) ) {
DWORD cb;
if ( !fFound ) {
SetLastError( ERROR_INVALID_INDEX );
fReturn = FALSE;
} else if ( (cb = str.QueryCB() + sizeof(CHAR)) > * lpdwSize) {
SetLastError( ERROR_INSUFFICIENT_BUFFER );
*lpdwSize = cb;
fReturn = FALSE;
} else {
*lpdwSize = cb;
CopyMemory( lpvBuffer, str.QueryStr(), cb );
DBG_ASSERT( fReturn);
}
}
}
return (fReturn);
} // GetServerVariable()
BOOL
WINAPI
AddFilterResponseHeaders(
HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszHeaders,
DWORD dwReserved
)
/*++
Routine Description:
Adds headers specified by the client to send with the response
Arguments:
pfc - Pointer to http filter context
lpszHeaders - List of '\r\n' terminated headers followed by '\0'
dwReserved - must be zero
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[GetServerVariable] Filter passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
return pFilter->QueryReq()->QueryAdditionalRespHeaders()->
Append( (CHAR*) lpszHeaders );
}
BOOL
WINAPI
WriteFilterClient(
HTTP_FILTER_CONTEXT * pfc,
LPVOID Buffer,
LPDWORD lpdwBytes,
DWORD dwReserved
)
/*++
Routine Description:
Callback for writing data to the client
Arguments:
pfc - Pointer to http filter context
Buffer - Pointer to data to send
lpdwBytes - Number of bytes to send, receives number of bytes sent
dwReserved - Not used
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
STR str;
DWORD cb;
HTTP_FILTER_DLL * pFilterDll;
DWORD CurrentDll;
DWORD dwIOFlags = IO_FLAG_SYNC;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[GetServerVariable] Filter passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
//
// Ignore zero length sends
//
if ( !*lpdwBytes )
{
return TRUE;
}
//
// Save the client context because the client may call
// WriteClient just after changing the context and we're about to
// write over it when we do the raw send notifications
//
CurrentDll = pFilter->QueryCurrentDll();
pFilter->SetClientContext( CurrentDll, pfc->pFilterContext );
//
// If we're doing a WriteClient from a Raw data notification then we need
// to notify only the filters down the food chain so save the current
// filter and set the start point in the list to the next filter (remember
// raw sends walk the list backwards to encryption filters are last)
//
if ( pFilter->IsInRawNotification() )
{
//
// If this is the first filter in the list, then there's nobody that
// needs to be notified
//
if ( pFilter->IsFirstFilter( CurrentDll ) )
{
dwIOFlags |= IO_FLAG_NO_FILTER;
}
else
{
pFilter->SetCurrentDll( CurrentDll - 1 );
}
}
if ( !pFilter->QueryReq()->WriteFile( Buffer,
*lpdwBytes,
lpdwBytes,
dwIOFlags ))
{
pFilter->SetCurrentDll( CurrentDll );
return FALSE;
}
pFilter->SetCurrentDll( CurrentDll );
return TRUE;
}
BOOL
WINAPI
GetFilterHeader(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszName,
LPVOID lpvBuffer,
LPDWORD lpdwSize
)
/*++
Routine Description:
Callback for retrieving unprocessed headers
Arguments:
pfc - Pointer to http filter context
lpszName - Name of header to retrieve ("User-Agent:")
lpvBuffer - Buffer to receive the value of the header
lpdwSize - Number of bytes in lpvBuffer, receives number of bytes copied
including the '\0'
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
HTTP_HEADERS * pHeaderList;
CHAR * pszValue;
DWORD cbNeeded;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[GetFilterHeader] Extension passed invalid parameters\r\n"
));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
pHeaderList = pFilter->QueryReq()->QueryHeaderList();
//
// First, see if the specified header is in the list
//
pszValue = pHeaderList->FindValue( lpszName, &cbNeeded );
//
// If not found, terminate the buffer and set the required size to the
// terminator
//
if ( !pszValue )
{
SetLastError( ERROR_INVALID_INDEX );
return FALSE;
}
//
// Found the value, copy it if there's space
//
if ( ++cbNeeded > *lpdwSize )
{
*lpdwSize = cbNeeded;
SetLastError( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
*lpdwSize = cbNeeded;
memcpy( lpvBuffer, pszValue, cbNeeded );
return TRUE;
}
BOOL
WINAPI
SetFilterHeader(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszName,
LPSTR lpszValue
)
/*++
Routine Description:
The specified header is added to the list with the specified value. If
any other occurrences of the header are found, they are removed from the
list.
Specifying a blank value will remove the header from the list
This will generally be used to replace the value of an existing header
Arguments:
pfc - Pointer to http filter context
lpszName - Name of header to set ("User-Agent:")
lpszValue - value of lpszValue
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
HTTP_HEADERS *pHeaderList;
VOID * pvCookie = NULL;
CHAR * pszListHeader;
CHAR * pszListValue;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[SetFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
pHeaderList = pFilter->QueryReq()->QueryHeaderList();
//
// Remove all occurrences of the value, then add the one we want
//
pHeaderList->CancelHeader( lpszName );
//
// Only add the value if they specified a replacement
//
if ( lpszValue && *lpszValue )
{
return pHeaderList->StoreHeader( lpszName, lpszValue );
}
return TRUE;
}
BOOL
WINAPI
AddFilterHeader(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszName,
LPSTR lpszValue
)
/*++
Routine Description:
The specified header is added to the list with the specified value.
Arguments:
pfc - Pointer to http filter context
lpszName - Name of header to set ("User-Agent:")
lpszValue - value of lpszValue
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
HTTP_HEADERS *pHeaderList;
VOID * pvCookie = NULL;
CHAR * pszListHeader;
CHAR * pszListValue;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[AddFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
pHeaderList = pFilter->QueryReq()->QueryHeaderList();
return pHeaderList->StoreHeader( lpszName, lpszValue);
} // AddFilterHeader()
BOOL
WINAPI
GetSendHeader(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszName,
LPVOID lpvBuffer,
LPDWORD lpdwSize
)
/*++
Routine Description:
Callback for retrieving headers about to be sent to the client
Arguments:
pfc - Pointer to http filter context
lpszName - Name of header to retrieve ("User-Agent:")
lpvBuffer - Buffer to receive the value of the header
lpdwSize - Number of bytes in lpvBuffer, receives number of bytes copied
including the '\0'
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
CHAR * pszValue;
DWORD cbNeeded = 0;
PARAM_LIST * pHeaderList;
PVOID Cookie = NULL;
CHAR * pszField;
DWORD cbField;
DWORD cbValue;
BOOL fFound = FALSE;
CHAR * pszTail = (CHAR *) lpvBuffer;
HTTP_REQ_BASE* pRequest;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[GetFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
DBG_ASSERT( pFilter != NULL );
pRequest = (HTTP_REQ_BASE*) pFilter->QueryReq();
DBG_ASSERT( pRequest != NULL );
if ( pRequest->IsPointNine() )
{
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
}
if ( !pFilter->AreSendHeadersParsed() &&
!pFilter->ParseSendHeaders() )
{
return FALSE;
}
pHeaderList = pFilter->QuerySendHeaders();
//
// First, see if the specified header is in the list
//
while ( Cookie = pHeaderList->NextPair( Cookie,
&pszField,
&cbField,
&pszValue,
&cbValue ))
{
if ( !_stricmp( pszField, lpszName ))
{
//
// If there is room, copy it in, note we need a comma separator
// after each subsequent entry
//
if ( (cbNeeded + cbValue + 1 + (fFound ? 1 : 0)) <= *lpdwSize )
{
if ( fFound )
{
*pszTail++ = ',';
}
memcpy( pszTail, pszValue, cbValue + 1 );
pszTail += cbValue;
}
cbNeeded += cbValue + (fFound ? 1 : 0);
fFound = TRUE;
}
}
//
// If not found, tell the caller
//
if ( !fFound )
{
SetLastError( ERROR_INVALID_INDEX );
return FALSE;
}
//
// Found the value, copy it if there's space
//
if ( ++cbNeeded > *lpdwSize )
{
*lpdwSize = cbNeeded;
SetLastError( ERROR_INSUFFICIENT_BUFFER );
return FALSE;
}
*lpdwSize = cbNeeded;
return TRUE;
}
BOOL
WINAPI
SetSendHeader(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszName,
LPSTR lpszValue
)
/*++
Routine Description:
The specified header is added to the list with the specified value. If
any other occurrences of the header are found, they are removed from the
list.
Specifying a blank value will remove the header from the list
This will generally be used to replace the value of an existing header
Arguments:
pfc - Pointer to http filter context
lpszName - Name of header to set ("User-Agent:")
lpszValue - value of lpszValue
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
PARAM_LIST * pHeaderList;
HTTP_REQ_BASE * pRequest;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[SetFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
DBG_ASSERT( pFilter != NULL );
pRequest = (HTTP_REQ_BASE*) pFilter->QueryReq();
DBG_ASSERT( pRequest != NULL );
if ( pRequest->IsPointNine() )
{
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
}
if ( !pFilter->AreSendHeadersParsed() &&
!pFilter->ParseSendHeaders() )
{
return FALSE;
}
pHeaderList = pFilter->QuerySendHeaders();
//
// Remove all occurrences of the value, then add the one we want
//
pFilter->SetSendHeadersChanged( TRUE );
pHeaderList->RemoveEntry( lpszName );
//
// Only add the value if they specified a replacement
//
if ( lpszValue && *lpszValue )
{
return pHeaderList->AddEntry( lpszName, lpszValue );
}
return TRUE;
}
BOOL
WINAPI
AddSendHeader(
struct _HTTP_FILTER_CONTEXT * pfc,
LPSTR lpszName,
LPSTR lpszValue
)
/*++
Routine Description:
The specified header is added to the list with the specified value.
Arguments:
pfc - Pointer to http filter context
lpszName - Name of header to set ("User-Agent:")
lpszValue - value of lpszValue
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
HTTP_REQ_BASE* pRequest;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[AddFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
DBG_ASSERT( pFilter != NULL );
pRequest = (HTTP_REQ_BASE*) pFilter->QueryReq();
DBG_ASSERT( pRequest != NULL );
if ( pRequest->IsPointNine() )
{
SetLastError( ERROR_NOT_SUPPORTED );
return FALSE;
}
if ( !pFilter->AreSendHeadersParsed() &&
!pFilter->ParseSendHeaders() )
{
return FALSE;
}
pFilter->SetSendHeadersChanged( TRUE );
return pFilter->QuerySendHeaders()->AddEntry( lpszName, lpszValue );
}
VOID *
WINAPI
AllocFilterMem(
struct _HTTP_FILTER_CONTEXT * pfc,
DWORD cbSize,
DWORD dwReserved
)
{
HTTP_FILTER * pFilter;
FILTER_POOL_ITEM * pfpi;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[GetFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return NULL;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
pfpi = FILTER_POOL_ITEM::CreateMemPoolItem( cbSize );
if ( pfpi )
{
InsertHeadList( pFilter->QueryPoolHead(), &pfpi->_ListEntry );
return pfpi->_pvData;
}
return NULL;
}
#if 0
PVOID
WINAPI
ServerFilterResize(
struct _HTTP_FILTER_CONTEXT * pfc,
DWORD cbSize
)
{
HTTP_FILTER * pFilter;
HTTP_FILTER_RAW_DATA * phfrd;
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[ServerFilterResize] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return NULL;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
phfrd = (HTTP_FILTER_RAW_DATA *) pFilter->QueryNotificationStruct();
//
// Only reallocate if necessary
//
if ( phfrd->cbOutBuffer < cbSize )
{
if ( !pFilter->QueryRecvTrans()->Resize( cbSize ) )
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return NULL;
}
phfrd->pvOutData = pFilter->QueryRecvTrans()->QueryPtr();
phfrd->cbOutBuffer = cbSize;
}
return phfrd->pvOutData;
}
#endif
PATQ_CONTEXT
HTTP_FILTER::QueryAtqContext(
VOID
) const
{
return _pRequest->QueryClientConn()->QueryAtqContext();
}
BOOL
WINAPI
GetUserToken(
struct _HTTP_FILTER_CONTEXT * pfc,
HANDLE * phToken
)
/*++
Routine Description:
Get impersonated user token
Arguments:
pfc - Filter context
phToken - Filled with impersonation token
Return Value:
TRUE on success, FALSE on failure
--*/
{
HTTP_FILTER * pFilter;
HTTP_REQ_BASE* pRequest;
if ( !pfc ||
!pfc->ServerContext ||
!phToken )
{
DBGPRINTF(( DBG_CONTEXT,
"[AddFilterHeader] Extension passed invalid parameters\r\n"));
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE;
}
pFilter = (HTTP_FILTER *) pfc->ServerContext;
DBG_ASSERT( pFilter != NULL );
pRequest = (HTTP_REQ_BASE*) pFilter->QueryReq();
DBG_ASSERT( pRequest != NULL );
*phToken = pRequest->QueryUserImpersonationHandle();
return TRUE;
}
BOOL
WINAPI
CompressionFilterCheck(
HTTP_FILTER_CONTEXT *pfc,
LPVOID lpszEncodingString,
ULONG_PTR lpszVerbString,
ULONG_PTR sizesForBuffers
)
/*++
Routine Description:
Special server suport function for compression filter to determine the need to
compress given request
Arguments:
pfc - Pointer to http filter context
lpszEncodingString - String containing accept encoding header if any
lpszVerbString - String containing method
sizesForBuffers - max size for buffers
Return Value:
TRUE if request is eligible for compression
--*/
{
BOOL fReturn = FALSE; // fast path value
if ( !pfc ||
!pfc->ServerContext )
{
DBGPRINTF(( DBG_CONTEXT,
"[CompressionFilterCheck] Filter sent invalid parameters\n"));
SetLastError( ERROR_INVALID_PARAMETER );
} else {
HTTP_FILTER * pFilter = (HTTP_FILTER *) pfc->ServerContext;
HTTP_REQ_BASE * pRequest = pFilter->QueryReq();
HTTP_HEADERS *pHttpHeaders;
DWORD len;
PCHAR pHdr_HM_ACE, pHdr_HM_MET;
pHttpHeaders = pRequest->QueryHeaderList();
*(PCHAR)lpszEncodingString = 0;
*((PCHAR)lpszVerbString) = 0;
//
// Get the Accept-Encoding sent by the client, if any. If we cannot
// get this header, or if the size of the header is too large, then
// we will make no effort to compress this request.
//
pHdr_HM_ACE = (PCHAR)pHttpHeaders->FastMapQueryValue (HM_ACE);
if ( pHdr_HM_ACE )
{
pHdr_HM_MET = (PCHAR)pHttpHeaders->FastMapQueryValue(HM_MET);
if (pHdr_HM_MET)
{
len = strlen((PCHAR)pHdr_HM_ACE)+1;
if (len > sizesForBuffers)
{
SetLastError (ERROR_INSUFFICIENT_BUFFER);
goto exit_point;
}
else
{
strcpy ((PCHAR)lpszEncodingString,pHdr_HM_ACE);
}
len = strlen((PCHAR)pHdr_HM_MET)+1;
if (len > sizesForBuffers)
{
SetLastError (ERROR_INSUFFICIENT_BUFFER);
goto exit_point;
}
else
{
strcpy ((PCHAR)lpszVerbString,pHdr_HM_MET);
fReturn = TRUE;
}
}
}
}
exit_point:
return fReturn;
}