able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/iisrearc/iisplus/ulw3/w3response.cxx

3265 lines
79 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1999 Microsoft Corporation
Module Name :
w3response.cxx
Abstract:
W3_RESPONSE object (a friendly wrapper of UL_HTTP_RESPONSE)
Author:
Bilal Alam (BAlam) 10-Dec-99
Project:
ULW3.DLL
--*/
#include "precomp.hxx"
//
// HTTP Status codes
//
HTTP_STATUS HttpStatusOk = { 200, REASON("OK") };
HTTP_STATUS HttpStatusPartialContent = { 206, REASON("Partial Content") };
HTTP_STATUS HttpStatusMultiStatus = { 207, REASON("Multi Status") };
HTTP_STATUS HttpStatusMovedPermanently = { 301, REASON("Moved Permanently") };
HTTP_STATUS HttpStatusRedirect = { 302, REASON("Redirect") };
HTTP_STATUS HttpStatusMovedTemporarily = { 307, REASON("Moved Temporarily") };
HTTP_STATUS HttpStatusNotModified = { 304, REASON("Not Modified") };
HTTP_STATUS HttpStatusBadRequest = { 400, REASON("Bad Request") };
HTTP_STATUS HttpStatusUnauthorized = { 401, REASON("Unauthorized") };
HTTP_STATUS HttpStatusForbidden = { 403, REASON("Forbidden") };
HTTP_STATUS HttpStatusNotFound = { 404, REASON("Not Found") };
HTTP_STATUS HttpStatusMethodNotAllowed = { 405, REASON("Method Not Allowed") };
HTTP_STATUS HttpStatusNotAcceptable = { 406, REASON("Not Acceptable") };
HTTP_STATUS HttpStatusProxyAuthRequired = { 407, REASON("Proxy Authorization Required") };
HTTP_STATUS HttpStatusPreconditionFailed= { 412, REASON("Precondition Failed") };
HTTP_STATUS HttpStatusUrlTooLong = { 414, REASON("URL Too Long") };
HTTP_STATUS HttpStatusRangeNotSatisfiable={ 416, REASON("Requested Range Not Satisfiable") };
HTTP_STATUS HttpStatusLockedError = { 423, REASON("Locked Error") };
HTTP_STATUS HttpStatusServerError = { 500, REASON("Internal Server Error") };
HTTP_STATUS HttpStatusNotImplemented = { 501, REASON("Not Implemented") };
HTTP_STATUS HttpStatusBadGateway = { 502, REASON("Bad Gateway") };
HTTP_STATUS HttpStatusServiceUnavailable= { 503, REASON("Service Unavailable") };
HTTP_STATUS HttpStatusGatewayTimeout = { 504, REASON("Gateway Timeout") };
//
// HTTP SubErrors. This goo is used in determining the proper default error
// message to send to the client when an applicable custom error is not
// configured
//
// As you can see, some sub errors have no corresponding resource string.
// (signified by a 0 index)
//
HTTP_SUB_ERROR HttpNoSubError = { 0, 0 };
HTTP_SUB_ERROR Http401BadLogon = { MD_ERROR_SUB401_LOGON, 0 };
HTTP_SUB_ERROR Http401Config = { MD_ERROR_SUB401_LOGON_CONFIG, 0 };
HTTP_SUB_ERROR Http401Resource = { MD_ERROR_SUB401_LOGON_ACL, 0 };
HTTP_SUB_ERROR Http401Filter = { MD_ERROR_SUB401_FILTER, 0 };
HTTP_SUB_ERROR Http401Application = { MD_ERROR_SUB401_APPLICATION, 0 };
HTTP_SUB_ERROR Http403ExecAccessDenied = { MD_ERROR_SUB403_EXECUTE_ACCESS_DENIED, IDS_EXECUTE_ACCESS_DENIED };
HTTP_SUB_ERROR Http403ReadAccessDenied = { MD_ERROR_SUB403_READ_ACCESS_DENIED, IDS_READ_ACCESS_DENIED };
HTTP_SUB_ERROR Http403WriteAccessDenied = { MD_ERROR_SUB403_WRITE_ACCESS_DENIED, IDS_WRITE_ACCESS_DENIED };
HTTP_SUB_ERROR Http403SSLRequired = { MD_ERROR_SUB403_SSL_REQUIRED, IDS_SSL_REQUIRED };
HTTP_SUB_ERROR Http403SSL128Required = { MD_ERROR_SUB403_SSL128_REQUIRED, IDS_SSL128_REQUIRED };
HTTP_SUB_ERROR Http403IPAddressReject = { MD_ERROR_SUB403_ADDR_REJECT, IDS_ADDR_REJECT };
HTTP_SUB_ERROR Http403CertRequired = { MD_ERROR_SUB403_CERT_REQUIRED, IDS_CERT_REQUIRED };
HTTP_SUB_ERROR Http403SiteAccessDenied = { MD_ERROR_SUB403_SITE_ACCESS_DENIED, IDS_SITE_ACCESS_DENIED };
HTTP_SUB_ERROR Http403TooManyUsers = { MD_ERROR_SUB403_TOO_MANY_USERS, IDS_TOO_MANY_USERS };
HTTP_SUB_ERROR Http403PasswordChange = { MD_ERROR_SUB403_PWD_CHANGE, IDS_PWD_CHANGE };
HTTP_SUB_ERROR Http403MapperDenyAccess = { MD_ERROR_SUB403_MAPPER_DENY_ACCESS, IDS_MAPPER_DENY_ACCESS };
HTTP_SUB_ERROR Http403CertRevoked = { MD_ERROR_SUB403_CERT_REVOKED, IDS_CERT_REVOKED };
HTTP_SUB_ERROR Http403DirBrowsingDenied = { MD_ERROR_SUB403_DIR_LIST_DENIED, IDS_DIR_LIST_DENIED };
HTTP_SUB_ERROR Http403CertInvalid = { MD_ERROR_SUB403_CERT_BAD, IDS_CERT_BAD };
HTTP_SUB_ERROR Http403CertTimeInvalid = { MD_ERROR_SUB403_CERT_TIME_INVALID, IDS_CERT_TIME_INVALID };
HTTP_SUB_ERROR Http502Timeout = { MD_ERROR_SUB502_TIMEOUT, IDS_CGI_APP_TIMEOUT };
HTTP_SUB_ERROR Http502PrematureExit = { MD_ERROR_SUB502_PREMATURE_EXIT, IDS_BAD_CGI_APP };
ALLOC_CACHE_HANDLER * SEND_RAW_BUFFER::sm_pachSendRawBuffers;
HRESULT
W3_RESPONSE::SetHeader(
DWORD ulResponseHeaderIndex,
CHAR * pszHeaderValue,
DWORD cchHeaderValue,
BOOL fAppend
)
/*++
Routine Description:
Set a response based on known header index
Arguments:
ulResponseHeaderIndex - index
pszHeaderValue - Header value
cchHeaderValue - Number of characters (without \0) in pszHeaderValue
Return Value:
HRESULT
--*/
{
STACK_STRA ( strNewHeaderValue, 32);
CHAR * pszNewHeaderValue = NULL;
HRESULT hr;
//
// If value is too long, reject now
//
if (cchHeaderValue > MAXUSHORT)
{
return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
}
DBG_ASSERT( ulResponseHeaderIndex < HttpHeaderResponseMaximum );
if ( _responseMode == RESPONSE_MODE_RAW )
{
hr = SwitchToParsedMode();
if ( FAILED( hr ) )
{
return NULL;
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
}
if ( fAppend )
{
CHAR * headerValue = GetHeader( ulResponseHeaderIndex );
if ( headerValue == NULL )
{
fAppend = FALSE;
}
else
{
hr = strNewHeaderValue.Append( headerValue );
if ( FAILED( hr ) )
{
return hr;
}
hr = strNewHeaderValue.Append( ",", 1 );
if ( FAILED( hr ) )
{
return hr;
}
hr = strNewHeaderValue.Append( pszHeaderValue,
cchHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
cchHeaderValue = strNewHeaderValue.QueryCCH();
}
}
//
// Regardless of the "known"osity of the header, we will have to
// copy the value. Do so now.
//
hr = _HeaderBuffer.AllocateSpace( fAppend ? strNewHeaderValue.QueryStr() :
pszHeaderValue,
cchHeaderValue,
&pszNewHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
//
// Set the header
//
return SetHeaderByReference( ulResponseHeaderIndex,
pszNewHeaderValue,
cchHeaderValue );
}
HRESULT
W3_RESPONSE::SetHeader(
CHAR * pszHeaderName,
DWORD cchHeaderName,
CHAR * pszHeaderValue,
DWORD cchHeaderValue,
BOOL fAppend,
BOOL fForceParsed,
BOOL fAlwaysAddUnknown
)
/*++
Routine Description:
Set a response based on header name
Arguments:
pszHeaderName - Points to header name
cchHeaderName - Number of characters (without \0) in pszHeaderName
pszHeaderValue - Points to the header value
cchHeaderValue - Number of characters (without \0) in pszHeaderValue
fAppend - Should we remove any existing value
fForceParsed - Regardless of mode, set the header structurally
fAlwaysAddUnknown - Add as a unknown header always
Return Value:
HRESULT
--*/
{
DWORD cHeaders;
HTTP_UNKNOWN_HEADER* pHeader;
CHAR * pszNewName = NULL;
CHAR * pszNewValue = NULL;
HRESULT hr;
ULONG ulHeaderIndex;
STACK_STRA( strOldHeaderValue, 128 );
//
// If name/value is too long, reject now
//
if (cchHeaderName > MAXUSHORT ||
cchHeaderValue > MAXUSHORT)
{
return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
}
//
// Try to stay in raw mode if we're already in that mode
//
// If we are not appending, that means we are just adding a new header
// so we can just append
//
if ( !fForceParsed )
{
if ( _responseMode == RESPONSE_MODE_RAW &&
!fAppend )
{
DBG_ASSERT( QueryChunks()->DataChunkType == HttpDataChunkFromMemory );
DBG_ASSERT( QueryChunks()->FromMemory.pBuffer == _strRawCoreHeaders.QueryStr() );
hr = _strRawCoreHeaders.Append( pszHeaderName, cchHeaderName );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( ": ", 2 );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( pszHeaderValue, cchHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( "\r\n", 2 );
if ( FAILED( hr ) )
{
return hr;
}
//
// Patch the headers back in
//
QueryChunks()->FromMemory.pBuffer = _strRawCoreHeaders.QueryStr();
QueryChunks()->FromMemory.BufferLength = _strRawCoreHeaders.QueryCB();
return NO_ERROR;
}
else
{
//
// No luck. We'll have to parse the headers and switch into parsed
// mode.
//
if ( _responseMode == RESPONSE_MODE_RAW )
{
hr = SwitchToParsedMode();
if ( FAILED( hr ) )
{
return hr;
}
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
}
}
//
// If we're appending, then get the old header value (if any) and
// append the new value (with a comma delimiter)
//
if ( fAppend )
{
hr = GetHeader( pszHeaderName,
&strOldHeaderValue );
if ( FAILED( hr ) )
{
fAppend = FALSE;
hr = NO_ERROR;
}
else
{
hr = strOldHeaderValue.Append( ",", 1 );
if ( FAILED( hr ) )
{
return hr;
}
hr = strOldHeaderValue.Append( pszHeaderValue,
cchHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
cchHeaderValue = strOldHeaderValue.QueryCCH();
DeleteHeader( pszHeaderName );
}
}
//
// Regardless of the "known"osity of the header, we will have to
// copy the value. Do so now.
//
hr = _HeaderBuffer.AllocateSpace( fAppend ? strOldHeaderValue.QueryStr() :
pszHeaderValue,
cchHeaderValue,
&pszNewValue );
if ( FAILED( hr ) )
{
return hr;
}
//
// Is this a known header? If so, we can just set by reference now
// since we have copied the header value
//
if ( !fAlwaysAddUnknown )
{
ulHeaderIndex = RESPONSE_HEADER_HASH::GetIndex( pszHeaderName );
if ( ulHeaderIndex != UNKNOWN_INDEX )
{
DBG_ASSERT( ulHeaderIndex < HttpHeaderResponseMaximum );
return SetHeaderByReference( ulHeaderIndex,
pszNewValue,
cchHeaderValue,
fForceParsed );
}
}
//
// OK. This is an unknown header. Make a copy of the header name as
// well and proceed the long way.
//
hr = _HeaderBuffer.AllocateSpace( pszHeaderName,
cchHeaderName,
&pszNewName );
if ( FAILED( hr ) )
{
return hr;
}
cHeaders = ++_ulHttpResponse.Headers.UnknownHeaderCount;
if ( cHeaders * sizeof( HTTP_UNKNOWN_HEADER )
> _bufUnknownHeaders.QuerySize() )
{
if ( !_bufUnknownHeaders.Resize( cHeaders *
sizeof( HTTP_UNKNOWN_HEADER ),
512 ) )
{
return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
}
}
_ulHttpResponse.Headers.pUnknownHeaders = (HTTP_UNKNOWN_HEADER*)
_bufUnknownHeaders.QueryPtr();
//
// We should have a place to put the header now!
//
pHeader = &(_ulHttpResponse.Headers.pUnknownHeaders[ cHeaders - 1 ]);
pHeader->pName = pszNewName;
pHeader->NameLength = cchHeaderName;
pHeader->pRawValue = pszNewValue;
pHeader->RawValueLength = (USHORT)cchHeaderValue;
_fResponseTouched = TRUE;
return S_OK;
}
HRESULT
W3_RESPONSE::SetHeaderByReference(
DWORD ulResponseHeaderIndex,
CHAR * pszHeaderValue,
DWORD cchHeaderValue,
BOOL fForceParsed
)
/*++
Routine Description:
Set a header value by reference. In other words, the caller takes the
reponsibility of managing the memory referenced. The other setheader
methods copy the header values to a private buffer.
Arguments:
ulResponseHeaderIndex - index
pszHeaderValue - Header value
cbHeaderValue - Size of header value in characters (without 0 terminator)
fForceParsed - Set to TRUE if we should always used parsed
Return Value:
HRESULT
--*/
{
HTTP_KNOWN_HEADER * pHeader;
HRESULT hr;
//
// If value is too long, reject now
//
if (cchHeaderValue > MAXUSHORT)
{
return HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER);
}
DBG_ASSERT( ulResponseHeaderIndex < HttpHeaderResponseMaximum );
DBG_ASSERT( pszHeaderValue != NULL || cchHeaderValue == 0 );
if ( !fForceParsed )
{
if ( _responseMode == RESPONSE_MODE_RAW )
{
hr = SwitchToParsedMode();
if ( FAILED( hr ) )
{
return hr;
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
}
}
//
// Set the header
//
pHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ ulResponseHeaderIndex ]);
if ( cchHeaderValue == 0 )
{
pHeader->pRawValue = NULL;
}
else
{
pHeader->pRawValue = pszHeaderValue;
_fResponseTouched = TRUE;
}
pHeader->RawValueLength = (USHORT)cchHeaderValue;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::DeleteHeader(
CHAR * pszHeaderName
)
/*++
Routine Description:
Delete a response header
Arguments:
pszHeaderName - Header to delete
Return Value:
HRESULT
--*/
{
ULONG ulHeaderIndex;
HRESULT hr;
HTTP_UNKNOWN_HEADER * pUnknownHeader;
DWORD i;
if ( _responseMode == RESPONSE_MODE_RAW )
{
hr = SwitchToParsedMode();
if ( FAILED( hr ) )
{
return hr;
}
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
//
// Is this a known header? If so, we can just set by reference now
// since we have copied the header value
//
ulHeaderIndex = RESPONSE_HEADER_HASH::GetIndex( pszHeaderName );
if ( ulHeaderIndex != UNKNOWN_INDEX &&
ulHeaderIndex < HttpHeaderResponseMaximum )
{
_ulHttpResponse.Headers.pKnownHeaders[ ulHeaderIndex ].pRawValue = "";
_ulHttpResponse.Headers.pKnownHeaders[ ulHeaderIndex ].RawValueLength = 0;
}
else
{
//
// Unknown header. First check if it exists
//
for ( i = 0;
i < _ulHttpResponse.Headers.UnknownHeaderCount;
i++ )
{
pUnknownHeader = &(_ulHttpResponse.Headers.pUnknownHeaders[ i ]);
DBG_ASSERT( pUnknownHeader != NULL );
if ( _stricmp( pUnknownHeader->pName, pszHeaderName ) == 0 )
{
break;
}
}
if ( i < _ulHttpResponse.Headers.UnknownHeaderCount )
{
//
// Now shrink the array to remove the header
//
memmove( _ulHttpResponse.Headers.pUnknownHeaders + i,
_ulHttpResponse.Headers.pUnknownHeaders + i + 1,
( _ulHttpResponse.Headers.UnknownHeaderCount - i - 1 ) *
sizeof( HTTP_UNKNOWN_HEADER ) );
_ulHttpResponse.Headers.UnknownHeaderCount--;
}
}
return NO_ERROR;
}
HRESULT
W3_RESPONSE::SetStatus(
USHORT statusCode,
STRA & strReason,
HTTP_SUB_ERROR & subError
)
/*++
Routine Description:
Set the status/reason of the response
Arguments:
status - Status code
strReason - Reason string
subError - Optional (default 0)
Return Value:
HRESULT
--*/
{
HRESULT hr;
CHAR * pszNewStatus;
hr = _HeaderBuffer.AllocateSpace( strReason.QueryStr(),
strReason.QueryCCH(),
&pszNewStatus );
if ( FAILED( hr ) )
{
return hr;
}
_ulHttpResponse.StatusCode = statusCode;
_ulHttpResponse.pReason = pszNewStatus;
_ulHttpResponse.ReasonLength = strReason.QueryCCH();
_subError = subError;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::GetStatusLine(
STRA * pstrStatusLine
)
/*++
Routine Description:
What a stupid little function. Here we generate what the response's
status line will be
Arguments:
pstrStatusLine - Filled with status like
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
CHAR achNum[ 32 ];
if ( pstrStatusLine == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
// BUGBUG
hr = pstrStatusLine->Copy( "HTTP/1.1 " );
if ( FAILED( hr ) )
{
return hr;
}
_itoa( _ulHttpResponse.StatusCode, achNum, 10 );
hr = pstrStatusLine->Append( achNum );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrStatusLine->Append( " ", 1 );
if ( FAILED( hr ) )
{
return hr;
}
hr = pstrStatusLine->Append( _ulHttpResponse.pReason,
_ulHttpResponse.ReasonLength );
return hr;
}
HRESULT
W3_RESPONSE::GetHeader(
CHAR * pszHeaderName,
STRA * pstrHeaderValue
)
/*++
Routine Description:
Get a response header
Arguments:
pszHeaderName - Header to retrieve
pstrHeaderValue - Filled with header value
Return Value:
HRESULT
--*/
{
ULONG ulHeaderIndex;
HTTP_UNKNOWN_HEADER * pUnknownHeader;
HTTP_KNOWN_HEADER * pKnownHeader;
HRESULT hr;
BOOL fFound = FALSE;
if ( pstrHeaderValue == NULL ||
pszHeaderName == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
if ( _responseMode == RESPONSE_MODE_RAW )
{
hr = SwitchToParsedMode();
if ( FAILED( hr ) )
{
return hr;
}
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
ulHeaderIndex = RESPONSE_HEADER_HASH::GetIndex( pszHeaderName );
if ( ulHeaderIndex == UNKNOWN_INDEX )
{
//
// Unknown header
//
for ( DWORD i = 0; i < _ulHttpResponse.Headers.UnknownHeaderCount; i++ )
{
pUnknownHeader = &(_ulHttpResponse.Headers.pUnknownHeaders[ i ]);
DBG_ASSERT( pUnknownHeader != NULL );
if ( _stricmp( pszHeaderName,
pUnknownHeader->pName ) == 0 )
{
fFound = TRUE;
break;
}
}
if ( fFound )
{
return pstrHeaderValue->Copy( pUnknownHeader->pRawValue,
pUnknownHeader->RawValueLength );
}
else
{
return HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
}
}
else
{
//
// Known header
//
// If a filter wanted the Content-Length response header, then we should
// generate it now (lazily)
//
if ( ulHeaderIndex == HttpHeaderContentLength )
{
CHAR achNum[ 32 ];
_ui64toa( QueryContentLength(),
achNum,
10 );
hr = SetHeader( HttpHeaderContentLength,
achNum,
strlen( achNum ) );
if ( FAILED( hr ) )
{
return hr;
}
}
pKnownHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ ulHeaderIndex ]);
if ( pKnownHeader->pRawValue != NULL &&
pKnownHeader->RawValueLength != 0 )
{
return pstrHeaderValue->Copy( pKnownHeader->pRawValue,
pKnownHeader->RawValueLength );
}
else
{
return HRESULT_FROM_WIN32( ERROR_INVALID_INDEX );
}
}
}
VOID
W3_RESPONSE::ClearHeaders(
VOID
)
/*++
Routine Description:
Clear headers
Arguments:
None
Return Value:
None
--*/
{
memset( &(_ulHttpResponse.Headers),
0,
sizeof( _ulHttpResponse.Headers ) );
}
HRESULT
W3_RESPONSE::AddFileHandleChunk(
HANDLE hFile,
ULONGLONG cbOffset,
ULONGLONG cbLength
)
/*++
Routine Description:
Add file handle chunk to response
Arguments:
hFile - File handle
cbOffset - Offset in file
cbLength - Length of chunk
Return Value:
HRESULT
--*/
{
HTTP_DATA_CHUNK DataChunk;
HRESULT hr;
_fResponseTouched = TRUE;
DataChunk.DataChunkType = HttpDataChunkFromFileHandle;
DataChunk.FromFileHandle.ByteRange.StartingOffset.QuadPart = cbOffset;
DataChunk.FromFileHandle.ByteRange.Length.QuadPart = cbLength;
DataChunk.FromFileHandle.FileHandle = hFile;
hr = InsertDataChunk( &DataChunk, -1 );
if ( FAILED( hr ) )
{
return hr;
}
//
// Update content length count
//
_cbContentLength += cbLength;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::AddMemoryChunkByReference(
PVOID pvBuffer,
DWORD cbBuffer
)
/*++
Routine Description:
Add memory chunk to W3_RESPONSE. Don't copy the memory -> we assume
the caller will manage the memory lifetime
Arguments:
pvBuffer - Memory buffer
cbBuffer - Size of memory buffer
Return Value:
HRESULT
--*/
{
HTTP_DATA_CHUNK DataChunk;
HRESULT hr;
_fResponseTouched = TRUE;
DataChunk.DataChunkType = HttpDataChunkFromMemory;
DataChunk.FromMemory.pBuffer = pvBuffer;
DataChunk.FromMemory.BufferLength = cbBuffer;
hr = InsertDataChunk( &DataChunk, -1 );
if ( FAILED( hr ) )
{
return hr;
}
//
// Update content length count
//
_cbContentLength += cbBuffer;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::GetChunks(
OUT BUFFER *chunkBuffer,
OUT DWORD *pdwNumChunks)
{
if ( !chunkBuffer->Resize( _cChunks * sizeof( HTTP_DATA_CHUNK ) ) )
{
return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
}
memcpy( chunkBuffer->QueryPtr(),
_bufChunks.QueryPtr(),
_cChunks * sizeof( HTTP_DATA_CHUNK ) );
*pdwNumChunks = _cChunks;
Clear( TRUE );
return S_OK;
}
HRESULT
W3_RESPONSE::Clear(
BOOL fClearEntityOnly
)
/*++
Routine Description:
Clear response
Arguments:
fEntityOnly - Set to TRUE to clear only entity
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
if ( !fClearEntityOnly )
{
//
// Must we send the response in raw mode?
//
_fIncompleteHeaders = FALSE;
//
// Raw mode management
//
_strRawCoreHeaders.Reset();
_cFirstEntityChunk = 0;
//
// Always start in parsed mode
//
_responseMode = RESPONSE_MODE_PARSED;
//
// Clear headers/status
//
ClearHeaders();
}
_cChunks = _cFirstEntityChunk;
_cbContentLength = 0;
return hr;
}
HRESULT
W3_RESPONSE::SwitchToParsedMode(
VOID
)
/*++
Routine Description:
Switch to parsed mode
Arguments:
None
Return Value:
HRESULT
--*/
{
HRESULT hr;
CHAR * pszHeaders;
HTTP_DATA_CHUNK * pCurrentChunk;
DWORD i;
DBG_ASSERT( _responseMode == RESPONSE_MODE_RAW );
//
// Loop thru all header chunks and parse them out
//
for ( i = 0;
i < _cFirstEntityChunk;
i++ )
{
pCurrentChunk = &(QueryChunks()[ i ]);
DBG_ASSERT( pCurrentChunk->DataChunkType == HttpDataChunkFromMemory );
pszHeaders = (CHAR*) pCurrentChunk->FromMemory.pBuffer;
if ( i == 0 )
{
//
// The first header chunk contains core headers plus status line
//
// (remember to skip the status line)
//
pszHeaders = strstr( pszHeaders, "\r\n" );
DBG_ASSERT( pszHeaders != NULL );
pszHeaders += 2;
DBG_ASSERT( *pszHeaders != '\0' );
}
hr = ParseHeadersFromStream( pszHeaders );
if ( FAILED( hr ) )
{
return hr;
}
}
_strRawCoreHeaders.Reset();
//
// Any chunks in the response which are actually headers should be
// removed
//
if ( _cFirstEntityChunk != 0 )
{
memmove( QueryChunks(),
QueryChunks() + _cFirstEntityChunk,
( _cChunks - _cFirstEntityChunk ) * sizeof( HTTP_DATA_CHUNK ) );
_cChunks -= _cFirstEntityChunk;
_cFirstEntityChunk = 0;
}
//
// Cool. Now we are in parsed mode
//
_responseMode = RESPONSE_MODE_PARSED;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::SwitchToRawMode(
W3_CONTEXT * pW3Context,
CHAR * pszAdditionalHeaders,
DWORD cchAdditionalHeaders
)
/*++
Routine Description:
Switch into raw mode.
Builds a raw response for use by raw data filters and/or ISAPI. This
raw response will be a set of chunks which contact the entire response
including serialized headers.
Arguments:
pW3Context - W3 context
pszAdditionalHeaders - Additional raw headers to add
cchAdditionalHeaders - Size of additional headers
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
HTTP_DATA_CHUNK dataChunk;
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
//
// Generate raw core headers
//
hr = BuildRawCoreHeaders( pW3Context );
if ( FAILED( hr ) )
{
return hr;
}
//
// Now fix up the chunks so the raw stream headers are in the right place
//
//
// First chunk is the raw core headers (includes the status line)
//
dataChunk.DataChunkType = HttpDataChunkFromMemory;
dataChunk.FromMemory.pBuffer = _strRawCoreHeaders.QueryStr();
dataChunk.FromMemory.BufferLength = _strRawCoreHeaders.QueryCB();
hr = InsertDataChunk( &dataChunk, 0 );
if ( FAILED( hr ) )
{
return hr;
}
//
// Remember the beginning of real entity
//
_cFirstEntityChunk = 1;
//
// Now add any additional header stream
//
if ( cchAdditionalHeaders != 0 )
{
dataChunk.DataChunkType = HttpDataChunkFromMemory;
dataChunk.FromMemory.pBuffer = pszAdditionalHeaders;
dataChunk.FromMemory.BufferLength = cchAdditionalHeaders;
hr = InsertDataChunk( &dataChunk, 1 );
if ( FAILED( hr ) )
{
return hr;
}
_cFirstEntityChunk++;
}
//
// We're now in raw mode
//
_responseMode = RESPONSE_MODE_RAW;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::SendResponse(
W3_CONTEXT * pW3Context,
DWORD dwResponseFlags,
DWORD * pcbSent,
HTTP_LOG_FIELDS_DATA * pUlLogData
)
/*++
Routine Description:
Send a W3_RESPONSE to the client. This is a very simple wrapper
of UlAtqSendHttpResponse.
Arguments:
pW3Context - W3 context (contains amongst other things ULATQ context)
dwResponseFlags - W3_RESPONSE* flags
pcbSent - Filled with number of bytes sent (if sync)
pUlLogData - Log data
Return Value:
HRESULT
--*/
{
HRESULT hr;
DWORD dwFlags = 0;
HTTP_CACHE_POLICY cachePolicy;
HTTP_DATA_CHUNK * pStartChunk;
BOOL fFinished = FALSE;
BOOL fAsync;
DBG_ASSERT( CheckSignature() );
if ( dwResponseFlags & W3_RESPONSE_SUPPRESS_HEADERS )
{
if (_responseMode == RESPONSE_MODE_RAW)
{
_cChunks -= _cFirstEntityChunk;
memmove( QueryChunks(),
QueryChunks() + _cFirstEntityChunk,
_cChunks * sizeof( HTTP_DATA_CHUNK ) );
_cFirstEntityChunk = 0;
}
return SendEntity( pW3Context,
dwResponseFlags,
pcbSent,
pUlLogData );
}
if ( dwResponseFlags & W3_RESPONSE_MORE_DATA )
{
//
// More data follows this response?
//
dwFlags |= HTTP_SEND_RESPONSE_FLAG_MORE_DATA;
}
//
// UL needs to see the disconnect flag on the initial response
// so that it knows to send the proper connection header to the
// client. This needs to happen even if the more data flag is
// set.
//
if ( dwResponseFlags & W3_RESPONSE_DISCONNECT )
{
//
// Disconnect or not?
//
dwFlags |= HTTP_SEND_RESPONSE_FLAG_DISCONNECT;
}
//
// Setup cache policy
//
if ( dwResponseFlags & W3_RESPONSE_UL_CACHEABLE )
{
cachePolicy.Policy = HttpCachePolicyUserInvalidates;
}
else
{
cachePolicy.Policy = HttpCachePolicyNocache;
}
//
// Convert to raw if filtering is needed
//
// OR if an ISAPI once gave us incomplete headers and thus we need to
// go back to raw mode (without terminating headers)
//
// OR an ISAPI has called WriteClient() before sending a response
//
if ( pW3Context->IsNotificationNeeded( SF_NOTIFY_SEND_RAW_DATA ) ||
_fIncompleteHeaders ||
_fResponseSent )
{
if ( _responseMode == RESPONSE_MODE_PARSED )
{
hr = GenerateAutomaticHeaders( pW3Context,
dwFlags );
if ( FAILED( hr ) )
{
return hr;
}
hr = SwitchToRawMode( pW3Context,
_fIncompleteHeaders ? "" : "\r\n",
_fIncompleteHeaders ? 0 : 2 );
if ( FAILED( hr ) )
{
return hr;
}
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_RAW );
//
// OK. This is a little lame. But the _strRawCoreHeaders may have
// changed a bit since we last setup the chunks for the header
// stream. Just adjust it here
//
pStartChunk = QueryChunks();
pStartChunk[0].FromMemory.pBuffer = _strRawCoreHeaders.QueryStr();
pStartChunk[0].FromMemory.BufferLength = _strRawCoreHeaders.QueryCB();
//
// If we're going to be kill entity and/or headers, do so now before
// calling into the filter
//
if ( dwResponseFlags & W3_RESPONSE_SUPPRESS_ENTITY )
{
_cChunks = _cFirstEntityChunk;
}
//
// Filter the chunks if needed
//
if ( pW3Context->IsNotificationNeeded( SF_NOTIFY_SEND_RAW_DATA ) )
{
hr = ProcessRawChunks( pW3Context, &fFinished );
if ( FAILED( hr ) )
{
return hr;
}
if ( fFinished )
{
dwFlags |= HTTP_SEND_RESPONSE_FLAG_DISCONNECT;
_cChunks = 0;
}
}
}
//
// Take care of any compression now
//
if ( !_fIncompleteHeaders &&
pW3Context->QueryUrlContext() != NULL )
{
W3_METADATA * pMetaData;
pMetaData = pW3Context->QueryUrlContext()->QueryMetaData();
DBG_ASSERT( pMetaData != NULL );
if ( !pW3Context->QueryDoneWithCompression() &&
pMetaData->QueryDoDynamicCompression() )
{
if (FAILED(hr = HTTP_COMPRESSION::OnSendResponse(
pW3Context,
!!( dwResponseFlags & W3_RESPONSE_MORE_DATA ) ) ) )
{
return hr;
}
}
}
//
// From now on, we must send any future responses raw
//
_fResponseSent = TRUE;
//
// Async?
//
fAsync = dwResponseFlags & W3_RESPONSE_ASYNC ? TRUE : FALSE;
if ( _responseMode == RESPONSE_MODE_RAW )
{
if ( dwResponseFlags & W3_RESPONSE_SUPPRESS_ENTITY )
{
_cChunks = _cFirstEntityChunk;
}
hr = UlAtqSendEntityBody( pW3Context->QueryUlatqContext(),
fAsync,
dwFlags | HTTP_SEND_RESPONSE_FLAG_RAW_HEADER,
_cChunks,
_cChunks ? QueryChunks() : NULL,
pcbSent,
pUlLogData );
}
else
{
if ( dwResponseFlags & W3_RESPONSE_SUPPRESS_ENTITY )
{
_cChunks = 0;
}
_ulHttpResponse.EntityChunkCount = _cChunks;
_ulHttpResponse.pEntityChunks = _cChunks ? QueryChunks() : NULL;
hr = UlAtqSendHttpResponse( pW3Context->QueryUlatqContext(),
fAsync,
dwFlags,
&(_ulHttpResponse),
&cachePolicy,
pcbSent,
pUlLogData );
}
if ( FAILED( hr ) )
{
//
// If we couldn't send the response thru UL, then this is really bad.
// Do not reset _fSendRawData since no response will get thru
//
}
return hr;
}
HRESULT
W3_RESPONSE::SendEntity(
W3_CONTEXT * pW3Context,
DWORD dwResponseFlags,
DWORD * pcbSent,
HTTP_LOG_FIELDS_DATA * pUlLogData
)
/*++
Routine Description:
Send entity to the client
Arguments:
pMainContext - Main context (contains amongst other things ULATQ context)
dwResponseFlags - W3_REPSONSE flags
pcbSent - Number of bytes sent (when sync)
pUlLogData - Log data for the response (this entity is part of response)
Return Value:
Win32 Error indicating status
--*/
{
HRESULT hr = NO_ERROR;
DWORD dwFlags = 0;
BOOL fAsync;
BOOL fFinished = FALSE;
DBG_ASSERT( CheckSignature() );
//
// If we get to here and a response hasn't yet been sent, then we must
// call HttpSendEntity first (not that HTTP.SYS lets us do that)
//
if ( !_fResponseSent )
{
_fResponseSent = TRUE;
dwFlags |= HTTP_SEND_RESPONSE_FLAG_RAW_HEADER;
}
//
// Note that both HTTP_SEND_RESPONSE_FLAG_MORE_DATA and
// HTTP_SEND_RESPONSE_FLAG_DISCONNECT cannot be set at the same time
//
if ( dwResponseFlags & W3_RESPONSE_MORE_DATA )
{
dwFlags |= HTTP_SEND_RESPONSE_FLAG_MORE_DATA;
}
else if ( dwResponseFlags & W3_RESPONSE_DISCONNECT )
{
dwFlags |= HTTP_SEND_RESPONSE_FLAG_DISCONNECT;
}
//
// Send chunks to be processed if filtering if needed (and there are
// chunks available)
//
if ( _cChunks &&
!( dwFlags & W3_RESPONSE_SUPPRESS_ENTITY ) &&
pW3Context->IsNotificationNeeded( SF_NOTIFY_SEND_RAW_DATA ) )
{
hr = ProcessRawChunks( pW3Context, &fFinished );
if ( FAILED( hr ) )
{
return hr;
}
if ( fFinished )
{
dwFlags |= HTTP_SEND_RESPONSE_FLAG_DISCONNECT;
_cChunks = 0;
}
}
//
// Take care of any compression now
//
if ( pW3Context->QueryUrlContext() != NULL )
{
W3_METADATA *pMetaData;
pMetaData = pW3Context->QueryUrlContext()->QueryMetaData();
DBG_ASSERT( pMetaData != NULL);
if (!pW3Context->QueryDoneWithCompression() &&
pMetaData->QueryDoDynamicCompression())
{
if (FAILED(hr = HTTP_COMPRESSION::DoDynamicCompression(
pW3Context,
dwResponseFlags & W3_RESPONSE_MORE_DATA ? TRUE : FALSE )))
{
return hr;
}
}
}
//
// If we are suppressing entity (in case of HEAD for example) do it
// now by clearing the chunk count
//
if ( dwResponseFlags & W3_RESPONSE_SUPPRESS_ENTITY )
{
_cChunks = 0;
}
fAsync = ( dwResponseFlags & W3_RESPONSE_ASYNC ) ? TRUE : FALSE;
//
// Finally, send stuff out
//
hr = UlAtqSendEntityBody(pW3Context->QueryUlatqContext(),
fAsync,
dwFlags,
_cChunks,
_cChunks ? QueryChunks() : NULL,
pcbSent,
pUlLogData);
return hr;
}
HRESULT
W3_RESPONSE::GenerateAutomaticHeaders(
W3_CONTEXT * pW3Context,
DWORD dwFlags
)
/*++
Routine Description:
Parse-Mode only function
Generate headers which UL normally generates on our behalf. This means
Server:
Connection:
Content-Length:
Date:
Arguments:
pW3Context - Helps us build the core headers (since we need to look at
the request). Can be NULL to indicate to use defaults
dwFlags - Flags we would have passed to UL
Return Value:
HRESULT
--*/
{
HTTP_KNOWN_HEADER * pHeader;
CHAR * pszHeaderValue;
CHAR achDate[ 128 ];
CHAR achNum[ 64 ];
DWORD cchDate;
DWORD cchNum;
SYSTEMTIME systemTime;
HTTP_VERSION httpVersion;
HRESULT hr;
BOOL fCreateContentLength;
BOOL fDisconnecting = FALSE;
DBG_ASSERT( _responseMode == RESPONSE_MODE_PARSED );
//
// Server:
//
pHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ HttpHeaderServer ]);
if ( pHeader->pRawValue == NULL )
{
pHeader->pRawValue = SERVER_SOFTWARE_STRING;
pHeader->RawValueLength = sizeof( SERVER_SOFTWARE_STRING ) - 1;
}
//
// Date:
//
pHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ HttpHeaderDate ]);
if ( pHeader->pRawValue == NULL )
{
if(!IISGetCurrentTimeAsSystemTime(&systemTime))
{
GetSystemTime( &systemTime );
}
if ( !SystemTimeToGMT( systemTime,
achDate,
sizeof(achDate) ) )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
cchDate = strlen( achDate );
hr = _HeaderBuffer.AllocateSpace( achDate,
cchDate,
&pszHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
DBG_ASSERT( pszHeaderValue != NULL );
pHeader->pRawValue = pszHeaderValue;
pHeader->RawValueLength = cchDate;
}
//
// Are we going to be disconnecting?
//
if ( pW3Context != NULL &&
( pW3Context->QueryDisconnect() ||
pW3Context->QueryRequest()->QueryClientWantsDisconnect() ) )
{
fDisconnecting = TRUE;
}
//
// Connection:
//
pHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ HttpHeaderConnection ] );
if ( pHeader->pRawValue == NULL )
{
if ( pW3Context == NULL )
{
HTTP_SET_VERSION( httpVersion, 1, 0 );
}
else
{
httpVersion = pW3Context->QueryRequest()->QueryVersion();
}
if ( fDisconnecting )
{
if ( HTTP_GREATER_EQUAL_VERSION( httpVersion, 1, 0 ) )
{
pHeader->pRawValue = "close";
pHeader->RawValueLength = sizeof( "close" ) - 1;
}
}
else
{
if ( HTTP_EQUAL_VERSION( httpVersion, 1, 0 ) )
{
pHeader->pRawValue = "keep-alive";
pHeader->RawValueLength = sizeof( "keep-alive" ) - 1;
}
}
}
//
// Should we generate content length?
//
fCreateContentLength = TRUE;
if ( dwFlags & HTTP_SEND_RESPONSE_FLAG_MORE_DATA )
{
fCreateContentLength = FALSE;
}
if ( fCreateContentLength &&
QueryStatusCode() / 100 == 1 ||
QueryStatusCode() == 204 ||
QueryStatusCode() == 304 )
{
fCreateContentLength = FALSE;
}
if ( fCreateContentLength &&
pW3Context != NULL &&
pW3Context->QueryMainContext()->QueryShouldGenerateContentLength() )
{
fCreateContentLength = FALSE;
}
//
// Now generate if needed
//
if ( fCreateContentLength )
{
//
// Generate a content length header if needed
//
pHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ HttpHeaderContentLength ]);
if ( pHeader->pRawValue == NULL )
{
_ui64toa( QueryContentLength(),
achNum,
10 );
cchNum = strlen( achNum );
pszHeaderValue = NULL;
hr = _HeaderBuffer.AllocateSpace( achNum,
cchNum,
&pszHeaderValue );
if ( FAILED( hr ) )
{
return hr;
}
DBG_ASSERT( pszHeaderValue != NULL );
pHeader->pRawValue = pszHeaderValue;
pHeader->RawValueLength = cchNum;
}
}
return NO_ERROR;
}
HRESULT
W3_RESPONSE::BuildRawCoreHeaders(
W3_CONTEXT * pW3Context
)
/*++
Routine Description:
Build raw header stream for the core headers that UL normally generates
on our behalf. This means structured headers and some special
"automatic" ones like Connection:, Date:, Server:, etc.
Arguments:
pW3Context - Helps us build core header (in particular the Connection:)
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
CHAR achNumber[ 32 ];
HTTP_KNOWN_HEADER * pKnownHeader;
HTTP_UNKNOWN_HEADER * pUnknownHeader;
CHAR * pszHeaderName;
DWORD cchHeaderName;
DWORD i;
if ( pW3Context == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
_strRawCoreHeaders.Reset();
//
// Build a status line
//
hr = _strRawCoreHeaders.Copy( "HTTP/1.1 " );
if ( FAILED( hr ) )
{
return hr;
}
_itoa( _ulHttpResponse.StatusCode,
achNumber,
10 );
hr = _strRawCoreHeaders.Append( achNumber );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( " " );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( _ulHttpResponse.pReason );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( "\r\n" );
if ( FAILED( hr ) )
{
return hr;
}
//
// Iterate thru all the headers in our structured response and set
// append them to the stream.
//
// Start with the known headers
//
for ( i = 0;
i < HttpHeaderResponseMaximum;
i++ )
{
pKnownHeader = &(_ulHttpResponse.Headers.pKnownHeaders[ i ]);
if ( pKnownHeader->pRawValue != NULL &&
pKnownHeader->pRawValue[ 0 ] != '\0' )
{
pszHeaderName = RESPONSE_HEADER_HASH::GetString( i, &cchHeaderName );
DBG_ASSERT( pszHeaderName != NULL );
hr = _strRawCoreHeaders.Append( pszHeaderName, cchHeaderName );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( ": ", 2 );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( pKnownHeader->pRawValue,
pKnownHeader->RawValueLength );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( "\r\n", 2 );
if ( FAILED( hr ) )
{
return hr;
}
//
// Now clear the header
//
pKnownHeader->pRawValue = NULL;
pKnownHeader->RawValueLength = 0;
}
}
//
// Next, the unknown headers
//
for ( i = 0;
i < _ulHttpResponse.Headers.UnknownHeaderCount;
i++ )
{
pUnknownHeader = &(_ulHttpResponse.Headers.pUnknownHeaders[ i ]);
hr = _strRawCoreHeaders.Append( pUnknownHeader->pName,
pUnknownHeader->NameLength );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( ": ", 2 );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( pUnknownHeader->pRawValue,
pUnknownHeader->RawValueLength );
if ( FAILED( hr ) )
{
return hr;
}
hr = _strRawCoreHeaders.Append( "\r\n", 2 );
if ( FAILED( hr ) )
{
return hr;
}
}
//
// Clear the unknown headers
//
_ulHttpResponse.Headers.UnknownHeaderCount = 0;
return NO_ERROR;
}
HRESULT
W3_RESPONSE::AppendResponseHeaders(
STRA & strHeaders
)
/*++
Routine Description:
Add response headers (an ISAPI filter special)
Arguments:
strHeaders - Additional headers to add
(may contain entity -> LAAAAAAMMMMME)
Return Value:
HRESULT
--*/
{
HRESULT hr;
LPSTR pszEntity;
HTTP_DATA_CHUNK DataChunk;
if ( strHeaders.IsEmpty() )
{
return NO_ERROR;
}
if ( _responseMode == RESPONSE_MODE_RAW &&
QueryChunks()->FromMemory.pBuffer == _strRawCoreHeaders.QueryStr() )
{
DBG_ASSERT( QueryChunks()->DataChunkType == HttpDataChunkFromMemory );
DBG_ASSERT( QueryChunks()->FromMemory.pBuffer == _strRawCoreHeaders.QueryStr() );
hr = _strRawCoreHeaders.Append( strHeaders );
if ( FAILED( hr ) )
{
return hr;
}
//
// Patch first chunk since point may have changed
//
QueryChunks()->FromMemory.pBuffer = _strRawCoreHeaders.QueryStr();
QueryChunks()->FromMemory.BufferLength = _strRawCoreHeaders.QueryCB();
}
else
{
hr = ParseHeadersFromStream( strHeaders.QueryStr() );
if ( FAILED( hr ) )
{
return hr;
}
//
// Look for entity body in headers
//
pszEntity = strstr( strHeaders.QueryStr(), "\r\n\r\n" );
if ( pszEntity != NULL )
{
DataChunk.DataChunkType = HttpDataChunkFromMemory;
DataChunk.FromMemory.pBuffer = pszEntity + ( sizeof( "\r\n\r\n" ) - 1 );
DataChunk.FromMemory.BufferLength = strlen( (LPSTR) DataChunk.FromMemory.pBuffer );
hr = InsertDataChunk( &DataChunk, 0 );
if ( FAILED( hr ) )
{
return hr;
}
}
}
return NO_ERROR;
}
HRESULT
W3_RESPONSE::BuildStatusFromIsapi(
CHAR * pszStatus
)
/*++
Routine Description:
Build up status for response given raw status line from ISAPI
Arguments:
pszStatus - Status line for response
Return Value:
HRESULT
--*/
{
USHORT status;
STACK_STRA( strReason, 32 );
CHAR * pszCursor = NULL;
HRESULT hr = NO_ERROR;
DBG_ASSERT( pszStatus != NULL );
status = (USHORT) atoi( pszStatus );
if ( status >= 100 &&
status <= 999 )
{
//
// Need to find the reason string
//
pszCursor = pszStatus;
while ( isdigit( *pszCursor ) )
{
pszCursor++;
}
if ( *pszCursor == ' ' )
{
hr = strReason.Copy( pszCursor + 1 );
if ( FAILED( hr ) )
{
return hr;
}
}
hr = SetStatus( (USHORT)status, strReason );
if ( FAILED( hr ) )
{
return hr;
}
}
return NO_ERROR;
}
HRESULT
W3_RESPONSE::FilterWriteClient(
W3_CONTEXT * pW3Context,
PVOID pvData,
DWORD cbData
)
/*++
Routine Description:
A non-intrusive WriteClient() for use with filters. Non-intrusive means
the current response structure (chunks/headers) is not reset/effected
by sending this data (think of a WriteClient() done in a SEND_RESPONSE
filter notification)
Arguments:
pW3Context - W3 Context used to help build core response header
pvData - Pointer to data sent
cbData - Size of data to send
Return Value:
HRESULT
--*/
{
HTTP_DATA_CHUNK dataChunk;
DWORD cbSent;
HTTP_FILTER_RAW_DATA rawStream;
BOOL fRet;
BOOL fFinished = FALSE;
DWORD dwFlags = HTTP_SEND_RESPONSE_FLAG_MORE_DATA |
HTTP_SEND_RESPONSE_FLAG_RAW_HEADER;
dataChunk.DataChunkType = HttpDataChunkFromMemory;
dataChunk.FromMemory.pBuffer = pvData;
dataChunk.FromMemory.BufferLength = cbData;
_fResponseTouched = TRUE;
_fResponseSent = TRUE;
//
// If there are send raw filters to be notified, do so now
//
if ( pW3Context->IsNotificationNeeded( SF_NOTIFY_SEND_RAW_DATA ) )
{
rawStream.pvInData = pvData;
rawStream.cbInData = cbData;
rawStream.cbInBuffer = cbData;
fRet = pW3Context->NotifyFilters( SF_NOTIFY_SEND_RAW_DATA,
&rawStream,
&fFinished );
if ( !fRet )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
if ( fFinished )
{
rawStream.cbInData = 0;
rawStream.cbInBuffer = 0;
dwFlags = HTTP_SEND_RESPONSE_FLAG_DISCONNECT |
HTTP_SEND_RESPONSE_FLAG_RAW_HEADER;
}
dataChunk.FromMemory.pBuffer = rawStream.pvInData;
dataChunk.FromMemory.BufferLength = rawStream.cbInData;
}
return UlAtqSendEntityBody( pW3Context->QueryUlatqContext(),
FALSE, // sync
dwFlags,
1,
&dataChunk,
&cbSent,
NULL );
}
HRESULT
W3_RESPONSE::BuildResponseFromIsapi(
W3_CONTEXT * pW3Context,
LPSTR pszStatusStream,
LPSTR pszHeaderStream,
DWORD cchHeaderStream
)
/*++
Routine Description:
Shift this response into raw mode since we want to hold onto the
streams from ISAPI and use them for the response if possible
Arguments:
pW3Context - W3 Context used to help build core response header
(can be NULL)
pszStatusStream - Status stream
pszHeaderStream - Header stream
cchHeaderStream - Size of above
Return Value:
HRESULT
--*/
{
HRESULT hr = NO_ERROR;
CHAR * pszEndOfHeaders = NULL;
CHAR * pszCursor;
CHAR * pszRawAdditionalIsapiHeaders = NULL;
DWORD cchRawAdditionalIsapiHeaders = 0;
CHAR * pszRawAdditionalIsapiEntity = NULL;
DWORD cchRawAdditionalIsapiEntity = 0;
HTTP_DATA_CHUNK DataChunk;
_fResponseTouched = TRUE;
//
// First parse the status line. We do this before switching into raw
// mode because we want the _strRawCoreHeader string to contain the
// correct status line and reason
//
if ( pszStatusStream != NULL &&
*pszStatusStream != '\0' )
{
hr = BuildStatusFromIsapi( pszStatusStream );
if ( FAILED( hr ) )
{
return hr;
}
}
//
// If there is no ISAPI header stream set, then we're done
//
if ( pszHeaderStream == NULL )
{
return NO_ERROR;
}
//
// Create automatic headers if necessary (but no content-length)
//
hr = GenerateAutomaticHeaders( pW3Context,
HTTP_SEND_RESPONSE_FLAG_MORE_DATA );
if ( FAILED( hr ) )
{
return hr;
}
//
// The ISAPI set some headers. Store them now
//
pszRawAdditionalIsapiHeaders = pszHeaderStream;
cchRawAdditionalIsapiHeaders = cchHeaderStream;
//
// If there is additional entity body (after ISAPI headers), then add it
// Look for a complete set of additional headers. Complete means that
// we can find a "\r\n\r\n".
//
pszEndOfHeaders = strstr( pszHeaderStream, "\r\n\r\n" );
if ( pszEndOfHeaders != NULL )
{
pszEndOfHeaders += 4; // go past the \r\n\r\n
//
// Update the header length since there is entity tacked on
//
cchRawAdditionalIsapiHeaders = DIFF( pszEndOfHeaders - pszHeaderStream );
if ( *pszEndOfHeaders != '\0' )
{
pszRawAdditionalIsapiEntity = pszEndOfHeaders;
cchRawAdditionalIsapiEntity = cchHeaderStream - cchRawAdditionalIsapiHeaders;
}
}
else
{
//
// ISAPI didn't complete the headers. That means the ISAPI will
// be completing the headers later. What this means for us is we
// must send the headers in the raw form with out adding our own
// \r\n\r\n
//
_fIncompleteHeaders = TRUE;
}
//
// Switch into raw mode if we're not already in it
//
if ( _responseMode == RESPONSE_MODE_PARSED )
{
hr = SwitchToRawMode( pW3Context,
pszRawAdditionalIsapiHeaders,
cchRawAdditionalIsapiHeaders );
if ( FAILED( hr ) )
{
return hr;
}
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_RAW );
//
// Now add the additional ISAPI entity
//
if ( cchRawAdditionalIsapiEntity != 0 )
{
DataChunk.DataChunkType = HttpDataChunkFromMemory;
DataChunk.FromMemory.pBuffer = pszRawAdditionalIsapiEntity;
DataChunk.FromMemory.BufferLength = cchRawAdditionalIsapiEntity;
hr = InsertDataChunk( &DataChunk, -1 );
if ( FAILED( hr ) )
{
return hr;
}
}
return NO_ERROR;
}
HRESULT
W3_RESPONSE::GetRawResponseStream(
STRA * pstrResponseStream
)
/*++
Routine Description:
Fill in the raw response stream for use by raw data filter code
Arguments:
pstrResponseStream - Filled with response stream
Return Value:
HRESULT
--*/
{
HRESULT hr;
DWORD i;
CHAR * pszChunk;
HTTP_DATA_CHUNK * pChunks;
if ( pstrResponseStream == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
DBG_ASSERT( _responseMode == RESPONSE_MODE_RAW );
pChunks = QueryChunks();
for ( i = 0;
i < _cFirstEntityChunk;
i++ )
{
DBG_ASSERT( pChunks[ i ].DataChunkType == HttpDataChunkFromMemory );
pszChunk = (CHAR*) pChunks[ i ].FromMemory.pBuffer;
DBG_ASSERT( pszChunk != NULL );
hr = pstrResponseStream->Append( pszChunk );
if ( FAILED( hr ) )
{
return hr;
}
}
return NO_ERROR;
}
VOID
W3_RESPONSE::Reset(
VOID
)
/*++
Routine Description:
Initialization of a W3_RESPONSE
Arguments:
None
Return Value:
None
--*/
{
_ulHttpResponse.Flags = 0;
Clear();
//
// Set status to 200 (default)
//
SetStatus( HttpStatusOk );
//
// Keep track of whether the response has been touched (augmented). This
// is useful when determining whether an response was intended
//
_fResponseTouched = FALSE;
//
// This response hasn't been sent yet
//
_fResponseSent = FALSE;
}
HRESULT
W3_RESPONSE::InsertDataChunk(
HTTP_DATA_CHUNK * pNewChunk,
LONG cPosition
)
/*++
Routine Description:
Insert given data chunk into list of chunks. The position is determined
by cPosition. If a chunk occupies the given spot, it (along with all
remaining) are shifted forward.
Arguments:
pNewChunk - Chunk to insert
cPosition - Position of new chunk (0 prepends, -1 appends)
Return Value:
HRESULT
--*/
{
HTTP_DATA_CHUNK * pChunks = NULL;
DWORD cOriginalChunkCount;
if ( pNewChunk == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// Must be real position or -1
//
DBG_ASSERT( cPosition >= -1 );
//
// Allocate the new chunk if needed
//
cOriginalChunkCount = _cChunks;
_cChunks += 1;
if ( !_bufChunks.Resize( _cChunks * sizeof( HTTP_DATA_CHUNK ),
512 ) )
{
return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
}
pChunks = QueryChunks();
//
// If we're appending then this is simple. Otherwise we must shift
//
if ( cPosition == -1 )
{
memcpy( pChunks + cOriginalChunkCount,
pNewChunk,
sizeof( HTTP_DATA_CHUNK ) );
}
else
{
if ( cOriginalChunkCount > cPosition )
{
memmove( pChunks + cPosition + 1,
pChunks + cPosition,
sizeof( HTTP_DATA_CHUNK ) * ( cOriginalChunkCount - cPosition ) );
}
memcpy( pChunks + cPosition,
pNewChunk,
sizeof( HTTP_DATA_CHUNK ) );
}
return NO_ERROR;
}
HRESULT
W3_RESPONSE::ParseHeadersFromStream(
CHAR * pszStream
)
/*++
Routine Description:
Parse raw headers from ISAPI into the HTTP_RESPONSE
Arguments:
pszStream - Stream of headers in form (Header: Value\r\nHeader2: value2\r\n)
Return Value:
HRESULT
--*/
{
CHAR * pszCursor;
CHAR * pszEnd;
CHAR * pszColon;
HRESULT hr = NO_ERROR;
STACK_STRA( strHeaderLine, 128 );
STACK_STRA( strHeaderName, 32 );
STACK_STRA( strHeaderValue, 64 );
if ( pszStream == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
//
// \r\n delimited
//
pszCursor = pszStream;
while ( pszCursor != NULL && *pszCursor != '\0' )
{
//
// Check to see if pszCursor points to the "\r\n"
// that separates the headers from the entity body
// of the response and add a memory chunk for any
// data that exists after it.
//
// This is to support ISAPI's that do something like
// SEND_RESPONSE_HEADER with "head1: value1\r\n\r\nEntity"
//
if ( *pszCursor == '\r' && *(pszCursor + 1) == '\n' )
{
break;
}
pszEnd = strstr( pszCursor, "\r\n" );
if ( pszEnd == NULL )
{
break;
}
//
// Split out a line and convert to unicode
//
hr = strHeaderLine.Copy( pszCursor,
DIFF(pszEnd - pszCursor) );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Advance the cursor the right after the \r\n
//
pszCursor = pszEnd + 2;
//
// Split the line above into header:value
//
pszColon = strchr( strHeaderLine.QueryStr(), ':' );
if ( pszColon == NULL )
{
continue;
}
else
{
if ( pszColon == strHeaderLine.QueryStr() )
{
strHeaderName.Reset();
}
else
{
hr = strHeaderName.Copy( strHeaderLine.QueryStr(),
DIFF(pszColon - strHeaderLine.QueryStr()) );
}
}
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Skip the first space after the : if there is one
//
if ( pszColon[ 1 ] == ' ' )
{
pszColon++;
}
hr = strHeaderValue.Copy( pszColon + 1 );
if ( FAILED( hr ) )
{
goto Finished;
}
//
// Add the header to the response
//
hr = SetHeader( strHeaderName.QueryStr(),
strHeaderName.QueryCCH(),
strHeaderValue.QueryStr(),
strHeaderValue.QueryCCH(),
FALSE,
TRUE );
if ( FAILED( hr ) )
{
goto Finished;
}
}
Finished:
if ( FAILED( hr ) )
{
//
// Don't allow the response to get into a quasi-bogus-state
//
Clear();
}
return hr;
}
//static
HRESULT
W3_RESPONSE::ReadFileIntoBuffer(
HANDLE hFile,
SEND_RAW_BUFFER * pSendBuffer,
ULONGLONG cbCurrentFileOffset
)
/*++
Routine Description:
Read contents of file into buffer
Arguments:
hFile - File to read
pSendBuffer - Buffer to read into
cbCurrentFileOffset - Offset to read from
Return Value:
HRESULT
--*/
{
OVERLAPPED overlapped;
LARGE_INTEGER liOffset;
BOOL fRet;
DWORD cbRead;
DWORD dwError;
if ( hFile == NULL ||
pSendBuffer == NULL )
{
DBG_ASSERT( FALSE );
return HRESULT_FROM_WIN32( ERROR_INVALID_PARAMETER );
}
pSendBuffer->SetLen( 0 );
liOffset.QuadPart = cbCurrentFileOffset;
//
// Setup overlapped with offset
//
ZeroMemory( &overlapped, sizeof( overlapped ) );
overlapped.Offset = liOffset.LowPart;
overlapped.OffsetHigh = liOffset.HighPart;
//
// Do the read
//
fRet = ReadFile( hFile,
pSendBuffer->QueryPtr(),
pSendBuffer->QuerySize(),
&cbRead,
&overlapped );
if ( !fRet )
{
dwError = GetLastError();
if ( dwError == ERROR_IO_PENDING )
{
fRet = GetOverlappedResult( hFile,
&overlapped,
&cbRead,
TRUE );
if ( !fRet )
{
dwError = GetLastError();
if ( dwError == ERROR_HANDLE_EOF )
{
fRet = TRUE;
}
}
}
else if ( dwError == ERROR_HANDLE_EOF )
{
fRet = TRUE;
}
}
//
// If there was an error, bail
//
if ( !fRet )
{
return HRESULT_FROM_WIN32( dwError );
}
else
{
pSendBuffer->SetLen( cbRead );
return NO_ERROR;
}
}
HRESULT
W3_RESPONSE::ProcessRawChunks(
W3_CONTEXT * pW3Context,
BOOL * pfFinished
)
/*++
Routine Description:
Iterate thru chunks, serializing and filtering as needed
Arguments:
pW3Context - Context used to filter with
pfFinished - Set to TRUE if filter wanted to finish
Return Value:
HRESULT
--*/
{
DWORD cCurrentChunk = 0;
DWORD cCurrentInsertPos = 0;
DWORD cFileChunkCount = 0;
HTTP_DATA_CHUNK * pChunk;
HTTP_DATA_CHUNK DataChunk;
HTTP_FILTER_RAW_DATA origStream;
HTTP_FILTER_RAW_DATA currStream;
HRESULT hr = NO_ERROR;
BOOL fRet;
LONGLONG cbCurrentFileOffset;
LONGLONG cbTarget;
SEND_RAW_BUFFER * pSendBuffer = NULL;
HANDLE hFile;
DBG_ASSERT( pfFinished != NULL );
DBG_ASSERT( pW3Context != NULL );
*pfFinished = FALSE;
//
// Start iterating thru chunks
//
for ( cCurrentChunk = 0;
cCurrentChunk < _cChunks;
cCurrentChunk++ )
{
pChunk = &(QueryChunks()[ cCurrentChunk ]);
//
// First remember this chunk incase filter changed it
//
//
// If memory chunk, this is easy. Otherwise we need to read the file
// handle and build up memory chunks
//
if ( pChunk->DataChunkType == HttpDataChunkFromMemory )
{
origStream.pvInData = pChunk->FromMemory.pBuffer;
origStream.cbInData = pChunk->FromMemory.BufferLength;
origStream.cbInBuffer = pChunk->FromMemory.BufferLength;
memcpy( &currStream, &origStream, sizeof( currStream ) );
fRet = pW3Context->NotifyFilters( SF_NOTIFY_SEND_RAW_DATA,
&currStream,
pfFinished );
if ( !fRet )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
break;
}
if ( *pfFinished )
{
goto Finished;
}
if ( currStream.pvInData == origStream.pvInData )
{
//
// Just adjust the chunk
//
pChunk->FromMemory.BufferLength = currStream.cbInData;
}
else
{
//
// Allocate new buffer and tweak chunk to refer to it
//
pSendBuffer = new SEND_RAW_BUFFER;
if ( pSendBuffer == NULL )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
break;
}
hr = pSendBuffer->Resize( currStream.cbInData );
if ( FAILED( hr ) )
{
break;
}
memcpy( pSendBuffer->QueryPtr(),
currStream.pvInData,
currStream.cbInData );
pChunk->FromMemory.BufferLength = currStream.cbInData;
pChunk->FromMemory.pBuffer = pSendBuffer->QueryPtr();
InsertHeadList( &_SendRawBufferHead,
&(pSendBuffer->_listEntry) );
pSendBuffer = NULL;
}
}
else if ( pChunk->DataChunkType == HttpDataChunkFromFileHandle )
{
//
// Reset file offsets
//
cbCurrentFileOffset = 0;
//
// How many bytes are we reading?
//
cbTarget = pChunk->FromFileHandle.ByteRange.Length.QuadPart;
//
// Remember where to start inserting memory chunks
//
cCurrentInsertPos = cCurrentChunk;
//
// First memory replacement chunk can use file handle chunk
//
cFileChunkCount = 0;
//
// Remember the handle now since we will be overwriting this
// chunk with a memory chunk
//
hFile = pChunk->FromFileHandle.FileHandle;
while ( cbCurrentFileOffset < cbTarget )
{
//
// Allocate a buffer
//
pSendBuffer = new SEND_RAW_BUFFER;
if ( pSendBuffer == NULL )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
break;
}
//
// Read some of the file into buffer
//
hr = ReadFileIntoBuffer( hFile,
pSendBuffer,
cbCurrentFileOffset );
if ( FAILED( hr ) )
{
break;
}
//
// Update offset
//
cbCurrentFileOffset += pSendBuffer->QueryCB();
//
// Setup memory chunk to filter
//
origStream.pvInData = pSendBuffer->QueryPtr();
origStream.cbInBuffer = pSendBuffer->QuerySize();
origStream.cbInData = pSendBuffer->QueryCB();
memcpy( &currStream, &origStream, sizeof( currStream ) );
//
// Filter the data
//
fRet = pW3Context->NotifyFilters( SF_NOTIFY_SEND_RAW_DATA,
&currStream,
pfFinished );
if ( !fRet )
{
hr = HRESULT_FROM_WIN32( GetLastError() );
break;
}
if ( *pfFinished )
{
goto Finished;
}
//
// Should we keep the file content chunk
//
if ( currStream.pvInData != origStream.pvInData )
{
//
// We have a new memory address containing data
//
if ( currStream.cbInData > pSendBuffer->QuerySize() )
{
hr = pSendBuffer->Resize( currStream.cbInData );
if ( FAILED( hr ) )
{
break;
}
}
memcpy( pSendBuffer->QueryPtr(),
currStream.pvInData,
currStream.cbInData );
}
//
// Add the chunk. If the first chunk, we can replace
// the original file handle chunk
//
if ( cFileChunkCount == 0 )
{
pChunk->DataChunkType = HttpDataChunkFromMemory;
pChunk->FromMemory.pBuffer = pSendBuffer->QueryPtr();
pChunk->FromMemory.BufferLength = currStream.cbInData;
cCurrentInsertPos++;
}
else
{
DataChunk.DataChunkType = HttpDataChunkFromMemory;
DataChunk.FromMemory.pBuffer = pSendBuffer->QueryPtr();
DataChunk.FromMemory.BufferLength = currStream.cbInData;
hr = InsertDataChunk( &DataChunk,
cCurrentInsertPos++ );
if ( FAILED( hr ) )
{
break;
}
}
InsertHeadList( &_SendRawBufferHead,
&(pSendBuffer->_listEntry) );
pSendBuffer = NULL;
cFileChunkCount++;
}
//
// If we're here because of failure, bail
//
if ( FAILED( hr ) )
{
break;
}
//
// Update current chunk to be processed
//
cCurrentChunk = cCurrentInsertPos;
}
else
{
//
// Only support file-handle and memory chunks
//
DBG_ASSERT( FALSE );
}
}
Finished:
if ( pSendBuffer != NULL )
{
delete pSendBuffer;
}
return hr;
}
//static
HRESULT
W3_RESPONSE::Initialize(
VOID
)
/*++
Routine Description:
Enable W3_RESPONSE globals
Arguments:
None
Return Value:
HRESULT
--*/
{
HRESULT hr;
hr = RESPONSE_HEADER_HASH::Initialize();
if ( FAILED( hr ) )
{
return hr;
}
hr = SEND_RAW_BUFFER::Initialize();
if ( FAILED( hr ) )
{
RESPONSE_HEADER_HASH::Terminate();
}
return hr;
}
//static
VOID
W3_RESPONSE::Terminate(
VOID
)
{
SEND_RAW_BUFFER::Terminate();
RESPONSE_HEADER_HASH::Terminate();
}
CONTEXT_STATUS
W3_STATE_RESPONSE::DoWork(
W3_MAIN_CONTEXT * pMainContext,
DWORD cbCompletion,
DWORD dwCompletionStatus
)
/*++
Routine Description:
This state is responsible for ensuring that a response does get sent
back to the client. We hope/expect that the handlers will do their
thing -> but if they don't we will catch that here and send a response
Arguments:
pMainContext - Context
cbCompletion - Number of bytes in an async completion
dwCompletionStatus - Error status of a completion
Return Value:
CONTEXT_STATUS_PENDING or CONTEXT_STATUS_CONTINUE
--*/
{
W3_RESPONSE* pResponse;
DWORD dwOldState;
HRESULT hr;
pResponse = pMainContext->QueryResponse();
DBG_ASSERT( pResponse != NULL );
//
// Has a response been sent? If not, bail
//
if ( pMainContext->QueryResponseSent() )
{
return CONTEXT_STATUS_CONTINUE;
}
//
// If the response has been touched, then just send that response. Else
// send a 500 error
//
if ( !pResponse->QueryResponseTouched() )
{
pResponse->SetStatus( HttpStatusServerError );
}
//
// Send it out
//
hr = pMainContext->SendResponse( W3_FLAG_ASYNC );
if ( FAILED( hr ) )
{
pMainContext->SetErrorStatus( hr );
return CONTEXT_STATUS_CONTINUE;
}
else
{
return CONTEXT_STATUS_PENDING;
}
}
CONTEXT_STATUS
W3_STATE_RESPONSE::OnCompletion(
W3_MAIN_CONTEXT * pW3Context,
DWORD cbCompletion,
DWORD dwCompletionStatus
)
/*++
Routine Description:
Subsequent completions in this state
Arguments:
pW3Context - Context
cbCompletion - Number of bytes in an async completion
dwCompletionStatus - Error status of a completion
Return Value:
CONTEXT_STATUS_PENDING or CONTEXT_STATUS_CONTINUE
--*/
{
//
// We received an IO completion. Just advance since we have nothing to
// cleanup
//
return CONTEXT_STATUS_CONTINUE;
}
//static
HRESULT
SEND_RAW_BUFFER::Initialize(
VOID
)
/*++
Routine Description:
Global initialization routine for SEND_RAW_BUFFERs
Arguments:
None
Return Value:
HRESULT
--*/
{
ALLOC_CACHE_CONFIGURATION acConfig;
HRESULT hr = NO_ERROR;
//
// Setup allocation lookaside
//
acConfig.nConcurrency = 1;
acConfig.nThreshold = 100;
acConfig.cbSize = sizeof( SEND_RAW_BUFFER );
DBG_ASSERT( sm_pachSendRawBuffers == NULL );
sm_pachSendRawBuffers = new ALLOC_CACHE_HANDLER( "SEND_RAW_BUFFER",
&acConfig );
if ( sm_pachSendRawBuffers == NULL )
{
return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
}
return NO_ERROR;
}
//static
VOID
SEND_RAW_BUFFER::Terminate(
VOID
)
/*++
Routine Description:
Terminate MAIN_CONTEXT globals
Arguments:
None
Return Value:
None
--*/
{
if ( sm_pachSendRawBuffers != NULL )
{
delete sm_pachSendRawBuffers;
sm_pachSendRawBuffers = NULL;
}
}
Reference in a new issue Copy permalink